I'm trying to use an OCaml program to form an umambiguous protocol
specification. I've convinced myself that by proper definition of
my types, and avoiding using the _ in matches, I can get OCaml to help
me verify that I have a complete specification. I'm doing this by
defining a function that specifies the behavior of one of the protocol
partners when it receives a message. Here is an example of what I
have.
let requestOp = REQUEST_KEY | SUCCESS;;
let message = None | Register of requestOp * int;;
let receive idList msg =
match message with
None -> None
| Register( REQUEST_KEY, id ) -> begin
match idList with
[] -> Register(SUCCESS, id)
| l when
(List.mem id l) -> Register(Success, (next_available_id l))
| _ -> Register(Success, id)
;;
The problem is with the final pattern in the inner match
expression. I'm really trying to avoid using _ in patterns so
that I'm forced to specify an action for each possible case (hence the
reason I'm trying to use OCaml here). It appears that
since I'm using a guard here that OCaml can't, at compile time,
determine whether or not I'm being exhaustive.
Is there a way to accomplish the same thing as above without using
guards so that OCaml will be able to determine that my match is
exhaustive?