packages feed

haskell-generate 0.2.3 → 0.2.4

raw patch · 4 files changed

+16/−10 lines, 4 filesdep ~haskell-src-extsPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: haskell-src-exts

API changes (from Hackage documentation)

- Language.Haskell.Generate.Expression: runExpression :: Expression t -> Exp
- Language.Haskell.Generate.Monad: instance Applicative Generate
- Language.Haskell.Generate.Monad: instance Applicative ModuleM
- Language.Haskell.Generate.Monad: instance Functor Generate
- Language.Haskell.Generate.Monad: instance Functor ModuleM
- Language.Haskell.Generate.Monad: instance GenExp (ExpG a)
- Language.Haskell.Generate.Monad: instance GenExp (Expression t)
- Language.Haskell.Generate.Monad: instance GenExp (FunRef t)
- Language.Haskell.Generate.Monad: instance GenExp Char
- Language.Haskell.Generate.Monad: instance GenExp Integer
- Language.Haskell.Generate.Monad: instance GenExp Rational
- Language.Haskell.Generate.Monad: instance GenExp a => GenExp [a]
- Language.Haskell.Generate.Monad: instance GenExp x => GenExp (ExpG a -> x)
- Language.Haskell.Generate.Monad: instance Monad Generate
- Language.Haskell.Generate.Monad: instance Monad ModuleM
- Language.Haskell.Generate.Monad: unGenerate :: Generate a -> StateT Integer (Writer (Set ModuleName)) a
- Language.Haskell.Generate.PreludeDef: instance Num t => Num (ExpG t)
+ Language.Haskell.Generate.Expression: [runExpression] :: Expression t -> Exp
+ Language.Haskell.Generate.Monad: [unGenerate] :: Generate a -> StateT Integer (Writer (Set ModuleName)) a
+ Language.Haskell.Generate.Monad: instance GHC.Base.Applicative Language.Haskell.Generate.Monad.Generate
+ Language.Haskell.Generate.Monad: instance GHC.Base.Applicative Language.Haskell.Generate.Monad.ModuleM
+ Language.Haskell.Generate.Monad: instance GHC.Base.Functor Language.Haskell.Generate.Monad.Generate
+ Language.Haskell.Generate.Monad: instance GHC.Base.Functor Language.Haskell.Generate.Monad.ModuleM
+ Language.Haskell.Generate.Monad: instance GHC.Base.Monad Language.Haskell.Generate.Monad.Generate
+ Language.Haskell.Generate.Monad: instance GHC.Base.Monad Language.Haskell.Generate.Monad.ModuleM
+ Language.Haskell.Generate.Monad: instance Language.Haskell.Generate.Monad.GenExp (Language.Haskell.Generate.Expression.Expression t)
+ Language.Haskell.Generate.Monad: instance Language.Haskell.Generate.Monad.GenExp (Language.Haskell.Generate.Monad.ExpG a)
+ Language.Haskell.Generate.Monad: instance Language.Haskell.Generate.Monad.GenExp (Language.Haskell.Generate.Monad.FunRef t)
+ Language.Haskell.Generate.Monad: instance Language.Haskell.Generate.Monad.GenExp GHC.Integer.Type.Integer
+ Language.Haskell.Generate.Monad: instance Language.Haskell.Generate.Monad.GenExp GHC.Real.Rational
+ Language.Haskell.Generate.Monad: instance Language.Haskell.Generate.Monad.GenExp GHC.Types.Char
+ Language.Haskell.Generate.Monad: instance Language.Haskell.Generate.Monad.GenExp a => Language.Haskell.Generate.Monad.GenExp [a]
+ Language.Haskell.Generate.Monad: instance Language.Haskell.Generate.Monad.GenExp x => Language.Haskell.Generate.Monad.GenExp (Language.Haskell.Generate.Monad.ExpG a -> x)
+ Language.Haskell.Generate.PreludeDef: instance GHC.Num.Num t => GHC.Num.Num (Language.Haskell.Generate.Monad.ExpG t)
- Language.Haskell.Generate.PreludeDef: abs' :: Num a_aakB => ExpG (a_aakB -> a_aakB)
+ Language.Haskell.Generate.PreludeDef: abs' :: Num a_aaZQ => ExpG (a_aaZQ -> a_aaZQ)
- Language.Haskell.Generate.PreludeDef: acos' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: acos' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: acosh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: acosh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: add' :: Num a_aakB => ExpG (a_aakB -> a_aakB -> a_aakB)
+ Language.Haskell.Generate.PreludeDef: add' :: Num a_aaZQ => ExpG (a_aaZQ -> a_aaZQ -> a_aaZQ)
- Language.Haskell.Generate.PreludeDef: all' :: ExpG ((a_afgb -> Bool) -> [a_afgb] -> Bool)
+ Language.Haskell.Generate.PreludeDef: all' :: Foldable t_agXx => ExpG ((a_agXw -> Bool) -> t_agXx a_agXw -> Bool)
- Language.Haskell.Generate.PreludeDef: and' :: ExpG ([Bool] -> Bool)
+ Language.Haskell.Generate.PreludeDef: and' :: Foldable t_agXs => ExpG (t_agXs Bool -> Bool)
- Language.Haskell.Generate.PreludeDef: any' :: ExpG ((a_afga -> Bool) -> [a_afga] -> Bool)
+ Language.Haskell.Generate.PreludeDef: any' :: Foldable t_agXv => ExpG ((a_agXu -> Bool) -> t_agXv a_agXu -> Bool)
- Language.Haskell.Generate.PreludeDef: append' :: ExpG ([a_aahj] -> [a_aahj] -> [a_aahj])
+ Language.Haskell.Generate.PreludeDef: append' :: ExpG ([a_aaWw] -> [a_aaWw] -> [a_aaWw])
- Language.Haskell.Generate.PreludeDef: asTypeOf' :: ExpG (a_affW -> a_affW -> a_affW)
+ Language.Haskell.Generate.PreludeDef: asTypeOf' :: ExpG (a_agXe -> a_agXe -> a_agXe)
- Language.Haskell.Generate.PreludeDef: asin' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: asin' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: asinh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: asinh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: atan' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: atan' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: atan2' :: RealFloat a_affh => ExpG (a_affh -> a_affh -> a_affh)
+ Language.Haskell.Generate.PreludeDef: atan2' :: RealFloat a_agWy => ExpG (a_agWy -> a_agWy -> a_agWy)
- Language.Haskell.Generate.PreludeDef: atanh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: atanh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: bind' :: Monad m_a8vs => forall a_a9rt b_a9ru. ExpG (m_a8vs a_a9rt -> (a_a9rt -> m_a8vs b_a9ru) -> m_a8vs b_a9ru)
+ Language.Haskell.Generate.PreludeDef: bind' :: Monad m_a9S0 => forall a_aai2 b_aai3. ExpG (m_a9S0 a_aai2 -> (a_aai2 -> m_a9S0 b_aai3) -> m_a9S0 b_aai3)
- Language.Haskell.Generate.PreludeDef: break' :: ExpG ((a_afgy -> Bool) -> [a_afgy] -> ([a_afgy], [a_afgy]))
+ Language.Haskell.Generate.PreludeDef: break' :: ExpG ((a_agXV -> Bool) -> [a_agXV] -> ([a_agXV], [a_agXV]))
- Language.Haskell.Generate.PreludeDef: ceiling' :: RealFrac a_aff1 => forall b_affe. Integral b_affe => ExpG (a_aff1 -> b_affe)
+ Language.Haskell.Generate.PreludeDef: ceiling' :: RealFrac a_agWi => forall b_agWv. Integral b_agWv => ExpG (a_agWi -> b_agWv)
- Language.Haskell.Generate.PreludeDef: concat' :: ExpG ([[a_af2e]] -> [a_af2e])
+ Language.Haskell.Generate.PreludeDef: concat' :: Foldable t_agJh => ExpG (t_agJh [a_agJi] -> [a_agJi])
- Language.Haskell.Generate.PreludeDef: concatMap' :: ExpG ((a_afge -> [b_afgf]) -> [a_afge] -> [b_afgf])
+ Language.Haskell.Generate.PreludeDef: concatMap' :: Foldable t_agXC => ExpG ((a_agXA -> [b_agXB]) -> t_agXC a_agXA -> [b_agXB])
- Language.Haskell.Generate.PreludeDef: const' :: ExpG (a_affT -> b_affU -> a_affT)
+ Language.Haskell.Generate.PreludeDef: const' :: ExpG (a_agXb -> b_agXc -> a_agXb)
- Language.Haskell.Generate.PreludeDef: cos' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: cos' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: cosh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: cosh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: curry' :: ExpG (((a_afec, b_afed) -> c_afee) -> a_afec -> b_afed -> c_afee)
+ Language.Haskell.Generate.PreludeDef: curry' :: ExpG (((a_agVt, b_agVu) -> c_agVv) -> a_agVt -> b_agVu -> c_agVv)
- Language.Haskell.Generate.PreludeDef: cycle' :: ExpG ([a_afgr] -> [a_afgr])
+ Language.Haskell.Generate.PreludeDef: cycle' :: ExpG ([a_agXO] -> [a_agXO])
- Language.Haskell.Generate.PreludeDef: decodeFloat' :: RealFloat a_affh => ExpG (a_affh -> (Integer, Int))
+ Language.Haskell.Generate.PreludeDef: decodeFloat' :: RealFloat a_agWy => ExpG (a_agWy -> (Integer, Int))
- Language.Haskell.Generate.PreludeDef: div' :: Integral a_afej => ExpG (a_afej -> a_afej -> a_afej)
+ Language.Haskell.Generate.PreludeDef: div' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> a_agVA)
- Language.Haskell.Generate.PreludeDef: divMod' :: Integral a_afej => ExpG (a_afej -> a_afej -> (a_afej, a_afej))
+ Language.Haskell.Generate.PreludeDef: divMod' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> (a_agVA, a_agVA))
- Language.Haskell.Generate.PreludeDef: divide' :: Fractional a_afew => ExpG (a_afew -> a_afew -> a_afew)
+ Language.Haskell.Generate.PreludeDef: divide' :: Fractional a_agVN => ExpG (a_agVN -> a_agVN -> a_agVN)
- Language.Haskell.Generate.PreludeDef: dot' :: ExpG ((b_a9BC -> c_a9BD) -> (a_a9BE -> b_a9BC) -> a_a9BE -> c_a9BD)
+ Language.Haskell.Generate.PreludeDef: dot' :: ExpG ((b_aaqm -> c_aaqn) -> (a_aaqo -> b_aaqm) -> a_aaqo -> c_aaqn)
- Language.Haskell.Generate.PreludeDef: drop' :: ExpG (Int -> [a_afgt] -> [a_afgt])
+ Language.Haskell.Generate.PreludeDef: drop' :: ExpG (Int -> [a_agXQ] -> [a_agXQ])
- Language.Haskell.Generate.PreludeDef: dropWhile' :: ExpG ((a_afgw -> Bool) -> [a_afgw] -> [a_afgw])
+ Language.Haskell.Generate.PreludeDef: dropWhile' :: ExpG ((a_agXT -> Bool) -> [a_agXT] -> [a_agXT])
- Language.Haskell.Generate.PreludeDef: either' :: ExpG ((a_afe7 -> c_afe8) -> (b_afe9 -> c_afe8) -> Either a_afe7 b_afe9 -> c_afe8)
+ Language.Haskell.Generate.PreludeDef: either' :: ExpG ((a_agVo -> c_agVp) -> (b_agVq -> c_agVp) -> Either a_agVo b_agVq -> c_agVp)
- Language.Haskell.Generate.PreludeDef: elem' :: Eq a_afgz => ExpG (a_afgz -> [a_afgz] -> Bool)
+ Language.Haskell.Generate.PreludeDef: elem' :: Foldable t_aaOT => forall a_agXW. Eq a_agXW => ExpG (a_agXW -> t_aaOT a_agXW -> Bool)
- Language.Haskell.Generate.PreludeDef: encodeFloat' :: RealFloat a_affh => ExpG (Integer -> Int -> a_affh)
+ Language.Haskell.Generate.PreludeDef: encodeFloat' :: RealFloat a_agWy => ExpG (Integer -> Int -> a_agWy)
- Language.Haskell.Generate.PreludeDef: equal' :: Eq a_afgB => ExpG (a_afgB -> a_afgB -> Bool)
+ Language.Haskell.Generate.PreludeDef: equal' :: Eq a_agXY => ExpG (a_agXY -> a_agXY -> Bool)
- Language.Haskell.Generate.PreludeDef: even' :: Integral a_affB => ExpG (a_affB -> Bool)
+ Language.Haskell.Generate.PreludeDef: even' :: Integral a_agWS => ExpG (a_agWS -> Bool)
- Language.Haskell.Generate.PreludeDef: exp' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: exp' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: exponent' :: RealFloat a_affh => ExpG (a_affh -> Int)
+ Language.Haskell.Generate.PreludeDef: exponent' :: RealFloat a_agWy => ExpG (a_agWy -> Int)
- Language.Haskell.Generate.PreludeDef: filter' :: ExpG ((a_affX -> Bool) -> [a_affX] -> [a_affX])
+ Language.Haskell.Generate.PreludeDef: filter' :: ExpG ((a_agXf -> Bool) -> [a_agXf] -> [a_agXf])
- Language.Haskell.Generate.PreludeDef: flip' :: ExpG ((a_aelq -> b_aelr -> c_aels) -> b_aelr -> a_aelq -> c_aels)
+ Language.Haskell.Generate.PreludeDef: flip' :: ExpG ((a_afMO -> b_afMP -> c_afMQ) -> b_afMP -> a_afMO -> c_afMQ)
- Language.Haskell.Generate.PreludeDef: floatDigits' :: RealFloat a_affh => ExpG (a_affh -> Int)
+ Language.Haskell.Generate.PreludeDef: floatDigits' :: RealFloat a_agWy => ExpG (a_agWy -> Int)
- Language.Haskell.Generate.PreludeDef: floatPow' :: Floating a_afeE => ExpG (a_afeE -> a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: floatPow' :: Floating a_agVV => ExpG (a_agVV -> a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: floatRadix' :: RealFloat a_affh => ExpG (a_affh -> Integer)
+ Language.Haskell.Generate.PreludeDef: floatRadix' :: RealFloat a_agWy => ExpG (a_agWy -> Integer)
- Language.Haskell.Generate.PreludeDef: floatRange' :: RealFloat a_affh => ExpG (a_affh -> (Int, Int))
+ Language.Haskell.Generate.PreludeDef: floatRange' :: RealFloat a_agWy => ExpG (a_agWy -> (Int, Int))
- Language.Haskell.Generate.PreludeDef: floor' :: RealFrac a_aff1 => forall b_afff. Integral b_afff => ExpG (a_aff1 -> b_afff)
+ Language.Haskell.Generate.PreludeDef: floor' :: RealFrac a_agWi => forall b_agWw. Integral b_agWw => ExpG (a_agWi -> b_agWw)
- Language.Haskell.Generate.PreludeDef: fmap' :: Functor f_a9bS => forall a_a9ci b_a9cj. ExpG ((a_a9ci -> b_a9cj) -> f_a9bS a_a9ci -> f_a9bS b_a9cj)
+ Language.Haskell.Generate.PreludeDef: fmap' :: Functor f_a9RH => forall a_a9Sj b_a9Sk. ExpG ((a_a9Sj -> b_a9Sk) -> f_a9RH a_a9Sj -> f_a9RH b_a9Sk)
- Language.Haskell.Generate.PreludeDef: foldl' :: ExpG ((b_afg5 -> a_afg6 -> b_afg5) -> b_afg5 -> [a_afg6] -> b_afg5)
+ Language.Haskell.Generate.PreludeDef: foldl' :: Foldable t_aaOT => forall b_agXn a_agXo. ExpG ((b_agXn -> a_agXo -> b_agXn) -> b_agXn -> t_aaOT a_agXo -> b_agXn)
- Language.Haskell.Generate.PreludeDef: foldl1' :: ExpG ((a_aac9 -> a_aac9 -> a_aac9) -> [a_aac9] -> a_aac9)
+ Language.Haskell.Generate.PreludeDef: foldl1' :: Foldable t_aaOT => forall a_aaPc. ExpG ((a_aaPc -> a_aaPc -> a_aaPc) -> t_aaOT a_aaPc -> a_aaPc)
- Language.Haskell.Generate.PreludeDef: foldr' :: ExpG ((a_afg7 -> b_afg8 -> b_afg8) -> b_afg8 -> [a_afg7] -> b_afg8)
+ Language.Haskell.Generate.PreludeDef: foldr' :: Foldable t_aaOT => forall a_agXp b_agXq. ExpG ((a_agXp -> b_agXq -> b_agXq) -> b_agXq -> t_aaOT a_agXp -> b_agXq)
- Language.Haskell.Generate.PreludeDef: foldr1' :: ExpG ((a_afg9 -> a_afg9 -> a_afg9) -> [a_afg9] -> a_afg9)
+ Language.Haskell.Generate.PreludeDef: foldr1' :: Foldable t_aaOT => forall a_agXr. ExpG ((a_agXr -> a_agXr -> a_agXr) -> t_aaOT a_agXr -> a_agXr)
- Language.Haskell.Generate.PreludeDef: fromInteger' :: Num a_aakB => ExpG (Integer -> a_aakB)
+ Language.Haskell.Generate.PreludeDef: fromInteger' :: Num a_aaZQ => ExpG (Integer -> a_aaZQ)
- Language.Haskell.Generate.PreludeDef: fromIntegral' :: (Integral a_affF, Num b_affG) => ExpG (a_affF -> b_affG)
+ Language.Haskell.Generate.PreludeDef: fromIntegral' :: (Integral a_agWW, Num b_agWX) => ExpG (a_agWW -> b_agWX)
- Language.Haskell.Generate.PreludeDef: fromRational' :: Fractional a_afew => ExpG (Rational -> a_afew)
+ Language.Haskell.Generate.PreludeDef: fromRational' :: Fractional a_agVN => ExpG (Rational -> a_agVN)
- Language.Haskell.Generate.PreludeDef: fst' :: ExpG ((a_aal1, b_aal2) -> a_aal1)
+ Language.Haskell.Generate.PreludeDef: fst' :: ExpG ((a_ab0n, b_ab0o) -> a_ab0n)
- Language.Haskell.Generate.PreludeDef: gcd' :: Integral a_affD => ExpG (a_affD -> a_affD -> a_affD)
+ Language.Haskell.Generate.PreludeDef: gcd' :: Integral a_agWU => ExpG (a_agWU -> a_agWU -> a_agWU)
- Language.Haskell.Generate.PreludeDef: head' :: ExpG ([a_affY] -> a_affY)
+ Language.Haskell.Generate.PreludeDef: head' :: ExpG ([a_agXg] -> a_agXg)
- Language.Haskell.Generate.PreludeDef: id' :: ExpG (a_aaAM -> a_aaAM)
+ Language.Haskell.Generate.PreludeDef: id' :: ExpG (a_abib -> a_abib)
- Language.Haskell.Generate.PreludeDef: index' :: ExpG ([a_agfI] -> Int -> a_agfI)
+ Language.Haskell.Generate.PreludeDef: index' :: ExpG ([a_ai3R] -> Int -> a_ai3R)
- Language.Haskell.Generate.PreludeDef: init' :: ExpG ([a_afg1] -> [a_afg1])
+ Language.Haskell.Generate.PreludeDef: init' :: ExpG ([a_agXj] -> [a_agXj])
- Language.Haskell.Generate.PreludeDef: isDenormalized' :: RealFloat a_affh => ExpG (a_affh -> Bool)
+ Language.Haskell.Generate.PreludeDef: isDenormalized' :: RealFloat a_agWy => ExpG (a_agWy -> Bool)
- Language.Haskell.Generate.PreludeDef: isIEEE' :: RealFloat a_affh => ExpG (a_affh -> Bool)
+ Language.Haskell.Generate.PreludeDef: isIEEE' :: RealFloat a_agWy => ExpG (a_agWy -> Bool)
- Language.Haskell.Generate.PreludeDef: isInfinite' :: RealFloat a_affh => ExpG (a_affh -> Bool)
+ Language.Haskell.Generate.PreludeDef: isInfinite' :: RealFloat a_agWy => ExpG (a_agWy -> Bool)
- Language.Haskell.Generate.PreludeDef: isNaN' :: RealFloat a_affh => ExpG (a_affh -> Bool)
+ Language.Haskell.Generate.PreludeDef: isNaN' :: RealFloat a_agWy => ExpG (a_agWy -> Bool)
- Language.Haskell.Generate.PreludeDef: isNegativeZero' :: RealFloat a_affh => ExpG (a_affh -> Bool)
+ Language.Haskell.Generate.PreludeDef: isNegativeZero' :: RealFloat a_agWy => ExpG (a_agWy -> Bool)
- Language.Haskell.Generate.PreludeDef: iterate' :: ExpG ((a_afgo -> a_afgo) -> a_afgo -> [a_afgo])
+ Language.Haskell.Generate.PreludeDef: iterate' :: ExpG ((a_agXL -> a_agXL) -> a_agXL -> [a_agXL])
- Language.Haskell.Generate.PreludeDef: just' :: ExpG (a_a7tq -> Maybe a_a7tq)
+ Language.Haskell.Generate.PreludeDef: just' :: ExpG (a_a9PI -> Maybe a_a9PI)
- Language.Haskell.Generate.PreludeDef: last' :: ExpG ([a_affZ] -> a_affZ)
+ Language.Haskell.Generate.PreludeDef: last' :: ExpG ([a_agXh] -> a_agXh)
- Language.Haskell.Generate.PreludeDef: lcm' :: Integral a_affE => ExpG (a_affE -> a_affE -> a_affE)
+ Language.Haskell.Generate.PreludeDef: lcm' :: Integral a_agWV => ExpG (a_agWV -> a_agWV -> a_agWV)
- Language.Haskell.Generate.PreludeDef: left' :: ExpG (a_a9Cn -> Either a_a9Cn b_a9Co)
+ Language.Haskell.Generate.PreludeDef: left' :: ExpG (a_aas6 -> Either a_aas6 b_aas7)
- Language.Haskell.Generate.PreludeDef: length' :: ExpG ([a_afg3] -> Int)
+ Language.Haskell.Generate.PreludeDef: length' :: Foldable t_aaOT => forall a_agXl. ExpG (t_aaOT a_agXl -> Int)
- Language.Haskell.Generate.PreludeDef: log' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: log' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: logBase' :: Floating a_afeE => ExpG (a_afeE -> a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: logBase' :: Floating a_agVV => ExpG (a_agVV -> a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: lookup' :: Eq a_afgH => ExpG (a_afgH -> [(a_afgH, b_afgI)] -> Maybe b_afgI)
+ Language.Haskell.Generate.PreludeDef: lookup' :: Eq a_agY5 => ExpG (a_agY5 -> [(a_agY5, b_agY6)] -> Maybe b_agY6)
- Language.Haskell.Generate.PreludeDef: map' :: ExpG ((a_a9Br -> b_a9Bs) -> [a_a9Br] -> [b_a9Bs])
+ Language.Haskell.Generate.PreludeDef: map' :: ExpG ((a_aaq9 -> b_aaqa) -> [a_aaq9] -> [b_aaqa])
- Language.Haskell.Generate.PreludeDef: mapM' :: Monad m_aaj6 => ExpG ((a_aaj5 -> m_aaj6 b_aaj7) -> [a_aaj5] -> m_aaj6 [b_aaj7])
+ Language.Haskell.Generate.PreludeDef: mapM' :: Traversable t_aaPj => forall a_aaYP m_aaYQ b_aaYR. Monad m_aaYQ => ExpG ((a_aaYP -> m_aaYQ b_aaYR) -> t_aaPj a_aaYP -> m_aaYQ (t_aaPj b_aaYR))
- Language.Haskell.Generate.PreludeDef: mapM_' :: Monad m_affR => ExpG ((a_affQ -> m_affR b_affS) -> [a_affQ] -> m_affR ())
+ Language.Haskell.Generate.PreludeDef: mapM_' :: (Foldable t_agXa, Monad m_agX8) => ExpG ((a_agX7 -> m_agX8 b_agX9) -> t_agXa a_agX7 -> m_agX8 ())
- Language.Haskell.Generate.PreludeDef: maximum' :: Ord a_afgg => ExpG ([a_afgg] -> a_afgg)
+ Language.Haskell.Generate.PreludeDef: maximum' :: Foldable t_aaOT => forall a_agXD. Ord a_agXD => ExpG (t_aaOT a_agXD -> a_agXD)
- Language.Haskell.Generate.PreludeDef: maybe' :: ExpG (b_aekV -> (a_aekW -> b_aekV) -> Maybe a_aekW -> b_aekV)
+ Language.Haskell.Generate.PreludeDef: maybe' :: ExpG (b_afM6 -> (a_afM7 -> b_afM6) -> Maybe a_afM7 -> b_afM6)
- Language.Haskell.Generate.PreludeDef: minimum' :: Ord a_afgh => ExpG ([a_afgh] -> a_afgh)
+ Language.Haskell.Generate.PreludeDef: minimum' :: Foldable t_aaOT => forall a_agXE. Ord a_agXE => ExpG (t_aaOT a_agXE -> a_agXE)
- Language.Haskell.Generate.PreludeDef: mod' :: Integral a_afej => ExpG (a_afej -> a_afej -> a_afej)
+ Language.Haskell.Generate.PreludeDef: mod' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> a_agVA)
- Language.Haskell.Generate.PreludeDef: mult' :: Num a_aakB => ExpG (a_aakB -> a_aakB -> a_aakB)
+ Language.Haskell.Generate.PreludeDef: mult' :: Num a_aaZQ => ExpG (a_aaZQ -> a_aaZQ -> a_aaZQ)
- Language.Haskell.Generate.PreludeDef: negate' :: Num a_aakB => ExpG (a_aakB -> a_aakB)
+ Language.Haskell.Generate.PreludeDef: negate' :: Num a_aaZQ => ExpG (a_aaZQ -> a_aaZQ)
- Language.Haskell.Generate.PreludeDef: notElem' :: Eq a_afgG => ExpG (a_afgG -> [a_afgG] -> Bool)
+ Language.Haskell.Generate.PreludeDef: notElem' :: (Foldable t_agY4, Eq a_agY3) => ExpG (a_agY3 -> t_agY4 a_agY3 -> Bool)
- Language.Haskell.Generate.PreludeDef: notequal' :: Eq a_afgB => ExpG (a_afgB -> a_afgB -> Bool)
+ Language.Haskell.Generate.PreludeDef: notequal' :: Eq a_agXY => ExpG (a_agXY -> a_agXY -> Bool)
- Language.Haskell.Generate.PreludeDef: nothing' :: ExpG (Maybe a_a7tk)
+ Language.Haskell.Generate.PreludeDef: nothing' :: ExpG (Maybe a_a9PI)
- Language.Haskell.Generate.PreludeDef: null' :: ExpG ([a_afg2] -> Bool)
+ Language.Haskell.Generate.PreludeDef: null' :: Foldable t_aaOT => forall a_agXk. ExpG (t_aaOT a_agXk -> Bool)
- Language.Haskell.Generate.PreludeDef: odd' :: Integral a_affC => ExpG (a_affC -> Bool)
+ Language.Haskell.Generate.PreludeDef: odd' :: Integral a_agWT => ExpG (a_agWT -> Bool)
- Language.Haskell.Generate.PreludeDef: or' :: ExpG ([Bool] -> Bool)
+ Language.Haskell.Generate.PreludeDef: or' :: Foldable t_agXt => ExpG (t_agXt Bool -> Bool)
- Language.Haskell.Generate.PreludeDef: pi' :: Floating a_afeE => ExpG a_afeE
+ Language.Haskell.Generate.PreludeDef: pi' :: Floating a_agVV => ExpG a_agVV
- Language.Haskell.Generate.PreludeDef: print' :: Show a_afsC => ExpG (a_afsC -> IO ())
+ Language.Haskell.Generate.PreludeDef: print' :: Show a_ah8A => ExpG (a_ah8A -> IO ())
- Language.Haskell.Generate.PreludeDef: product' :: Num a_afgd => ExpG ([a_afgd] -> a_afgd)
+ Language.Haskell.Generate.PreludeDef: product' :: Foldable t_aaOT => forall a_agXz. Num a_agXz => ExpG (t_aaOT a_agXz -> a_agXz)
- Language.Haskell.Generate.PreludeDef: properFraction' :: RealFrac a_aff1 => forall b_affb. Integral b_affb => ExpG (a_aff1 -> (b_affb, a_aff1))
+ Language.Haskell.Generate.PreludeDef: properFraction' :: RealFrac a_agWi => forall b_agWs. Integral b_agWs => ExpG (a_agWi -> (b_agWs, a_agWi))
- Language.Haskell.Generate.PreludeDef: quot' :: Integral a_afej => ExpG (a_afej -> a_afej -> a_afej)
+ Language.Haskell.Generate.PreludeDef: quot' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> a_agVA)
- Language.Haskell.Generate.PreludeDef: quotRem' :: Integral a_afej => ExpG (a_afej -> a_afej -> (a_afej, a_afej))
+ Language.Haskell.Generate.PreludeDef: quotRem' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> (a_agVA, a_agVA))
- Language.Haskell.Generate.PreludeDef: read' :: Read a_afh0 => ExpG (String -> a_afh0)
+ Language.Haskell.Generate.PreludeDef: read' :: Read a_agYo => ExpG (String -> a_agYo)
- Language.Haskell.Generate.PreludeDef: readIO' :: Read a_afuc => ExpG (String -> IO a_afuc)
+ Language.Haskell.Generate.PreludeDef: readIO' :: Read a_aha5 => ExpG (String -> IO a_aha5)
- Language.Haskell.Generate.PreludeDef: readLn' :: Read a_afud => ExpG (IO a_afud)
+ Language.Haskell.Generate.PreludeDef: readLn' :: Read a_aha6 => ExpG (IO a_aha6)
- Language.Haskell.Generate.PreludeDef: realToFrac' :: (Real a_affH, Fractional b_affI) => ExpG (a_affH -> b_affI)
+ Language.Haskell.Generate.PreludeDef: realToFrac' :: (Real a_agWY, Fractional b_agWZ) => ExpG (a_agWY -> b_agWZ)
- Language.Haskell.Generate.PreludeDef: recip' :: Fractional a_afew => ExpG (a_afew -> a_afew)
+ Language.Haskell.Generate.PreludeDef: recip' :: Fractional a_agVN => ExpG (a_agVN -> a_agVN)
- Language.Haskell.Generate.PreludeDef: rem' :: Integral a_afej => ExpG (a_afej -> a_afej -> a_afej)
+ Language.Haskell.Generate.PreludeDef: rem' :: Integral a_agVA => ExpG (a_agVA -> a_agVA -> a_agVA)
- Language.Haskell.Generate.PreludeDef: repeat' :: ExpG (a_afgp -> [a_afgp])
+ Language.Haskell.Generate.PreludeDef: repeat' :: ExpG (a_agXM -> [a_agXM])
- Language.Haskell.Generate.PreludeDef: replicate' :: ExpG (Int -> a_afgq -> [a_afgq])
+ Language.Haskell.Generate.PreludeDef: replicate' :: ExpG (Int -> a_agXN -> [a_agXN])
- Language.Haskell.Generate.PreludeDef: return' :: Monad m_a8vs => forall a_a9rF. ExpG (a_a9rF -> m_a8vs a_a9rF)
+ Language.Haskell.Generate.PreludeDef: return' :: Monad m_a9S0 => forall a_aaie. ExpG (a_aaie -> m_a9S0 a_aaie)
- Language.Haskell.Generate.PreludeDef: reverse' :: ExpG ([a_afg4] -> [a_afg4])
+ Language.Haskell.Generate.PreludeDef: reverse' :: ExpG ([a_agXm] -> [a_agXm])
- Language.Haskell.Generate.PreludeDef: right' :: ExpG (b_a9Cv -> Either a_a9Cu b_a9Cv)
+ Language.Haskell.Generate.PreludeDef: right' :: ExpG (b_aas7 -> Either a_aas6 b_aas7)
- Language.Haskell.Generate.PreludeDef: round' :: RealFrac a_aff1 => forall b_affd. Integral b_affd => ExpG (a_aff1 -> b_affd)
+ Language.Haskell.Generate.PreludeDef: round' :: RealFrac a_agWi => forall b_agWu. Integral b_agWu => ExpG (a_agWi -> b_agWu)
- Language.Haskell.Generate.PreludeDef: scaleFloat' :: RealFloat a_affh => ExpG (Int -> a_affh -> a_affh)
+ Language.Haskell.Generate.PreludeDef: scaleFloat' :: RealFloat a_agWy => ExpG (Int -> a_agWy -> a_agWy)
- Language.Haskell.Generate.PreludeDef: scanl' :: ExpG ((b_afgi -> a_afgj -> b_afgi) -> b_afgi -> [a_afgj] -> [b_afgi])
+ Language.Haskell.Generate.PreludeDef: scanl' :: ExpG ((b_agXF -> a_agXG -> b_agXF) -> b_agXF -> [a_agXG] -> [b_agXF])
- Language.Haskell.Generate.PreludeDef: scanl1' :: ExpG ((a_afgm -> a_afgm -> a_afgm) -> [a_afgm] -> [a_afgm])
+ Language.Haskell.Generate.PreludeDef: scanl1' :: ExpG ((a_agXJ -> a_agXJ -> a_agXJ) -> [a_agXJ] -> [a_agXJ])
- Language.Haskell.Generate.PreludeDef: scanr' :: ExpG ((a_afgk -> b_afgl -> b_afgl) -> b_afgl -> [a_afgk] -> [b_afgl])
+ Language.Haskell.Generate.PreludeDef: scanr' :: ExpG ((a_agXH -> b_agXI -> b_agXI) -> b_agXI -> [a_agXH] -> [b_agXI])
- Language.Haskell.Generate.PreludeDef: scanr1' :: ExpG ((a_afgn -> a_afgn -> a_afgn) -> [a_afgn] -> [a_afgn])
+ Language.Haskell.Generate.PreludeDef: scanr1' :: ExpG ((a_agXK -> a_agXK -> a_agXK) -> [a_agXK] -> [a_agXK])
- Language.Haskell.Generate.PreludeDef: show' :: Show a_aahm => ExpG (a_aahm -> String)
+ Language.Haskell.Generate.PreludeDef: show' :: Show a_aaWA => ExpG (a_aaWA -> String)
- Language.Haskell.Generate.PreludeDef: significand' :: RealFloat a_affh => ExpG (a_affh -> a_affh)
+ Language.Haskell.Generate.PreludeDef: significand' :: RealFloat a_agWy => ExpG (a_agWy -> a_agWy)
- Language.Haskell.Generate.PreludeDef: signum' :: Num a_aakB => ExpG (a_aakB -> a_aakB)
+ Language.Haskell.Generate.PreludeDef: signum' :: Num a_aaZQ => ExpG (a_aaZQ -> a_aaZQ)
- Language.Haskell.Generate.PreludeDef: sin' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: sin' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: sinh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: sinh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: snd' :: ExpG ((a_afea, b_afeb) -> b_afeb)
+ Language.Haskell.Generate.PreludeDef: snd' :: ExpG ((a_agVr, b_agVs) -> b_agVs)
- Language.Haskell.Generate.PreludeDef: span' :: ExpG ((a_afgx -> Bool) -> [a_afgx] -> ([a_afgx], [a_afgx]))
+ Language.Haskell.Generate.PreludeDef: span' :: ExpG ((a_agXU -> Bool) -> [a_agXU] -> ([a_agXU], [a_agXU]))
- Language.Haskell.Generate.PreludeDef: splitAt' :: ExpG (Int -> [a_afgu] -> ([a_afgu], [a_afgu]))
+ Language.Haskell.Generate.PreludeDef: splitAt' :: ExpG (Int -> [a_agXR] -> ([a_agXR], [a_agXR]))
- Language.Haskell.Generate.PreludeDef: sqrt' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: sqrt' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: subtract' :: Num a_affA => ExpG (a_affA -> a_affA -> a_affA)
+ Language.Haskell.Generate.PreludeDef: subtract' :: Num a_agWR => ExpG (a_agWR -> a_agWR -> a_agWR)
- Language.Haskell.Generate.PreludeDef: sum' :: Num a_afgc => ExpG ([a_afgc] -> a_afgc)
+ Language.Haskell.Generate.PreludeDef: sum' :: Foldable t_aaOT => forall a_agXy. Num a_agXy => ExpG (t_aaOT a_agXy -> a_agXy)
- Language.Haskell.Generate.PreludeDef: tail' :: ExpG ([a_afg0] -> [a_afg0])
+ Language.Haskell.Generate.PreludeDef: tail' :: ExpG ([a_agXi] -> [a_agXi])
- Language.Haskell.Generate.PreludeDef: take' :: ExpG (Int -> [a_afgs] -> [a_afgs])
+ Language.Haskell.Generate.PreludeDef: take' :: ExpG (Int -> [a_agXP] -> [a_agXP])
- Language.Haskell.Generate.PreludeDef: takeWhile' :: ExpG ((a_afgv -> Bool) -> [a_afgv] -> [a_afgv])
+ Language.Haskell.Generate.PreludeDef: takeWhile' :: ExpG ((a_agXS -> Bool) -> [a_agXS] -> [a_agXS])
- Language.Haskell.Generate.PreludeDef: tan' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: tan' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: tanh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)
+ Language.Haskell.Generate.PreludeDef: tanh' :: Floating a_agVV => ExpG (a_agVV -> a_agVV)
- Language.Haskell.Generate.PreludeDef: then' :: Monad m_a8vs => forall a_a9rz b_a9rA. ExpG (m_a8vs a_a9rz -> m_a8vs b_a9rA -> m_a8vs b_a9rA)
+ Language.Haskell.Generate.PreludeDef: then' :: Monad m_a9S0 => forall a_aai8 b_aai9. ExpG (m_a9S0 a_aai8 -> m_a9S0 b_aai9 -> m_a9S0 b_aai9)
- Language.Haskell.Generate.PreludeDef: toInteger' :: Integral a_afej => ExpG (a_afej -> Integer)
+ Language.Haskell.Generate.PreludeDef: toInteger' :: Integral a_agVA => ExpG (a_agVA -> Integer)
- Language.Haskell.Generate.PreludeDef: truncate' :: RealFrac a_aff1 => forall b_affc. Integral b_affc => ExpG (a_aff1 -> b_affc)
+ Language.Haskell.Generate.PreludeDef: truncate' :: RealFrac a_agWi => forall b_agWt. Integral b_agWt => ExpG (a_agWi -> b_agWt)
- Language.Haskell.Generate.PreludeDef: uncurry' :: ExpG ((a_afef -> b_afeg -> c_afeh) -> (a_afef, b_afeg) -> c_afeh)
+ Language.Haskell.Generate.PreludeDef: uncurry' :: ExpG ((a_agVw -> b_agVx -> c_agVy) -> (a_agVw, b_agVx) -> c_agVy)
- Language.Haskell.Generate.PreludeDef: until' :: ExpG ((a_affV -> Bool) -> (a_affV -> a_affV) -> a_affV -> a_affV)
+ Language.Haskell.Generate.PreludeDef: until' :: ExpG ((a_agXd -> Bool) -> (a_agXd -> a_agXd) -> a_agXd -> a_agXd)
- Language.Haskell.Generate.PreludeDef: unzip' :: ExpG ([(a_afgV, b_afgW)] -> ([a_afgV], [b_afgW]))
+ Language.Haskell.Generate.PreludeDef: unzip' :: ExpG ([(a_agYj, b_agYk)] -> ([a_agYj], [b_agYk]))
- Language.Haskell.Generate.PreludeDef: unzip3' :: ExpG ([(a_afgX, b_afgY, c_afgZ)] -> ([a_afgX], [b_afgY], [c_afgZ]))
+ Language.Haskell.Generate.PreludeDef: unzip3' :: ExpG ([(a_agYl, b_agYm, c_agYn)] -> ([a_agYl], [b_agYm], [c_agYn]))
- Language.Haskell.Generate.PreludeDef: zip' :: ExpG ([a_afgJ] -> [b_afgK] -> [(a_afgJ, b_afgK)])
+ Language.Haskell.Generate.PreludeDef: zip' :: ExpG ([a_agY7] -> [b_agY8] -> [(a_agY7, b_agY8)])
- Language.Haskell.Generate.PreludeDef: zip3' :: ExpG ([a_afgL] -> [b_afgM] -> [c_afgN] -> [(a_afgL, b_afgM, c_afgN)])
+ Language.Haskell.Generate.PreludeDef: zip3' :: ExpG ([a_agY9] -> [b_agYa] -> [c_agYb] -> [(a_agY9, b_agYa, c_agYb)])
- Language.Haskell.Generate.PreludeDef: zipWith' :: ExpG ((a_afgO -> b_afgP -> c_afgQ) -> [a_afgO] -> [b_afgP] -> [c_afgQ])
+ Language.Haskell.Generate.PreludeDef: zipWith' :: ExpG ((a_agYc -> b_agYd -> c_agYe) -> [a_agYc] -> [b_agYd] -> [c_agYe])
- Language.Haskell.Generate.PreludeDef: zipWith3' :: ExpG ((a_afgR -> b_afgS -> c_afgT -> d_afgU) -> [a_afgR] -> [b_afgS] -> [c_afgT] -> [d_afgU])
+ Language.Haskell.Generate.PreludeDef: zipWith3' :: ExpG ((a_agYf -> b_agYg -> c_agYh -> d_agYi) -> [a_agYf] -> [b_agYg] -> [c_agYh] -> [d_agYi])

Files

.travis.yml view
@@ -2,7 +2,8 @@  - GHCVER=7.4.2 CABALVER=1.16  - GHCVER=7.6.3 CABALVER=1.18  - GHCVER=7.8.3 CABALVER=1.20- - GHCVER=head CABALVER=1.20+ - GHCVER=7.10.2 CABALVER=1.22+ - GHCVER=head CABALVER=1.22  before_install:  - sudo add-apt-repository -y ppa:hvr/ghc@@ -21,5 +22,5 @@  matrix:   allow_failures:-   - env: GHCVER=head CABALVER=1.20+   - env: GHCVER=head CABALVER=1.22   fast_finish: true
haskell-generate.cabal view
@@ -1,5 +1,5 @@ name:          haskell-generate-version:       0.2.3+version:       0.2.4 license:       BSD3 category:      Code Generation, Language cabal-version: >= 1.10@@ -56,6 +56,4 @@     , doctest >= 0.9.1     , filepath   ghc-options: -Wall -threaded-  if impl(ghc<7.6.1)-    ghc-options: -Werror   hs-source-dirs: tests
src/Language/Haskell/Generate/Monad.hs view
@@ -36,6 +36,8 @@ import           Language.Haskell.Exts.Syntax import           Language.Haskell.Generate.Expression +import Prelude+ -------------------------------------------------------------------------------- -- Generate expressions @@ -62,9 +64,11 @@ caseE :: ExpG x -> [(Pat, ExpG t)] -> ExpG t caseE v alt = do   v' <- v-#if MIN_VERSION_haskell_src_exts(1,16,0)   +#if MIN_VERSION_haskell_src_exts(1,17,0)+  alt' <- mapM (\(p,a) -> fmap (\a' -> Alt noLoc p (UnGuardedRhs $ runExpression a') Nothing) a) alt+#elif MIN_VERSION_haskell_src_exts(1,16,0)   alt' <- mapM (\(p,a) -> fmap (\a' -> Alt noLoc p (UnGuardedRhs $ runExpression a') (BDecls [])) a) alt-#else  +#else   alt' <- mapM (\(p,a) -> fmap (\a' -> Alt noLoc p (UnGuardedAlt $ runExpression a') (BDecls [])) a) alt #endif   return $ Expression $ Case (runExpression v') alt'@@ -210,7 +214,7 @@  -- | Generate a ExportSpec for a given function item. exportFun :: FunRef t -> ExportSpec -#if MIN_VERSION_haskell_src_exts(1,16,0) +#if MIN_VERSION_haskell_src_exts(1,16,0) && !MIN_VERSION_haskell_src_exts(1,17,0) exportFun (FunRef name) = EVar NoNamespace (UnQual name)   #else exportFun (FunRef name) = EVar (UnQual name)@@ -220,7 +224,11 @@ addDecl :: Name -> ExpG t -> ModuleM (FunRef t) addDecl name e = ModuleM $ do   let (body, mods) = runGenerate e+#if MIN_VERSION_haskell_src_exts(1,17,0)+  tell (mods, [FunBind [Match noLoc name [] Nothing (UnGuardedRhs $ runExpression body) Nothing]])+#else   tell (mods, [FunBind [Match noLoc name [] Nothing (UnGuardedRhs $ runExpression body) $ BDecls []]])+#endif   return $ FunRef name  -- | Extract the Module from a module generator.
tests/doctests.hsc view
@@ -20,18 +20,17 @@ import System.Directory import System.FilePath import Test.DocTest+import Prelude  ##ifdef mingw32_HOST_ARCH ##ifdef i386_HOST_ARCH ##define USE_CP-import Control.Applicative import Control.Exception import Foreign.C.Types foreign import stdcall "windows.h SetConsoleCP" c_SetConsoleCP :: CUInt -> IO Bool foreign import stdcall "windows.h GetConsoleCP" c_GetConsoleCP :: IO CUInt ##elif defined(x86_64_HOST_ARCH) ##define USE_CP-import Control.Applicative import Control.Exception import Foreign.C.Types foreign import ccall "windows.h SetConsoleCP" c_SetConsoleCP :: CUInt -> IO Bool