cons :: operator for sequences in F#?

Question

Is there a better code that does not need to transform the sequence into a list ?

let rec addentry map keys  =
   match keys with 
   | ((i,j) :: tail) ->  Map.add (i,j) ((inputd.[i]).[j]) (addentry map tail)
   | ([]) -> map

addentry Map.empty (Cartesian keys1 keys2 |> Seq.toList)

score 5 · Accepted Answer · edited Mar 01 '12 at 16:25

5

This is a great place to use Seq.fold. It collapses a collection down into a single value.

Cartesian keys1 keys2
|> Seq.fold (fun map (i, j) ->
  let value = (inputd.[i]).[j]
  Map.add (i, j) value map) Map.empty

edited Mar 01 '12 at 16:25

Onorio Catenacci

14,928
14
81
132

answered Mar 01 '12 at 16:23

JaredPar

733,204
149
1,241
1,454

I just realised that. i dont know where was my head. – nicolas Mar 01 '12 at 16:36

score 5 · Answer 2 · answered Mar 01 '12 at 16:32

5

Cartesian keys1 keys2
|> Seq.map (fun (i, j) -> ((i, j), (inputd.[i]).[j]))
|> Map.ofSeq

answered Mar 01 '12 at 16:32

Daniel

47,404
11
101
179

score 5 · Answer 3 · answered Mar 02 '12 at 11:28

5

As a complement to the previous answers, if you want to be able to pattern-match sequences, you can define an active pattern:

let (|Cons|Nil|) s =
    if Seq.isEmpty s then
        Nil
    else
        Cons(Seq.head s, Seq.skip 1 s)

let rec addentry map keys  =
    match keys with 
    | Cons((i,j), tail) ->  Map.add (i,j) ((inputd.[i]).[j]) (addentry map tail)
    | Nil -> map

answered Mar 02 '12 at 11:28

Tarmil

11,177
30
35

Sadly, this active pattern appears to be orders of magnitude slower than a list's cons operator. – Scott Hutchinson Nov 11 '16 at 19:19

cons :: operator for sequences in F#?

3 Answers3