Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
GHC 7.10 RC3 Shake issues
This file has been truncated, but you can view the full file.
[31 of 55] Compiling Development.Shake.Errors ( src\Development\Shake\Errors.hs, .hpc\core\Development\Shake\Errors.o )
==================== Tidy Core ====================
Result size of Tidy Core
= {terms: 2,070, types: 2,156, coercions: 13}
Development.Shake.Errors.$fExceptionShakeException1 :: [Char]
[GblId,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 40 0}]
Development.Shake.Errors.$fExceptionShakeException1 =
GHC.CString.unpackCString# "* "#
Development.Shake.Errors.$fExceptionShakeException2 :: [Char]
[GblId,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 130 0}]
Development.Shake.Errors.$fExceptionShakeException2 =
GHC.CString.unpackCString#
"Error when running Shake build system:"#
Development.Shake.Errors.$fExceptionShakeException_ww4 :: String
[GblId,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 90 0}]
Development.Shake.Errors.$fExceptionShakeException_ww4 =
GHC.CString.unpackCString# "Development.Shake.Errors"#
Development.Shake.Errors.$fExceptionShakeException_ww5 :: String
[GblId,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 70 0}]
Development.Shake.Errors.$fExceptionShakeException_ww5 =
GHC.CString.unpackCString# "ShakeException"#
Development.Shake.Errors.$fExceptionShakeException_ww2 :: String
[GblId,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 40 0}]
Development.Shake.Errors.$fExceptionShakeException_ww2 =
GHC.CString.unpackCString# "main"#
Development.Shake.Errors.$fExceptionShakeException_wild :: TyCon
[GblId,
Str=DmdType m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 60}]
Development.Shake.Errors.$fExceptionShakeException_wild =
Data.Typeable.Internal.TyCon
(__word 10157797340292954314)
(__word 7334185207056361348)
Development.Shake.Errors.$fExceptionShakeException_ww2
Development.Shake.Errors.$fExceptionShakeException_ww4
Development.Shake.Errors.$fExceptionShakeException_ww5
Development.Shake.Errors.$fExceptionShakeException5 :: TypeRep
[GblId,
Str=DmdType m,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [] 10 60}]
Development.Shake.Errors.$fExceptionShakeException5 =
Data.Typeable.Internal.TypeRep
(__word 10157797340292954314)
(__word 7334185207056361348)
Development.Shake.Errors.$fExceptionShakeException_wild
(GHC.Types.[] @ Data.Typeable.Internal.KindRep)
(GHC.Types.[] @ TypeRep)
Development.Shake.Errors.$fExceptionShakeException4
:: GHC.Prim.Proxy# ShakeException -> TypeRep
[GblId,
Arity=1,
Str=DmdType <L,A>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=True)
Tmpl= \ _ [Occ=Dead] ->
Development.Shake.Errors.$fExceptionShakeException5}]
Development.Shake.Errors.$fExceptionShakeException4 =
\ _ [Occ=Dead] ->
Development.Shake.Errors.$fExceptionShakeException5
Development.Shake.Errors.$fExceptionShakeException3
:: Typeable ShakeException
[GblId,
Arity=1,
Str=DmdType <L,A>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
Tmpl= Development.Shake.Errors.$fExceptionShakeException4
`cast` (Sym
(Data.Typeable.Internal.NTCo:Typeable[0] <*>_N <ShakeException>_N)
:: (GHC.Prim.Proxy# ShakeException -> TypeRep)
~R# Typeable ShakeException)}]
Development.Shake.Errors.$fExceptionShakeException3 =
Development.Shake.Errors.$fExceptionShakeException4
`cast` (Sym
(Data.Typeable.Internal.NTCo:Typeable[0] <*>_N <ShakeException>_N)
:: (GHC.Prim.Proxy# ShakeException -> TypeRep)
~R# Typeable ShakeException)
Development.Shake.Errors.$w$cshow [InlPrag=[0]]
:: [String] -> SomeException -> String
[GblId,
Arity=2,
Str=DmdType <L,1*U><L,1*U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [0 20] 260 0}]
Development.Shake.Errors.$w$cshow =
\ (ww_sbsp :: [String]) (ww1_sbsq :: SomeException) ->
unlines
(GHC.Types.:
@ String
Development.Shake.Errors.$fExceptionShakeException2
(let {
a34_sbdZ :: [Char]
[LclId, Str=DmdType]
a34_sbdZ =
case ww1_sbsq
of _ [Occ=Dead]
{ SomeException @ e0_iaFO $dException_iaFP e1_iaFQ ->
showsPrec
@ e0_iaFO
(GHC.Exception.$p2Exception @ e0_iaFO $dException_iaFP)
GHC.Show.shows18
e1_iaFQ
(GHC.Types.[] @ Char)
} } in
let {
z3_iaAT :: [[Char]]
[LclId, Str=DmdType]
z3_iaAT =
GHC.Types.: @ [Char] a34_sbdZ (GHC.Types.[] @ [Char]) } in
letrec {
go2_iaAV [Occ=LoopBreaker] :: [[Char]] -> [[Char]]
[LclId, Arity=1, Str=DmdType <S,1*U>]
go2_iaAV =
\ (ds_iaAW :: [[Char]]) ->
case ds_iaAW of _ [Occ=Dead] {
[] -> z3_iaAT;
: y_iaB1 ys_iaB2 ->
GHC.Types.:
@ [Char]
(++
@ Char Development.Shake.Errors.$fExceptionShakeException1 y_iaB1)
(go2_iaAV ys_iaB2)
}; } in
go2_iaAV ww_sbsp))
Development.Shake.Errors.$fExceptionShakeException_$cshow [InlPrag=INLINE[0]]
:: ShakeException -> String
[GblId,
Arity=1,
Str=DmdType <S,1*U(A,1*U,1*U)>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (w_sbsl [Occ=Once!] :: ShakeException) ->
case w_sbsl
of _ [Occ=Dead]
{ ShakeException _ [Occ=Dead] ww2_sbsp [Occ=Once]
ww3_sbsq [Occ=Once] ->
Development.Shake.Errors.$w$cshow ww2_sbsp ww3_sbsq
}}]
Development.Shake.Errors.$fExceptionShakeException_$cshow =
\ (w_sbsl :: ShakeException) ->
case w_sbsl
of _ [Occ=Dead] { ShakeException ww1_sbso ww2_sbsp ww3_sbsq ->
Development.Shake.Errors.$w$cshow ww2_sbsp ww3_sbsq
}
Development.Shake.Errors.$fShowShakeException_$cshowsPrec
:: Int -> ShakeException -> ShowS
[GblId,
Arity=3,
Str=DmdType <L,A><S,1*U(A,1*U,1*U)><L,1*U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=3,unsat_ok=True,boring_ok=False)
Tmpl= \ _ [Occ=Dead]
(x_iaDM [Occ=Once] :: ShakeException)
(s_iaDN [Occ=Once] :: String) ->
GHC.Base.augment
@ Char
(\ (@ b_iaEy)
(c_iaEz [Occ=Once, OS=OneShot] :: Char -> b_iaEy -> b_iaEy)
(n_iaEA [Occ=Once, OS=OneShot] :: b_iaEy) ->
GHC.Base.foldr
@ Char
@ b_iaEy
c_iaEz
n_iaEA
(Development.Shake.Errors.$fExceptionShakeException_$cshow x_iaDM))
s_iaDN}]
Development.Shake.Errors.$fShowShakeException_$cshowsPrec =
\ _ [Occ=Dead] (x_iaDM :: ShakeException) (s_iaDN :: String) ->
case x_iaDM
of _ [Occ=Dead] { ShakeException ww1_sbso ww2_sbsp ww3_sbsq ->
++
@ Char (Development.Shake.Errors.$w$cshow ww2_sbsp ww3_sbsq) s_iaDN
}
Development.Shake.Errors.$fShowShakeException1
:: ShakeException -> String -> [Char]
[GblId,
Arity=2,
Str=DmdType,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [20 0] 70 0}]
Development.Shake.Errors.$fShowShakeException1 =
\ (x_iaDM :: ShakeException) (s_iaDN [OS=OneShot] :: String) ->
case x_iaDM
of _ [Occ=Dead] { ShakeException ww1_sbso ww2_sbsp ww3_sbsq ->
++
@ Char (Development.Shake.Errors.$w$cshow ww2_sbsp ww3_sbsq) s_iaDN
}
Development.Shake.Errors.$fShowShakeException_$cshowList
:: [ShakeException] -> ShowS
[GblId,
Arity=2,
Str=DmdType <S,1*U><L,U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [0 0] 40 0}]
Development.Shake.Errors.$fShowShakeException_$cshowList =
\ (ls_iaDD :: [ShakeException]) (s_iaDE :: String) ->
GHC.Show.showList__
@ ShakeException
Development.Shake.Errors.$fShowShakeException1
ls_iaDD
s_iaDE
Development.Shake.Errors.$fShowShakeException [InlPrag=[ALWAYS] CONLIKE]
:: Show ShakeException
[GblId[DFunId],
Str=DmdType m,
Unf=DFun: \ ->
GHC.Show.D:Show TYPE ShakeException
Development.Shake.Errors.$fShowShakeException_$cshowsPrec
Development.Shake.Errors.$fExceptionShakeException_$cshow
Development.Shake.Errors.$fShowShakeException_$cshowList]
Development.Shake.Errors.$fShowShakeException =
GHC.Show.D:Show
@ ShakeException
Development.Shake.Errors.$fShowShakeException_$cshowsPrec
Development.Shake.Errors.$fExceptionShakeException_$cshow
Development.Shake.Errors.$fShowShakeException_$cshowList
Development.Shake.Errors.$fExceptionShakeException_$cdisplayException
:: ShakeException -> String
[GblId,
Arity=1,
Str=DmdType <S,1*U(A,1*U,1*U)>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=0,unsat_ok=True,boring_ok=True)
Tmpl= Development.Shake.Errors.$fExceptionShakeException_$cshow}]
Development.Shake.Errors.$fExceptionShakeException_$cdisplayException =
Development.Shake.Errors.$fExceptionShakeException_$cshow
Development.Shake.Errors.$fExceptionShakeException_$cfromException
:: SomeException -> Maybe ShakeException
[GblId,
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S,1*U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True, Guidance=IF_ARGS [20] 91 40}]
Development.Shake.Errors.$fExceptionShakeException_$cfromException =
\ (eta_iaE1 :: SomeException) ->
case eta_iaE1
of _ [Occ=Dead]
{ SomeException @ e10_iaE7 $dException1_iaE8 e2_iaE9 ->
case ((GHC.Exception.$p1Exception @ e10_iaE7 $dException1_iaE8)
`cast` (Data.Typeable.Internal.NTCo:Typeable[0] <*>_N <e10_iaE7>_N
:: Typeable e10_iaE7 ~R# (GHC.Prim.Proxy# e10_iaE7 -> TypeRep)))
(GHC.Prim.proxy# @ * @ e10_iaE7)
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep dt_iaP6 dt1_iaP7 ds2_iaP8 ds3_iaP9
ds4_iaPa ->
case dt_iaP6 of _ [Occ=Dead] {
__DEFAULT -> GHC.Base.Nothing @ ShakeException;
__word 10157797340292954314 ->
case dt1_iaP7 of _ [Occ=Dead] {
__DEFAULT -> GHC.Base.Nothing @ ShakeException;
__word 7334185207056361348 ->
GHC.Base.Just
@ ShakeException
(e2_iaE9
`cast` (UnivCo mkUnsafeCo representational e10_iaE7 ShakeException
:: e10_iaE7 ~R# ShakeException))
}
}
}
}
Rec {
Development.Shake.Errors.$fExceptionShakeException [InlPrag=[ALWAYS] CONLIKE]
:: Exception ShakeException
[GblId[DFunId],
Str=DmdType m,
Unf=DFun: \ ->
GHC.Exception.D:Exception TYPE ShakeException
Development.Shake.Errors.$fExceptionShakeException3
Development.Shake.Errors.$fShowShakeException
Development.Shake.Errors.$fExceptionShakeException_$ctoException
Development.Shake.Errors.$fExceptionShakeException_$cfromException
Development.Shake.Errors.$fExceptionShakeException_$cdisplayException]
Development.Shake.Errors.$fExceptionShakeException =
GHC.Exception.D:Exception
@ ShakeException
(Development.Shake.Errors.$fExceptionShakeException4
`cast` (Sym
(Data.Typeable.Internal.NTCo:Typeable[0] <*>_N <ShakeException>_N)
:: (GHC.Prim.Proxy# ShakeException -> TypeRep)
~R# Typeable ShakeException))
Development.Shake.Errors.$fShowShakeException
Development.Shake.Errors.$fExceptionShakeException_$ctoException
Development.Shake.Errors.$fExceptionShakeException_$cfromException
Development.Shake.Errors.$fExceptionShakeException_$cshow
Development.Shake.Errors.$fExceptionShakeException_$ctoException [Occ=LoopBreaker]
:: ShakeException -> SomeException
[GblId, Arity=1, Str=DmdType]
Development.Shake.Errors.$fExceptionShakeException_$ctoException =
GHC.Exception.SomeException
@ ShakeException Development.Shake.Errors.$fExceptionShakeException
end Rec }
a_rbOo :: [Char]
[GblId, Str=DmdType]
a_rbOo = GHC.CString.unpackCString# "_rule_"#
a1_rbOp :: [Char]
[GblId, Str=DmdType]
a1_rbOp = GHC.CString.unpackCString# "oracle"#
a2_rbOq :: ([Char], [Char])
[GblId, Str=DmdType m]
a2_rbOq = (a_rbOo, a1_rbOp)
a3_rbOr :: [Char]
[GblId, Str=DmdType]
a3_rbOr = GHC.CString.unpackCString# "_Rule_"#
a4_rbOs :: [Char]
[GblId, Str=DmdType]
a4_rbOs = GHC.CString.unpackCString# "Oracle"#
a5_rbOt :: ([Char], [Char])
[GblId, Str=DmdType m]
a5_rbOt = (a3_rbOr, a4_rbOs)
a6_rbOu :: [Char]
[GblId, Str=DmdType]
a6_rbOu = GHC.CString.unpackCString# "_key_"#
a7_rbOv :: [Char]
[GblId, Str=DmdType]
a7_rbOv = GHC.CString.unpackCString# "question"#
a8_rbOw :: ([Char], [Char])
[GblId, Str=DmdType m]
a8_rbOw = (a6_rbOu, a7_rbOv)
a9_rbOx :: [Char]
[GblId, Str=DmdType]
a9_rbOx = GHC.CString.unpackCString# "_Key_"#
a10_rbOy :: [Char]
[GblId, Str=DmdType]
a10_rbOy = GHC.CString.unpackCString# "Question"#
a11_rbOz :: ([Char], [Char])
[GblId, Str=DmdType m]
a11_rbOz = (a9_rbOx, a10_rbOy)
a12_rbOA :: [Char]
[GblId, Str=DmdType]
a12_rbOA = GHC.CString.unpackCString# "_result_"#
a13_rbOB :: [Char]
[GblId, Str=DmdType]
a13_rbOB = GHC.CString.unpackCString# "answer"#
a14_rbOC :: ([Char], [Char])
[GblId, Str=DmdType m]
a14_rbOC = (a12_rbOA, a13_rbOB)
a15_rbOD :: [Char]
[GblId, Str=DmdType]
a15_rbOD = GHC.CString.unpackCString# "_Result_"#
a16_rbOE :: [Char]
[GblId, Str=DmdType]
a16_rbOE = GHC.CString.unpackCString# "Answer"#
a17_rbOF :: ([Char], [Char])
[GblId, Str=DmdType m]
a17_rbOF = (a15_rbOD, a16_rbOE)
a18_rbOG :: [Char]
[GblId, Str=DmdType]
a18_rbOG = GHC.CString.unpackCString# "_rule/defaultRule_"#
a19_rbOH :: [Char]
[GblId, Str=DmdType]
a19_rbOH = GHC.CString.unpackCString# "addOracle"#
a20_rbOI :: ([Char], [Char])
[GblId, Str=DmdType m]
a20_rbOI = (a18_rbOG, a19_rbOH)
a21_rbOJ :: [Char]
[GblId, Str=DmdType]
a21_rbOJ = GHC.CString.unpackCString# "_apply_"#
a22_rbOK :: [Char]
[GblId, Str=DmdType]
a22_rbOK = GHC.CString.unpackCString# "askOracle"#
a23_rbOL :: ([Char], [Char])
[GblId, Str=DmdType m]
a23_rbOL = (a21_rbOJ, a22_rbOK)
a24_rbOM :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a24_rbOM =
GHC.Types.:
@ ([Char], [Char]) a23_rbOL (GHC.Types.[] @ ([Char], [Char]))
a25_rbON :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a25_rbON = GHC.Types.: @ ([Char], [Char]) a20_rbOI a24_rbOM
a26_rbOO :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a26_rbOO = GHC.Types.: @ ([Char], [Char]) a17_rbOF a25_rbON
a27_rbOP :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a27_rbOP = GHC.Types.: @ ([Char], [Char]) a14_rbOC a26_rbOO
a28_rbOQ :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a28_rbOQ = GHC.Types.: @ ([Char], [Char]) a11_rbOz a27_rbOP
a29_rbOR :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a29_rbOR = GHC.Types.: @ ([Char], [Char]) a8_rbOw a28_rbOQ
a30_rbOS :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a30_rbOS = GHC.Types.: @ ([Char], [Char]) a5_rbOt a29_rbOR
alternatives_r9dx :: [([Char], [Char])]
[GblId, Str=DmdType m2]
alternatives_r9dx = GHC.Types.: @ ([Char], [Char]) a2_rbOq a30_rbOS
lvl_rbOT :: [Char]
[GblId, Str=DmdType]
lvl_rbOT = GHC.CString.unpackCString# ")"#
err :: forall a_a9dN. String -> a_a9dN
[GblId, Arity=1, Str=DmdType <L,U>b]
err =
\ (@ a34_a9yC) (msg_a9dO :: String) ->
error
@ a34_a9yC
(GHC.CString.unpackAppendCString#
"Development.Shake: Internal error, please report to Neil Mitchell ("#
(++ @ Char msg_a9dO lvl_rbOT))
lvl1_rbOU :: [Char]
[GblId, Str=DmdType]
lvl1_rbOU =
GHC.CString.unpackCString#
"Build system error - no _rule_ matches the _key_ type"#
lvl2_rbOV :: forall a_a9y7. a_a9y7
[GblId, Str=DmdType b]
lvl2_rbOV = \ (@ a34_a9y7) -> error @ a34_a9y7 lvl1_rbOU
errorNoRuleToBuildType [InlPrag=INLINE (sat-args=3)]
:: forall a_a9dJ.
TypeRep -> Maybe String -> Maybe TypeRep -> a_a9dJ
[GblId,
Arity=3,
Str=DmdType <B,A><B,A><B,A>b,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=3,unsat_ok=False,boring_ok=False)
Tmpl= \ (@ a34_a9y7) _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] ->
error
@ a34_a9y7
(GHC.Base.build
@ Char
(\ (@ b_iaEl) ->
GHC.CString.unpackFoldrCString#
@ b_iaEl
"Build system error - no _rule_ matches the _key_ type"#))}]
errorNoRuleToBuildType =
\ (@ a34_a9y7) _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] ->
lvl2_rbOV @ a34_a9y7
lvl3_rbOW :: IO ()
[GblId, Str=DmdType b]
lvl3_rbOW = error @ (IO ()) lvl1_rbOU
errorNoRuleToBuildType2 [InlPrag=NOINLINE]
:: TypeRep -> TypeRep -> IO ()
[GblId, Arity=2, Str=DmdType <B,A><B,A>b]
errorNoRuleToBuildType2 = \ _ [Occ=Dead] _ [Occ=Dead] -> lvl3_rbOW
shakeExceptionInner :: ShakeException -> SomeException
[GblId[[RecSel]],
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S(LLS),1*U(A,A,1*U)>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_daAt [Occ=Once!] :: ShakeException) ->
case ds_daAt
of _ [Occ=Dead]
{ ShakeException _ [Occ=Dead] _ [Occ=Dead] ds3_daAw [Occ=Once] ->
ds3_daAw
}}]
shakeExceptionInner =
\ (ds_daAt :: ShakeException) ->
case ds_daAt
of _ [Occ=Dead] { ShakeException ds1_daAu ds2_daAv ds3_daAw ->
ds3_daAw
}
shakeExceptionStack :: ShakeException -> [String]
[GblId[[RecSel]],
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S(LSL),1*U(A,1*U,A)>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_daAp [Occ=Once!] :: ShakeException) ->
case ds_daAp
of _ [Occ=Dead]
{ ShakeException _ [Occ=Dead] ds2_daAr [Occ=Once] _ [Occ=Dead] ->
ds2_daAr
}}]
shakeExceptionStack =
\ (ds_daAp :: ShakeException) ->
case ds_daAp
of _ [Occ=Dead] { ShakeException ds1_daAq ds2_daAr ds3_daAs ->
ds2_daAr
}
shakeExceptionTarget :: ShakeException -> String
[GblId[[RecSel]],
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S(SLL),1*U(1*U,A,A)>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_daAl [Occ=Once!] :: ShakeException) ->
case ds_daAl
of _ [Occ=Dead]
{ ShakeException ds1_daAm [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] ->
ds1_daAm
}}]
shakeExceptionTarget =
\ (ds_daAl :: ShakeException) ->
case ds_daAl
of _ [Occ=Dead] { ShakeException ds1_daAm ds2_daAn ds3_daAo ->
ds1_daAm
}
lvl4_rbOX :: Int
[GblId, Caf=NoCafRefs, Str=DmdType m]
lvl4_rbOX = GHC.Types.I# 0
lvl5_rbOY :: ([Char], String) -> Int
[GblId, Arity=1, Caf=NoCafRefs, Str=DmdType <S(SL),1*U(1*U,A)>m]
lvl5_rbOY =
\ (x_iaBu :: ([Char], String)) ->
case x_iaBu of _ [Occ=Dead] { (x1_iaBA, ds1_iaBB) ->
case GHC.List.$wlenAcc @ Char x1_iaBA 0 of ww2_ib1S { __DEFAULT ->
GHC.Types.I# ww2_ib1S
}
}
lvl6_rbOZ :: Char
[GblId, Caf=NoCafRefs, Str=DmdType m]
lvl6_rbOZ = GHC.Types.C# ':'
lvl7_rbP0 :: Char
[GblId, Caf=NoCafRefs, Str=DmdType m]
lvl7_rbP0 = GHC.Types.C# ' '
lvl8_rbP1 :: [Char]
[GblId, Str=DmdType]
lvl8_rbP1 = GHC.CString.unpackCString# ":"#
Rec {
go_rbP2 :: [(String, Maybe String)] -> [(String, String)]
[GblId, Arity=1, Caf=NoCafRefs, Str=DmdType <S,1*U>]
go_rbP2 =
\ (ds_iaAW :: [(String, Maybe String)]) ->
case ds_iaAW of _ [Occ=Dead] {
[] -> GHC.Types.[] @ (String, String);
: y_iaB1 ys_iaB2 ->
case y_iaB1 of _ [Occ=Dead] { (a34_a9dV, ds1_dazw) ->
case ds1_dazw of _ [Occ=Dead] {
Nothing -> go_rbP2 ys_iaB2;
Just b_a9dW ->
GHC.Types.: @ (String, String) (a34_a9dV, b_a9dW) (go_rbP2 ys_iaB2)
}
}
}
end Rec }
lvl9_rbP3
:: forall a_a9yv.
String -> [(String, Maybe String)] -> String -> a_a9yv
[GblId, Arity=3, Str=DmdType <L,U><L,U><L,U>b]
lvl9_rbP3 =
\ (@ a34_a9yv)
(eta_B1 :: String)
(eta1_B2 :: [(String, Maybe String)])
(eta2_B3 :: String) ->
error
@ a34_a9yv
(unlines
(GHC.Types.:
@ [Char]
(++ @ Char eta2_B3 lvl8_rbP1)
(let {
args2_saOy [Dmd=<S,U>] :: [(String, String)]
[LclId, Str=DmdType]
args2_saOy = go_rbP2 eta1_B2 } in
let {
as_saOx [Dmd=<L,U(U)>] :: Int
[LclId, Str=DmdType]
as_saOx =
GHC.List.strictMaximum
@ Int
GHC.Classes.$fOrdInt
(GHC.Types.:
@ Int
lvl4_rbOX
(map @ ([Char], String) @ Int lvl5_rbOY args2_saOy)) } in
let {
z3_iaAT :: [[Char]]
[LclId, Str=DmdType]
z3_iaAT =
case GHC.Classes.$fEq[]_$s$c==1 eta_B1 (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ [Char] eta_B1 (GHC.Types.[] @ [Char]);
True -> GHC.Types.[] @ [Char]
} } in
letrec {
go2_XaE3 [Occ=LoopBreaker] :: [(String, String)] -> [[Char]]
[LclId, Arity=1, Str=DmdType <S,1*U>]
go2_XaE3 =
\ (ds_iaAW :: [(String, String)]) ->
case ds_iaAW of _ [Occ=Dead] {
[] -> z3_iaAT;
: y_iaB1 ys_iaB2 ->
case y_iaB1 of _ [Occ=Dead] { (a35_a9dX, b_a9dY) ->
GHC.Types.:
@ [Char]
(GHC.CString.unpackAppendCString#
" "#
(++
@ Char
a35_a9dX
(let {
n_XaH5 :: [Char]
[LclId, Str=DmdType]
n_XaH5 =
case as_saOx of _ [Occ=Dead] { GHC.Types.I# x_iaHS ->
case GHC.List.$wlenAcc @ Char a35_a9dX 0
of ww2_ib1S { __DEFAULT ->
let {
y1_iaBc :: GHC.Prim.Int#
[LclId, Str=DmdType]
y1_iaBc = GHC.Prim.+# (GHC.Prim.-# x_iaHS ww2_ib1S) 2 } in
case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# 0 y1_iaBc)
of _ [Occ=Dead] {
False -> b_a9dY;
True ->
let {
lvl65_sbFf :: [Char]
[LclId, Str=DmdType]
lvl65_sbFf = GHC.Types.: @ Char lvl7_rbP0 b_a9dY } in
letrec {
$wxs_sbsD [InlPrag=[0], Occ=LoopBreaker]
:: GHC.Prim.Int# -> [Char]
[LclId, Arity=1, Str=DmdType <S,1*U>]
$wxs_sbsD =
\ (ww_sbsB :: GHC.Prim.Int#) ->
case ww_sbsB of ds1_iaIV {
__DEFAULT ->
GHC.Types.:
@ Char
lvl7_rbP0
($wxs_sbsD (GHC.Prim.-# ds1_iaIV 1));
1 -> lvl65_sbFf
}; } in
$wxs_sbsD y1_iaBc
}
}
} } in
case GHC.Classes.$fEq[]_$s$c==1 a35_a9dX (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ Char lvl6_rbOZ n_XaH5;
True -> n_XaH5
})))
(go2_XaE3 ys_iaB2)
}
}; } in
go2_XaE3 args2_saOy)))
errorStructured [InlPrag=INLINE (sat-args=3)]
:: forall a_a9dM.
String -> [(String, Maybe String)] -> String -> a_a9dM
[GblId,
Arity=3,
Str=DmdType <B,1*U><B,1*U><B,U>b,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=3,unsat_ok=False,boring_ok=False)
Tmpl= \ (@ a34_a9yv)
(msg_a9dQ [Occ=Once] :: String)
(args_a9dR [Occ=Once] :: [(String, Maybe String)])
(hint_a9dS :: String) ->
let {
args2_a9dU :: [(String, String)]
[LclId, Str=DmdType]
args2_a9dU =
GHC.Base.build
@ (String, String)
(\ (@ a35_dazr)
(c_dazs [Occ=OnceL!, OS=OneShot]
:: (String, String) -> a35_dazr -> a35_dazr)
(n_dazt [Occ=Once, OS=OneShot] :: a35_dazr) ->
GHC.Base.foldr
@ (String, Maybe String)
@ a35_dazr
(\ (ds_dazv [Occ=Once!] :: (String, Maybe String))
(ds1_dazu [Occ=Once*, OS=OneShot] :: a35_dazr) ->
case ds_dazv
of _ [Occ=Dead] { (a36_a9dV [Occ=Once], ds2_dazw [Occ=Once!]) ->
case ds2_dazw of _ [Occ=Dead] {
Nothing -> ds1_dazu;
Just b_a9dW [Occ=Once] -> c_dazs (a36_a9dV, b_a9dW) ds1_dazu
}
})
n_dazt
args_a9dR) } in
let {
as_a9dT [Occ=OnceL] :: Int
[LclId, Str=DmdType]
as_a9dT =
$ @ [Int]
@ Int
(GHC.List.strictMaximum @ Int GHC.Classes.$fOrdInt)
(GHC.Types.:
@ Int
(GHC.Types.I# 0)
(GHC.Base.build
@ Int
(\ (@ b1_iaFn)
(c_iaFo [Occ=Once, OS=OneShot] :: Int -> b1_iaFn -> b1_iaFn)
(n_iaFp [Occ=Once, OS=OneShot] :: b1_iaFn) ->
GHC.Base.foldr
@ ([Char], String)
@ b1_iaFn
(GHC.Base.mapFB
@ Int
@ b1_iaFn
@ ([Char], String)
c_iaFo
(\ (x_iaBu [Occ=Once, OS=ProbOneShot] :: ([Char], String)) ->
GHC.Base.foldr
@ Char
@ (Int -> Int)
(GHC.List.lengthFB @ Char)
GHC.List.idLength
(fst @ [Char] @ String x_iaBu)
(GHC.Types.I# 0)))
n_iaFp
args2_a9dU))) } in
$ @ [Char]
@ a34_a9yv
(error @ a34_a9yv)
($ @ [String]
@ [Char]
unlines
(GHC.Base.build
@ [Char]
(\ (@ b_iaF9)
(c_iaFa [OS=OneShot] :: [Char] -> b_iaF9 -> b_iaF9)
(n_iaFb [Occ=Once*, OS=OneShot] :: b_iaF9) ->
c_iaFa
(GHC.Base.build
@ Char
(\ (@ b1_XaGf)
(c1_XaGh [OS=OneShot] :: Char -> b1_XaGf -> b1_XaGf)
(n1_XaGj [Occ=Once, OS=OneShot] :: b1_XaGf) ->
GHC.Base.foldr
@ Char
@ b1_XaGf
c1_XaGh
(GHC.CString.unpackFoldrCString#
@ b1_XaGf ":"# c1_XaGh n1_XaGj)
msg_a9dQ))
(GHC.Base.foldr
@ (String, String)
@ b_iaF9
(\ (ds_dazh [Occ=Once!] :: (String, String))
(ds1_dazg [Occ=Once, OS=OneShot] :: b_iaF9) ->
case ds_dazh of _ [Occ=Dead] { (a35_a9dX, b1_a9dY [Occ=Once]) ->
c_iaFa
(GHC.Base.augment
@ Char
(\ (@ b2_XaFL)
(c1_XaFN [Occ=Once, OS=OneShot]
:: Char -> b2_XaFL -> b2_XaFL)
(n1_XaFP [Occ=Once, OS=OneShot] :: b2_XaFL) ->
GHC.CString.unpackFoldrCString#
@ b2_XaFL " "# c1_XaFN n1_XaFP)
(GHC.Base.augment
@ Char
(\ (@ b2_XaFJ)
(c1_XaH2 [Occ=Once, OS=OneShot]
:: Char -> b2_XaFJ -> b2_XaFJ)
(n1_XaH5 [Occ=Once, OS=OneShot] :: b2_XaFJ) ->
GHC.Base.foldr
@ Char @ b2_XaFJ c1_XaH2 n1_XaH5 a35_a9dX)
(GHC.Base.augment
@ Char
(\ (@ b2_XaGX)
(c1_XaH0 [Occ=Once!, OS=OneShot]
:: Char -> b2_XaGX -> b2_XaGX)
(n1_XaH3 [Occ=Once*, OS=OneShot] :: b2_XaGX) ->
case not
(GHC.Classes.$fEq[]_$s$c==1
a35_a9dX (GHC.Types.[] @ Char))
of _ [Occ=Dead] {
False -> n1_XaH3;
True -> c1_XaH0 (GHC.Types.C# ':') n1_XaH3
})
(GHC.Base.augment
@ Char
(\ (@ b2_XaFM)
(c1_XaFO [Occ=Once, OS=OneShot]
:: Char -> b2_XaFM -> b2_XaFM)
(n1_XaFQ [Occ=Once*, OS=OneShot] :: b2_XaFM) ->
case GHC.Num.$fNumInt_$c+
(GHC.Num.$fNumInt_$c-
as_a9dT
(GHC.Base.foldr
@ Char
@ (Int -> Int)
(GHC.List.lengthFB @ Char)
GHC.List.idLength
a35_a9dX
(GHC.Types.I# 0)))
(GHC.Types.I# 2)
of wild1_iaBa
{ GHC.Types.I# y_iaBc [Occ=Once] ->
case GHC.Prim.tagToEnum#
@ Bool (GHC.Prim.<# 0 y_iaBc)
of _ [Occ=Dead] {
False -> n1_XaFQ;
True ->
GHC.List.repeatFB
@ Char
@ (Int -> b2_XaFM)
(GHC.List.takeFB
@ Char @ b2_XaFM c1_XaFO n1_XaFQ)
(GHC.Types.C# ' ')
wild1_iaBa
}
})
b1_a9dY))))
ds1_dazg
})
(case not
(GHC.Classes.$fEq[]_$s$c==1
hint_a9dS (GHC.Types.[] @ Char))
of _ [Occ=Dead] {
False -> n_iaFb;
True -> c_iaFa hint_a9dS n_iaFb
})
args2_a9dU))))}]
errorStructured =
\ (@ a34_a9yv)
(eta_B3 :: String)
(eta1_B2 :: [(String, Maybe String)])
(eta2_B1 :: String) ->
lvl9_rbP3 @ a34_a9yv eta2_B1 eta1_B2 eta_B3
lvl10_rbP4 :: [Char]
[GblId, Str=DmdType]
lvl10_rbP4 =
GHC.CString.unpackCString#
"Build system error - recursion detected"#
lvl11_rbP5 :: [Char]
[GblId, Str=DmdType]
lvl11_rbP5 = GHC.CString.unpackCString# "Key type"#
lvl12_rbP6 :: [Char]
[GblId, Str=DmdType]
lvl12_rbP6 = GHC.CString.unpackCString# "Key value"#
lvl13_rbP7 :: [Char]
[GblId, Str=DmdType]
lvl13_rbP7 =
GHC.CString.unpackCString# "Rules may not be recursive"#
lvl14_rbP8 :: [Char]
[GblId, Str=DmdType]
lvl14_rbP8 = ++ @ Char lvl10_rbP4 lvl8_rbP1
z_rbP9 :: [[Char]]
[GblId, Str=DmdType]
z_rbP9 =
case GHC.Classes.$fEq[]_$s$c==1 lvl13_rbP7 (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ [Char] lvl13_rbP7 (GHC.Types.[] @ [Char]);
True -> GHC.Types.[] @ [Char]
}
errorRuleRecursion
:: forall a_a9dF. Maybe TypeRep -> Maybe String -> a_a9dF
[GblId, Arity=2, Str=DmdType <L,U><L,U>b]
errorRuleRecursion =
\ (@ a34_a9xw)
(tk_a9ew :: Maybe TypeRep)
(k_a9ex :: Maybe String) ->
error
@ a34_a9xw
(unlines
(GHC.Types.:
@ [Char]
lvl14_rbP8
(let {
args2_a9dU [Dmd=<S,U>] :: [(String, String)]
[LclId, Str=DmdType]
args2_a9dU =
case tk_a9ew of _ [Occ=Dead] {
Nothing ->
case k_a9ex of _ [Occ=Dead] {
Nothing -> GHC.Types.[] @ (String, String);
Just b_a9dW ->
GHC.Types.:
@ (String, String)
(lvl12_rbP6, b_a9dW)
(GHC.Types.[] @ (String, String))
};
Just a35_iaJQ ->
GHC.Types.:
@ (String, String)
(lvl11_rbP5, Data.Typeable.Internal.$fShowTypeRep_$cshow a35_iaJQ)
(case k_a9ex of _ [Occ=Dead] {
Nothing -> GHC.Types.[] @ (String, String);
Just b_X9hS ->
GHC.Types.:
@ (String, String)
(lvl12_rbP6, b_X9hS)
(GHC.Types.[] @ (String, String))
})
} } in
let {
as_a9dT [Dmd=<L,U(U)>] :: Int
[LclId, Str=DmdType]
as_a9dT =
GHC.List.strictMaximum
@ Int
GHC.Classes.$fOrdInt
(GHC.Types.:
@ Int
lvl4_rbOX
(map @ ([Char], String) @ Int lvl5_rbOY args2_a9dU)) } in
letrec {
go2_iaAV [Occ=LoopBreaker] :: [(String, String)] -> [[Char]]
[LclId, Arity=1, Str=DmdType <S,1*U>]
go2_iaAV =
\ (ds_iaAW :: [(String, String)]) ->
case ds_iaAW of _ [Occ=Dead] {
[] -> z_rbP9;
: y_iaB1 ys_iaB2 ->
case y_iaB1 of _ [Occ=Dead] { (a35_a9dX, b_a9dY) ->
GHC.Types.:
@ [Char]
(GHC.CString.unpackAppendCString#
" "#
(++
@ Char
a35_a9dX
(let {
n_XaH3 :: [Char]
[LclId, Str=DmdType]
n_XaH3 =
case as_a9dT of _ [Occ=Dead] { GHC.Types.I# x_iaHS ->
case GHC.List.$wlenAcc @ Char a35_a9dX 0
of ww2_ib1S { __DEFAULT ->
let {
y1_iaBc :: GHC.Prim.Int#
[LclId, Str=DmdType]
y1_iaBc = GHC.Prim.+# (GHC.Prim.-# x_iaHS ww2_ib1S) 2 } in
case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# 0 y1_iaBc)
of _ [Occ=Dead] {
False -> b_a9dY;
True ->
let {
lvl65_sbFp :: [Char]
[LclId, Str=DmdType]
lvl65_sbFp = GHC.Types.: @ Char lvl7_rbP0 b_a9dY } in
letrec {
$wxs_sbsK [InlPrag=[0], Occ=LoopBreaker]
:: GHC.Prim.Int# -> [Char]
[LclId, Arity=1, Str=DmdType <S,1*U>]
$wxs_sbsK =
\ (ww_sbsI :: GHC.Prim.Int#) ->
case ww_sbsI of ds1_iaIV {
__DEFAULT ->
GHC.Types.:
@ Char
lvl7_rbP0
($wxs_sbsK (GHC.Prim.-# ds1_iaIV 1));
1 -> lvl65_sbFp
}; } in
$wxs_sbsK y1_iaBc
}
}
} } in
case GHC.Classes.$fEq[]_$s$c==1 a35_a9dX (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ Char lvl6_rbOZ n_XaH3;
True -> n_XaH3
})))
(go2_iaAV ys_iaB2)
}
}; } in
go2_iaAV args2_a9dU)))
lvl15_rbPa :: [Char]
[GblId, Str=DmdType]
lvl15_rbPa =
GHC.CString.unpackCString#
"Build system error - duplicate oracles for the same question type"#
lvl16_rbPb :: [Char]
[GblId, Str=DmdType]
lvl16_rbPb = GHC.CString.unpackCString# "Question type"#
lvl17_rbPc :: [Char]
[GblId, Str=DmdType]
lvl17_rbPc = GHC.CString.unpackCString# "Question value"#
lvl18_rbPd :: Integer
[GblId, Caf=NoCafRefs, Str=DmdType]
lvl18_rbPd = __integer 1
lvl19_rbPe :: [Integer]
[GblId, Str=DmdType]
lvl19_rbPe =
case GHC.Enum.$wenumDeltaInteger lvl18_rbPd lvl18_rbPd
of _ [Occ=Dead] { (# ww1_ib3X, ww2_ib3Y #) ->
GHC.Types.: @ Integer ww1_ib3X ww2_ib3Y
}
lvl20_rbPf :: [Char]
[GblId, Str=DmdType]
lvl20_rbPf =
GHC.CString.unpackCString#
"Only one call to addOracle is allowed per question type"#
lvl21_rbPg :: [Char]
[GblId, Str=DmdType]
lvl21_rbPg = ++ @ Char lvl15_rbPa lvl8_rbP1
Rec {
go1_rbPh :: [Integer] -> [TypeRep] -> [(String, String)]
[GblId, Arity=2, Str=DmdType <S,1*U><L,1*U>]
go1_rbPh =
\ (ds_iaLN :: [Integer]) (_ys_iaLO :: [TypeRep]) ->
case ds_iaLN of _ [Occ=Dead] {
[] -> GHC.Types.[] @ (String, String);
: ipv_iaLT ipv1_iaLU ->
case _ys_iaLO of _ [Occ=Dead] {
[] -> GHC.Types.[] @ (String, String);
: ipv2_iaM0 ipv3_iaM1 ->
GHC.Types.:
@ (String, String)
(GHC.CString.unpackAppendCString#
"Answer type "#
(case GHC.Show.$w$cshowsPrec1 0 ipv_iaLT (GHC.Types.[] @ Char)
of _ [Occ=Dead] { (# ww3_iaUn, ww4_iaUo #) ->
GHC.Types.: @ Char ww3_iaUn ww4_iaUo
}),
Data.Typeable.Internal.$fShowTypeRep_$cshow ipv2_iaM0)
(go1_rbPh ipv1_iaLU ipv3_iaM1)
}
}
end Rec }
lvl22_rbPi :: String
[GblId, Str=DmdType b]
lvl22_rbPi =
Control.Exception.Base.absentError @ String "ww_sbt9 String"#
lvl23_rbPj :: String
[GblId, Str=DmdType b]
lvl23_rbPj =
Control.Exception.Base.absentError @ String "ww_sbta String"#
z1_rbPk :: [[Char]]
[GblId, Str=DmdType]
z1_rbPk =
case GHC.Classes.$fEq[]_$s$c==1 lvl20_rbPf (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ [Char] lvl20_rbPf (GHC.Types.[] @ [Char]);
True -> GHC.Types.[] @ [Char]
}
lvl24_rbPl
:: forall a_a9dE.
Maybe String
-> [TypeRep]
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> a_a9dE
[GblId, Arity=7, Str=DmdType <L,U><L,U><L,U><L,U><L,U><L,U><L,U>b]
lvl24_rbPl =
\ (@ a34_a9dE)
(w_sbsY :: Maybe String)
(w1_sbsZ :: [TypeRep])
(ww_sbt7 :: GHC.Prim.Word#)
(ww1_sbt8 :: GHC.Prim.Word#)
(ww2_sbtb :: String)
(ww3_sbtd :: [Data.Typeable.Internal.KindRep])
(ww4_sbte :: [TypeRep]) ->
error
@ a34_a9dE
(unlines
(GHC.Types.:
@ [Char]
lvl21_rbPg
(let {
a35_sb45 :: String
[LclId, Str=DmdType]
a35_sb45 =
Data.Typeable.Internal.$w$cshowsPrec
GHC.Show.shows18
(Data.Typeable.Internal.TyCon
ww_sbt7 ww1_sbt8 lvl22_rbPi lvl23_rbPj ww2_sbtb)
ww3_sbtd
ww4_sbte
(GHC.Types.[] @ Char) } in
let {
a36_sb44 :: (String, String)
[LclId, Str=DmdType m]
a36_sb44 = (lvl16_rbPb, a35_sb45) } in
let {
a37_sb46 :: [(String, String)]
[LclId, Str=DmdType]
a37_sb46 =
case w_sbsY of _ [Occ=Dead] {
Nothing -> go1_rbPh lvl19_rbPe w1_sbsZ;
Just b_a9dW ->
GHC.Types.:
@ (String, String)
(lvl17_rbPc, b_a9dW)
(go1_rbPh lvl19_rbPe w1_sbsZ)
} } in
let {
args2_a9dU :: [(String, String)]
[LclId, Str=DmdType]
args2_a9dU = GHC.Types.: @ (String, String) a36_sb44 a37_sb46 } in
let {
as_a9dT [Dmd=<L,U(U)>] :: Int
[LclId, Str=DmdType]
as_a9dT =
GHC.List.strictMaximum
@ Int
GHC.Classes.$fOrdInt
(GHC.Types.:
@ Int
lvl4_rbOX
(map @ ([Char], String) @ Int lvl5_rbOY args2_a9dU)) } in
letrec {
go2_iaAV [Occ=LoopBreaker] :: [(String, String)] -> [[Char]]
[LclId, Arity=1, Str=DmdType <S,1*U>]
go2_iaAV =
\ (ds_iaAW :: [(String, String)]) ->
case ds_iaAW of _ [Occ=Dead] {
[] -> z1_rbPk;
: y_iaB1 ys_iaB2 ->
case y_iaB1 of _ [Occ=Dead] { (a38_a9dX, b_a9dY) ->
GHC.Types.:
@ [Char]
(GHC.CString.unpackAppendCString#
" "#
(++
@ Char
a38_a9dX
(let {
n_XaH3 :: [Char]
[LclId, Str=DmdType]
n_XaH3 =
case as_a9dT of _ [Occ=Dead] { GHC.Types.I# x_iaHS ->
case GHC.List.$wlenAcc @ Char a38_a9dX 0
of ww5_ib1S { __DEFAULT ->
let {
y1_iaBc :: GHC.Prim.Int#
[LclId, Str=DmdType]
y1_iaBc = GHC.Prim.+# (GHC.Prim.-# x_iaHS ww5_ib1S) 2 } in
case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# 0 y1_iaBc)
of _ [Occ=Dead] {
False -> b_a9dY;
True ->
let {
lvl65_sbFG :: [Char]
[LclId, Str=DmdType]
lvl65_sbFG = GHC.Types.: @ Char lvl7_rbP0 b_a9dY } in
letrec {
$wxs_sbsV [InlPrag=[0], Occ=LoopBreaker]
:: GHC.Prim.Int# -> [Char]
[LclId, Arity=1, Str=DmdType <S,1*U>]
$wxs_sbsV =
\ (ww6_sbsT :: GHC.Prim.Int#) ->
case ww6_sbsT of ds1_iaIV {
__DEFAULT ->
GHC.Types.:
@ Char
lvl7_rbP0
($wxs_sbsV (GHC.Prim.-# ds1_iaIV 1));
1 -> lvl65_sbFG
}; } in
$wxs_sbsV y1_iaBc
}
}
} } in
case GHC.Classes.$fEq[]_$s$c==1 a38_a9dX (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ Char lvl6_rbOZ n_XaH3;
True -> n_XaH3
})))
(go2_iaAV ys_iaB2)
}
}; } in
go2_iaAV args2_a9dU)))
$werrorDuplicateOracle_rbPm
:: forall a_a9dE.
GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> Maybe String
-> [TypeRep]
-> a_a9dE
[GblId,
Arity=7,
Str=DmdType <B,U><B,U><B,U><B,1*U><B,1*U><B,1*U><B,1*U>b]
$werrorDuplicateOracle_rbPm =
\ (@ a34_a9dE)
(ww_sbt7 :: GHC.Prim.Word#)
(ww1_sbt8 :: GHC.Prim.Word#)
(ww2_sbtb :: String)
(ww3_sbtd :: [Data.Typeable.Internal.KindRep])
(ww4_sbte :: [TypeRep])
(w_sbsY :: Maybe String)
(w1_sbsZ :: [TypeRep]) ->
lvl24_rbPl
@ a34_a9dE
w_sbsY
w1_sbsZ
ww_sbt7
ww1_sbt8
ww2_sbtb
ww3_sbtd
ww4_sbte
lvl25_rbPn :: [Char]
[GblId, Str=DmdType]
lvl25_rbPn = GHC.CString.unpackCString# "OracleQ"#
lvl26_rbPo :: [Char]
[GblId, Str=DmdType]
lvl26_rbPo =
GHC.CString.unpackCString#
"Build system error - _rule_ used at the wrong _result_ type"#
lvl27_rbPp :: [Char]
[GblId, Str=DmdType]
lvl27_rbPp = GHC.CString.unpackCString# "_Key_ type"#
lvl28_rbPq :: [Char]
[GblId, Str=DmdType]
lvl28_rbPq = GHC.CString.unpackCString# "_Key_ value"#
lvl29_rbPr :: [Char]
[GblId, Str=DmdType]
lvl29_rbPr = GHC.CString.unpackCString# "_Rule_ _result_ type"#
lvl30_rbPs :: [Char]
[GblId, Str=DmdType]
lvl30_rbPs = GHC.CString.unpackCString# "Requested _result_ type"#
lvl31_rbPt :: [Char]
[GblId, Str=DmdType]
lvl31_rbPt =
GHC.CString.unpackCString#
"Either the function passed to _rule/defaultRule_ has the wrong _result_ type, or the result of _apply_ is used at the wrong type"#
a31_rbPu :: Char -> Bool
[GblId, Arity=1, Caf=NoCafRefs, Str=DmdType <S(S),1*U(1*U)>]
a31_rbPu =
\ (ds_dazZ :: Char) ->
case ds_dazZ of _ [Occ=Dead] { GHC.Types.C# c1_iaKt ->
case c1_iaKt of _ [Occ=Dead] {
__DEFAULT -> GHC.Types.True;
'_' -> GHC.Types.False
}
}
Rec {
$wunsafeDrop_rbPv
:: forall a1_iaBN. GHC.Prim.Int# -> [a1_iaBN] -> [a1_iaBN]
[GblId, Arity=2, Caf=NoCafRefs, Str=DmdType <L,1*U><S,1*U>]
$wunsafeDrop_rbPv =
\ (@ a34_iaBN) (ww_sbtl :: GHC.Prim.Int#) (w_sbti :: [a34_iaBN]) ->
case w_sbti of _ [Occ=Dead] {
[] -> GHC.Types.[] @ a34_iaBN;
: ipv1_iaBY ipv2_iaBZ ->
case ww_sbtl of ds3_iaC1 {
__DEFAULT ->
$wunsafeDrop_rbPv @ a34_iaBN (GHC.Prim.-# ds3_iaC1 1) ipv2_iaBZ;
1 -> ipv2_iaBZ
}
}
end Rec }
Rec {
g_rbPw :: [Char] -> [Char]
[GblId, Arity=1, Str=DmdType <L,U>]
g_rbPw =
\ (xs_a9e5 :: [Char]) ->
case filter
@ ([Char], [Char])
(\ (ds_daA1 [OS=ProbOneShot] :: ([Char], [Char])) ->
case ds_daA1 of _ [Occ=Dead] { (a34_a9e6, b_a9e7) ->
isPrefixOf @ Char GHC.Classes.$fEqChar a34_a9e6 xs_a9e5
})
alternatives_r9dx
of _ [Occ=Dead] {
[] ->
case xs_a9e5 of _ [Occ=Dead] {
[] -> GHC.Types.[] @ Char;
: x_a9ea xs1_a9eb -> GHC.Types.: @ Char x_a9ea (g_rbPw xs1_a9eb)
};
: ds_daA3 ds1_daA4 ->
case ds_daA3 of _ [Occ=Dead] { (a34_a9e8, b_a9e9) ->
++
@ Char
b_a9e9
(g_rbPw
(case GHC.List.$wlenAcc @ Char a34_a9e8 0
of ww2_ib1S { __DEFAULT ->
case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# ww2_ib1S 0)
of _ [Occ=Dead] {
False -> $wunsafeDrop_rbPv @ Char ww2_ib1S xs_a9e5;
True -> xs_a9e5
}
}))
}
}
end Rec }
lvl32_rbPx :: String
[GblId, Str=DmdType b]
lvl32_rbPx =
Control.Exception.Base.absentError @ String "ww_sbtK String"#
lvl33_rbPy :: String
[GblId, Str=DmdType b]
lvl33_rbPy =
Control.Exception.Base.absentError @ String "ww_sbtL String"#
lvl34_rbPz :: String
[GblId, Str=DmdType b]
lvl34_rbPz =
Control.Exception.Base.absentError @ String "ww_sbu0 String"#
lvl35_rbPA :: String
[GblId, Str=DmdType b]
lvl35_rbPA =
Control.Exception.Base.absentError @ String "ww_sbu1 String"#
lvl36_rbPB :: String
[GblId, Str=DmdType b]
lvl36_rbPB =
Control.Exception.Base.absentError @ String "ww_sbug String"#
lvl37_rbPC :: String
[GblId, Str=DmdType b]
lvl37_rbPC =
Control.Exception.Base.absentError @ String "ww_sbuh String"#
lvl38_rbPD
:: forall a_a9dI.
Maybe String
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> a_a9dI
[GblId,
Arity=16,
Str=DmdType <L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U>b]
lvl38_rbPD =
\ (@ a34_a9dI)
(w_sbty :: Maybe String)
(ww_sbtI :: GHC.Prim.Word#)
(ww1_sbtJ :: GHC.Prim.Word#)
(ww2_sbtM :: String)
(ww3_sbtO :: [Data.Typeable.Internal.KindRep])
(ww4_sbtP :: [TypeRep])
(ww5_sbtY :: GHC.Prim.Word#)
(ww6_sbtZ :: GHC.Prim.Word#)
(ww7_sbu2 :: String)
(ww8_sbu4 :: [Data.Typeable.Internal.KindRep])
(ww9_sbu5 :: [TypeRep])
(ww10_sbue :: GHC.Prim.Word#)
(ww11_sbuf :: GHC.Prim.Word#)
(ww12_sbui :: String)
(ww13_sbuk :: [Data.Typeable.Internal.KindRep])
(ww14_sbul :: [TypeRep]) ->
let {
alt_a9dZ [Dmd=<B,U>] :: Bool
[LclId, Str=DmdType]
alt_a9dZ = GHC.Base.eqString ww2_sbtM lvl25_rbPn } in
let {
f_a9e3 :: [Char] -> [Char]
[LclId, Arity=1, Str=DmdType <L,U>]
f_a9e3 =
\ (x_iaBu :: [Char]) ->
case alt_a9dZ of _ [Occ=Dead] {
False -> filter @ Char a31_rbPu x_iaBu;
True -> filter @ Char a31_rbPu (g_rbPw x_iaBu)
} } in
error
@ a34_a9dI
(unlines
(GHC.Types.:
@ [Char]
(++ @ Char (f_a9e3 lvl26_rbPo) lvl8_rbP1)
(let {
ds_dazu :: [(String, String)]
[LclId, Str=DmdType]
ds_dazu =
let {
a35_sbfQ :: String
[LclId, Str=DmdType]
a35_sbfQ =
Data.Typeable.Internal.$w$cshowsPrec
GHC.Show.shows18
(Data.Typeable.Internal.TyCon
ww10_sbue ww11_sbuf lvl36_rbPB lvl37_rbPC ww12_sbui)
ww13_sbuk
ww14_sbul
(GHC.Types.[] @ Char) } in
let {
a36_sbfV :: String
[LclId, Str=DmdType]
a36_sbfV =
Data.Typeable.Internal.$w$cshowsPrec
GHC.Show.shows18
(Data.Typeable.Internal.TyCon
ww5_sbtY ww6_sbtZ lvl34_rbPz lvl35_rbPA ww7_sbu2)
ww8_sbu4
ww9_sbu5
(GHC.Types.[] @ Char) } in
case w_sbty of _ [Occ=Dead] {
Nothing ->
GHC.Types.:
@ (String, String)
(f_a9e3 lvl29_rbPr, a36_sbfV)
(GHC.Types.:
@ (String, String)
(f_a9e3 lvl30_rbPs, a35_sbfQ)
(GHC.Types.[] @ (String, String)));
Just b_X9ia ->
GHC.Types.:
@ (String, String)
(f_a9e3 lvl28_rbPq, b_X9ia)
(GHC.Types.:
@ (String, String)
(f_a9e3 lvl29_rbPr, a36_sbfV)
(GHC.Types.:
@ (String, String)
(f_a9e3 lvl30_rbPs, a35_sbfQ)
(GHC.Types.[] @ (String, String))))
} } in
let {
a35_sbg2 :: String
[LclId, Str=DmdType]
a35_sbg2 =
Data.Typeable.Internal.$w$cshowsPrec
GHC.Show.shows18
(Data.Typeable.Internal.TyCon
ww_sbtI ww1_sbtJ lvl32_rbPx lvl33_rbPy ww2_sbtM)
ww3_sbtO
ww4_sbtP
(GHC.Types.[] @ Char) } in
let {
a36_sbg4 :: [Char]
[LclId, Str=DmdType]
a36_sbg4 = f_a9e3 lvl27_rbPp } in
let {
a37_sbg3 :: (String, String)
[LclId, Str=DmdType m]
a37_sbg3 = (a36_sbg4, a35_sbg2) } in
let {
args2_a9dU :: [(String, String)]
[LclId, Str=DmdType]
args2_a9dU = GHC.Types.: @ (String, String) a37_sbg3 ds_dazu } in
let {
as_a9dT [Dmd=<L,U(U)>] :: Int
[LclId, Str=DmdType]
as_a9dT =
GHC.List.strictMaximum
@ Int
GHC.Classes.$fOrdInt
(GHC.Types.:
@ Int
lvl4_rbOX
(map @ ([Char], String) @ Int lvl5_rbOY args2_a9dU)) } in
let {
z3_iaAT :: [[Char]]
[LclId, Str=DmdType]
z3_iaAT =
let {
hint_a9dS [Dmd=<S,U>] :: String
[LclId, Str=DmdType]
hint_a9dS = f_a9e3 lvl31_rbPt } in
case GHC.Classes.$fEq[]_$s$c==1 hint_a9dS (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ [Char] hint_a9dS (GHC.Types.[] @ [Char]);
True -> GHC.Types.[] @ [Char]
} } in
letrec {
go2_iaAV [Occ=LoopBreaker] :: [(String, String)] -> [[Char]]
[LclId, Arity=1, Str=DmdType <S,1*U>]
go2_iaAV =
\ (ds1_iaAW :: [(String, String)]) ->
case ds1_iaAW of _ [Occ=Dead] {
[] -> z3_iaAT;
: y_iaB1 ys_iaB2 ->
case y_iaB1 of _ [Occ=Dead] { (a38_a9dX, b_a9dY) ->
GHC.Types.:
@ [Char]
(GHC.CString.unpackAppendCString#
" "#
(++
@ Char
a38_a9dX
(let {
n_XaH3 :: [Char]
[LclId, Str=DmdType]
n_XaH3 =
case as_a9dT of _ [Occ=Dead] { GHC.Types.I# x_iaHS ->
case GHC.List.$wlenAcc @ Char a38_a9dX 0
of ww15_ib1S { __DEFAULT ->
let {
y1_iaBc :: GHC.Prim.Int#
[LclId, Str=DmdType]
y1_iaBc = GHC.Prim.+# (GHC.Prim.-# x_iaHS ww15_ib1S) 2 } in
case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# 0 y1_iaBc)
of _ [Occ=Dead] {
False -> b_a9dY;
True ->
let {
lvl65_sbG0 :: [Char]
[LclId, Str=DmdType]
lvl65_sbG0 = GHC.Types.: @ Char lvl7_rbP0 b_a9dY } in
letrec {
$wxs_sbtv [InlPrag=[0], Occ=LoopBreaker]
:: GHC.Prim.Int# -> [Char]
[LclId, Arity=1, Str=DmdType <S,1*U>]
$wxs_sbtv =
\ (ww16_sbtt :: GHC.Prim.Int#) ->
case ww16_sbtt of ds2_iaIV {
__DEFAULT ->
GHC.Types.:
@ Char
lvl7_rbP0
($wxs_sbtv (GHC.Prim.-# ds2_iaIV 1));
1 -> lvl65_sbG0
}; } in
$wxs_sbtv y1_iaBc
}
}
} } in
case GHC.Classes.$fEq[]_$s$c==1 a38_a9dX (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ Char lvl6_rbOZ n_XaH3;
True -> n_XaH3
})))
(go2_iaAV ys_iaB2)
}
}; } in
go2_iaAV args2_a9dU)))
Development.Shake.Errors.$werrorRuleTypeMismatch [InlPrag=[0]]
:: forall a_a9dI.
GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> Maybe String
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> a_a9dI
[GblId,
Arity=16,
Str=DmdType <B,U><B,U><B,U><B,1*U><B,1*U><B,1*U><B,U><B,U><B,U><B,1*U><B,1*U><B,U><B,U><B,U><B,1*U><B,1*U>b]
Development.Shake.Errors.$werrorRuleTypeMismatch =
\ (@ a34_a9dI)
(ww_sbtI :: GHC.Prim.Word#)
(ww1_sbtJ :: GHC.Prim.Word#)
(ww2_sbtM :: String)
(ww3_sbtO :: [Data.Typeable.Internal.KindRep])
(ww4_sbtP :: [TypeRep])
(w_sbty :: Maybe String)
(ww5_sbtY :: GHC.Prim.Word#)
(ww6_sbtZ :: GHC.Prim.Word#)
(ww7_sbu2 :: String)
(ww8_sbu4 :: [Data.Typeable.Internal.KindRep])
(ww9_sbu5 :: [TypeRep])
(ww10_sbue :: GHC.Prim.Word#)
(ww11_sbuf :: GHC.Prim.Word#)
(ww12_sbui :: String)
(ww13_sbuk :: [Data.Typeable.Internal.KindRep])
(ww14_sbul :: [TypeRep]) ->
lvl38_rbPD
@ a34_a9dI
w_sbty
ww_sbtI
ww1_sbtJ
ww2_sbtM
ww3_sbtO
ww4_sbtP
ww5_sbtY
ww6_sbtZ
ww7_sbu2
ww8_sbu4
ww9_sbu5
ww10_sbue
ww11_sbuf
ww12_sbui
ww13_sbuk
ww14_sbul
errorRuleTypeMismatch [InlPrag=INLINE[0]]
:: forall a_a9dI.
TypeRep -> Maybe String -> TypeRep -> TypeRep -> a_a9dI
[GblId,
Arity=4,
Str=DmdType <B,U(A,A,U(U,U,A,A,U),1*U,1*U)><B,1*U><B,1*U(A,A,U(U,U,A,A,U),1*U,1*U)><B,1*U(A,A,U(U,U,A,A,U),1*U,1*U)>b,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=4,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ a34_a9dI)
(w_sbtx [Occ=Once!] :: TypeRep)
(w1_sbty [Occ=Once] :: Maybe String)
(w2_sbtz [Occ=Once!] :: TypeRep)
(w3_sbtA [Occ=Once!] :: TypeRep) ->
case w_sbtx
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep _ [Occ=Dead] _ [Occ=Dead]
ww3_sbtF [Occ=Once!] ww4_sbtO [Occ=Once]
ww5_sbtP [Occ=Once] ->
case ww3_sbtF
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww7_sbtI [Occ=Once]
ww8_sbtJ [Occ=Once] _ [Occ=Dead] _ [Occ=Dead]
ww11_sbtM [Occ=Once] ->
case w2_sbtz
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep _ [Occ=Dead] _ [Occ=Dead]
ww15_sbtV [Occ=Once!] ww16_sbu4 [Occ=Once]
ww17_sbu5 [Occ=Once] ->
case ww15_sbtV
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww19_sbtY [Occ=Once]
ww20_sbtZ [Occ=Once] _ [Occ=Dead] _ [Occ=Dead]
ww23_sbu2 [Occ=Once] ->
case w3_sbtA
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep _ [Occ=Dead] _ [Occ=Dead]
ww27_sbub [Occ=Once!] ww28_sbuk [Occ=Once]
ww29_sbul [Occ=Once] ->
case ww27_sbub
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww31_sbue [Occ=Once]
ww32_sbuf [Occ=Once] _ [Occ=Dead] _ [Occ=Dead]
ww35_sbui [Occ=Once] ->
Development.Shake.Errors.$werrorRuleTypeMismatch
@ a34_a9dI
ww7_sbtI
ww8_sbtJ
ww11_sbtM
ww4_sbtO
ww5_sbtP
w1_sbty
ww19_sbtY
ww20_sbtZ
ww23_sbu2
ww16_sbu4
ww17_sbu5
ww31_sbue
ww32_sbuf
ww35_sbui
ww28_sbuk
ww29_sbul
}
}
}
}
}
}}]
errorRuleTypeMismatch =
\ (@ a34_a9dI)
(w_sbtx :: TypeRep)
(w1_sbty :: Maybe String)
(w2_sbtz :: TypeRep)
(w3_sbtA :: TypeRep) ->
case w_sbtx
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep ww1_sbtD ww2_sbtE ww3_sbtF
ww4_sbtO ww5_sbtP ->
case ww3_sbtF
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww7_sbtI ww8_sbtJ ww9_sbtK ww10_sbtL
ww11_sbtM ->
case w2_sbtz
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep ww13_sbtT ww14_sbtU ww15_sbtV
ww16_sbu4 ww17_sbu5 ->
case ww15_sbtV
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww19_sbtY ww20_sbtZ ww21_sbu0
ww22_sbu1 ww23_sbu2 ->
case w3_sbtA
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep ww25_sbu9 ww26_sbua ww27_sbub
ww28_sbuk ww29_sbul ->
case ww27_sbub
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww31_sbue ww32_sbuf ww33_sbug
ww34_sbuh ww35_sbui ->
Development.Shake.Errors.$werrorRuleTypeMismatch
@ a34_a9dI
ww7_sbtI
ww8_sbtJ
ww11_sbtM
ww4_sbtO
ww5_sbtP
w1_sbty
ww19_sbtY
ww20_sbtZ
ww23_sbu2
ww16_sbu4
ww17_sbu5
ww31_sbue
ww32_sbuf
ww35_sbui
ww28_sbuk
ww29_sbul
}
}
}
}
}
}
lvl39_rbPE :: [Char]
[GblId, Str=DmdType]
lvl39_rbPE =
GHC.CString.unpackCString#
"Build system error - cannot currently call _apply_"#
lvl40_rbPF :: [Char]
[GblId, Str=DmdType]
lvl40_rbPF = GHC.CString.unpackCString# "Reason"#
lvl41_rbPG :: [Char]
[GblId, Str=DmdType]
lvl41_rbPG =
GHC.CString.unpackCString# "Move the _apply_ call earlier/later"#
Rec {
$wunsafeDrop1_rbPH
:: forall a1_iaBN. GHC.Prim.Int# -> [a1_iaBN] -> [a1_iaBN]
[GblId, Arity=2, Caf=NoCafRefs, Str=DmdType <L,1*U><S,1*U>]
$wunsafeDrop1_rbPH =
\ (@ a34_iaBN) (ww_sbus :: GHC.Prim.Int#) (w_sbup :: [a34_iaBN]) ->
case w_sbup of _ [Occ=Dead] {
[] -> GHC.Types.[] @ a34_iaBN;
: ipv1_iaBY ipv2_iaBZ ->
case ww_sbus of ds3_iaC1 {
__DEFAULT ->
$wunsafeDrop1_rbPH @ a34_iaBN (GHC.Prim.-# ds3_iaC1 1) ipv2_iaBZ;
1 -> ipv2_iaBZ
}
}
end Rec }
Rec {
g1_rbPI :: [Char] -> [Char]
[GblId, Arity=1, Str=DmdType <L,U>]
g1_rbPI =
\ (xs_a9e5 :: [Char]) ->
case filter
@ ([Char], [Char])
(\ (ds_daA1 [OS=ProbOneShot] :: ([Char], [Char])) ->
case ds_daA1 of _ [Occ=Dead] { (a34_a9e6, b_a9e7) ->
isPrefixOf @ Char GHC.Classes.$fEqChar a34_a9e6 xs_a9e5
})
alternatives_r9dx
of _ [Occ=Dead] {
[] ->
case xs_a9e5 of _ [Occ=Dead] {
[] -> GHC.Types.[] @ Char;
: x_a9ea xs1_a9eb -> GHC.Types.: @ Char x_a9ea (g1_rbPI xs1_a9eb)
};
: ds_daA3 ds1_daA4 ->
case ds_daA3 of _ [Occ=Dead] { (a34_a9e8, b_a9e9) ->
++
@ Char
b_a9e9
(g1_rbPI
(case GHC.List.$wlenAcc @ Char a34_a9e8 0
of ww2_ib1S { __DEFAULT ->
case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<=# ww2_ib1S 0)
of _ [Occ=Dead] {
False -> $wunsafeDrop1_rbPH @ Char ww2_ib1S xs_a9e5;
True -> xs_a9e5
}
}))
}
}
end Rec }
lvl42_rbPJ :: String
[GblId, Str=DmdType b]
lvl42_rbPJ =
Control.Exception.Base.absentError @ String "ww_sbuQ String"#
lvl43_rbPK :: String
[GblId, Str=DmdType b]
lvl43_rbPK =
Control.Exception.Base.absentError @ String "ww_sbuR String"#
lvl44_rbPL
:: forall a_a9dD.
Maybe String
-> String
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> a_a9dD
[GblId, Arity=7, Str=DmdType <L,U><L,U><L,U><L,U><L,U><L,U><L,U>b]
lvl44_rbPL =
\ (@ a34_a9dD)
(w_sbuF :: Maybe String)
(w1_sbuG :: String)
(ww_sbuO :: GHC.Prim.Word#)
(ww1_sbuP :: GHC.Prim.Word#)
(ww2_sbuS :: String)
(ww3_sbuU :: [Data.Typeable.Internal.KindRep])
(ww4_sbuV :: [TypeRep]) ->
let {
alt_a9dZ [Dmd=<B,U>] :: Bool
[LclId, Str=DmdType]
alt_a9dZ = GHC.Base.eqString ww2_sbuS lvl25_rbPn } in
let {
f_a9e3 :: [Char] -> [Char]
[LclId, Arity=1, Str=DmdType <L,U>]
f_a9e3 =
\ (x_iaBu :: [Char]) ->
case alt_a9dZ of _ [Occ=Dead] {
False -> filter @ Char a31_rbPu x_iaBu;
True -> filter @ Char a31_rbPu (g1_rbPI x_iaBu)
} } in
error
@ a34_a9dD
(unlines
(GHC.Types.:
@ [Char]
(++ @ Char (f_a9e3 lvl39_rbPE) lvl8_rbP1)
(let {
a35_sbgG :: [Char]
[LclId, Str=DmdType]
a35_sbgG = f_a9e3 lvl40_rbPF } in
let {
a36_sbgF :: (String, String)
[LclId, Str=DmdType m]
a36_sbgF = (a35_sbgG, w1_sbuG) } in
let {
ds_XaDm :: [(String, String)]
[LclId, Str=DmdType]
ds_XaDm =
case w_sbuF of _ [Occ=Dead] {
Nothing -> GHC.Types.[] @ (String, String);
Just b_a9dW ->
GHC.Types.:
@ (String, String)
(f_a9e3 lvl28_rbPq, b_a9dW)
(GHC.Types.[] @ (String, String))
} } in
let {
a37_sbgB :: String
[LclId, Str=DmdType]
a37_sbgB =
Data.Typeable.Internal.$w$cshowsPrec
GHC.Show.shows18
(Data.Typeable.Internal.TyCon
ww_sbuO ww1_sbuP lvl42_rbPJ lvl43_rbPK ww2_sbuS)
ww3_sbuU
ww4_sbuV
(GHC.Types.[] @ Char) } in
let {
a38_sbgD :: [Char]
[LclId, Str=DmdType]
a38_sbgD = f_a9e3 lvl27_rbPp } in
let {
a39_sbgC :: (String, String)
[LclId, Str=DmdType m]
a39_sbgC = (a38_sbgD, a37_sbgB) } in
let {
a40_sbgH :: [(String, String)]
[LclId, Str=DmdType]
a40_sbgH = GHC.Types.: @ (String, String) a39_sbgC ds_XaDm } in
let {
args2_a9dU :: [(String, String)]
[LclId, Str=DmdType]
args2_a9dU = GHC.Types.: @ (String, String) a36_sbgF a40_sbgH } in
let {
as_a9dT [Dmd=<L,U(U)>] :: Int
[LclId, Str=DmdType]
as_a9dT =
GHC.List.strictMaximum
@ Int
GHC.Classes.$fOrdInt
(GHC.Types.:
@ Int
lvl4_rbOX
(map @ ([Char], String) @ Int lvl5_rbOY args2_a9dU)) } in
let {
z3_iaAT :: [[Char]]
[LclId, Str=DmdType]
z3_iaAT =
let {
hint_a9dS [Dmd=<S,U>] :: String
[LclId, Str=DmdType]
hint_a9dS = f_a9e3 lvl41_rbPG } in
case GHC.Classes.$fEq[]_$s$c==1 hint_a9dS (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ [Char] hint_a9dS (GHC.Types.[] @ [Char]);
True -> GHC.Types.[] @ [Char]
} } in
letrec {
go2_iaAV [Occ=LoopBreaker] :: [(String, String)] -> [[Char]]
[LclId, Arity=1, Str=DmdType <S,1*U>]
go2_iaAV =
\ (ds1_iaAW :: [(String, String)]) ->
case ds1_iaAW of _ [Occ=Dead] {
[] -> z3_iaAT;
: y_iaB1 ys_iaB2 ->
case y_iaB1 of _ [Occ=Dead] { (a41_a9dX, b_a9dY) ->
GHC.Types.:
@ [Char]
(GHC.CString.unpackAppendCString#
" "#
(++
@ Char
a41_a9dX
(let {
n_XaH3 :: [Char]
[LclId, Str=DmdType]
n_XaH3 =
case as_a9dT of _ [Occ=Dead] { GHC.Types.I# x_iaHS ->
case GHC.List.$wlenAcc @ Char a41_a9dX 0
of ww5_ib1S { __DEFAULT ->
let {
y1_iaBc :: GHC.Prim.Int#
[LclId, Str=DmdType]
y1_iaBc = GHC.Prim.+# (GHC.Prim.-# x_iaHS ww5_ib1S) 2 } in
case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# 0 y1_iaBc)
of _ [Occ=Dead] {
False -> b_a9dY;
True ->
let {
lvl65_sbGg :: [Char]
[LclId, Str=DmdType]
lvl65_sbGg = GHC.Types.: @ Char lvl7_rbP0 b_a9dY } in
letrec {
$wxs_sbuC [InlPrag=[0], Occ=LoopBreaker]
:: GHC.Prim.Int# -> [Char]
[LclId, Arity=1, Str=DmdType <S,1*U>]
$wxs_sbuC =
\ (ww6_sbuA :: GHC.Prim.Int#) ->
case ww6_sbuA of ds2_iaIV {
__DEFAULT ->
GHC.Types.:
@ Char
lvl7_rbP0
($wxs_sbuC (GHC.Prim.-# ds2_iaIV 1));
1 -> lvl65_sbGg
}; } in
$wxs_sbuC y1_iaBc
}
}
} } in
case GHC.Classes.$fEq[]_$s$c==1 a41_a9dX (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ Char lvl6_rbOZ n_XaH3;
True -> n_XaH3
})))
(go2_iaAV ys_iaB2)
}
}; } in
go2_iaAV args2_a9dU)))
Development.Shake.Errors.$werrorNoApply [InlPrag=[0]]
:: forall a_a9dD.
GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> Maybe String
-> String
-> a_a9dD
[GblId,
Arity=7,
Str=DmdType <B,U><B,U><B,U><B,1*U><B,1*U><B,1*U><B,U>b]
Development.Shake.Errors.$werrorNoApply =
\ (@ a34_a9dD)
(ww_sbuO :: GHC.Prim.Word#)
(ww1_sbuP :: GHC.Prim.Word#)
(ww2_sbuS :: String)
(ww3_sbuU :: [Data.Typeable.Internal.KindRep])
(ww4_sbuV :: [TypeRep])
(w_sbuF :: Maybe String)
(w1_sbuG :: String) ->
lvl44_rbPL
@ a34_a9dD
w_sbuF
w1_sbuG
ww_sbuO
ww1_sbuP
ww2_sbuS
ww3_sbuU
ww4_sbuV
errorNoApply [InlPrag=INLINE[0]]
:: forall a_a9dD. TypeRep -> Maybe String -> String -> a_a9dD
[GblId,
Arity=3,
Str=DmdType <B,U(A,A,U(U,U,A,A,U),1*U,1*U)><B,1*U><B,U>b,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=3,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ a34_a9dD)
(w_sbuE [Occ=Once!] :: TypeRep)
(w1_sbuF [Occ=Once] :: Maybe String)
(w2_sbuG [Occ=Once] :: String) ->
case w_sbuE
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep _ [Occ=Dead] _ [Occ=Dead]
ww3_sbuL [Occ=Once!] ww4_sbuU [Occ=Once]
ww5_sbuV [Occ=Once] ->
case ww3_sbuL
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww7_sbuO [Occ=Once]
ww8_sbuP [Occ=Once] _ [Occ=Dead] _ [Occ=Dead]
ww11_sbuS [Occ=Once] ->
Development.Shake.Errors.$werrorNoApply
@ a34_a9dD
ww7_sbuO
ww8_sbuP
ww11_sbuS
ww4_sbuU
ww5_sbuV
w1_sbuF
w2_sbuG
}
}}]
errorNoApply =
\ (@ a34_a9dD)
(w_sbuE :: TypeRep)
(w1_sbuF :: Maybe String)
(w2_sbuG :: String) ->
case w_sbuE
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep ww1_sbuJ ww2_sbuK ww3_sbuL
ww4_sbuU ww5_sbuV ->
case ww3_sbuL
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww7_sbuO ww8_sbuP ww9_sbuQ ww10_sbuR
ww11_sbuS ->
Development.Shake.Errors.$werrorNoApply
@ a34_a9dD
ww7_sbuO
ww8_sbuP
ww11_sbuS
ww4_sbuU
ww5_sbuV
w1_sbuF
w2_sbuG
}
}
lvl45_rbPM :: [Char]
[GblId, Str=DmdType]
lvl45_rbPM = GHC.CString.unpackCString# "multiple"#
lvl46_rbPN :: [Char]
[GblId, Str=DmdType]
lvl46_rbPN = GHC.CString.unpackCString# "no"#
lvl47_rbPO :: [Char]
[GblId, Str=DmdType]
lvl47_rbPO = GHC.CString.unpackCString# "Rules matched"#
lvl48_rbPP :: [Char]
[GblId, Str=DmdType]
lvl48_rbPP =
GHC.CString.unpackCString#
"Modify your rules/defaultRules so only one can produce the above key"#
lvl49_rbPQ :: [Char]
[GblId, Str=DmdType]
lvl49_rbPQ =
GHC.CString.unpackCString#
"Either add a rule that produces the above key, or stop requiring the above key"#
a32_rbPR :: String
[GblId, Str=DmdType b]
a32_rbPR =
Control.Exception.Base.absentError @ String "ww_sbvh String"#
a33_rbPS :: String
[GblId, Str=DmdType b]
a33_rbPS =
Control.Exception.Base.absentError @ String "ww_sbvi String"#
lvl50_rbPT :: [Char]
[GblId, Str=DmdType]
lvl50_rbPT = GHC.CString.unpackCString# " rules:"#
lvl51_rbPU :: [Char]
[GblId, Str=DmdType]
lvl51_rbPU = ++ @ Char lvl45_rbPM lvl50_rbPT
lvl52_rbPV :: [Char]
[GblId, Str=DmdType]
lvl52_rbPV = ++ @ Char lvl46_rbPN lvl50_rbPT
lvl53_rbPW
:: forall a_a9dG.
String
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> GHC.Prim.Int#
-> a_a9dG
[GblId, Arity=7, Str=DmdType <L,U><L,U><L,U><L,U><L,U><L,U><L,U>b]
lvl53_rbPW =
\ (@ a34_a9dG)
(w_sbv6 :: String)
(ww_sbvf :: GHC.Prim.Word#)
(ww1_sbvg :: GHC.Prim.Word#)
(ww2_sbvj :: String)
(ww3_sbvl :: [Data.Typeable.Internal.KindRep])
(ww4_sbvm :: [TypeRep])
(ww5_sbvq :: GHC.Prim.Int#) ->
error
@ a34_a9dG
(unlines
(GHC.Types.:
@ [Char]
(GHC.CString.unpackAppendCString#
"Build system error - key matches "#
(case ww5_sbvq of _ [Occ=Dead] {
__DEFAULT -> lvl51_rbPU;
0 -> lvl52_rbPV
}))
(let {
a35_sb5L :: String
[LclId, Str=DmdType]
a35_sb5L =
Data.Typeable.Internal.$w$cshowsPrec
GHC.Show.shows18
(Data.Typeable.Internal.TyCon
ww_sbvf ww1_sbvg a32_rbPR a33_rbPS ww2_sbvj)
ww3_sbvl
ww4_sbvm
(GHC.Types.[] @ Char) } in
let {
a36_sb5K :: (String, String)
[LclId, Str=DmdType m]
a36_sb5K = (lvl11_rbP5, a35_sb5L) } in
let {
a37_sb5N :: (String, String)
[LclId, Str=DmdType m]
a37_sb5N = (lvl12_rbP6, w_sbv6) } in
let {
a38_sb5Q :: String
[LclId, Str=DmdType]
a38_sb5Q =
case GHC.Show.$wshowSignedInt 0 ww5_sbvq (GHC.Types.[] @ Char)
of _ [Occ=Dead] { (# ww7_ib8B, ww8_ib8C #) ->
GHC.Types.: @ Char ww7_ib8B ww8_ib8C
} } in
let {
a39_sb5P :: (String, String)
[LclId, Str=DmdType m]
a39_sb5P = (lvl47_rbPO, a38_sb5Q) } in
let {
a40_sb5O :: [(String, String)]
[LclId, Str=DmdType]
a40_sb5O =
GHC.Types.:
@ (String, String) a39_sb5P (GHC.Types.[] @ (String, String)) } in
let {
a41_sb5M :: [(String, String)]
[LclId, Str=DmdType]
a41_sb5M = GHC.Types.: @ (String, String) a37_sb5N a40_sb5O } in
let {
args2_a9dU :: [(String, String)]
[LclId, Str=DmdType]
args2_a9dU = GHC.Types.: @ (String, String) a36_sb5K a41_sb5M } in
let {
as_a9dT [Dmd=<L,U(U)>] :: Int
[LclId, Str=DmdType]
as_a9dT =
GHC.List.strictMaximum
@ Int
GHC.Classes.$fOrdInt
(GHC.Types.:
@ Int
lvl4_rbOX
(map @ ([Char], String) @ Int lvl5_rbOY args2_a9dU)) } in
let {
z3_iaAT :: [[Char]]
[LclId, Str=DmdType]
z3_iaAT =
let {
hint_a9dS [Dmd=<S,U>] :: String
[LclId, Str=DmdType]
hint_a9dS =
case ww5_sbvq of _ [Occ=Dead] {
__DEFAULT -> lvl48_rbPP;
0 -> lvl49_rbPQ
} } in
case GHC.Classes.$fEq[]_$s$c==1 hint_a9dS (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ [Char] hint_a9dS (GHC.Types.[] @ [Char]);
True -> GHC.Types.[] @ [Char]
} } in
letrec {
go2_iaAV [Occ=LoopBreaker] :: [(String, String)] -> [[Char]]
[LclId, Arity=1, Str=DmdType <S,1*U>]
go2_iaAV =
\ (ds_iaAW :: [(String, String)]) ->
case ds_iaAW of _ [Occ=Dead] {
[] -> z3_iaAT;
: y_iaB1 ys_iaB2 ->
case y_iaB1 of _ [Occ=Dead] { (a42_a9dX, b_a9dY) ->
GHC.Types.:
@ [Char]
(GHC.CString.unpackAppendCString#
" "#
(++
@ Char
a42_a9dX
(let {
n_XaH3 :: [Char]
[LclId, Str=DmdType]
n_XaH3 =
case as_a9dT of _ [Occ=Dead] { GHC.Types.I# x_iaHS ->
case GHC.List.$wlenAcc @ Char a42_a9dX 0
of ww6_ib1S { __DEFAULT ->
let {
y1_iaBc :: GHC.Prim.Int#
[LclId, Str=DmdType]
y1_iaBc = GHC.Prim.+# (GHC.Prim.-# x_iaHS ww6_ib1S) 2 } in
case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# 0 y1_iaBc)
of _ [Occ=Dead] {
False -> b_a9dY;
True ->
let {
lvl65_sbGv :: [Char]
[LclId, Str=DmdType]
lvl65_sbGv = GHC.Types.: @ Char lvl7_rbP0 b_a9dY } in
letrec {
$wxs_sbv3 [InlPrag=[0], Occ=LoopBreaker]
:: GHC.Prim.Int# -> [Char]
[LclId, Arity=1, Str=DmdType <S,1*U>]
$wxs_sbv3 =
\ (ww7_sbv1 :: GHC.Prim.Int#) ->
case ww7_sbv1 of ds1_iaIV {
__DEFAULT ->
GHC.Types.:
@ Char
lvl7_rbP0
($wxs_sbv3 (GHC.Prim.-# ds1_iaIV 1));
1 -> lvl65_sbGv
}; } in
$wxs_sbv3 y1_iaBc
}
}
} } in
case GHC.Classes.$fEq[]_$s$c==1 a42_a9dX (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ Char lvl6_rbOZ n_XaH3;
True -> n_XaH3
})))
(go2_iaAV ys_iaB2)
}
}; } in
go2_iaAV args2_a9dU)))
lvl54_rbPX
:: forall a_a9dG.
String
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> a_a9dG
[GblId, Arity=6, Str=DmdType <L,U><L,U><L,U><L,U><L,U><L,U>b]
lvl54_rbPX =
\ (@ a34_a9dG)
(w_sbv6 :: String)
(ww_sbvf :: GHC.Prim.Word#)
(ww1_sbvg :: GHC.Prim.Word#)
(ww2_sbvj :: String)
(ww3_sbvl :: [Data.Typeable.Internal.KindRep])
(ww4_sbvm :: [TypeRep]) ->
$werrorDuplicateOracle_rbPm
@ a34_a9dG
ww_sbvf
ww1_sbvg
ww2_sbvj
ww3_sbvl
ww4_sbvm
(GHC.Base.Just @ String w_sbv6)
(GHC.Types.[] @ TypeRep)
lvl55_rbPY
:: forall a_a9dG.
GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> a_a9dG
[GblId, Arity=5, Str=DmdType <L,U><L,U><L,U><L,U><L,U>b]
lvl55_rbPY =
\ (@ a34_a9dG)
(ww_sbvf :: GHC.Prim.Word#)
(ww1_sbvg :: GHC.Prim.Word#)
(ww2_sbvj :: String)
(ww3_sbvl :: [Data.Typeable.Internal.KindRep])
(ww4_sbvm :: [TypeRep]) ->
err
@ a34_a9dG
(GHC.CString.unpackAppendCString#
"no oracle match for "#
(Data.Typeable.Internal.$w$cshowsPrec
GHC.Show.shows18
(Data.Typeable.Internal.TyCon
ww_sbvf ww1_sbvg a32_rbPR a33_rbPS ww2_sbvj)
ww3_sbvl
ww4_sbvm
(GHC.Types.[] @ Char)))
Development.Shake.Errors.$werrorMultipleRulesMatch [InlPrag=[0]]
:: forall a_a9dG.
GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> String
-> GHC.Prim.Int#
-> a_a9dG
[GblId, Arity=7, Str=DmdType <B,U><B,U><B,U><B,U><B,U><B,U><B,U>b]
Development.Shake.Errors.$werrorMultipleRulesMatch =
\ (@ a34_a9dG)
(ww_sbvf :: GHC.Prim.Word#)
(ww1_sbvg :: GHC.Prim.Word#)
(ww2_sbvj :: String)
(ww3_sbvl :: [Data.Typeable.Internal.KindRep])
(ww4_sbvm :: [TypeRep])
(w_sbv6 :: String)
(ww5_sbvq :: GHC.Prim.Int#) ->
case GHC.Base.eqString ww2_sbvj lvl25_rbPn of _ [Occ=Dead] {
False ->
lvl53_rbPW
@ a34_a9dG
w_sbv6
ww_sbvf
ww1_sbvg
ww2_sbvj
ww3_sbvl
ww4_sbvm
ww5_sbvq;
True ->
case ww5_sbvq of _ [Occ=Dead] {
__DEFAULT ->
lvl54_rbPX
@ a34_a9dG w_sbv6 ww_sbvf ww1_sbvg ww2_sbvj ww3_sbvl ww4_sbvm;
0 ->
lvl55_rbPY @ a34_a9dG ww_sbvf ww1_sbvg ww2_sbvj ww3_sbvl ww4_sbvm
}
}
errorMultipleRulesMatch [InlPrag=INLINE[0]]
:: forall a_a9dG. TypeRep -> String -> Int -> a_a9dG
[GblId,
Arity=3,
Str=DmdType <B,1*U(A,A,U(U,U,A,A,U),U,U)><B,U><B,U(U)>b,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=3,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ a34_a9dG)
(w_sbv5 [Occ=Once!] :: TypeRep)
(w1_sbv6 [Occ=Once] :: String)
(w2_sbv7 [Occ=Once!] :: Int) ->
case w_sbv5
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep _ [Occ=Dead] _ [Occ=Dead]
ww3_sbvc [Occ=Once!] ww4_sbvl [Occ=Once]
ww5_sbvm [Occ=Once] ->
case ww3_sbvc
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww7_sbvf [Occ=Once]
ww8_sbvg [Occ=Once] _ [Occ=Dead] _ [Occ=Dead]
ww11_sbvj [Occ=Once] ->
case w2_sbv7 of _ [Occ=Dead] { GHC.Types.I# ww13_sbvq [Occ=Once] ->
Development.Shake.Errors.$werrorMultipleRulesMatch
@ a34_a9dG
ww7_sbvf
ww8_sbvg
ww11_sbvj
ww4_sbvl
ww5_sbvm
w1_sbv6
ww13_sbvq
}
}
}}]
errorMultipleRulesMatch =
\ (@ a34_a9dG)
(w_sbv5 :: TypeRep)
(w1_sbv6 :: String)
(w2_sbv7 :: Int) ->
case w_sbv5
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep ww1_sbva ww2_sbvb ww3_sbvc
ww4_sbvl ww5_sbvm ->
case ww3_sbvc
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww7_sbvf ww8_sbvg ww9_sbvh ww10_sbvi
ww11_sbvj ->
case w2_sbv7 of _ [Occ=Dead] { GHC.Types.I# ww13_sbvq ->
Development.Shake.Errors.$werrorMultipleRulesMatch
@ a34_a9dG
ww7_sbvf
ww8_sbvg
ww11_sbvj
ww4_sbvl
ww5_sbvm
w1_sbv6
ww13_sbvq
}
}
}
lvl56_rbPZ :: [Char]
[GblId, Str=DmdType]
lvl56_rbPZ =
GHC.CString.unpackCString#
"Build system error - rule has multiple result types"#
lvl57_rbQ0 :: [Char]
[GblId, Str=DmdType]
lvl57_rbQ0 = GHC.CString.unpackCString# "First result type"#
lvl58_rbQ1 :: [Char]
[GblId, Str=DmdType]
lvl58_rbQ1 = GHC.CString.unpackCString# "Second result type"#
lvl59_rbQ2 :: [Char]
[GblId, Str=DmdType]
lvl59_rbQ2 =
GHC.CString.unpackCString#
"A function passed to rule/defaultRule has the wrong result type"#
lvl60_rbQ3 :: [Char]
[GblId, Str=DmdType]
lvl60_rbQ3 = ++ @ Char lvl56_rbPZ lvl8_rbP1
lvl61_rbQ4 :: String
[GblId, Str=DmdType b]
lvl61_rbQ4 =
Control.Exception.Base.absentError @ String "ww_sbvM String"#
lvl62_rbQ5 :: String
[GblId, Str=DmdType b]
lvl62_rbQ5 =
Control.Exception.Base.absentError @ String "ww_sbvN String"#
z2_rbQ6 :: [[Char]]
[GblId, Str=DmdType]
z2_rbQ6 =
case GHC.Classes.$fEq[]_$s$c==1 lvl59_rbQ2 (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ [Char] lvl59_rbQ2 (GHC.Types.[] @ [Char]);
True -> GHC.Types.[] @ [Char]
}
lvl63_rbQ7
:: forall a_a9dH.
TypeRep
-> TypeRep
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> a_a9dH
[GblId, Arity=7, Str=DmdType <L,U><L,U><L,U><L,U><L,U><L,U><L,U>b]
lvl63_rbQ7 =
\ (@ a34_a9dH)
(w_sbvB :: TypeRep)
(w1_sbvC :: TypeRep)
(ww_sbvK :: GHC.Prim.Word#)
(ww1_sbvL :: GHC.Prim.Word#)
(ww2_sbvO :: String)
(ww3_sbvQ :: [Data.Typeable.Internal.KindRep])
(ww4_sbvR :: [TypeRep]) ->
error
@ a34_a9dH
(unlines
(GHC.Types.:
@ [Char]
lvl60_rbQ3
(let {
a35_sb6h :: String
[LclId, Str=DmdType]
a35_sb6h =
Data.Typeable.Internal.$w$cshowsPrec
GHC.Show.shows18
(Data.Typeable.Internal.TyCon
ww_sbvK ww1_sbvL lvl61_rbQ4 lvl62_rbQ5 ww2_sbvO)
ww3_sbvQ
ww4_sbvR
(GHC.Types.[] @ Char) } in
let {
a36_sb6g :: (String, String)
[LclId, Str=DmdType m]
a36_sb6g = (lvl11_rbP5, a35_sb6h) } in
let {
a37_sb6k :: String
[LclId, Str=DmdType]
a37_sb6k =
case w_sbvB
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep ww6_iaVl ww7_iaVm ww8_iaVn
ww9_iaVo ww10_iaVp ->
Data.Typeable.Internal.$w$cshowsPrec
GHC.Show.shows18 ww8_iaVn ww9_iaVo ww10_iaVp (GHC.Types.[] @ Char)
} } in
let {
a38_sb6j :: (String, String)
[LclId, Str=DmdType m]
a38_sb6j = (lvl57_rbQ0, a37_sb6k) } in
let {
a39_sb6n :: String
[LclId, Str=DmdType]
a39_sb6n =
case w1_sbvC
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep ww6_iaVl ww7_iaVm ww8_iaVn
ww9_iaVo ww10_iaVp ->
Data.Typeable.Internal.$w$cshowsPrec
GHC.Show.shows18 ww8_iaVn ww9_iaVo ww10_iaVp (GHC.Types.[] @ Char)
} } in
let {
a40_sb6m :: (String, String)
[LclId, Str=DmdType m]
a40_sb6m = (lvl58_rbQ1, a39_sb6n) } in
let {
a41_sb6l :: [(String, String)]
[LclId, Str=DmdType]
a41_sb6l =
GHC.Types.:
@ (String, String) a40_sb6m (GHC.Types.[] @ (String, String)) } in
let {
a42_sb6i :: [(String, String)]
[LclId, Str=DmdType]
a42_sb6i = GHC.Types.: @ (String, String) a38_sb6j a41_sb6l } in
let {
args2_a9dU :: [(String, String)]
[LclId, Str=DmdType]
args2_a9dU = GHC.Types.: @ (String, String) a36_sb6g a42_sb6i } in
let {
as_a9dT [Dmd=<L,U(U)>] :: Int
[LclId, Str=DmdType]
as_a9dT =
GHC.List.strictMaximum
@ Int
GHC.Classes.$fOrdInt
(GHC.Types.:
@ Int
lvl4_rbOX
(map @ ([Char], String) @ Int lvl5_rbOY args2_a9dU)) } in
letrec {
go2_iaAV [Occ=LoopBreaker] :: [(String, String)] -> [[Char]]
[LclId, Arity=1, Str=DmdType <S,1*U>]
go2_iaAV =
\ (ds_iaAW :: [(String, String)]) ->
case ds_iaAW of _ [Occ=Dead] {
[] -> z2_rbQ6;
: y_iaB1 ys_iaB2 ->
case y_iaB1 of _ [Occ=Dead] { (a43_a9dX, b_a9dY) ->
GHC.Types.:
@ [Char]
(GHC.CString.unpackAppendCString#
" "#
(++
@ Char
a43_a9dX
(let {
n_XaH3 :: [Char]
[LclId, Str=DmdType]
n_XaH3 =
case as_a9dT of _ [Occ=Dead] { GHC.Types.I# x_iaHS ->
case GHC.List.$wlenAcc @ Char a43_a9dX 0
of ww5_ib1S { __DEFAULT ->
let {
y1_iaBc :: GHC.Prim.Int#
[LclId, Str=DmdType]
y1_iaBc = GHC.Prim.+# (GHC.Prim.-# x_iaHS ww5_ib1S) 2 } in
case GHC.Prim.tagToEnum# @ Bool (GHC.Prim.<# 0 y1_iaBc)
of _ [Occ=Dead] {
False -> b_a9dY;
True ->
let {
lvl65_sbGK :: [Char]
[LclId, Str=DmdType]
lvl65_sbGK = GHC.Types.: @ Char lvl7_rbP0 b_a9dY } in
letrec {
$wxs_sbvy [InlPrag=[0], Occ=LoopBreaker]
:: GHC.Prim.Int# -> [Char]
[LclId, Arity=1, Str=DmdType <S,1*U>]
$wxs_sbvy =
\ (ww6_sbvw :: GHC.Prim.Int#) ->
case ww6_sbvw of ds1_iaIV {
__DEFAULT ->
GHC.Types.:
@ Char
lvl7_rbP0
($wxs_sbvy (GHC.Prim.-# ds1_iaIV 1));
1 -> lvl65_sbGK
}; } in
$wxs_sbvy y1_iaBc
}
}
} } in
case GHC.Classes.$fEq[]_$s$c==1 a43_a9dX (GHC.Types.[] @ Char)
of _ [Occ=Dead] {
False -> GHC.Types.: @ Char lvl6_rbOZ n_XaH3;
True -> n_XaH3
})))
(go2_iaAV ys_iaB2)
}
}; } in
go2_iaAV args2_a9dU)))
lvl64_rbQ8
:: forall a_a9dH.
TypeRep
-> TypeRep
-> GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> a_a9dH
[GblId, Arity=7, Str=DmdType <L,U><L,U><L,U><L,U><L,U><L,U><L,U>b]
lvl64_rbQ8 =
\ (@ a34_a9dH)
(w_sbvB :: TypeRep)
(w1_sbvC :: TypeRep)
(ww_sbvK :: GHC.Prim.Word#)
(ww1_sbvL :: GHC.Prim.Word#)
(ww2_sbvO :: String)
(ww3_sbvQ :: [Data.Typeable.Internal.KindRep])
(ww4_sbvR :: [TypeRep]) ->
$werrorDuplicateOracle_rbPm
@ a34_a9dH
ww_sbvK
ww1_sbvL
ww2_sbvO
ww3_sbvQ
ww4_sbvR
(GHC.Base.Nothing @ String)
(GHC.Types.:
@ TypeRep
w_sbvB
(GHC.Types.: @ TypeRep w1_sbvC (GHC.Types.[] @ TypeRep)))
Development.Shake.Errors.$werrorIncompatibleRules [InlPrag=[0]]
:: forall a_a9dH.
GHC.Prim.Word#
-> GHC.Prim.Word#
-> String
-> [Data.Typeable.Internal.KindRep]
-> [TypeRep]
-> TypeRep
-> TypeRep
-> a_a9dH
[GblId, Arity=7, Str=DmdType <B,U><B,U><B,U><B,U><B,U><B,U><B,U>b]
Development.Shake.Errors.$werrorIncompatibleRules =
\ (@ a34_a9dH)
(ww_sbvK :: GHC.Prim.Word#)
(ww1_sbvL :: GHC.Prim.Word#)
(ww2_sbvO :: String)
(ww3_sbvQ :: [Data.Typeable.Internal.KindRep])
(ww4_sbvR :: [TypeRep])
(w_sbvB :: TypeRep)
(w1_sbvC :: TypeRep) ->
case GHC.Base.eqString ww2_sbvO lvl25_rbPn of _ [Occ=Dead] {
False ->
lvl63_rbQ7
@ a34_a9dH
w_sbvB
w1_sbvC
ww_sbvK
ww1_sbvL
ww2_sbvO
ww3_sbvQ
ww4_sbvR;
True ->
lvl64_rbQ8
@ a34_a9dH
w_sbvB
w1_sbvC
ww_sbvK
ww1_sbvL
ww2_sbvO
ww3_sbvQ
ww4_sbvR
}
errorIncompatibleRules [InlPrag=INLINE[0]]
:: forall a_a9dH. TypeRep -> TypeRep -> TypeRep -> a_a9dH
[GblId,
Arity=3,
Str=DmdType <B,1*U(A,A,U(U,U,A,A,U),U,U)><B,U><B,U>b,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=3,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ a34_a9dH)
(w_sbvA [Occ=Once!] :: TypeRep)
(w1_sbvB [Occ=Once] :: TypeRep)
(w2_sbvC [Occ=Once] :: TypeRep) ->
case w_sbvA
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep _ [Occ=Dead] _ [Occ=Dead]
ww3_sbvH [Occ=Once!] ww4_sbvQ [Occ=Once]
ww5_sbvR [Occ=Once] ->
case ww3_sbvH
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww7_sbvK [Occ=Once]
ww8_sbvL [Occ=Once] _ [Occ=Dead] _ [Occ=Dead]
ww11_sbvO [Occ=Once] ->
Development.Shake.Errors.$werrorIncompatibleRules
@ a34_a9dH
ww7_sbvK
ww8_sbvL
ww11_sbvO
ww4_sbvQ
ww5_sbvR
w1_sbvB
w2_sbvC
}
}}]
errorIncompatibleRules =
\ (@ a34_a9dH)
(w_sbvA :: TypeRep)
(w1_sbvB :: TypeRep)
(w2_sbvC :: TypeRep) ->
case w_sbvA
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep ww1_sbvF ww2_sbvG ww3_sbvH
ww4_sbvQ ww5_sbvR ->
case ww3_sbvH
of _ [Occ=Dead]
{ Data.Typeable.Internal.TyCon ww7_sbvK ww8_sbvL ww9_sbvM ww10_sbvN
ww11_sbvO ->
Development.Shake.Errors.$werrorIncompatibleRules
@ a34_a9dH
ww7_sbvK
ww8_sbvL
ww11_sbvO
ww4_sbvQ
ww5_sbvR
w1_sbvB
w2_sbvC
}
}
[35 of 55] Compiling Development.Shake.Core ( src\Development\Shake\Core.hs, .hpc\core\Development\Shake\Core.o )
==================== Tidy Core ====================
Result size of Tidy Core
= {terms: 10,462, types: 23,048, coercions: 4,135}
Development.Shake.Core.$p1Rule
:: forall key_aeta value_aetb.
Rule key_aeta value_aetb =>
ShakeValue key_aeta
[GblId[ClassOp],
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S(SLLL),U(U,A,A,A)>,
RULES: Built in rule for Development.Shake.Core.$p1Rule: "Class op $p1Rule"]
Development.Shake.Core.$p1Rule =
\ (@ key_aeta)
(@ value_aetb)
(tpl_B1 :: Rule key_aeta value_aetb) ->
case tpl_B1
of tpl_B1
{ Development.Shake.Core.D:Rule tpl_B2 tpl_B3 tpl_B4 tpl_B5 ->
tpl_B2
}
Development.Shake.Core.$p2Rule
:: forall key_aeta value_aetb.
Rule key_aeta value_aetb =>
ShakeValue value_aetb
[GblId[ClassOp],
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S(LSLL),U(A,U,A,A)>,
RULES: Built in rule for Development.Shake.Core.$p2Rule: "Class op $p2Rule"]
Development.Shake.Core.$p2Rule =
\ (@ key_aeta)
(@ value_aetb)
(tpl_B1 :: Rule key_aeta value_aetb) ->
case tpl_B1
of tpl_B1
{ Development.Shake.Core.D:Rule tpl_B2 tpl_B3 tpl_B4 tpl_B5 ->
tpl_B3
}
storedValue
:: forall key_aeta value_aetb.
Rule key_aeta value_aetb =>
ShakeOptions -> key_aeta -> IO (Maybe value_aetb)
[GblId[ClassOp],
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S(LLSL),U(A,A,U,A)>,
RULES: Built in rule for storedValue: "Class op storedValue"]
storedValue =
\ (@ key_aeta)
(@ value_aetb)
(tpl_B1 :: Rule key_aeta value_aetb) ->
case tpl_B1
of tpl_B1
{ Development.Shake.Core.D:Rule tpl_B2 tpl_B3 tpl_B4 tpl_B5 ->
tpl_B4
}
equalValue
:: forall key_aeta value_aetb.
Rule key_aeta value_aetb =>
ShakeOptions -> key_aeta -> value_aetb -> value_aetb -> EqualCost
[GblId[ClassOp],
Arity=1,
Caf=NoCafRefs,
Str=DmdType <S(LLLS),U(A,A,A,U)>,
RULES: Built in rule for equalValue: "Class op equalValue"]
equalValue =
\ (@ key_aeta)
(@ value_aetb)
(tpl_B1 :: Rule key_aeta value_aetb) ->
case tpl_B1
of tpl_B1
{ Development.Shake.Core.D:Rule tpl_B2 tpl_B3 tpl_B4 tpl_B5 ->
tpl_B5
}
Development.Shake.Core.$WLocal [InlPrag=INLINE]
:: Stack
-> Verbosity
-> Maybe String
-> [Depends]
-> Seconds
-> [Trace]
-> [Key -> Bool]
-> [Key]
-> Local
[GblId[DataConWrapper],
Arity=8,
Caf=NoCafRefs,
Str=DmdType <L,U><L,U><L,U><L,U><S,U><L,U><L,U><L,U>m,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=8,unsat_ok=False,boring_ok=False)
Tmpl= \ (dt_aeEz [Occ=Once] :: Stack)
(dt_aeEA [Occ=Once] :: Verbosity)
(dt_aeEB [Occ=Once] :: Maybe String)
(dt_aeEC [Occ=Once] :: [Depends])
(dt_aeED [Occ=Once!] :: Seconds)
(dt_aeEE [Occ=Once] :: [Trace])
(dt_aeEF [Occ=Once] :: [Key -> Bool])
(dt_aeEG [Occ=Once] :: [Key]) ->
case dt_aeED of _ [Occ=Dead] { GHC.Types.D# dt_aeEH [Occ=Once] ->
Development.Shake.Core.Local
dt_aeEz dt_aeEA dt_aeEB dt_aeEC dt_aeEH dt_aeEE dt_aeEF dt_aeEG
}}]
Development.Shake.Core.$WLocal =
\ (dt_aeEz [Occ=Once] :: Stack)
(dt_aeEA [Occ=Once] :: Verbosity)
(dt_aeEB [Occ=Once] :: Maybe String)
(dt_aeEC [Occ=Once] :: [Depends])
(dt_aeED [Occ=Once!] :: Seconds)
(dt_aeEE [Occ=Once] :: [Trace])
(dt_aeEF [Occ=Once] :: [Key -> Bool])
(dt_aeEG [Occ=Once] :: [Key]) ->
case dt_aeED of _ [Occ=Dead] { GHC.Types.D# dt_aeEH [Occ=Once] ->
Development.Shake.Core.Local
dt_aeEz dt_aeEA dt_aeEB dt_aeEC dt_aeEH dt_aeEE dt_aeEF dt_aeEG
}
Development.Shake.Core.withoutActions1
:: Rules ()
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, ((), SRules Action) #)
[GblId,
Arity=2,
Caf=NoCafRefs,
Str=DmdType <C(S(LS)),1*C1(U(U,1*U(U,1*U(A,U))))><L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=2,unsat_ok=True,boring_ok=False)
Tmpl= \ (ds_XjzD [Occ=Once] :: Rules ())
(s_ilkM [Occ=Once, OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld) ->
case (ds_XjzD
`cast` (Development.Shake.Core.NTCo:Rules[0] <()>_N
; Control.Monad.Trans.Writer.Strict.NTCo:WriterT[0]
<SRules Action>_N <IO>_R <()>_N
; GHC.Types.NTCo:IO[0] <((), SRules Action)>_R
:: Rules ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld,
((), SRules Action) #))))
s_ilkM
of _ [Occ=Dead]
{ (# ipv_ilkP [Occ=Once], ipv1_ilkQ [Occ=Once!] #) ->
case ipv1_ilkQ
of _ [Occ=Dead] { (a59_apWD [Occ=Once], w4_apWE [Occ=Once!]) ->
(# ipv_ilkP,
(a59_apWD,
case w4_apWE
of _ [Occ=Dead] { SRules _ [Occ=Dead] ds3_djer [Occ=Once] ->
Development.Shake.Core.SRules
@ Action (GHC.Types.[] @ (Action ())) ds3_djer
}) #)
}
}}]
Development.Shake.Core.withoutActions1 =
\ (ds_XjzD :: Rules ())
(s_ilkM [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case (ds_XjzD
`cast` (Development.Shake.Core.NTCo:Rules[0] <()>_N
; Control.Monad.Trans.Writer.Strict.NTCo:WriterT[0]
<SRules Action>_N <IO>_R <()>_N
; GHC.Types.NTCo:IO[0] <((), SRules Action)>_R
:: Rules ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, ((), SRules Action) #))))
s_ilkM
of _ [Occ=Dead] { (# ipv_ilkP, ipv1_ilkQ #) ->
case ipv1_ilkQ of _ [Occ=Dead] { (a59_apWD, w4_apWE) ->
(# ipv_ilkP,
(a59_apWD,
case w4_apWE of _ [Occ=Dead] { SRules ds2_djeq ds3_djer ->
Development.Shake.Core.SRules
@ Action (GHC.Types.[] @ (Action ())) ds3_djer
}) #)
}
}
a_rxsz :: [Char]
[GblId, Str=DmdType]
a_rxsz = GHC.CString.unpackCString# "askOracle"#
a1_rxsA :: [Char]
[GblId, Str=DmdType]
a1_rxsA = GHC.CString.unpackCString# "_apply_"#
a2_rxsB :: ([Char], [Char])
[GblId, Str=DmdType m]
a2_rxsB = (a1_rxsA, a_rxsz)
a3_rxsC :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a3_rxsC =
GHC.Types.:
@ ([Char], [Char]) a2_rxsB (GHC.Types.[] @ ([Char], [Char]))
a4_rxsD :: [Char]
[GblId, Str=DmdType]
a4_rxsD = GHC.CString.unpackCString# "addOracle"#
a5_rxsE :: [Char]
[GblId, Str=DmdType]
a5_rxsE = GHC.CString.unpackCString# "_rule/defaultRule_"#
a6_rxsF :: ([Char], [Char])
[GblId, Str=DmdType m]
a6_rxsF = (a5_rxsE, a4_rxsD)
a7_rxsG :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a7_rxsG = GHC.Types.: @ ([Char], [Char]) a6_rxsF a3_rxsC
a8_rxsH :: [Char]
[GblId, Str=DmdType]
a8_rxsH = GHC.CString.unpackCString# "Answer"#
a9_rxsI :: [Char]
[GblId, Str=DmdType]
a9_rxsI = GHC.CString.unpackCString# "_Result_"#
a10_rxsJ :: ([Char], [Char])
[GblId, Str=DmdType m]
a10_rxsJ = (a9_rxsI, a8_rxsH)
a11_rxsK :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a11_rxsK = GHC.Types.: @ ([Char], [Char]) a10_rxsJ a7_rxsG
a12_rxsL :: [Char]
[GblId, Str=DmdType]
a12_rxsL = GHC.CString.unpackCString# "answer"#
a13_rxsM :: [Char]
[GblId, Str=DmdType]
a13_rxsM = GHC.CString.unpackCString# "_result_"#
a14_rxsN :: ([Char], [Char])
[GblId, Str=DmdType m]
a14_rxsN = (a13_rxsM, a12_rxsL)
a15_rxsO :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a15_rxsO = GHC.Types.: @ ([Char], [Char]) a14_rxsN a11_rxsK
a16_rxsP :: [Char]
[GblId, Str=DmdType]
a16_rxsP = GHC.CString.unpackCString# "Question"#
a17_rxsQ :: [Char]
[GblId, Str=DmdType]
a17_rxsQ = GHC.CString.unpackCString# "_Key_"#
a18_rxsR :: ([Char], [Char])
[GblId, Str=DmdType m]
a18_rxsR = (a17_rxsQ, a16_rxsP)
a19_rxsS :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a19_rxsS = GHC.Types.: @ ([Char], [Char]) a18_rxsR a15_rxsO
a20_rxsT :: [Char]
[GblId, Str=DmdType]
a20_rxsT = GHC.CString.unpackCString# "question"#
a21_rxsU :: [Char]
[GblId, Str=DmdType]
a21_rxsU = GHC.CString.unpackCString# "_key_"#
a22_rxsV :: ([Char], [Char])
[GblId, Str=DmdType m]
a22_rxsV = (a21_rxsU, a20_rxsT)
a23_rxsW :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a23_rxsW = GHC.Types.: @ ([Char], [Char]) a22_rxsV a19_rxsS
a24_rxsX :: [Char]
[GblId, Str=DmdType]
a24_rxsX = GHC.CString.unpackCString# "Oracle"#
a25_rxsY :: [Char]
[GblId, Str=DmdType]
a25_rxsY = GHC.CString.unpackCString# "_Rule_"#
a26_rxsZ :: ([Char], [Char])
[GblId, Str=DmdType m]
a26_rxsZ = (a25_rxsY, a24_rxsX)
a27_rxt0 :: [([Char], [Char])]
[GblId, Str=DmdType m2]
a27_rxt0 = GHC.Types.: @ ([Char], [Char]) a26_rxsZ a23_rxsW
a28_rxt1 :: [Char]
[GblId, Str=DmdType]
a28_rxt1 = GHC.CString.unpackCString# "oracle"#
a29_rxt2 :: [Char]
[GblId, Str=DmdType]
a29_rxt2 = GHC.CString.unpackCString# "_rule_"#
a30_rxt3 :: ([Char], [Char])
[GblId, Str=DmdType m]
a30_rxt3 = (a29_rxt2, a28_rxt1)
Development.Shake.Core.unsafeIgnoreDependencies1
:: forall a_af0q.
Action a_af0q
-> S Global Local
-> (a_af0q -> IO ())
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
Arity=4,
Caf=NoCafRefs,
Str=DmdType <L,1*C1(C1(C1(U(U,U))))><S(LLS),1*U(U,U,U(U))><L,C(C1(U))><L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=4,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ a59_af0q)
(act_XeFz [Occ=Once] :: Action a59_af0q)
(eta_B3 [Occ=Once!] :: S Global Local)
(eta1_Xcq [Occ=OnceL!] :: a59_af0q -> IO ())
(eta2_B1 [Occ=Once, OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld) ->
case eta_B3
of wild_ilT9 { S _ [Occ=Dead] _ [Occ=Dead] ds2_ilTd [Occ=Once] ->
case ds2_ilTd
`cast` (GHC.IORef.NTCo:IORef[0] <Local>_N
:: IORef Local ~R# GHC.STRef.STRef GHC.Prim.RealWorld Local)
of _ [Occ=Dead] { GHC.STRef.STRef var#_ilTh ->
case GHC.Prim.readMutVar#
@ GHC.Prim.RealWorld @ Local var#_ilTh eta2_B1
of _ [Occ=Dead]
{ (# ipv_ilTl [Occ=Once], ipv1_ilTm [Occ=Once!] #) ->
let {
pre_aeCx [Occ=OnceL] :: [Depends]
[LclId, Str=DmdType]
pre_aeCx =
case ipv1_ilTm
of _ [Occ=Dead]
{ Local _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] ds7_djmp [Occ=Once]
_ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] ->
ds7_djmp
} } in
(((((act_XeFz
`cast` (Development.Shake.Core.NTCo:Action[0]
; Development.Shake.Monad.NTCo:RAW[0]
<Global>_R <Local>_R <a59_af0q>_N
; Control.Monad.Trans.Reader.NTCo:ReaderT[0]
<S Global Local>_R <ContT () IO>_R <a59_af0q>_N
:: Action a59_af0q ~R# (S Global Local -> ContT () IO a59_af0q)))
wild_ilT9)
`cast` (Control.Monad.Trans.Cont.NTCo:ContT[0]
<()>_N <IO>_R <a59_af0q>_R
:: ContT () IO a59_af0q ~R# ((a59_af0q -> IO ()) -> IO ())))
((\ (x_ilFI [Occ=Once] :: a59_af0q)
(eta3_XcA [Occ=Once, OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld) ->
case GHC.Prim.readMutVar#
@ GHC.Prim.RealWorld @ Local var#_ilTh eta3_XcA
of _ [Occ=Dead]
{ (# ipv2_ilTR [Occ=Once], ipv3_ilTS [Occ=Once!] #) ->
case ipv3_ilTS
of _ [Occ=Dead]
{ Local ds5_dj8F [Occ=Once] ds6_dj8G [Occ=Once] ds7_dj8H [Occ=Once]
_ [Occ=Dead] dt_djut [Occ=Once] ds9_dj8K [Occ=Once]
ds10_dj8L [Occ=Once] ds11_dj8M [Occ=Once] ->
case GHC.Prim.writeMutVar#
@ GHC.Prim.RealWorld
@ Local
var#_ilTh
(Development.Shake.Core.Local
ds5_dj8F
ds6_dj8G
ds7_dj8H
pre_aeCx
dt_djut
ds9_dj8K
ds10_dj8L
ds11_dj8M)
ipv2_ilTR
of s2#_ilTV [OS=OneShot] { __DEFAULT ->
((eta1_Xcq x_ilFI)
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
s2#_ilTV
}
}
})
`cast` (<a59_af0q>_R -> Sym (GHC.Types.NTCo:IO[0] <()>_R)
:: (a59_af0q
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# (a59_af0q -> IO ()))))
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
ipv_ilTl
}
}
}}]
Development.Shake.Core.unsafeIgnoreDependencies1 =
\ (@ a59_af0q)
(act_XeFz :: Action a59_af0q)
(eta_B3 :: S Global Local)
(eta1_Xcq :: a59_af0q -> IO ())
(eta2_B1 [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case eta_B3 of wild_ilT9 { S ds_ilTb ds1_ilTc ds2_ilTd ->
case ds2_ilTd
`cast` (GHC.IORef.NTCo:IORef[0] <Local>_N
:: IORef Local ~R# GHC.STRef.STRef GHC.Prim.RealWorld Local)
of _ [Occ=Dead] { GHC.STRef.STRef var#_ilTh ->
case GHC.Prim.readMutVar#
@ GHC.Prim.RealWorld @ Local var#_ilTh eta2_B1
of _ [Occ=Dead] { (# ipv_ilTl, ipv1_ilTm #) ->
let {
pre_aeCx :: [Depends]
[LclId, Str=DmdType]
pre_aeCx =
case ipv1_ilTm
of _ [Occ=Dead]
{ Local ds4_djmm ds5_djmn ds6_djmo ds7_djmp dt_djuV ds8_djmr
ds9_djms ds10_djmt ->
ds7_djmp
} } in
(((((act_XeFz
`cast` (Development.Shake.Core.NTCo:Action[0]
; Development.Shake.Monad.NTCo:RAW[0]
<Global>_R <Local>_R <a59_af0q>_N
; Control.Monad.Trans.Reader.NTCo:ReaderT[0]
<S Global Local>_R <ContT () IO>_R <a59_af0q>_N
:: Action a59_af0q ~R# (S Global Local -> ContT () IO a59_af0q)))
wild_ilT9)
`cast` (Control.Monad.Trans.Cont.NTCo:ContT[0]
<()>_N <IO>_R <a59_af0q>_R
:: ContT () IO a59_af0q ~R# ((a59_af0q -> IO ()) -> IO ())))
((\ (x_ilFI :: a59_af0q)
(eta3_XcA [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case GHC.Prim.readMutVar#
@ GHC.Prim.RealWorld @ Local var#_ilTh eta3_XcA
of _ [Occ=Dead] { (# ipv2_ilTR, ipv3_ilTS #) ->
case ipv3_ilTS
of _ [Occ=Dead]
{ Local ds5_dj8F ds6_dj8G ds7_dj8H ds8_dj8I dt_djut ds9_dj8K
ds10_dj8L ds11_dj8M ->
case GHC.Prim.writeMutVar#
@ GHC.Prim.RealWorld
@ Local
var#_ilTh
(Development.Shake.Core.Local
ds5_dj8F
ds6_dj8G
ds7_dj8H
pre_aeCx
dt_djut
ds9_dj8K
ds10_dj8L
ds11_dj8M)
ipv2_ilTR
of s2#_ilTV [OS=OneShot] { __DEFAULT ->
((eta1_Xcq x_ilFI)
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
s2#_ilTV
}
}
})
`cast` (<a59_af0q>_R -> Sym (GHC.Types.NTCo:IO[0] <()>_R)
:: (a59_af0q
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))
~R# (a59_af0q -> IO ()))))
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
ipv_ilTl
}
}
}
Development.Shake.Core.$wa4 [InlPrag=[0]]
:: forall key_af2X.
ShakeValue key_af2X =>
key_af2X
-> Database
-> GHC.Prim.MutVar# GHC.Prim.RealWorld Local
-> (() -> IO ())
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
Arity=6,
Str=DmdType <L,U(1*U,U,1*U,1*U,1*U,1*U)><L,U><L,U(U(U),A,U(U),A,A,A,A)><L,U><L,1*C1(C1(U(U,U)))><L,U>]
Development.Shake.Core.$wa4 =
\ (@ key_af2X)
(w_st71 :: ShakeValue key_af2X)
(w1_st72 :: key_af2X)
(ww_st7c :: Database)
(ww1_st7r :: GHC.Prim.MutVar# GHC.Prim.RealWorld Local)
(w2_st74 :: () -> IO ())
(w3_st75 [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case GHC.Prim.readMutVar#
@ GHC.Prim.RealWorld @ Local ww1_st7r w3_st75
of _ [Occ=Dead] { (# ipv_imIb, ipv1_imIc #) ->
case ipv1_imIc
of _ [Occ=Dead]
{ Local ds_djax ds1_djay ds2_djaz ds4_djaA dt_djuu ds5_djaC
ds6_djaD ds7_djaE ->
letrec {
a59_smJs [Occ=LoopBreaker]
:: [Depends]
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, [[Key]] #)
[LclId, Arity=2, Str=DmdType <S,1*U><L,U>]
a59_smJs =
\ (ds8_ik58 :: [Depends])
(eta_XrH [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case ds8_ik58 of _ [Occ=Dead] {
[] -> (# eta_XrH, GHC.Types.[] @ [Key] #);
: y_ik5e ys_ik5f ->
case ww_st7c
of _ [Occ=Dead]
{ Development.Shake.Database.Database ww3_imHL ww4_imHM ww5_imHN
ww6_imHO ww7_imHP ww8_imHQ ww9_imHR ->
case Development.Shake.Database.$wa8
ww3_imHL ww5_imHN y_ik5e eta_XrH
of _ [Occ=Dead] { (# ipv2_ilkP, ipv3_ilkQ #) ->
case a59_smJs ys_ik5f ipv2_ilkP
of _ [Occ=Dead] { (# ipv4_XlMM, ipv5_XlMO #) ->
(# ipv4_XlMM, GHC.Types.: @ [Key] ipv3_ilkQ ipv5_XlMO #)
}
}
}
}; } in
case a59_smJs ds4_djaA ipv_imIb
of _ [Occ=Dead] { (# ipv2_ilkP, ipv3_ilkQ #) ->
case ds_djax
of wild1_ik5n
{ Development.Shake.Database.Stack key1_ik5s ds9_ik5t ds10_ik5u ->
let {
$j_snHY
:: GHC.Prim.Void# -> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[LclId, Arity=1, Str=DmdType <L,A>]
$j_snHY =
\ _ [Occ=Dead, OS=OneShot] ->
let {
a60_smHy :: Eq key_af2X
[LclId, Str=DmdType]
a60_smHy =
case w_st71
of _ [Occ=Dead]
{ (tpl_X5X, tpl1_X5Z, tpl2_Xcp, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl2_Xcp
} } in
let {
a61_smHz :: Show key_af2X
[LclId, Str=DmdType]
a61_smHz =
case w_st71
of _ [Occ=Dead]
{ (tpl_X61, tpl1_X63, tpl2_Xcr, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl_X61
} } in
let {
a62_smHA :: Typeable key_af2X
[LclId, Str=DmdType]
a62_smHA =
case w_st71
of _ [Occ=Dead]
{ (tpl_X5Z, tpl1_X61, tpl2_Xct, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl1_X61
} } in
let {
a63_smHB :: Hashable key_af2X
[LclId, Str=DmdType]
a63_smHB =
case w_st71
of _ [Occ=Dead]
{ (tpl_X5V, tpl1_X5X, tpl2_Xcv, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl3_B4
} } in
let {
a64_smHC :: Binary key_af2X
[LclId, Str=DmdType]
a64_smHC =
case w_st71
of _ [Occ=Dead]
{ (tpl_X5T, tpl1_X5V, tpl2_Xcx, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl4_B5
} } in
let {
a65_smHD :: NFData key_af2X
[LclId, Str=DmdType]
a65_smHD =
case w_st71
of _ [Occ=Dead]
{ (tpl_X5R, tpl1_X5T, tpl2_Xcz, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl5_B6
} } in
let {
a66_smHx :: Value
[LclId, Str=DmdType]
a66_smHx =
Development.Shake.Value.Value
@ key_af2X
a60_smHy
a61_smHz
a62_smHA
a63_smHB
a64_smHC
a65_smHD
w1_st72 } in
case GHC.List.elem
@ Key
Development.Shake.Value.$fEqKey
(a66_smHx
`cast` (Sym Development.Shake.Value.NTCo:Key[0] :: Value ~R# Key))
(Control.Monad.Extra.concatMapM1 @ Key ipv3_ilkQ)
of _ [Occ=Dead] {
False ->
letrec {
go5_imIR [Occ=LoopBreaker] :: [Key -> Bool] -> Any
[LclId, Arity=1, Str=DmdType <S,1*U>]
go5_imIR =
\ (ds11_imIS :: [Key -> Bool]) ->
case ds11_imIS of _ [Occ=Dead] {
[] ->
GHC.Types.False
`cast` (Sym Data.Monoid.NTCo:Any[0] :: Bool ~R# Any);
: y_imIX ys_imIY ->
case y_imIX
(a66_smHx
`cast` (Sym Development.Shake.Value.NTCo:Key[0] :: Value ~R# Key))
of _ [Occ=Dead] {
False -> go5_imIR ys_imIY;
True ->
GHC.Types.True `cast` (Sym Data.Monoid.NTCo:Any[0] :: Bool ~R# Any)
}
}; } in
case (go5_imIR ds6_djaD)
`cast` (Data.Monoid.NTCo:Any[0] :: Any ~R# Bool)
of _ [Occ=Dead] {
False ->
case GHC.Prim.writeMutVar#
@ GHC.Prim.RealWorld
@ Local
ww1_st7r
(Development.Shake.Core.Local
wild1_ik5n
ds1_djay
ds2_djaz
ds4_djaA
dt_djuu
ds5_djaC
ds6_djaD
(GHC.Types.:
@ Key
(a66_smHx
`cast` (Sym Development.Shake.Value.NTCo:Key[0] :: Value ~R# Key))
ds7_djaE))
ipv2_ilkP
of s2#_imIw [OS=OneShot] { __DEFAULT ->
((w2_st74 GHC.Tuple.())
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
s2#_imIw
};
True ->
((w2_st74 GHC.Tuple.())
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
ipv2_ilkP
};
True ->
((w2_st74 GHC.Tuple.())
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
ipv2_ilkP
} } in
case key1_ik5s of _ [Occ=Dead] {
Nothing -> $j_snHY GHC.Prim.void#;
Just a60_iksH ->
case a60_iksH
`cast` (Development.Shake.Value.NTCo:Key[0] :: Key ~R# Value)
of _ [Occ=Dead]
{ Development.Shake.Value.Value @ a61_ilr2 $dEq_ilr3 $dShow_ilr4
$dTypeable_ilr5 $dHashable_ilr6 $dBinary_ilr7 $dNFData_ilr8
a62_ilr9 ->
case w_st71
of _ [Occ=Dead]
{ (tpl_X5Z, tpl1_X61, tpl2_Xdu, tpl3_B4, tpl4_B5, tpl5_B6) ->
case (tpl1_X61
`cast` (Data.Typeable.Internal.NTCo:Typeable[0] <*>_N <key_af2X>_N
:: Typeable key_af2X ~R# (GHC.Prim.Proxy# key_af2X -> TypeRep)))
(GHC.Prim.proxy# @ * @ key_af2X)
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep dt1_ilro dt2_ilrp ds11_ilrq
ds12_ilrr ds13_ilrs ->
case ($dTypeable_ilr5
`cast` (Data.Typeable.Internal.NTCo:Typeable[0] <*>_N <a61_ilr2>_N
:: Typeable a61_ilr2 ~R# (GHC.Prim.Proxy# a61_ilr2 -> TypeRep)))
(GHC.Prim.proxy# @ * @ a61_ilr2)
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep dt3_ilrw dt4_ilrx ds14_ilry
ds15_ilrz ds16_ilrA ->
case GHC.Prim.tagToEnum#
@ Bool (GHC.Prim.eqWord# dt1_ilro dt3_ilrw)
of _ [Occ=Dead] {
False -> $j_snHY GHC.Prim.void#;
True ->
case GHC.Prim.tagToEnum#
@ Bool (GHC.Prim.eqWord# dt2_ilrp dt4_ilrx)
of _ [Occ=Dead] {
False -> $j_snHY GHC.Prim.void#;
True ->
case ==
@ a61_ilr2
$dEq_ilr3
a62_ilr9
(w1_st72
`cast` (UnivCo mkUnsafeCo representational key_af2X a61_ilr2
:: key_af2X ~R# a61_ilr2))
of _ [Occ=Dead] {
False -> $j_snHY GHC.Prim.void#;
True ->
((w2_st74 GHC.Tuple.())
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
ipv2_ilkP
}
}
}
}
}
}
}
}
}
}
}
}
Development.Shake.Core.trackUse1 [InlPrag=INLINE[0]]
:: forall key_af2X.
ShakeValue key_af2X =>
key_af2X
-> S Global Local
-> (() -> IO ())
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
Arity=5,
Str=DmdType <L,U(1*U,U,1*U,1*U,1*U,1*U)><L,U><S(LSS),1*U(A,1*U(U(U(U),A,U(U),A,A,A,A),A,A,A,A,A,A,A,A,A,A),1*U(U))><L,1*C1(C1(U(U,U)))><L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=5,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ key_af2X)
(w_st71 [Occ=Once] :: ShakeValue key_af2X)
(w1_st72 [Occ=Once] :: key_af2X)
(w2_st73 [Occ=Once!] :: S Global Local)
(w3_st74 [Occ=Once] :: () -> IO ())
(w4_st75 [Occ=Once, OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld) ->
case w2_st73
of _ [Occ=Dead]
{ S _ [Occ=Dead] ww2_st79 [Occ=Once!] ww3_st7o [Occ=Once] ->
case ww2_st79
of _ [Occ=Dead]
{ Global ww5_st7c [Occ=Once] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead]
_ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead]
_ [Occ=Dead] _ [Occ=Dead] ->
case ww3_st7o
`cast` (GHC.IORef.NTCo:IORef[0] <Local>_N
:: IORef Local ~R# GHC.STRef.STRef GHC.Prim.RealWorld Local)
of _ [Occ=Dead] { GHC.STRef.STRef ww17_st7r [Occ=Once] ->
Development.Shake.Core.$wa4
@ key_af2X w_st71 w1_st72 ww5_st7c ww17_st7r w3_st74 w4_st75
}
}
}}]
Development.Shake.Core.trackUse1 =
\ (@ key_af2X)
(w_st71 :: ShakeValue key_af2X)
(w1_st72 :: key_af2X)
(w2_st73 :: S Global Local)
(w3_st74 :: () -> IO ())
(w4_st75 [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case w2_st73 of _ [Occ=Dead] { S ww1_st78 ww2_st79 ww3_st7o ->
case ww2_st79
of _ [Occ=Dead]
{ Global ww5_st7c ww6_st7d ww7_st7e ww8_st7f ww9_st7g ww10_st7h
ww11_st7i ww12_st7j ww13_st7k ww14_st7l ww15_st7m ->
case ww3_st7o
`cast` (GHC.IORef.NTCo:IORef[0] <Local>_N
:: IORef Local ~R# GHC.STRef.STRef GHC.Prim.RealWorld Local)
of _ [Occ=Dead] { GHC.STRef.STRef ww17_st7r ->
Development.Shake.Core.$wa4
@ key_af2X w_st71 w1_st72 ww5_st7c ww17_st7r w3_st74 w4_st75
}
}
}
Development.Shake.Core.$wa3 [InlPrag=[0]]
:: forall key_af2y.
ShakeValue key_af2y =>
key_af2y
-> IORef [(Key, Key)]
-> GHC.Prim.MutVar# GHC.Prim.RealWorld Local
-> (() -> IO ())
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
Arity=6,
Caf=NoCafRefs,
Str=DmdType <L,U(1*U,U,1*U,1*U,1*U,1*U)><L,U><L,1*U(U)><L,U><L,1*C1(C1(U(U,U)))><L,U>]
Development.Shake.Core.$wa3 =
\ (@ key_af2y)
(w_st7z :: ShakeValue key_af2y)
(w1_st7A :: key_af2y)
(ww_st7U :: IORef [(Key, Key)])
(ww1_st7Z :: GHC.Prim.MutVar# GHC.Prim.RealWorld Local)
(w2_st7C :: () -> IO ())
(w3_st7D [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case GHC.Prim.readMutVar#
@ GHC.Prim.RealWorld @ Local ww1_st7Z w3_st7D
of _ [Occ=Dead] { (# ipv_imIb, ipv1_imIc #) ->
case ipv1_imIc
of _ [Occ=Dead]
{ Local ds_dj9Z ds1_dja0 ds2_dja1 ds4_dja2 dt_djuw ds5_dja4
ds6_dja5 ds7_dja6 ->
case ds_dj9Z
of _ [Occ=Dead]
{ Development.Shake.Database.Stack key1_ik5s ds8_ik5t ds9_ik5u ->
let {
$wa19_st7y [InlPrag=[0]]
:: GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[LclId, Arity=1, Str=DmdType <L,U>]
$wa19_st7y =
\ (w4_st7x [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
let {
a59_smJV :: Eq key_af2y
[LclId, Str=DmdType]
a59_smJV =
case w_st7z
of _ [Occ=Dead]
{ (tpl_X5Y, tpl1_X60, tpl2_Xck, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl2_Xck
} } in
let {
a60_smJW :: Show key_af2y
[LclId, Str=DmdType]
a60_smJW =
case w_st7z
of _ [Occ=Dead]
{ (tpl_X62, tpl1_X64, tpl2_Xcm, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl_X62
} } in
let {
a61_smJX :: Typeable key_af2y
[LclId, Str=DmdType]
a61_smJX =
case w_st7z
of _ [Occ=Dead]
{ (tpl_X60, tpl1_X62, tpl2_Xco, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl1_X62
} } in
let {
a62_smJY :: Hashable key_af2y
[LclId, Str=DmdType]
a62_smJY =
case w_st7z
of _ [Occ=Dead]
{ (tpl_X5W, tpl1_X5Y, tpl2_Xcq, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl3_B4
} } in
let {
a63_smJZ :: Binary key_af2y
[LclId, Str=DmdType]
a63_smJZ =
case w_st7z
of _ [Occ=Dead]
{ (tpl_X5U, tpl1_X5W, tpl2_Xcs, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl4_B5
} } in
let {
a64_smK0 :: NFData key_af2y
[LclId, Str=DmdType]
a64_smK0 =
case w_st7z
of _ [Occ=Dead]
{ (tpl_X5S, tpl1_X5U, tpl2_Xcu, tpl3_B4, tpl4_B5, tpl5_B6) ->
tpl5_B6
} } in
let {
a65_smJU :: Value
[LclId, Str=DmdType]
a65_smJU =
Development.Shake.Value.Value
@ key_af2y
a59_smJV
a60_smJW
a61_smJX
a62_smJY
a63_smJZ
a64_smK0
w1_st7A } in
letrec {
go5_imIR [Occ=LoopBreaker] :: [Key -> Bool] -> Any
[LclId, Arity=1, Str=DmdType <S,1*U>]
go5_imIR =
\ (ds10_imIS :: [Key -> Bool]) ->
case ds10_imIS of _ [Occ=Dead] {
[] ->
GHC.Types.False
`cast` (Sym Data.Monoid.NTCo:Any[0] :: Bool ~R# Any);
: y_imIX ys_imIY ->
case y_imIX
(a65_smJU
`cast` (Sym Development.Shake.Value.NTCo:Key[0] :: Value ~R# Key))
of _ [Occ=Dead] {
False -> go5_imIR ys_imIY;
True ->
GHC.Types.True `cast` (Sym Data.Monoid.NTCo:Any[0] :: Bool ~R# Any)
}
}; } in
case (go5_imIR ds6_dja5)
`cast` (Data.Monoid.NTCo:Any[0] :: Any ~R# Bool)
of _ [Occ=Dead] {
False ->
case ww_st7U
`cast` (GHC.IORef.NTCo:IORef[0] <[(Key, Key)]>_N
:: IORef [(Key, Key)]
~R# GHC.STRef.STRef GHC.Prim.RealWorld [(Key, Key)])
of _ [Occ=Dead] { GHC.STRef.STRef r#_imv3 ->
let {
a66_smK6 :: Key
[LclId, Str=DmdType]
a66_smK6 =
case key1_ik5s of _ [Occ=Dead] {
Nothing ->
a65_smJU
`cast` (Sym Development.Shake.Value.NTCo:Key[0] :: Value ~R# Key);
Just v_ik3e -> v_ik3e
} } in
let {
lvl116_sliq :: (Key, Key)
[LclId, Str=DmdType m]
lvl116_sliq =
(a66_smK6,
a65_smJU
`cast` (Sym Development.Shake.Value.NTCo:Key[0]
:: Value ~R# Key)) } in
GHC.Prim.atomicModifyMutVar#
@ GHC.Prim.RealWorld
@ [(Key, Key)]
@ ([(Key, Key)], ())
@ ()
r#_imv3
(\ (ks_aeBf :: [(Key, Key)]) ->
(GHC.Types.: @ (Key, Key) lvl116_sliq ks_aeBf, GHC.Tuple.()))
w4_st7x
};
True -> (# w4_st7x, GHC.Tuple.() #)
} } in
case key1_ik5s of _ [Occ=Dead] {
Nothing ->
case $wa19_st7y ipv_imIb
of _ [Occ=Dead] { (# ipv2_ilkP, ipv3_ilkQ #) ->
((w2_st7C ipv3_ilkQ)
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
ipv2_ilkP
};
Just a59_iksH ->
case a59_iksH
`cast` (Development.Shake.Value.NTCo:Key[0] :: Key ~R# Value)
of _ [Occ=Dead]
{ Development.Shake.Value.Value @ a60_ilr2 $dEq_ilr3 $dShow_ilr4
$dTypeable_ilr5 $dHashable_ilr6 $dBinary_ilr7 $dNFData_ilr8
a61_ilr9 ->
case w_st7z
of _ [Occ=Dead]
{ (tpl_X60, tpl1_X62, tpl2_Xdo, tpl3_B4, tpl4_B5, tpl5_B6) ->
case (tpl1_X62
`cast` (Data.Typeable.Internal.NTCo:Typeable[0] <*>_N <key_af2y>_N
:: Typeable key_af2y ~R# (GHC.Prim.Proxy# key_af2y -> TypeRep)))
(GHC.Prim.proxy# @ * @ key_af2y)
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep dt1_ilro dt2_ilrp ds10_ilrq
ds11_ilrr ds12_ilrs ->
case ($dTypeable_ilr5
`cast` (Data.Typeable.Internal.NTCo:Typeable[0] <*>_N <a60_ilr2>_N
:: Typeable a60_ilr2 ~R# (GHC.Prim.Proxy# a60_ilr2 -> TypeRep)))
(GHC.Prim.proxy# @ * @ a60_ilr2)
of _ [Occ=Dead]
{ Data.Typeable.Internal.TypeRep dt3_ilrw dt4_ilrx ds13_ilry
ds14_ilrz ds15_ilrA ->
case GHC.Prim.tagToEnum#
@ Bool (GHC.Prim.eqWord# dt1_ilro dt3_ilrw)
of _ [Occ=Dead] {
False ->
case $wa19_st7y ipv_imIb
of _ [Occ=Dead] { (# ipv2_ilkP, ipv3_ilkQ #) ->
((w2_st7C ipv3_ilkQ)
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
ipv2_ilkP
};
True ->
case GHC.Prim.tagToEnum#
@ Bool (GHC.Prim.eqWord# dt2_ilrp dt4_ilrx)
of _ [Occ=Dead] {
False ->
case $wa19_st7y ipv_imIb
of _ [Occ=Dead] { (# ipv2_ilkP, ipv3_ilkQ #) ->
((w2_st7C ipv3_ilkQ)
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
ipv2_ilkP
};
True ->
case ==
@ a60_ilr2
$dEq_ilr3
a61_ilr9
(w1_st7A
`cast` (UnivCo mkUnsafeCo representational key_af2y a60_ilr2
:: key_af2y ~R# a60_ilr2))
of _ [Occ=Dead] {
False ->
case $wa19_st7y ipv_imIb
of _ [Occ=Dead] { (# ipv2_ilkP, ipv3_ilkQ #) ->
((w2_st7C ipv3_ilkQ)
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
ipv2_ilkP
};
True ->
((w2_st7C GHC.Tuple.())
`cast` (GHC.Types.NTCo:IO[0] <()>_R
:: IO ()
~R# (GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #))))
ipv_imIb
}
}
}
}
}
}
}
}
}
}
}
Development.Shake.Core.trackChange1 [InlPrag=INLINE[0]]
:: forall key_af2y.
ShakeValue key_af2y =>
key_af2y
-> S Global Local
-> (() -> IO ())
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
Arity=5,
Caf=NoCafRefs,
Str=DmdType <L,U(1*U,U,1*U,1*U,1*U,1*U)><L,U><S(LSS),1*U(A,1*U(A,A,A,A,A,A,A,A,A,A,1*U(U)),1*U(U))><L,1*C1(C1(U(U,U)))><L,U>,
Unf=Unf{Src=InlineStable, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=ALWAYS_IF(arity=5,unsat_ok=True,boring_ok=False)
Tmpl= \ (@ key_af2y)
(w_st7z [Occ=Once] :: ShakeValue key_af2y)
(w1_st7A [Occ=Once] :: key_af2y)
(w2_st7B [Occ=Once!] :: S Global Local)
(w3_st7C [Occ=Once] :: () -> IO ())
(w4_st7D [Occ=Once, OS=OneShot]
:: GHC.Prim.State# GHC.Prim.RealWorld) ->
case w2_st7B
of _ [Occ=Dead]
{ S _ [Occ=Dead] ww2_st7H [Occ=Once!] ww3_st7W [Occ=Once] ->
case ww2_st7H
of _ [Occ=Dead]
{ Global _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead]
_ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead] _ [Occ=Dead]
_ [Occ=Dead] ww15_st7U [Occ=Once] ->
case ww3_st7W
`cast` (GHC.IORef.NTCo:IORef[0] <Local>_N
:: IORef Local ~R# GHC.STRef.STRef GHC.Prim.RealWorld Local)
of _ [Occ=Dead] { GHC.STRef.STRef ww17_st7Z [Occ=Once] ->
Development.Shake.Core.$wa3
@ key_af2y w_st7z w1_st7A ww15_st7U ww17_st7Z w3_st7C w4_st7D
}
}
}}]
Development.Shake.Core.trackChange1 =
\ (@ key_af2y)
(w_st7z :: ShakeValue key_af2y)
(w1_st7A :: key_af2y)
(w2_st7B :: S Global Local)
(w3_st7C :: () -> IO ())
(w4_st7D [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case w2_st7B of _ [Occ=Dead] { S ww1_st7G ww2_st7H ww3_st7W ->
case ww2_st7H
of _ [Occ=Dead]
{ Global ww5_st7K ww6_st7L ww7_st7M ww8_st7N ww9_st7O ww10_st7P
ww11_st7Q ww12_st7R ww13_st7S ww14_st7T ww15_st7U ->
case ww3_st7W
`cast` (GHC.IORef.NTCo:IORef[0] <Local>_N
:: IORef Local ~R# GHC.STRef.STRef GHC.Prim.RealWorld Local)
of _ [Occ=Dead] { GHC.STRef.STRef ww17_st7Z ->
Development.Shake.Core.$wa3
@ key_af2y w_st7z w1_st7A ww15_st7U ww17_st7Z w3_st7C w4_st7D
}
}
}
Development.Shake.Core.$wa1 [InlPrag=[0]]
:: forall a_af6Q b_af6R.
Bool
-> Action a_af6Q
-> IO b_af6R
-> IORef (SomeException -> IO ())
-> Database
-> Pool
-> GHC.Prim.MutVar# GHC.Prim.RealWorld General.Cleanup.S
-> IO Seconds
-> Map.HashMap TypeRep (RuleInfo Action)
-> (Verbosity -> String -> IO ())
-> ShakeOptions
-> (String -> IO ())
-> (String -> IO ())
-> IORef [IO ()]
-> IORef [(Key, Key)]
-> IORef Local
-> (a_af6Q -> IO ())
-> GHC.Prim.State# GHC.Prim.RealWorld
-> (# GHC.Prim.State# GHC.Prim.RealWorld, () #)
[GblId,
Arity=18,
Str=DmdType <L,U><L,1*C1(U)><L,C(U(U,A))><L,U(U)><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,U><L,C(C1(U))><L,U>,
Unf=Unf{Src=<vanilla>, TopLvl=True, Value=True, ConLike=True,
WorkFree=True, Expandable=True,
Guidance=IF_ARGS [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 60 0] 264 0}]
Development.Shake.Core.$wa1 =
\ (@ a59_af6Q)
(@ b_af6R)
(w_st83 :: Bool)
(w1_st84 :: Action a59_af6Q)
(w2_st85 :: IO b_af6R)
(ww_st8b :: IORef (SomeException -> IO ()))
(ww1_st8f :: Database)
(ww2_st8g :: Pool)
(ww3_st8k :: GHC.Prim.MutVar# GHC.Prim.RealWorld General.Cleanup.S)
(ww4_st8m :: IO Seconds)
(ww5_st8n :: Map.HashMap TypeRep (RuleInfo Action))
(ww6_st8o :: Verbosity -> String -> IO ())
(ww7_st8p :: ShakeOptions)
(ww8_st8q :: String -> IO ())
(ww9_st8r :: String -> IO ())
(ww10_st8s :: IORef [IO ()])
(ww11_st8t :: IORef [(Key, Key)])
(ww12_st8v :: IORef Local)
(w3_st87 :: a59_af6Q -> IO ())
(w4_st88 [OS=OneShot] :: GHC.Prim.State# GHC.Prim.RealWorld) ->
case General.Cleanup.$wa
ww3_st8k