Perché la comprensione delle liste Haskell con più generatori considera il generatore più a destra come il ciclo più stretto?

Question

Sto leggendo il Gentle Introduction e mi sto chiedendo perché in una lista di comprensione con due generatori, il generatore più a destra è iterato "il più veloce" (cioè compila il ciclo più interno, immagino). Osservare il seguente output GHCi:

*Main> concat [[(x,y) | x <- [0..2]] | y <- [0..2]] 
[(0,0),(1,0),(2,0),(0,1),(1,1),(2,1),(0,2),(1,2),(2,2)] 
*Main> [(x,y) | x <- [0..2], y <- [0..2]] 
[(0,0),(0,1),(0,2),(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)] 

Se il generatore più a sinistra sono stati iterata più veloce, queste due espressioni avrebbero lo stesso valore, che a mio avviso rende la scelta di questa convenzione più naturale in qualche modo.

Così qualcuno sa perché è stata scelta la convenzione opposta? Ho notato che Python ha la stessa convenzione di Haskell (forse l'ha anche preso in prestito da Haskell?), E nel mondo Python the word sembra che l'ordine sia stato scelto "perché è l'ordine in cui si scrive un ciclo for", ma io Raccogliere che pensare in termini di cicli for non è esattamente ciò che la maggior parte dei programmatori Haskell fa ...

Pensieri?

---

Dal mio commento sulla risposta di Louis Wasserman di seguito:

immagino qui l'ordine corrispondente ad una spiegazione imperativo stile della comprensione è stato considerato più naturale di averlo corrisponde nidificazione lista. Quindi in sostanza la spiegazione di Haskell per questo è la stessa della spiegazione Python che ho inserito nella domanda, dopotutto, sembra.

Answer 1

Così che le cose vanno bene.

[(x, y) | x <- [1..10], y <- [1..x]] 

ha un senso - x è portata per la comprensione su y - ma

[(x, y) | y <- [1..x], x <- [1..10]] 

rende un po 'meno senso.

Inoltre, in questo modo è coerente con la sintassi do monade:

do x <- [1..10] 
    y <- [1..x] 
    return (x, y) 

Answer 2

realtà Python utilizza la stessa struttura portata di Haskell per list comprehension.

Confronta il tuo Haskell:

*Main> concat [[(x,y) | x <- [0..2]] | y <- [0..2]] 
[(0,0),(1,0),(2,0),(0,1),(1,1),(2,1),(0,2),(1,2),(2,2)] 
*Main> [(x,y) | x <- [0..2], y <- [0..2]] 
[(0,0),(0,1),(0,2),(1,0),(1,1),(1,2),(2,0),(2,1),(2,2)] 

con questo Python:

>>> from itertools import chain 
>>> list(chain(*[[(x,y) for x in range(3)] for y in range(3)])) 
[(0, 0), (1, 0), (2, 0), (0, 1), (1, 1), (2, 1), (0, 2), (1, 2), (2, 2)] 
>>> [(x,y) for x in range(3) for y in range(3)] 
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)] 
>>> 

Answer 3

può rendere più senso se si espande al di lista prima in do notazione e poi in lega monadici.Diciamo che vogliamo scrivere la comprensione in cui ci si riferisce di nuovo a nomi che sono già vincolati:

[ (x,y) | x <- [1,2,3], y <- [x+1,x+2] ] 

Questo si espande per

do x <- [1,2,3] 
    y <- [x+1,x+2] 
    return (x,y) 

che si espande a

[1,2,3] >>= \x -> 
[x+1,x+2] >>= \y -> 
return (x,y) 

che mette in chiaro che x è nello scope esattamente quando deve essere.

Se l'espansione in do notazione è accaduto da destra a sinistra invece che da sinistra a destra, allora la nostra espressione originale si espanderebbe in

[x+1,x+2] >>= \y -> 
[1,2,3] >>= \x -> 
return (x,y) 

che è chiaramente priva di senso - si riferisce al valore della x in un ambito in cui x non è ancora associato. Così avremmo dovuto scrivere la nostra comprensione originale come

[ (x,y) | y <- [x+1,x+2], x <- [1,2,3] ] 

per ottenere il risultato che volevamo, che sembra innaturale - al momento le scansioni degli occhi oltre la frase y <- [x+1,x+2] in realtà non sanno che cosa è x. Dovresti leggere la comprensione all'indietro per scoprirlo.

Quindi che sarebbe non aveva bisogno essere il caso che il più a destra legame è srotolato nel "ciclo interno", ma ha senso se si considera che gli umani stanno per avere a leggere il codice risultante .