Found that I needed to process an array (returned by an Async expression) and stop once a particular status is hit, ignoring results after that point. My first thought was to code this with a do/until loop. However, F# does not have one of those. So, next thought: code it up using a while loop and break when the value is found, but after processing the element. However, F# does not have one of those either (break, that is).

So, turning a 2 minute change into an hour, I finally figured out I could implement a takeUntil loop on sequences, which returns values until and including the first time a predicate evaluates to true.

1
2
3
4
5
6
7
8
9

module Seq =
    let takeUntil' (p:'a->bool) (s:seq<'a>) =
        seq { let e = s.GetEnumerator()
              let bMore = ref (e.MoveNext()) in
              while !bMore do
                  yield item
                  do bMore := not (p e.Current) && e.MoveNext()
              done
            }

But stop! This reports an error on the line "do bMore" which reads "unmatched 'let' or 'do'"! (hence the hour of debugging) This feels like a bug, but perhaps I'm missing something with the syntax. Can anyone point out why this code fails?

Note that moving the "yield" to the bottom of the loop does work, but I'm not sure why:

1
2
3
4
5
6
7
8
9
10

module Seq =
    let takeUntil (p:'a->bool) (s:seq<'a>) =
        seq { let e = s.GetEnumerator()
              let bMore = ref (e.MoveNext()) in
              while !bMore do
                  let item = e.Current
                  do bMore := e.MoveNext() && not (p item)
                  yield item
              done
            }

On the whole, though, I do (still) miss my do/until and break statements.