2 people like it.

# Continue sequence after applying Seq.takeWhile, skip, take, etc

Sometimes you need to take more elements from a sequence, e.g. look at https://stackoverflow.com/questions/12562327/how-to-do-seq-takewhile-one-item-in-f This solution allows fetching elements from the same sequence after applying takeWhile, skip, take and other sequence functions. However, need to remember to call function with right parameter: use 'true' to include current element into result sequence (after takeWhile for example)

 ``` 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: ``` ``````/// allows fetching elements from same sequence let continueSeq (xs: 'a seq) = use en = xs.GetEnumerator() fun(includeCurrent: bool) -> let s = seq { while en.MoveNext() do yield en.Current } let c = seq { en.Current } if includeCurrent then Seq.append c s else s /// usage example: let a = seq [1; 2; 3; 4; 5; 6; 7] let seqfun = continueSeq a let s1 = seqfun(false) |> Seq.takeWhile((>) 3) // take 1 and 2, 3 is current let s2 = seqfun(true) |> Seq.take(2) // take 3 and 4 let s3 = seqfun(false) |> Seq.skip(1) // skip 5 let s = s1 |> Seq.append <| s2 |> Seq.append <| s3 |> Seq.toList // s = [1; 2; 3; 4; 6; 7] ``````
val continueSeq : xs:seq<unit> -> (bool -> seq<unit>)

Full name: Script.continueSeq

allows fetching elements from same sequence
val xs : seq<unit>
Multiple items
val seq : sequence:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Core.Operators.seq

--------------------
type seq<'T> = System.Collections.Generic.IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>
val en : System.Collections.Generic.IEnumerator<unit>
System.Collections.Generic.IEnumerable.GetEnumerator() : System.Collections.Generic.IEnumerator<unit>
val includeCurrent : bool
type bool = System.Boolean

Full name: Microsoft.FSharp.Core.bool
val s : seq<unit>
System.Collections.IEnumerator.MoveNext() : bool
property System.Collections.Generic.IEnumerator.Current: unit
val c : seq<unit>
module Seq

from Microsoft.FSharp.Collections
val append : source1:seq<'T> -> source2:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.append
val a : seq<int>

Full name: Script.a

usage example:
val seqfun : (bool -> seq<unit>)

Full name: Script.seqfun
val s1 : seq<unit>

Full name: Script.s1
val takeWhile : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.takeWhile
val s2 : seq<unit>

Full name: Script.s2
val take : count:int -> source:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.take
val s3 : seq<unit>

Full name: Script.s3
val skip : count:int -> source:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.skip
val s : unit list

Full name: Script.s
val toList : source:seq<'T> -> 'T list

Full name: Microsoft.FSharp.Collections.Seq.toList