Pattern matching on a record

I have this:

type 'a queue = {f : 'a stream; lenf : int; r : 'a stream; lenr : int};;

let empty :'a queue = {f = Nil; lenf = 0; r = Nil; lenr = 0};;

let is_empty (q :'a queue) = 
  match q with
  | {Nil; _; Nil; _} -> true
  | {_; _; _; _} -> false;;

But it doesn't compile. What is wrong with {Nil; _; Nil; _}?

Fields of a record are accessed by name, not by order. So you need to give field names in a record pattern.

# let is_empty (q : 'a queue) =
      match q with
      | { f = Nil; lenf = _; r = Nil; lenr = _ } -> true
      | _ -> false
  ;;
val is_empty : 'a queue -> bool = <fun>

You can leave out fields if you don't care about them, i.e., if they can match anything. There is a warning (Warning 9) for incompletely specified record patterns. If you include a trailing _ the compiler won't warn you that some fields weren't specified even if Warning 9 is in effect:

# let is_empty (q : 'a queue) =
      match q with
      | { f = Nil; r = Nil; _ } -> true
      | _ -> false
  ;;
val is_empty : 'a queue -> bool = <fun>

Alternatively, you might simply access the pertinent record fields and use a boolean expression.

# let is_empty (q : 'a queue) = 
    q.f = Nil && q.r = Nil;;
val is_empty : 'a queue -> bool = <fun>

The match expression is a great tool, but it's not the only tool you have in OCaml. Use the best tool for the job.

One more thing...

You can pattern-match in the arguments of a function.

# let is_empty ({f; r; _} : 'a queue) =
    f = Nil && r = Nil;;
val is_empty : 'a queue -> bool = <fun>

And if you still needed to bind the name q to the whole queue, you could use as. Optionally, a leading underscore in the name of that binding will suppress the unused variable warning.

# let is_empty ({f; r; _} as q : 'a queue) =
    f = Nil && r = Nil;;
Line 1, characters 14-28:
Warning 26 [unused-var]: unused variable q.
val is_empty : 'a queue -> bool = <fun>
# let is_empty ({f; r; _} as _q : 'a queue) =
    f = Nil && r = Nil;;
val is_empty : 'a queue -> bool = <fun>