Comparison of Haskell and Julia List Comprehensions(blog.lojic.com)

  (1⌷⊢){⍺/⍵}⍨⊣=0⌷⊢

    [
       let y = x + 1
         z = 2y
         -z
       end 
       for x in 1:5
    ]

  for xs in xss:
      for x in xs:
          x

  [for xs in xss for x in xs : x]

  [x | xs <- xss, x <- xs]

  do { xs <- xss; x <- xs; return x }

  x, such as x is in xs, xs is in xss

  x | x ∈ xs, xs ∈ xss # my math is rusty
 
  [x | x <- xs, xs <- xss] # haskell, erlang is isimilar

  [ x for xs in xss for x in xs ] # python, julia, order might be different

  [ X || X <- Xs, Xs <- Xss]

  [ z for x in range(1,6) for y in [x+1] for z in [2*y] for z in [-z] ]

    for xs in xss:
        for x in xs:
            ...

  data Matrix a = Matrix
    { matrixDimensions :: [Int]
    , matrixCells :: [a]
    } deriving (Show)

  fromList :: [a] -> Matrix a
  fromList xs = Matrix [length xs] xs

  instance Functor Matrix where
    fmap f (Matrix dims xs) = Matrix dims $ fmap f xs

  instance Applicative Matrix where
    pure x = Matrix [] [x]
    Matrix fds fs <*> Matrix xds xs =
      Matrix (fds ++ xds) (fs <*> xs)

  instance Monad Matrix where
    Matrix ds xs >>= f = Matrix (ds ++ rds) rs
      where
        Matrix rds rs = case f <$> xs of
          [] -> Matrix [] []
          ms@(Matrix frds _:_) ->
            Matrix frds (concat $ matrixCells <$> ms)


  ghci> [(x, y) | x <- fromList [1..3], y <- fromList [2..5] ]
  Matrix {matrixDimensions = [3,4], matrixCells = [(1,2),(1,3),(1,4),(1,5),(2,2),(2,3),(2,4),(2,5),(3,2),(3,3),(3,4),(3,5)]}

  julia> [ (x,y) for x in 1:3, y in 1:x ]
  ERROR: UndefVarError: x not defined
  Stacktrace:
   [1] top-level scope
     @ REPL[1]:1

  julia> [ (x,y) for x in 1:y, y in 1:3 ]
  ERROR: UndefVarError: y not defined
  Stacktrace:
   [1] top-level scope
     @ REPL[2]:1

    [ $_² for 1..5 ]

  do .² for 1…5

  (1…5)»²