Split sequences

Split sequences based on a predicate.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24:

open System.Collections.Generic

let fromEnum (input : 'a IEnumerator) = 
    seq {
        while input.MoveNext() do
            yield input.Current
    }

let getMore (input : 'a IEnumerator) = 
    if input.MoveNext() = false then None
    else Some ((input |> fromEnum) |> Seq.append [input.Current])
    
let splitBy (f : 'a -> bool) (input : 'a seq)  = 
    use s = input.GetEnumerator()
    let rec loop (acc : 'a seq seq) = 
        match s |> getMore with 
        | None -> acc
        | Some x ->[x |> Seq.takeWhile (f >> not) |> Seq.toList |> List.toSeq]
                   |> Seq.append acc
                   |> loop
    loop Seq.empty |> Seq.filter (Seq.isEmpty >> not)
    
seq [1;2;3;4;1;5;6;7;1;9;5;5;1]
|> splitBy ( (=) 1) |> printfn "%A"

namespace System

namespace System.Collections

namespace System.Collections.Generic

val fromEnum : input:IEnumerator<'a> -> seq<'a>

Full name: Script.fromEnum

val input : IEnumerator<'a>

type IEnumerator<'T> =
member Current : 'T

Full name: System.Collections.Generic.IEnumerator<_>

Multiple items
val seq : sequence:seq<'T> -> seq<'T>

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

--------------------
type seq<'T> = IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>

System.Collections.IEnumerator.MoveNext() : bool

property IEnumerator.Current: 'a

val getMore : input:IEnumerator<'a> -> seq<'a> option

Full name: Script.getMore

union case Option.None: Option<'T>

union case Option.Some: Value: 'T -> Option<'T>

module Seq

from Microsoft.FSharp.Collections

val append : source1:seq<'T> -> source2:seq<'T> -> seq<'T>

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

val splitBy : f:('a -> bool) -> input:seq<'a> -> seq<seq<'a>>

Full name: Script.splitBy

val f : ('a -> bool)

type bool = System.Boolean

Full name: Microsoft.FSharp.Core.bool

val input : seq<'a>

val s : IEnumerator<'a>

IEnumerable.GetEnumerator() : IEnumerator<'a>

val loop : (seq<seq<'a>> -> seq<seq<'a>>)

val acc : seq<seq<'a>>

val x : seq<'a>

val takeWhile : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>

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

val not : value:bool -> bool

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

val toList : source:seq<'T> -> 'T list

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

Multiple items
type List<'T> =
  new : unit -> List<'T> + 2 overloads
  member Add : item:'T -> unit
  member AddRange : collection:IEnumerable<'T> -> unit
  member AsReadOnly : unit -> ReadOnlyCollection<'T>
  member BinarySearch : item:'T -> int + 2 overloads
  member Capacity : int with get, set
  member Clear : unit -> unit
  member Contains : item:'T -> bool
  member ConvertAll<'TOutput> : converter:Converter<'T, 'TOutput> -> List<'TOutput>
  member CopyTo : array:'T[] -> unit + 2 overloads
  ...
  nested type Enumerator

Full name: System.Collections.Generic.List<_>

--------------------
List() : unit
List(capacity: int) : unit
List(collection: IEnumerable<'T>) : unit

val toSeq : list:'T list -> seq<'T>

Full name: Microsoft.FSharp.Collections.List.toSeq

val empty<'T> : seq<'T>

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

val filter : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>

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

val isEmpty : source:seq<'T> -> bool

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

val printfn : format:Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printfn

Next Version Raw view Test code New version

More information

Link:	http://fssnip.net/6z
Posted:	13 years ago
Author:	Ankur Dhama
Tags:	sequences