gistfile1.txt

Prelude> :set -XMonadComprehensions
Prelude> take 10 [x^2 | x <- [1..]]

==================== Desugared ====================
let {
  $dEnum_a3oz :: GHC.Enum.Enum GHC.Integer.Type.Integer
  [LclId]
  $dEnum_a3oz = GHC.Enum.$fEnumInteger } in
let {
  $dNum_a3oy :: GHC.Num.Num GHC.Integer.Type.Integer
  [LclId]
  $dNum_a3oy = GHC.Num.$fNumInteger } in
let {
  $dShow_a3oB :: GHC.Show.Show GHC.Integer.Type.Integer
  [LclId]
  $dShow_a3oB = GHC.Show.$fShowInteger } in
let {
  $dShow_a3ow :: GHC.Show.Show [GHC.Integer.Type.Integer]
  [LclId]
  $dShow_a3ow
    = GHC.Show.$fShow[] @ GHC.Integer.Type.Integer $dShow_a3oB } in
letrec {
  it_a3kk :: forall a. (GHC.Num.Num a, GHC.Enum.Enum a) => [a]
  [LclId]
  it_a3kk
    = \ (@ a_a3nL)
        ($dNum_a3of :: GHC.Num.Num a_a3nL)
        ($dEnum_a3og :: GHC.Enum.Enum a_a3nL) ->
        let {
          $dNum_a3oa :: GHC.Num.Num GHC.Integer.Type.Integer
          [LclId]
          $dNum_a3oa = $dNum_a3oy } in
        let {
          $dIntegral_a3o6 :: GHC.Real.Integral GHC.Integer.Type.Integer
          [LclId]
          $dIntegral_a3o6 = GHC.Real.$fIntegralInteger } in
        let {
          $dEnum_a3nX :: GHC.Enum.Enum a_a3nL
          [LclId]
          $dEnum_a3nX = $dEnum_a3og } in
        let {
          $dNum_a3nW :: GHC.Num.Num a_a3nL
          [LclId]
          $dNum_a3nW = $dNum_a3of } in
        let {
          $dNum_a3o5 :: GHC.Num.Num a_a3nL
          [LclId]
          $dNum_a3o5 = $dNum_a3nW } in
        let {
          $dMonad_a3nP :: GHC.Base.Monad []
          [LclId]
          $dMonad_a3nP = GHC.Base.$fMonad[] } in
        let {
          $dMonad_a3o1 :: GHC.Base.Monad []
          [LclId]
          $dMonad_a3o1 = $dMonad_a3nP } in
        letrec {
          it_a3od :: [a_a3nL]
          [LclId]
          it_a3od
            = GHC.List.take
                @ a_a3nL
                (GHC.Types.I# 10#)
                (GHC.Base.>>=
                   @ []
                   $dMonad_a3nP
                   @ a_a3nL
                   @ a_a3nL
                   (GHC.Enum.enumFrom
                      @ a_a3nL $dEnum_a3nX (GHC.Num.fromInteger @ a_a3nL $dNum_a3nW 1))
                   (\ (x_a3ki :: a_a3nL) ->
                      GHC.Base.return
                        @ []
                        $dMonad_a3o1
                        @ a_a3nL
                        (GHC.Real.^
                           @ a_a3nL
                           @ GHC.Integer.Type.Integer
                           $dNum_a3o5
                           $dIntegral_a3o6
                           x_a3ki
                           2))); } in
        it_a3od; } in
GHC.Base.thenIO
  @ ()
  @ [()]
  (System.IO.print
     @ [GHC.Integer.Type.Integer]
     $dShow_a3ow
     (it_a3kk @ GHC.Integer.Type.Integer $dNum_a3oy $dEnum_a3oz))
  (GHC.Base.returnIO
     @ [()]
     (GHC.Types.:
        @ ()
        (GHC.Prim.unsafeCoerce#
           @ 'GHC.Types.LiftedRep
           @ 'GHC.Types.LiftedRep
           @ (forall a. (GHC.Num.Num a, GHC.Enum.Enum a) => [a])
           @ ()
           it_a3kk)
        (GHC.Types.[] @ ())))

        letrec {
it_a3od = GHC.List.take
                (GHC.Types.I# 10#)
                (GHC.Base.>>=
                   (GHC.Enum.enumFrom
                      (GHC.Num.fromInteger 1))
                   (\ (x_a3ki) ->
                      GHC.Base.return
                        (GHC.Real.^
                           x_a3ki
                           2))); } in ...

let { a = take 10 ((>>=) (enumFrom 1) (\ b -> return ((^) b 2))) } in a