Question

I want to generate a sequence like a multiplication table. So for a start of 1 and a stop of 10 I am looking for a sequence like

1, 2, 3, 4, 5, 6, 7, 8, 9, 10,  // 1*1 - 1*10
2, 4, 6, 8, 10, 12, 14, 16, 18, 20, // 2*1 - 2*10
3, 6, 9, 12, ... // 3*1 - 3*10

Here is my lame start at it, however I can’t seem to figure out how to cleanly increment j when the stop is reached, or how to reset i back to the start.

let multable (start,stop) =
    (start,start)
    |> Seq.unfold(
        fun (i,j) ->
        Some(i*j, (i+1, j)))

let its = multable(1, 1)

let first10 = Seq.take 10 its
printf "%A" (Seq.to_list first10)  

Which of course gives me 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Answer 1

Use a sequence expression:

let multable start stop = seq{
    for a = start to stop do
      for b = start to stop do
        yield a*b
}

Output:

> multable 1 3 |> Seq.to_list;;
val it : int list = [1; 2; 3; 2; 4; 6; 3; 6; 9]

It’s weird to represent a fundamentally 2d structure in this fashion. Why not a sequence of sequences:

let multable2 start stop = seq {
    for a = start to stop do yield seq {
      for b = start to stop do
        yield a*b
    }
}

Output:

val multable2 : int -> int -> seq<seq<int>>

> multable2 1 3 |> Seq.to_list;;
val it : seq<int> list = [seq [1; 2; 3]; seq [2; 4; 6]; seq [3; 6; 9]]

If you want to be “clever” and avoid multiplication:

let multable4 start stop = seq {
    for a = start to stop do yield seq {
      let s = ref 0 in
      for b = start to stop do
        s:=!s+a
        yield !s
    }
}

I don’t actually see any nice prepackaged “sequence from a to b” outside of comprehensions/sequence expressions, although there’s obviously [a..b] (list) and [|a..b|] (array) which you can project through Seq.unfold, Seq.map, etc. to make a Seq.