Gibt es eine Kurzform für die Konstruktion eines 2D-Arrays?

Question

Gibt es eine Kurzschriftmethode zum Erstellen eines 2D-Arrays?

ich wirklich nicht wollen, folgendes tun:

let board = array2D [| 
         [| 0;0 |] 
         [| 0;1 |] 
         [| 0;2 |] 
         [| 0;3 |] 
         [| 0;4 |] 
         [| 0;5 |] 
         [| 0;6 |] 
         [| 0;7 |] 
         [| 1;0 |] 
         [| 1;1 |] 
         [| 1;2 |] 
         ... 
         [| 7;7 |] 
        |] 

Ich dachte, ich etwas tun könnte:

let board = array2D [| 
         [| 0;0 |]..[|7;7|] 
        |] 

Oder diese:

let board = array2D [| 
         [| 0.., 0..7 |] 
        |] 

Jede mögliche Anleitung ?

Answer 1

Vielleicht haben Sie was brauchen, ist ein Verständnis:

array2D [for i in 0..7 do for j in 0..7 do yield [|i;j|] ] 

Das gibt was, was Sie in der gewünschten Reihenfolge wollen zu sein scheint:

val it : int [,] = [[0; 0] 
        [0; 1] 
        [0; 2] 
        [0; 3] 
        [0; 4] 
        [0; 5] 
        [0; 6] 
        [0; 7] 
        [1; 0] 
        [1; 1] 
        [1; 2] 
        [1; 3] 
        [1; 4] 
        [1; 5] 
        [1; 6] 
        [1; 7] 
        [2; 0] 
        [2; 1] 
        [2; 2] 
        [2; 3] 
        [2; 4] 
        [2; 5] 
        [2; 6] 
        [2; 7] 
        [3; 0] 
        [3; 1] 
        [3; 2] 
        [3; 3] 
        [3; 4] 
        [3; 5] 
        [3; 6] 
        [3; 7] 
        [4; 0] 
        [4; 1] 
        [4; 2] 
        [4; 3] 
        [4; 4] 
        [4; 5] 
        [4; 6] 
        [4; 7] 
        [5; 0] 
        [5; 1] 
        [5; 2] 
        [5; 3] 
        [5; 4] 
        [5; 5] 
        [5; 6] 
        [5; 7] 
        [6; 0] 
        [6; 1] 
        [6; 2] 
        [6; 3] 
        [6; 4] 
        [6; 5] 
        [6; 6] 
        [6; 7] 
        [7; 0] 
        [7; 1] 
        [7; 2] 
        [7; 3] 
        [7; 4] 
        [7; 5] 
        [7; 6] 
        [7; 7]] 

Answer 2

Ringils Antwort ist richtiger (für das, was Sie gefragt haben). wenn Sie für eine andere Art und Weise mit einer etwas anderen Array Form suchen, können Sie jedoch Folgendes tun:

können Sie verwenden Array2D.init:

> let board = Array2D.init 8 8 (fun x y -> (x,y));; 

val board : (int * int) [,] = 
    [[(0, 0); (0, 1); (0, 2); (0, 3); (0, 4); (0, 5); (0, 6); (0, 7)] 
    [(1, 0); (1, 1); (1, 2); (1, 3); (1, 4); (1, 5); (1, 6); (1, 7)] 
    [(2, 0); (2, 1); (2, 2); (2, 3); (2, 4); (2, 5); (2, 6); (2, 7)] 
    [(3, 0); (3, 1); (3, 2); (3, 3); (3, 4); (3, 5); (3, 6); (3, 7)] 
    [(4, 0); (4, 1); (4, 2); (4, 3); (4, 4); (4, 5); (4, 6); (4, 7)] 
    [(5, 0); (5, 1); (5, 2); (5, 3); (5, 4); (5, 5); (5, 6); (5, 7)] 
    [(6, 0); (6, 1); (6, 2); (6, 3); (6, 4); (6, 5); (6, 6); (6, 7)] 
    [(7, 0); (7, 1); (7, 2); (7, 3); (7, 4); (7, 5); (7, 6); (7, 7)]] 

Ich werde dies hier jemand im Fall verlassen findet es sinnvoll, , da ich denke, dass diese Datenform in vielen Fällen sinnvoll ist.