Seq Kopf und Schwanz

Question

Gibt es einen One-Liner-Weg zu implementieren nextLine?

let s = ref seqOfLines 
let nextLine() = 
    let hd = Seq.head !s 
    s := Seq.skip 1 !s 
    hd 

seqOfLines angenommen wird

Answer 1

Eine Möglichkeit, unendlich zu sein, dies zu tun ist, um die zugrunde liegenden IEnumerator<String> zu nutzen. Es ist kein Ein-Liner, aber es scheint ein bisschen sauberer als die Implementierung, die Sie haben. (Verlässt sich nicht auf veränderbar, verwendet ordnungsgemäß die .NET-Idiome.)

Im Wesentlichen erhalten Sie die IEnumerator<'a>-Schnittstelle aus der Sequenz, und dann nur beim Aufruf von MoveNext Schleife. Dies funktioniert in einer unendlichen Sequenz.

> let getNextFunc (seqOfLines : seq<'a>) =    
-  let linesIE : IEnumerator<'a> = seqOfLines.GetEnumerator() 
-  (fun() -> ignore (linesIE.MoveNext()); linesIE.Current);; 

val getNextFunc : seq<'a> -> (unit -> 'a) 

zu verwenden, nur getNextFunc eine Folge passieren, und es wird Ihre Funktion nextline zurück.

> let sequenceOfStrings = seq { for i = 0 to 10000 do yield i.ToString() };; 

val sequenceOfStrings : seq<string> 

> let nextLine = getNextFunc sequenceOfStrings;; 

val nextLine : (unit -> string) 

> nextLine();; 
val it : string = "0" 
> nextLine();; 
val it : string = "1" 
> nextLine();; 
val it : string = "2" 
> nextLine();; 
val it : string = "3" 

Answer 2

Hmmm, ich glaube, Sie versuchen, dies zu imperativ zu nähern, und als ein Ergebnis, Sie gehen einige flippige Code, um am Ende zu schreiben und die Vorteile der Funktionsprogrammierung zu verlieren.

Sie könnten profitieren, indem Sie Ihre Funktion neu schreiben, so dass es current state und value * next state zurückgibt. Dadurch bleibt Ihre Funktion rein funktional. Man könnte es auch einfacher, finden Sie Ihre unendlichen seq zu einem LazyList statt zu konvertieren (Sie müssen die F # Powerpack für diese verweisen), so dass Sie den zugrunde liegenden enumerator nicht direkt berühren müssen:

> open LazyList 
let seqOfLines = Seq.initInfinite (fun i -> i) |> LazyList.ofSeq 
let nextLine = function Cons(x, xs) -> x, xs | Nil -> failwith "Empty list";; 

val seqOfLines : LazyList<int> 
val nextLine : LazyList<'a> -> 'a * LazyList<'a> 

> nextLine seqOfLines;; 
val it : int * LazyList<int> = (0, seq [1; 2; 3; 4; ...]) 
> nextLine (snd it);; 
val it : int * LazyList<int> = (1, seq [2; 3; 4; 5; ...]) 
> nextLine (snd it);; 
val it : int * LazyList<int> = (2, seq [3; 4; 5; 6; ...]) 
> nextLine (snd it);; 
val it : int * LazyList<int> = (3, seq [4; 5; 6; 7; ...]) 

Answer 3

FSharpx.Collections einige hat nützliche/effiziente Funktionen wie Seq.tail, Seq.Head und Seq.UnCons, die nützlich sein könnten, wenn Sie einen Seq in Kopf und Schwanz zerlegen möchten.