Implementing sequences of sequences in F#

I am trying to expose a 2 dimensional array as a sequence of sequences on an object(to be able to do Seq.fold (fun x -> Seq.fold (fun ->..) [] x) [] mytype stuff specifically)

Below is a toy program that 开发者_如何转开发exposes the identical functionality.

From what I understand there is a lot going on here, first of IEnumerable has an ambiguous overload and requires a type annotation to explicitly isolate which IEnumerable you are talking about.

But then there can be issues with unit as well requiring additional help:

type blah =
class
    interface int seq seq with
        member self.GetEnumerator () : System.Collections.Generic.IEnumerable<System.Collections.Generic.IEnumerable<(int*int)>> =
                seq{ for i = 0 to 10 do
                        yield seq { for j=0 to 10 do
                                        yield (i,j)} }
end

Is there some way of getting the above code to work as intended(return a seq<seq<int>>) or am I missing something fundamental?

Well for one thing, GetEnumerator() is supposed to return IEnumerator<T> not IEnumerable<T>...

This will get your sample code to compile.

type blah =
    interface seq<seq<(int * int)>> with
        member self.GetEnumerator () =
            (seq { for i = 0 to 10 do
                    yield seq { for j=0 to 10 do
                                    yield (i,j)} }).GetEnumerator()
    interface System.Collections.IEnumerable with
        member self.GetEnumerator () =
            (self :> seq<seq<(int * int)>>).GetEnumerator() :> System.Collections.IEnumerator

How about:

let toSeqOfSeq (array:array<array<_>>) = array |> Seq.map (fun x -> x :> seq<_>)

But this works with an array of arrays, not a two-dimensional array. Which do you want?

What are you really out to do? A seq of seqs is rarely useful. All collections are seqs, so you can just use an array of arrays, a la

let myArrayOfArrays = [|
    for i = 0 to 9 do
        yield [|
            for j = 0 to 9 do
                yield (i,j)
            |]
    |]

let sumAllProds = myArrayOfArrays |> Seq.fold (fun st a ->
                             st + (a |> Seq.fold (fun st (x,y) -> st + x*y) 0) ) 0
printfn "%d" sumAllProds

if that helps...

   module Array2D =
      // Converts 2D array 'T[,] into seq<seq<'T>>  
      let toSeq (arr : 'T [,]) =
         let f1,f2 = Array2D.base1 arr , Array2D.base2 arr
         let t1,t2 = Array2D.length1 arr - f1 - 1 , Array2D.length2 arr - f2 - 1
         seq {
           for i in f1 .. t1 do
              yield seq {
                 for j in f2 .. t2 do
                    yield Array2D.get arr i j }}

    let myArray2D : string[,] = array2D [["a1"; "b1"; "c1"]; ["a2"; "b2"; "c2"]]

    printf "%A" (Array2D.toSeq myArray2D)