Question

In the F# code I’m trying to convert to OCaml, I’ve run into the following:

    let rec parseList lst off =
        seq {
            if List.isEmpty lst then ()
            else
                match parse off <| List.head lst with
                | (Unmatched, _) as y -> yield y
                | (y, z) -> yield (y, z)
                            yield! parseList (List.tail lst) z
        }

I’m wondering about how to convert that seq{…} expression with yield‘s to OCaml? My first guess is that the seq would have to become a list.

Answer 1

Simplest translation (not tail recursive) is:

let rec parseList lst off =
  match lst with
  | [] -> []
  | x::xs ->
      match parse off x with
      | Unmatched, _ as y -> [y]
      | y, z -> (y, z)::parseList xs z

Tail recursive version is:

let parseList lst off =
  let rec loop xs off = function
    | [] -> xs
    | y::ys ->
        match parse off y with
        | Unmatched, _ as x -> x::xs
        | _, z as x -> loop (x::xs) z ys in
  List.rev (loop [] off lst)

Note that the F# code you’re starting from leaves a lot to be desired. The calls to List.head and List.tail are unnecessary potential sources of exceptions when you can more easily use pattern matching instead. And there are superfluous parentheses.