Skip to content

Instantly share code, notes, and snippets.

@osa1

osa1/Main.dump-stg

Created June 6, 2016 08:21
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save osa1/ef41506079e3e60abe289d09e078ea5a to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save osa1/ef41506079e3e60abe289d09e078ea5a to your computer and use it in GitHub Desktop.
Download ZIP
Raw
Main.dump-stg
==================== STG syntax: ====================
2016-06-06 08:13:50.663576479 UTC
Main.$WCons [InlPrag=INLINE]
:: forall a_art. a_art -> Main.List a_art -> Main.List a_art
[GblId[DataConWrapper],
Arity=2,
Caf=NoCafRefs,
Str=DmdType <S,U><S,U>m1,
Unf=OtherCon []] =
\r srt:SRT:[] [dt_s6tR dt_s6tS]
case dt_s6tR of dt_s6tT {
__DEFAULT ->
case dt_s6tS of dt_s6tU {
__DEFAULT -> Main.Cons [dt_s6tT dt_s6tU];
};
};
Main.main2 :: Text.ParserCombinators.ReadP.P GHC.Types.Int
[GblId, Str=DmdType] =
\u srt:SRT:[rb :-> GHC.Read.$fReadInt_$sconvertInt,
rc :-> GHC.Read.$fReadInt3] []
GHC.Read.$fReadInt3
GHC.Read.$fReadInt_$sconvertInt
Text.ParserCombinators.ReadPrec.minPrec
Text.ParserCombinators.ReadP.$fApplicativeP_$cpure;
lvl1_r6tI :: GHC.Base.Maybe GHC.Types.Int -> GHC.Base.String
[GblId, Arity=1, Str=DmdType <S,1*U>, Unf=OtherCon []] =
\r srt:SRT:[r13 :-> GHC.Show.$fShowMaybe1,
r19 :-> GHC.Show.$fShowMaybe3] [x_s6tV]
case x_s6tV of _ [Occ=Dead] {
GHC.Base.Nothing -> GHC.Show.$fShowMaybe3;
GHC.Base.Just b1_s6tX [Occ=Once!] ->
let {
sat_s6u3 [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] []
case b1_s6tX of _ [Occ=Dead] {
GHC.Types.I# ww3_s6tZ [Occ=Once] ->
case
GHC.Show.$wshowSignedInt 11# ww3_s6tZ GHC.Types.[]
of
_ [Occ=Dead]
{ (#,#) ww5_s6u1 [Occ=Once] ww6_s6u2 [Occ=Once] ->
: [ww5_s6u1 ww6_s6u2];
};
};
} in GHC.Base.++ GHC.Show.$fShowMaybe1 sat_s6u3;
};
lvl2_r6tJ
:: GHC.Types.Int -> GHC.Base.Maybe GHC.Types.Int -> GHC.Show.ShowS
[GblId, Arity=2, Str=DmdType, Unf=OtherCon []] =
\r srt:SRT:[rN :-> GHC.Show.$fShowMaybe_$cshowsPrec] [eta_B2
eta_B1]
GHC.Show.$fShowMaybe_$cshowsPrec GHC.Show.$fShowInt eta_B2 eta_B1;
lvl3_r6tK :: GHC.Base.Maybe GHC.Types.Int -> GHC.Show.ShowS
[GblId, Arity=1, Str=DmdType, Unf=OtherCon []] =
\r srt:SRT:[rN :-> GHC.Show.$fShowMaybe_$cshowsPrec] [eta_B1]
GHC.Show.$fShowMaybe_$cshowsPrec
GHC.Show.$fShowInt GHC.Show.shows22 eta_B1;
Main.$s$fShowMaybe_$s$fShowMaybe_$cshowList
:: [GHC.Base.Maybe GHC.Types.Int] -> GHC.Show.ShowS
[GblId, Arity=2, Str=DmdType <S,1*U><L,U>, Unf=OtherCon []] =
\r srt:SRT:[r6tK :-> lvl3_r6tK] [eta_s6u4 eta1_s6u5]
GHC.Show.showList__ lvl3_r6tK eta_s6u4 eta1_s6u5;
Main.$s$fShowMaybe [InlPrag=[ALWAYS] CONLIKE]
:: GHC.Show.Show (GHC.Base.Maybe GHC.Types.Int)
[GblId, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Show.C:Show! [lvl2_r6tJ
lvl1_r6tI
Main.$s$fShowMaybe_$s$fShowMaybe_$cshowList];
lvl4_r6tL :: [GHC.Types.Char]
[GblId, Str=DmdType] =
\u srt:SRT:[] [] GHC.CString.unpackCString# "Nil"#;
lvl5_r6tM :: GHC.Show.ShowS
[GblId, Arity=1, Str=DmdType, Unf=OtherCon []] =
\r srt:SRT:[r6tL :-> lvl4_r6tL] [eta_B1]
GHC.Base.++ lvl4_r6tL eta_B1;
lvl6_r6tN :: [GHC.Types.Char]
[GblId, Str=DmdType] =
\u srt:SRT:[] [] GHC.CString.unpackCString# "Cons "#;
Main.$fShowItem4 :: [GHC.Types.Char]
[GblId, Caf=NoCafRefs, Str=DmdType, Unf=OtherCon []] =
NO_CCS :! [GHC.Show.shows6 GHC.Types.[]];
Main.$fShowItem5 :: [GHC.Types.Char]
[GblId, Str=DmdType] =
\u srt:SRT:[r19 :-> GHC.Show.$fShowMaybe3] []
GHC.Base.++ GHC.Show.$fShowMaybe3 GHC.Types.[];
Main.$fShowItem3 :: GHC.Types.Int
[GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Types.I#! [11#];
Main.$fShowList_$s$cshowsPrec [Occ=LoopBreaker]
:: Main.List (Main.Item GHC.Types.Int)
-> GHC.Prim.Int#
-> GHC.Show.Show (Main.Item GHC.Types.Int) => GHC.Show.ShowS
[GblId,
Arity=3,
Str=DmdType <S,1*U><L,U><L,U(C(C1(U)),A,A)>,
Unf=OtherCon []] =
\r srt:SRT:[rh :-> Main.$fShowList_$s$cshowsPrec,
r6tM :-> lvl5_r6tM, r6tN :-> lvl6_r6tN] [sc_s6u6 sc1_s6u7 sc2_s6u8]
case sc_s6u6 of _ [Occ=Dead] {
Main.Cons b1_s6ua [Occ=Once] b2_s6ub [Occ=Once] ->
let {
f_s6uc [Occ=OnceL*!, Dmd=<L,C(U)>]
:: GHC.Base.String -> GHC.Base.String
[LclId, Str=DmdType] =
\u srt:SRT:[] []
GHC.Show.showsPrec sc2_s6u8 Main.$fShowItem3 b1_s6ua; } in
let {
g_s6ud [Occ=OnceL*!, Dmd=<L,C(U)>]
:: GHC.Base.String -> GHC.Base.String
[LclId, Str=DmdType] =
\u srt:SRT:[rh :-> Main.$fShowList_$s$cshowsPrec] []
Main.$fShowList_$s$cshowsPrec b2_s6ub 11# sc2_s6u8;
} in
case >=# [sc1_s6u7 11#] of sat_s6ue {
__DEFAULT ->
case tagToEnum# [sat_s6ue] of _ [Occ=Dead] {
GHC.Types.False ->
let {
sat_s6uk [Occ=Once] :: GHC.Base.String -> [GHC.Types.Char]
[LclId, Str=DmdType] =
\r srt:SRT:[r6tN :-> lvl6_r6tN] [x_s6ug]
let {
sat_s6uj [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] []
let {
sat_s6uh [Occ=Once] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\u srt:SRT:[] [] g_s6ud x_s6ug; } in
let {
sat_s6ui [Occ=Once] :: GHC.Base.String
[LclId, Str=DmdType] =
NO_CCS :! [GHC.Show.showSpace1 sat_s6uh];
} in f_s6uc sat_s6ui;
} in GHC.Base.++ lvl6_r6tN sat_s6uj;
} in sat_s6uk;
GHC.Types.True ->
let {
sat_s6ur [Occ=Once] :: GHC.Base.String -> [GHC.Types.Char]
[LclId, Str=DmdType] =
\r srt:SRT:[r6tN :-> lvl6_r6tN] [x_s6ul]
let {
sat_s6uq [Occ=Once] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\u srt:SRT:[r6tN :-> lvl6_r6tN] []
let {
sat_s6up [Occ=Once, Dmd=<L,1*U>]
:: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] []
let {
sat_s6un [Occ=Once] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\u srt:SRT:[] []
let {
sat_s6um [Occ=Once]
:: GHC.Base.String
[LclId, Str=DmdType] =
NO_CCS :! [GHC.Show.shows6
x_s6ul];
} in g_s6ud sat_s6um; } in
let {
sat_s6uo [Occ=Once] :: GHC.Base.String
[LclId, Str=DmdType] =
NO_CCS :! [GHC.Show.showSpace1
sat_s6un];
} in f_s6uc sat_s6uo;
} in GHC.Base.++ lvl6_r6tN sat_s6up;
} in : [GHC.Show.shows9 sat_s6uq];
} in sat_s6ur;
};
};
Main.Nil -> lvl5_r6tM;
};
Main.$fShowList_$cshowsPrec [Occ=LoopBreaker]
:: forall a_a2wy.
GHC.Show.Show a_a2wy =>
GHC.Types.Int -> Main.List a_a2wy -> GHC.Show.ShowS
[GblId,
Arity=3,
Str=DmdType <L,U(C(C1(U)),A,A)><L,1*U(U)><S,1*U>,
Unf=OtherCon []] =
\r srt:SRT:[rR :-> Main.$fShowList_$cshowsPrec, r6tM :-> lvl5_r6tM,
r6tN :-> lvl6_r6tN] [$dShow_s6us a1_s6ut ds_s6uu]
case ds_s6uu of _ [Occ=Dead] {
Main.Cons b1_s6uw [Occ=Once] b2_s6ux [Occ=Once] ->
case a1_s6ut of _ [Occ=Dead] {
GHC.Types.I# x_s6uz [Occ=Once] ->
let {
f_s6uA [Occ=OnceL*!, Dmd=<L,C(U)>]
:: GHC.Base.String -> GHC.Base.String
[LclId, Str=DmdType] =
\u srt:SRT:[] []
GHC.Show.showsPrec $dShow_s6us Main.$fShowItem3 b1_s6uw; } in
let {
g_s6uB [Occ=OnceL*!, Dmd=<L,C(U)>]
:: GHC.Base.String -> GHC.Base.String
[LclId, Str=DmdType] =
\u srt:SRT:[rR :-> Main.$fShowList_$cshowsPrec] []
Main.$fShowList_$cshowsPrec $dShow_s6us Main.$fShowItem3 b2_s6ux;
} in
case >=# [x_s6uz 11#] of sat_s6uC {
__DEFAULT ->
case tagToEnum# [sat_s6uC] of _ [Occ=Dead] {
GHC.Types.False ->
let {
sat_s6uI [Occ=Once] :: GHC.Base.String -> [GHC.Types.Char]
[LclId, Str=DmdType] =
\r srt:SRT:[r6tN :-> lvl6_r6tN] [x1_s6uE]
let {
sat_s6uH [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] []
let {
sat_s6uF [Occ=Once] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\u srt:SRT:[] [] g_s6uB x1_s6uE; } in
let {
sat_s6uG [Occ=Once] :: GHC.Base.String
[LclId, Str=DmdType] =
NO_CCS :! [GHC.Show.showSpace1
sat_s6uF];
} in f_s6uA sat_s6uG;
} in GHC.Base.++ lvl6_r6tN sat_s6uH;
} in sat_s6uI;
GHC.Types.True ->
let {
sat_s6uP [Occ=Once] :: GHC.Base.String -> [GHC.Types.Char]
[LclId, Str=DmdType] =
\r srt:SRT:[r6tN :-> lvl6_r6tN] [x1_s6uJ]
let {
sat_s6uO [Occ=Once] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\u srt:SRT:[r6tN :-> lvl6_r6tN] []
let {
sat_s6uN [Occ=Once, Dmd=<L,1*U>]
:: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] []
let {
sat_s6uL [Occ=Once]
:: [GHC.Types.Char]
[LclId, Str=DmdType] =
\u srt:SRT:[] []
let {
sat_s6uK [Occ=Once]
:: GHC.Base.String
[LclId, Str=DmdType] =
NO_CCS :! [GHC.Show.shows6
x1_s6uJ];
} in
g_s6uB sat_s6uK; } in
let {
sat_s6uM [Occ=Once]
:: GHC.Base.String
[LclId, Str=DmdType] =
NO_CCS :! [GHC.Show.showSpace1
sat_s6uL];
} in f_s6uA sat_s6uM;
} in GHC.Base.++ lvl6_r6tN sat_s6uN;
} in : [GHC.Show.shows9 sat_s6uO];
} in sat_s6uP;
};
};
};
Main.Nil -> lvl5_r6tM;
};
Main.$fShowList_$cshow
:: forall a_a2wy.
GHC.Show.Show a_a2wy =>
Main.List a_a2wy -> GHC.Base.String
[GblId,
Arity=2,
Str=DmdType <L,U(C(C1(U)),A,A)><S,1*U>,
Unf=OtherCon []] =
\r srt:SRT:[rR :-> Main.$fShowList_$cshowsPrec] [$dShow_s6uQ
x_s6uR]
Main.$fShowList_$cshowsPrec
$dShow_s6uQ GHC.Show.shows22 x_s6uR GHC.Types.[];
Main.$fShowItem2 :: [GHC.Types.Char]
[GblId, Str=DmdType] =
\u srt:SRT:[] [] GHC.CString.unpackCString# "Item "#;
Main.$w$s$cshowsPrec [InlPrag=[0]]
:: GHC.Prim.Int# -> Main.Item GHC.Types.Int -> GHC.Show.ShowS
[GblId, Arity=2, Str=DmdType <S,U><L,1*U>, Unf=OtherCon []] =
\r srt:SRT:[rN :-> GHC.Show.$fShowMaybe_$cshowsPrec,
r17 :-> Main.$fShowItem2] [ww_s6uS w_s6uT]
let {
g_s6uU [Occ=OnceL*!, Dmd=<L,C(U)>]
:: GHC.Base.String -> GHC.Base.String
[LclId, Str=DmdType] =
\u srt:SRT:[rN :-> GHC.Show.$fShowMaybe_$cshowsPrec] []
GHC.Show.$fShowMaybe_$cshowsPrec
GHC.Show.$fShowInt Main.$fShowItem3 w_s6uT;
} in
case >=# [ww_s6uS 11#] of sat_s6uV {
__DEFAULT ->
case tagToEnum# [sat_s6uV] of _ [Occ=Dead] {
GHC.Types.False ->
let {
sat_s6uZ [Occ=Once] :: GHC.Base.String -> [GHC.Types.Char]
[LclId, Str=DmdType] =
\r srt:SRT:[r17 :-> Main.$fShowItem2] [x_s6uX]
let {
sat_s6uY [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] [] g_s6uU x_s6uX;
} in GHC.Base.++ Main.$fShowItem2 sat_s6uY;
} in sat_s6uZ;
GHC.Types.True ->
let {
sat_s6v4 [Occ=Once] :: GHC.Base.String -> [GHC.Types.Char]
[LclId, Str=DmdType] =
\r srt:SRT:[r17 :-> Main.$fShowItem2] [x_s6v0]
let {
sat_s6v3 [Occ=Once] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\u srt:SRT:[r17 :-> Main.$fShowItem2] []
let {
sat_s6v2 [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] []
let {
sat_s6v1 [Occ=Once] :: GHC.Base.String
[LclId, Str=DmdType] =
NO_CCS :! [GHC.Show.shows6 x_s6v0];
} in g_s6uU sat_s6v1;
} in GHC.Base.++ Main.$fShowItem2 sat_s6v2;
} in : [GHC.Show.shows9 sat_s6v3];
} in sat_s6v4;
};
};
Main.$fShowItem_$s$cshowsPrec [InlPrag=INLINE[0]]
:: GHC.Types.Int -> Main.Item GHC.Types.Int -> GHC.Show.ShowS
[GblId,
Arity=2,
Str=DmdType <S(S),1*U(U)><L,1*U>,
Unf=OtherCon []] =
\r srt:SRT:[r1b :-> Main.$w$s$cshowsPrec] [w_s6v5 w1_s6v6]
case w_s6v5 of _ [Occ=Dead] {
GHC.Types.I# ww1_s6v8 [Occ=Once] ->
Main.$w$s$cshowsPrec ww1_s6v8 w1_s6v6;
};
Main.$fShowItem1 :: Main.Item GHC.Types.Int -> GHC.Show.ShowS
[GblId, Arity=1, Str=DmdType, Unf=OtherCon []] =
\r srt:SRT:[r1b :-> Main.$w$s$cshowsPrec] [w_s6v9]
Main.$w$s$cshowsPrec 0# w_s6v9;
Main.$fShowItem_$s$cshowList
:: [Main.Item GHC.Types.Int] -> GHC.Show.ShowS
[GblId, Arity=2, Str=DmdType <S,1*U><L,U>, Unf=OtherCon []] =
\r srt:SRT:[rV :-> Main.$fShowItem1] [eta_s6va eta1_s6vb]
GHC.Show.showList__ Main.$fShowItem1 eta_s6va eta1_s6vb;
Main.$fShowItem_$s$cshow
:: Main.Item GHC.Types.Int -> GHC.Base.String
[GblId, Arity=1, Str=DmdType <L,1*U>, Unf=OtherCon []] =
\r srt:SRT:[r13 :-> GHC.Show.$fShowMaybe1,
r15 :-> Main.$fShowItem5, r17 :-> Main.$fShowItem2] [x_s6vc]
let {
sat_s6vm [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[r13 :-> GHC.Show.$fShowMaybe1,
r15 :-> Main.$fShowItem5] []
case x_s6vc of _ [Occ=Dead] {
GHC.Base.Nothing -> Main.$fShowItem5;
GHC.Base.Just b1_s6ve [Occ=Once!] ->
let {
sat_s6vl [Occ=Once] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\u srt:SRT:[r13 :-> GHC.Show.$fShowMaybe1] []
let {
sat_s6vk [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] []
case b1_s6ve of _ [Occ=Dead] {
GHC.Types.I# ww3_s6vg [Occ=Once] ->
case
GHC.Show.$wshowSignedInt
11# ww3_s6vg Main.$fShowItem4
of
_ [Occ=Dead]
{ (#,#) ww5_s6vi [Occ=Once] ww6_s6vj [Occ=Once] ->
: [ww5_s6vi ww6_s6vj];
};
};
} in GHC.Base.++ GHC.Show.$fShowMaybe1 sat_s6vk;
} in : [GHC.Show.shows9 sat_s6vl];
};
} in GHC.Base.++ Main.$fShowItem2 sat_s6vm;
Main.$fShowItem_$s$fShowItem [InlPrag=[ALWAYS] CONLIKE]
:: GHC.Show.Show (Main.Item GHC.Types.Int)
[GblId, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Show.C:Show! [Main.$fShowItem_$s$cshowsPrec
Main.$fShowItem_$s$cshow
Main.$fShowItem_$s$cshowList];
Main.$w$cshowsPrec [InlPrag=[0]]
:: forall a_a2vM.
GHC.Show.Show a_a2vM =>
GHC.Prim.Int# -> Main.Item a_a2vM -> GHC.Show.ShowS
[GblId,
Arity=3,
Str=DmdType <L,1*U(1*C1(C1(U)),A,A)><S,U><L,1*U>,
Unf=OtherCon []] =
\r srt:SRT:[rN :-> GHC.Show.$fShowMaybe_$cshowsPrec,
r17 :-> Main.$fShowItem2] [w_s6vn ww_s6vo w1_s6vp]
let {
g_s6vq [Occ=OnceL*!, Dmd=<L,C(U)>]
:: GHC.Base.String -> GHC.Base.String
[LclId, Str=DmdType] =
\u srt:SRT:[rN :-> GHC.Show.$fShowMaybe_$cshowsPrec] []
GHC.Show.$fShowMaybe_$cshowsPrec w_s6vn Main.$fShowItem3 w1_s6vp;
} in
case >=# [ww_s6vo 11#] of sat_s6vr {
__DEFAULT ->
case tagToEnum# [sat_s6vr] of _ [Occ=Dead] {
GHC.Types.False ->
let {
sat_s6vv [Occ=Once] :: GHC.Base.String -> [GHC.Types.Char]
[LclId, Str=DmdType] =
\r srt:SRT:[r17 :-> Main.$fShowItem2] [x_s6vt]
let {
sat_s6vu [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] [] g_s6vq x_s6vt;
} in GHC.Base.++ Main.$fShowItem2 sat_s6vu;
} in sat_s6vv;
GHC.Types.True ->
let {
sat_s6vA [Occ=Once] :: GHC.Base.String -> [GHC.Types.Char]
[LclId, Str=DmdType] =
\r srt:SRT:[r17 :-> Main.$fShowItem2] [x_s6vw]
let {
sat_s6vz [Occ=Once] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\u srt:SRT:[r17 :-> Main.$fShowItem2] []
let {
sat_s6vy [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] []
let {
sat_s6vx [Occ=Once] :: GHC.Base.String
[LclId, Str=DmdType] =
NO_CCS :! [GHC.Show.shows6 x_s6vw];
} in g_s6vq sat_s6vx;
} in GHC.Base.++ Main.$fShowItem2 sat_s6vy;
} in : [GHC.Show.shows9 sat_s6vz];
} in sat_s6vA;
};
};
Main.$fShowItem_$cshowsPrec [InlPrag=INLINE[0]]
:: forall a_a2vM.
GHC.Show.Show a_a2vM =>
GHC.Types.Int -> Main.Item a_a2vM -> GHC.Show.ShowS
[GblId,
Arity=3,
Str=DmdType <L,1*U(1*C1(C1(U)),A,A)><S(S),1*U(U)><L,1*U>,
Unf=OtherCon []] =
\r srt:SRT:[rX :-> Main.$w$cshowsPrec] [w_s6vB w1_s6vC w2_s6vD]
case w1_s6vC of _ [Occ=Dead] {
GHC.Types.I# ww1_s6vF [Occ=Once] ->
Main.$w$cshowsPrec w_s6vB ww1_s6vF w2_s6vD;
};
Main.$fShowItem_$cshow
:: forall a_a2vM.
GHC.Show.Show a_a2vM =>
Main.Item a_a2vM -> GHC.Base.String
[GblId,
Arity=2,
Str=DmdType <L,1*U(1*C1(C1(C1(U))),A,A)><L,1*U>,
Unf=OtherCon []] =
\r srt:SRT:[r13 :-> GHC.Show.$fShowMaybe1,
r15 :-> Main.$fShowItem5, r17 :-> Main.$fShowItem2] [$dShow_s6vG
x_s6vH]
let {
sat_s6vM [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[r13 :-> GHC.Show.$fShowMaybe1,
r15 :-> Main.$fShowItem5] []
case x_s6vH of _ [Occ=Dead] {
GHC.Base.Nothing -> Main.$fShowItem5;
GHC.Base.Just b1_s6vJ [Occ=Once] ->
let {
sat_s6vL [Occ=Once] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\u srt:SRT:[r13 :-> GHC.Show.$fShowMaybe1] []
let {
sat_s6vK [Occ=Once, Dmd=<L,1*U>] :: [GHC.Types.Char]
[LclId, Str=DmdType] =
\s srt:SRT:[] []
GHC.Show.showsPrec
$dShow_s6vG
GHC.Show.appPrec1
b1_s6vJ
Main.$fShowItem4;
} in GHC.Base.++ GHC.Show.$fShowMaybe1 sat_s6vK;
} in : [GHC.Show.shows9 sat_s6vL];
};
} in GHC.Base.++ Main.$fShowItem2 sat_s6vM;
Main.$fShowItem6 :: GHC.Types.Int
[GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Types.I#! [0#];
Main.$fShowItem_$cshowList
:: forall a_a2vM.
GHC.Show.Show a_a2vM =>
[Main.Item a_a2vM] -> GHC.Show.ShowS
[GblId,
Arity=3,
Str=DmdType <L,U(C(C1(U)),A,A)><S,1*U><L,U>,
Unf=OtherCon []] =
\r srt:SRT:[rX :-> Main.$w$cshowsPrec] [$dShow_s6vN
eta_s6vO
eta1_s6vP]
let {
sat_s6vR [Occ=Once] :: Main.Item a_a2vM -> GHC.Show.ShowS
[LclId, Str=DmdType] =
\r srt:SRT:[rX :-> Main.$w$cshowsPrec] [w_s6vQ]
Main.$w$cshowsPrec $dShow_s6vN 0# w_s6vQ;
} in GHC.Show.showList__ sat_s6vR eta_s6vO eta1_s6vP;
Main.$fShowItem [InlPrag=[ALWAYS] CONLIKE]
:: forall a_a1dN.
GHC.Show.Show a_a1dN =>
GHC.Show.Show (Main.Item a_a1dN)
[GblId[DFunId],
Arity=1,
Str=DmdType <L,U(C(C1(U)),A,A)>m,
Unf=OtherCon []] =
\r srt:SRT:[r1d :-> Main.$fShowItem_$cshowList,
r1e :-> Main.$fShowItem_$cshow,
r1f :-> Main.$fShowItem_$cshowsPrec] [$dShow_s6vS]
let {
sat_s6vV [Occ=Once] :: [Main.Item a_a2vM] -> GHC.Show.ShowS
[LclId, Str=DmdType] =
\r srt:SRT:[r1d :-> Main.$fShowItem_$cshowList] [eta_B2 eta_B1]
Main.$fShowItem_$cshowList $dShow_s6vS eta_B2 eta_B1; } in
let {
sat_s6vU [Occ=Once] :: Main.Item a_a2vM -> GHC.Base.String
[LclId, Str=DmdType] =
\r srt:SRT:[r1e :-> Main.$fShowItem_$cshow] [eta_B1]
Main.$fShowItem_$cshow $dShow_s6vS eta_B1; } in
let {
sat_s6vT [Occ=Once]
:: GHC.Types.Int -> Main.Item a_a2vM -> GHC.Show.ShowS
[LclId, Str=DmdType] =
\r srt:SRT:[r1f :-> Main.$fShowItem_$cshowsPrec] [eta_B2 eta_B1]
Main.$fShowItem_$cshowsPrec $dShow_s6vS eta_B2 eta_B1;
} in GHC.Show.C:Show [sat_s6vT sat_s6vU sat_s6vV];
Main.$fShowList_$cshowList
:: forall a_a2wy.
GHC.Show.Show a_a2wy =>
[Main.List a_a2wy] -> GHC.Show.ShowS
[GblId,
Arity=3,
Str=DmdType <L,U(C(C1(U)),A,A)><S,1*U><L,U>,
Unf=OtherCon []] =
\r srt:SRT:[rR :-> Main.$fShowList_$cshowsPrec] [$dShow_s6vW
eta_s6vX
eta1_s6vY]
let {
sat_s6vZ [Occ=Once] :: Main.List a_a2wy -> GHC.Show.ShowS
[LclId, Str=DmdType] =
\r srt:SRT:[rR :-> Main.$fShowList_$cshowsPrec] [eta_B1]
Main.$fShowList_$cshowsPrec $dShow_s6vW Main.$fShowItem6 eta_B1;
} in GHC.Show.showList__ sat_s6vZ eta_s6vX eta1_s6vY;
Main.$fShowList [InlPrag=[ALWAYS] CONLIKE]
:: forall a_a1dO.
GHC.Show.Show a_a1dO =>
GHC.Show.Show (Main.List a_a1dO)
[GblId[DFunId],
Arity=1,
Str=DmdType <L,U(C(C1(U)),A,A)>m,
Unf=OtherCon []] =
\r srt:SRT:[rP :-> Main.$fShowList_$cshowList,
rQ :-> Main.$fShowList_$cshow,
rR :-> Main.$fShowList_$cshowsPrec] [$dShow_s6w0]
let {
sat_s6w3 [Occ=Once] :: [Main.List a_a2wy] -> GHC.Show.ShowS
[LclId, Str=DmdType] =
\r srt:SRT:[rP :-> Main.$fShowList_$cshowList] [eta_B2 eta_B1]
Main.$fShowList_$cshowList $dShow_s6w0 eta_B2 eta_B1; } in
let {
sat_s6w2 [Occ=Once] :: Main.List a_a2wy -> GHC.Base.String
[LclId, Str=DmdType] =
\r srt:SRT:[rQ :-> Main.$fShowList_$cshow] [eta_B1]
Main.$fShowList_$cshow $dShow_s6w0 eta_B1; } in
let {
sat_s6w1 [Occ=Once]
:: GHC.Types.Int -> Main.List a_a2wy -> GHC.Show.ShowS
[LclId, Str=DmdType] =
\r srt:SRT:[rR :-> Main.$fShowList_$cshowsPrec] [eta_B2 eta_B1]
Main.$fShowList_$cshowsPrec $dShow_s6w0 eta_B2 eta_B1;
} in GHC.Show.C:Show [sat_s6w1 sat_s6w2 sat_s6w3];
Main.$fFunctorList_$s$cfmap [Occ=LoopBreaker]
:: Main.List (GHC.Base.Maybe GHC.Types.Int)
-> ((GHC.Base.Maybe GHC.Types.Int
-> GHC.Base.Maybe GHC.Types.Int) :: *)
~R#
((GHC.Base.Maybe GHC.Types.Int -> Main.Item GHC.Types.Int) :: *) =>
Main.List (Main.Item GHC.Types.Int)
[GblId,
Arity=2,
Caf=NoCafRefs,
Str=DmdType <S,1*U><L,U>,
Unf=OtherCon []] =
\r srt:SRT:[] [sc_s6w4 sg0_s6sk]
case sc_s6w4 of _ [Occ=Dead] {
Main.Cons a1_s6w6 [Occ=Once] a2_s6w7 [Occ=Once] ->
case
Main.$fFunctorList_$s$cfmap a2_s6w7 GHC.Prim.coercionToken#
of
dt_s6w8
{ __DEFAULT -> Main.Cons [a1_s6w6 dt_s6w8];
};
Main.Nil -> Main.Nil [];
};
Main.$fFunctorList_$cfmap [Occ=LoopBreaker]
:: forall a_aOt b_aOu.
(a_aOt -> b_aOu) -> Main.List a_aOt -> Main.List b_aOu
[GblId,
Arity=2,
Caf=NoCafRefs,
Str=DmdType <L,C(U)><S,1*U>,
Unf=OtherCon []] =
\r srt:SRT:[] [f_s6w9 ds_s6wa]
case ds_s6wa of _ [Occ=Dead] {
Main.Cons a1_s6wc [Occ=Once] a2_s6wd [Occ=Once] ->
case f_s6w9 a1_s6wc of dt_s6we {
__DEFAULT ->
case Main.$fFunctorList_$cfmap f_s6w9 a2_s6wd of dt1_s6wf {
__DEFAULT -> Main.Cons [dt_s6we dt1_s6wf];
};
};
Main.Nil -> Main.Nil [];
};
Main.$fFunctorList_$c<$
:: forall a_aOv b_aOw. a_aOv -> Main.List b_aOw -> Main.List a_aOv
[GblId,
Arity=2,
Caf=NoCafRefs,
Str=DmdType <L,U><S,1*U>,
Unf=OtherCon []] =
\r srt:SRT:[] [eta_s6wg eta1_s6wh]
let {
sat_s6wj [Occ=Once] :: b_a3lu -> a_a3lt
[LclId, Str=DmdType] =
\r srt:SRT:[] [ds_s6wi] eta_s6wg;
} in Main.$fFunctorList_$cfmap sat_s6wj eta1_s6wh;
Main.$fFunctorList [InlPrag=[ALWAYS] CONLIKE]
:: GHC.Base.Functor Main.List
[GblId[DFunId], Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Base.C:Functor! [Main.$fFunctorList_$cfmap
Main.$fFunctorList_$c<$];
Main.maybeToItem1
:: forall a_a29W. GHC.Base.Maybe a_a29W -> GHC.Base.Maybe a_a29W
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S,1*U>,
Unf=OtherCon []] =
\r srt:SRT:[] [tpl_s6wk] tpl_s6wk;
Main.maybeToItem
:: forall a_aIy. GHC.Base.Maybe a_aIy -> Main.Item a_aIy
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S,1*U>,
Unf=OtherCon []] =
\r srt:SRT:[] [eta_B1] Main.maybeToItem1 eta_B1;
Main.$trModule2 :: GHC.Types.TrName
[GblId, Caf=NoCafRefs, Str=DmdType m1, Unf=OtherCon []] =
NO_CCS GHC.Types.TrNameS! ["main"#];
Main.$trModule1 :: GHC.Types.TrName
[GblId, Caf=NoCafRefs, Str=DmdType m1, Unf=OtherCon []] =
NO_CCS GHC.Types.TrNameS! ["Main"#];
Main.$trModule :: GHC.Types.Module
[GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Types.Module! [Main.$trModule2 Main.$trModule1];
Main.$tc'Item1 :: GHC.Types.TrName
[GblId, Caf=NoCafRefs, Str=DmdType m1, Unf=OtherCon []] =
NO_CCS GHC.Types.TrNameS! ["'Item"#];
Main.$tc'Item :: GHC.Types.TyCon
[GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Types.TyCon! [9403546597716412637##
4305456962569213254##
Main.$trModule
Main.$tc'Item1];
Main.$tcItem1 :: GHC.Types.TrName
[GblId, Caf=NoCafRefs, Str=DmdType m1, Unf=OtherCon []] =
NO_CCS GHC.Types.TrNameS! ["Item"#];
Main.$tcItem :: GHC.Types.TyCon
[GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Types.TyCon! [10616686856361203596##
7251075470827260331##
Main.$trModule
Main.$tcItem1];
Main.$tc'Nil1 :: GHC.Types.TrName
[GblId, Caf=NoCafRefs, Str=DmdType m1, Unf=OtherCon []] =
NO_CCS GHC.Types.TrNameS! ["'Nil"#];
Main.$tc'Nil :: GHC.Types.TyCon
[GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Types.TyCon! [16673662833419711035##
7628056425835309196##
Main.$trModule
Main.$tc'Nil1];
Main.$tc'Cons1 :: GHC.Types.TrName
[GblId, Caf=NoCafRefs, Str=DmdType m1, Unf=OtherCon []] =
NO_CCS GHC.Types.TrNameS! ["'Cons"#];
Main.$tc'Cons :: GHC.Types.TyCon
[GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Types.TyCon! [18207026349337875767##
15163872925107883080##
Main.$trModule
Main.$tc'Cons1];
Main.$tcList1 :: GHC.Types.TrName
[GblId, Caf=NoCafRefs, Str=DmdType m1, Unf=OtherCon []] =
NO_CCS GHC.Types.TrNameS! ["List"#];
Main.$tcList :: GHC.Types.TyCon
[GblId, Caf=NoCafRefs, Str=DmdType m, Unf=OtherCon []] =
NO_CCS GHC.Types.TyCon! [12354673840372940676##
2337390273253147553##
Main.$trModule
Main.$tcList1];
Main.$wmkList [InlPrag=[0], Occ=LoopBreaker]
:: GHC.Prim.Int# -> Main.List GHC.Types.Int
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S,U>,
Unf=OtherCon []] =
\r srt:SRT:[] [ww_s6wl]
case ww_s6wl of ds_s6wm {
__DEFAULT ->
case -# [ds_s6wm 1#] of sat_s6wn {
__DEFAULT ->
case Main.$wmkList sat_s6wn of dt_s6wo {
__DEFAULT ->
let {
sat_s6wp [Occ=Once] :: GHC.Types.Int
[LclId, Str=DmdType] =
NO_CCS GHC.Types.I#! [ds_s6wm];
} in Main.Cons [sat_s6wp dt_s6wo];
};
};
0# -> Main.Nil [];
};
Main.mkList [InlPrag=INLINE[0]]
:: GHC.Types.Int -> Main.List GHC.Types.Int
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S(S),1*U(U)>,
Unf=OtherCon []] =
\r srt:SRT:[] [w_s6wq]
case w_s6wq of _ [Occ=Dead] {
GHC.Types.I# ww1_s6ws [Occ=Once] -> Main.$wmkList ww1_s6ws;
};
Main.main1
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=1, Str=DmdType <S,U>, Unf=OtherCon []] =
\r srt:SRT:[re :-> System.IO.readIO2,
rf :-> Main.$fShowItem_$s$fShowItem,
rh :-> Main.$fShowList_$s$cshowsPrec, ri :-> Main.$s$fShowMaybe,
rj :-> GHC.IO.Handle.FD.stdout, rk :-> GHC.IO.Handle.Text.hPutStr2,
rm :-> System.IO.readIO5, ro :-> Main.main2,
rq :-> System.IO.readIO8, rs :-> GHC.IO.Handle.Text.hGetLine2,
rt :-> GHC.IO.Handle.FD.stdin, ru :-> GHC.IO.Handle.Text.hGetLine4,
rv :-> GHC.IO.Handle.Internals.wantReadableHandle_1,
rR :-> Main.$fShowList_$cshowsPrec] [s_s6wt]
case
GHC.IO.Handle.Internals.wantReadableHandle_1
GHC.IO.Handle.Text.hGetLine4
GHC.IO.Handle.FD.stdin
GHC.IO.Handle.Text.hGetLine2
s_s6wt
of
_ [Occ=Dead]
{ (#,#) ipv_s6wv [Occ=Once*] ipv1_s6ww [Occ=Once] ->
case
Text.ParserCombinators.ReadP.run Main.main2 ipv1_s6ww
of
sat_s6wx
{ __DEFAULT ->
case System.IO.readIO8 sat_s6wx of _ [Occ=Dead] {
[] -> raiseIO# [System.IO.readIO5 ipv_s6wv];
: x_s6wA [Occ=Once!] ds_s6wB [Occ=Once!] ->
case ds_s6wB of _ [Occ=Dead] {
[] ->
let {
lst_s6wD :: Main.List (GHC.Base.Maybe GHC.Types.Int)
[LclId, Str=DmdType] =
\u srt:SRT:[] []
case x_s6wA of _ [Occ=Dead] {
GHC.Types.I# ww1_s6wF [Occ=Once] ->
case Main.$wmkList ww1_s6wF of sat_s6wG {
__DEFAULT ->
Main.$fFunctorList_$cfmap
GHC.Base.Just sat_s6wG;
};
}; } in
let {
sat_s6wH [Occ=Once, Dmd=<L,1*U>] :: GHC.Base.String
[LclId, Str=DmdType] =
\s srt:SRT:[ri :-> Main.$s$fShowMaybe,
rR :-> Main.$fShowList_$cshowsPrec] []
Main.$fShowList_$cshowsPrec
Main.$s$fShowMaybe
GHC.Show.shows22
lst_s6wD
GHC.Types.[];
} in
case
GHC.IO.Handle.Text.hPutStr2
GHC.IO.Handle.FD.stdout sat_s6wH GHC.Types.True ipv_s6wv
of
_ [Occ=Dead]
{ (#,#) ipv2_s6wJ [Occ=Once] _ [Occ=Dead] ->
let {
sat_s6wM [Occ=Once, Dmd=<L,1*U>] :: GHC.Base.String
[LclId, Str=DmdType] =
\s srt:SRT:[ri :-> Main.$s$fShowMaybe,
rR :-> Main.$fShowList_$cshowsPrec] []
case
Main.$fFunctorList_$cfmap GHC.Base.id lst_s6wD
of
sat_s6wL
{ __DEFAULT ->
Main.$fShowList_$cshowsPrec
Main.$s$fShowMaybe
GHC.Show.shows22
sat_s6wL
GHC.Types.[];
};
} in
case
GHC.IO.Handle.Text.hPutStr2
GHC.IO.Handle.FD.stdout
sat_s6wM
GHC.Types.True
ipv2_s6wJ
of
_ [Occ=Dead]
{ (#,#) ipv4_s6wO [Occ=Once] _ [Occ=Dead] ->
let {
sat_s6wR [Occ=Once, Dmd=<L,1*U>]
:: GHC.Base.String
[LclId, Str=DmdType] =
\s srt:SRT:[rf :-> Main.$fShowItem_$s$fShowItem,
rh :-> Main.$fShowList_$s$cshowsPrec] []
case
Main.$fFunctorList_$s$cfmap
lst_s6wD GHC.Prim.coercionToken#
of
sat_s6wQ
{ __DEFAULT ->
Main.$fShowList_$s$cshowsPrec
sat_s6wQ
0#
Main.$fShowItem_$s$fShowItem
GHC.Types.[];
};
} in
GHC.IO.Handle.Text.hPutStr2
GHC.IO.Handle.FD.stdout
sat_s6wR
GHC.Types.True
ipv4_s6wO;
};
};
: _ [Occ=Dead] _ [Occ=Dead] ->
raiseIO# [System.IO.readIO2 ipv_s6wv];
};
};
};
};
Main.main :: GHC.Types.IO ()
[GblId, Arity=1, Str=DmdType <S,U>, Unf=OtherCon []] =
\r srt:SRT:[rx :-> Main.main1] [eta_B1] Main.main1 eta_B1;
Main.main3
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId, Arity=1, Str=DmdType, Unf=OtherCon []] =
\r srt:SRT:[r7 :-> GHC.TopHandler.runMainIO1,
rx :-> Main.main1] [eta_B1]
GHC.TopHandler.runMainIO1 Main.main1 eta_B1;
:Main.main :: GHC.Types.IO ()
[GblId, Arity=1, Str=DmdType, Unf=OtherCon []] =
\r srt:SRT:[r6tG :-> Main.main3] [eta_B1] Main.main3 eta_B1;
Main.Cons
:: forall a_art. a_art -> Main.List a_art -> Main.List a_art
[GblId[DataCon],
Arity=2,
Caf=NoCafRefs,
Str=DmdType <L,U><L,U>m1,
Unf=OtherCon []] =
\r srt:SRT:[] [eta_B2 eta_B1] Main.Cons [eta_B2 eta_B1];
Main.Nil :: forall a_art. Main.List a_art
[GblId[DataCon], Caf=NoCafRefs, Str=DmdType, Unf=OtherCon []] =
NO_CCS Main.Nil! [];
Raw
Main.hs
{-# LANGUAGE DeriveFunctor #-}
module Main where
newtype Item a = Item (Maybe a)
deriving (Show)
data List a = Cons !a !(List a) | Nil
deriving (Show, Functor)
mkList :: Int -> List Int
mkList 0 = Nil
mkList i = Cons i (mkList (i - 1))
maybeToItem :: Maybe a -> Item a
maybeToItem = Item
main :: IO ()
main = do
i <- readLn :: IO Int
let lst = fmap Just (mkList i)
print lst
print (fmap id lst)
print (fmap Item lst)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment