Tại sao tính năng hiểu danh sách Haskell với nhiều máy phát điện xử lý máy phát điện ngoài cùng bên phải là vòng lặp chặt chẽ nhất?

Question

Tôi đang đọc qua số Gentle Introduction và tự hỏi tại sao trong danh sách hiểu với hai trình tạo, trình tạo đúng bên phải được lặp lại "nhanh nhất" (tức là biên dịch đến vòng lặp trong cùng, tôi đoán). Quan sát đầu ra GHCi sau:

*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)] 

Nếu máy phát điện tận cùng bên trái được lặp nhanh nhất, hai biểu thức trên sẽ có giá trị như nhau, mà tôi nghĩ rằng làm cho việc lựa chọn Công ước này tự nhiên hơn bằng cách nào đó.

Vì vậy, có ai biết tại sao quy ước ngược lại đã được chọn không? Tôi nhận thấy Python có cùng quy ước như Haskell (thậm chí có thể mượn nó từ Haskell?), Và trong thế giới Python the word có vẻ là thứ tự đã được chọn "bởi vì đó là thứ tự bạn muốn viết vòng lặp", nhưng tôi thu thập suy nghĩ đó về vòng lặp không phải là chính xác những gì hầu hết các lập trình viên Haskell làm ...

Suy nghĩ?

---

Từ nhận xét của tôi về câu trả lời Louis Wasserman của dưới đây:

Tôi đoán đây thứ tự tương ứng với một sự giải thích bắt buộc giữa các đồng chí hiểu được coi là tự nhiên hơn có nó tương ứng với làm tổ trong danh sách. Vì vậy, trong bản chất giải thích Haskell cho điều này là giống như lời giải thích Python tôi liên kết trong câu hỏi, sau khi tất cả, có vẻ như.

Answer 1

Vì vậy, mọi thứ đều theo một cách lành mạnh.

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

làm cho tinh thần - x là trong phạm vi cho sự hiểu biết về y - nhưng

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

làm cho hơi ít ý nghĩa.

Thêm vào đó, cách này đó là phù hợp với cú pháp do đơn nguyên:

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

Answer 2

Trên thực tế Python sử dụng cấu trúc phạm vi tương tự như Haskell cho comprehensions danh sách.

Hãy so sánh Haskell của bạn:

*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)] 

với Python này:

>>> 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

Nó có thể có ý nghĩa hơn nếu bạn mở rộng danh sách hiểu biết đầu tiên vào do ký hiệu và sau đó vào với phím tắt monadic.Hãy nói rằng chúng tôi muốn viết một sự hiểu biết mà chúng ta xem lại tên được đã bị ràng buộc:

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

này mở rộng để

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

mà mở rộng để

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

mà làm cho nó rõ ràng rằng x nằm trong phạm vi chính xác khi cần.

Nếu việc mở rộng thành do ký hiệu đã xảy ra từ phải sang trái thay vì từ trái sang phải, sau đó biểu hiện ban đầu của chúng tôi sẽ mở rộng sang

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

đó rõ ràng là vô nghĩa - nó đề cập đến giá trị của x trong phạm vi mà x chưa bị ràng buộc. Vì vậy, chúng tôi phải viết hiểu biết ban đầu của chúng tôi như

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

để có được những kết quả chúng tôi muốn, mà có vẻ không tự nhiên - vào thời điểm đó quét mắt qua các cụm từ y <- [x+1,x+2] bạn không thực sự biết x là gì. Bạn sẽ phải đọc hiểu ngược để tìm hiểu.

Vì vậy, nó không phải cần là trường hợp liên kết bên phải nhất được bỏ vào "vòng lặp bên trong" nhưng nó có ý nghĩa khi bạn xem xét rằng con người sẽ phải đọc mã kết quả .