f# - 折叠还是选择直到无？

Question

有没有办法做类似 chooseTill 的事情？或 foldTill ，它会在哪里处理，直到收到 None 选项？真的，任何带有“直到”选项的高阶函数。当然，这对于像 map 这样的东西毫无意义，但我发现我经常需要这种东西，我想确保我没有重新发明轮子。

一般来说，写这样的东西很容易，但我很好奇是否已经有办法做到这一点，或者是否存在于某个已知的库中？

let chooseTill predicate (sequence:seq<'a>) = 
    seq {
            let finished = ref false                            
            for elem in sequence do
                if not !finished then
                    match predicate elem with
                        | Some(x) -> yield x 
                        | None -> finished := true
    }

let foldTill predicate seed list = 
    let rec foldTill' acc = function
        | [] -> acc
        | (h::t) -> match predicate acc h with 
                        | Some(x) -> foldTill' x t
                        | None -> acc
    foldTill' seed list

let (++) a b = a.ToString() + b.ToString()

let abcdef =  foldTill (fun acc v -> 
                        if Char.IsWhiteSpace v then None 
                        else Some(acc ++ v)) "" ("abcdef ghi"  |> Seq.toList)

// result is "abcdef"

Answer 1

我认为您可以通过组合 Seq.scan 轻松获得这一点。和 Seq.takeWhile :

open System

"abcdef ghi"
|> Seq.scan (fun (_, state) c -> c, (string c) + state) ('x', "")
|> Seq.takeWhile (fst >> Char.IsWhiteSpace >> not)
|> Seq.last |> snd

这个想法是 Seq.scan正在做类似 Seq.fold 的事情，但它不会等待最终结果，而是在进行时产生中间状态。然后，您可以继续采取中间状态，直到到达终点。在上面的例子中，状态是当前字符和连接的字符串(以便我们可以检查字符是否为空格)。

基于返回 option 的函数的更通用版本看起来像这样:

let foldWhile f initial input =
  // Generate sequence of all intermediate states
  input |> Seq.scan (fun stateOpt inp -> 
       // If the current state is not 'None', then calculate a new one
       // if 'f' returns 'None' then the overall result will be 'None'
       stateOpt |> Option.bind (fun state -> f state inp)) (Some initial)
  // Take only 'Some' states and get the last one
  |> Seq.takeWhile Option.isSome
  |> Seq.last |> Option.get