2 people like it.
Like the snippet!

groupAdjacent

A variation of another snippet "Seq.groupWhen". This one groups adjacent elements based on a predicate that accepts two arguments - the previous and current elements

 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:

module Seq =
    let groupAdjacent f input = 
        let prev = Seq.head input
        let sgs,n = 
            (([],prev),input |> Seq.tail)
            ||> Seq.fold(fun (acc,prev) next -> 
                if f (prev,next) then 
                    match acc with
                    | [] -> [[prev]],next
                    | xs::rest -> (prev::xs)::rest,next
                else
                    match acc with 
                    | [] -> [[];[prev]],next
                    | xs::rest -> []::(prev::xs)::rest,next)
        let sgs = 
            match sgs with 
            | [] -> [[n]]
            | xs::rest -> 
                match xs with
                | [] -> [n]::rest
                | ys -> (n::ys)::rest
        sgs |> List.map List.rev |> List.rev

(*
["a"; "a"; "a"; "b"; "c"; "c"] |> Seq.groupAdjacent (fun (a,b)->a=b)
val it : seq<seq<string>> = seq [["a"; "a"; "a"]; ["b"]; ["c"; "c"]]
*)

module Seq

from Microsoft.FSharp.Collections

val groupAdjacent : f:('a * 'a -> bool) -> input:seq<'a> -> 'a list list

val f : ('a * 'a -> bool)

val input : seq<'a>

val prev : 'a

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

val sgs : 'a list list

val n : 'a

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

val fold : folder:('State -> 'T -> 'State) -> state:'State -> source:seq<'T> -> 'State

val acc : 'a list list

val next : 'a

val xs : 'a list

val rest : 'a list list

val ys : 'a list

Multiple items
module List

from Microsoft.FSharp.Collections

--------------------
type List<'T> =
  | ( [] )
  | ( :: ) of Head: 'T * Tail: 'T list
    interface IReadOnlyList<'T>
    interface IReadOnlyCollection<'T>
    interface IEnumerable
    interface IEnumerable<'T>
    member GetReverseIndex : rank:int * offset:int -> int
    member GetSlice : startIndex:int option * endIndex:int option -> 'T list
    member Head : 'T
    member IsEmpty : bool
    member Item : index:int -> 'T with get
    member Length : int
    ...

val map : mapping:('T -> 'U) -> list:'T list -> 'U list

val rev : list:'T list -> 'T list

Previous Version Raw view Test code New version

More information

Link:	http://fssnip.net/mI
Posted:	1 year ago
Author:	Faisal Waris
Tags:	seq , sequence