73 people like it.
Like the snippet!

Break sequence into n-element subsequences

I'm working on parallel computations and I thought it would be useful to break work into chunks, especially when processing each element asynchronously is too expensive. The neat thing is that this function is general even though motivation for it is specific. Another neat thing is that this is true lazy sequence unlike what you'd get if you used Seq.groupBy. There are three versions for your enjoyment.

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

module Seq=
    let breakBy n s = 
        let filter k (i,x) = ((i/n) = k)
        let index = Seq.mapi (fun i x -> (i,x))
        let rec loop s = 
            seq { if not (Seq.isEmpty s) then 
                    let k = (s |> Seq.head |> fst) / n
                    yield (s |> Seq.takeWhile (filter k)
                             |> Seq.map (fun (i,x) -> x))
                    yield! loop (s |> Seq.skipWhile (filter k)) }
        loop (s |> index)

seq {1..25000} |> Seq.breakBy 50
(*
val it : seq<seq<int>> =
  seq
    [seq [1; 2; 3; 4; ...]; seq [51; 52; 53; 54; ...];
     seq [101; 102; 103; 104; ...]; seq [151; 152; 153; 154; ...]; ...]
*)

module Seq

from Microsoft.FSharp.Collections

val breakBy : n:int -> s:seq<'a> -> seq<seq<'a>>

Full name: Script.Seq.breakBy

val n : int

val s : seq<'a>

val filter : (int -> int * 'b -> bool)

val k : int

val i : int

val x : 'b

val index : (seq<'a> -> seq<int * 'a>)

val mapi : mapping:(int -> 'T -> 'U) -> source:seq<'T> -> seq<'U>

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

val x : 'a

val loop : (seq<int * 'b> -> seq<seq<'b>>)

val s : seq<int * 'b>

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 not : value:bool -> bool

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

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

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

val head : source:seq<'T> -> 'T

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

val fst : tuple:('T1 * 'T2) -> 'T1

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

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

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

val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>

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

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

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

Multiple items
module Seq

from Script

--------------------
module Seq

from Microsoft.FSharp.Collections

Next Version Raw view Test code New version

More information

Link:	http://fssnip.net/1o
Posted:	13 years ago
Author:	Dmitri Pavlenkov
Tags:	seq