Question

是否有办法执行chooseTill或foldTill之类的操作，直到收到“无”选项才会处理？实际上，任何具有“until”选项的高阶函数。当然，对于像地图这样的东西没有任何意义，但我发现我经常需要这种东西而且我想确保我没有重新发明轮子。

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

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的事情，但是不是等待最终结果，而是产生中间状态。然后，您可以继续使用中间状态，直到结束。在上面的示例中，state是当前字符和连接字符串（以便我们可以检查字符是否为空格）。

基于返回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

折叠或选择直到无？

1 个答案: