haskell-generate 0.2.2 → 0.2.3

raw patch · 4 files changed

+9/−6 lines, 4 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

+ Language.Haskell.Generate.PreludeDef: notequal' :: Eq a_afgB => ExpG (a_afgB -> a_afgB -> Bool)

- Language.Haskell.Generate.PreludeDef: abs' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV)

+ Language.Haskell.Generate.PreludeDef: abs' :: Num a_aakB => ExpG (a_aakB -> a_aakB)

- Language.Haskell.Generate.PreludeDef: acos' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: acos' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: acosh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: acosh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: add' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV -> a_a4qV)

+ Language.Haskell.Generate.PreludeDef: add' :: Num a_aakB => ExpG (a_aakB -> a_aakB -> a_aakB)

- Language.Haskell.Generate.PreludeDef: all' :: ExpG ((a_a7G3 -> Bool) -> [a_a7G3] -> Bool)

+ Language.Haskell.Generate.PreludeDef: all' :: ExpG ((a_afgb -> Bool) -> [a_afgb] -> Bool)

- Language.Haskell.Generate.PreludeDef: any' :: ExpG ((a_a7G2 -> Bool) -> [a_a7G2] -> Bool)

+ Language.Haskell.Generate.PreludeDef: any' :: ExpG ((a_afga -> Bool) -> [a_afga] -> Bool)

- Language.Haskell.Generate.PreludeDef: append' :: ExpG ([a_a4ky] -> [a_a4ky] -> [a_a4ky])

+ Language.Haskell.Generate.PreludeDef: append' :: ExpG ([a_aahj] -> [a_aahj] -> [a_aahj])

- Language.Haskell.Generate.PreludeDef: asTypeOf' :: ExpG (a_a7FN -> a_a7FN -> a_a7FN)

+ Language.Haskell.Generate.PreludeDef: asTypeOf' :: ExpG (a_affW -> a_affW -> a_affW)

- Language.Haskell.Generate.PreludeDef: asin' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: asin' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: asinh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: asinh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: atan' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: atan' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: atan2' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> a_a7Fv -> a_a7Fv)

+ Language.Haskell.Generate.PreludeDef: atan2' :: RealFloat a_affh => ExpG (a_affh -> a_affh -> a_affh)

- Language.Haskell.Generate.PreludeDef: atanh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: atanh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: bind' :: Monad m_a3LS => forall a_a4ke b_a4kf. ExpG (m_a3LS a_a4ke -> (a_a4ke -> m_a3LS b_a4kf) -> m_a3LS b_a4kf)

+ 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: break' :: ExpG ((a_a7Gq -> Bool) -> [a_a7Gq] -> ([a_a7Gq], [a_a7Gq]))

+ Language.Haskell.Generate.PreludeDef: break' :: ExpG ((a_afgy -> Bool) -> [a_afgy] -> ([a_afgy], [a_afgy]))

- Language.Haskell.Generate.PreludeDef: ceiling' :: RealFrac a_a7Fo => forall b_a7Fs. Integral b_a7Fs => ExpG (a_a7Fo -> b_a7Fs)

+ Language.Haskell.Generate.PreludeDef: ceiling' :: RealFrac a_aff1 => forall b_affe. Integral b_affe => ExpG (a_aff1 -> b_affe)

- Language.Haskell.Generate.PreludeDef: concat' :: ExpG ([[a_a7cJ]] -> [a_a7cJ])

+ Language.Haskell.Generate.PreludeDef: concat' :: ExpG ([[a_af2e]] -> [a_af2e])

- Language.Haskell.Generate.PreludeDef: concatMap' :: ExpG ((a_a7G6 -> [b_a7G7]) -> [a_a7G6] -> [b_a7G7])

+ Language.Haskell.Generate.PreludeDef: concatMap' :: ExpG ((a_afge -> [b_afgf]) -> [a_afge] -> [b_afgf])

- Language.Haskell.Generate.PreludeDef: const' :: ExpG (a_a7FK -> b_a7FL -> a_a7FK)

+ Language.Haskell.Generate.PreludeDef: const' :: ExpG (a_affT -> b_affU -> a_affT)

- Language.Haskell.Generate.PreludeDef: cos' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: cos' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: cosh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: cosh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: curry' :: ExpG (((a_a7Fb, b_a7Fc) -> c_a7Fd) -> a_a7Fb -> b_a7Fc -> c_a7Fd)

+ Language.Haskell.Generate.PreludeDef: curry' :: ExpG (((a_afec, b_afed) -> c_afee) -> a_afec -> b_afed -> c_afee)

- Language.Haskell.Generate.PreludeDef: cycle' :: ExpG ([a_a7Gj] -> [a_a7Gj])

+ Language.Haskell.Generate.PreludeDef: cycle' :: ExpG ([a_afgr] -> [a_afgr])

- Language.Haskell.Generate.PreludeDef: decodeFloat' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> (Integer, Int))

+ Language.Haskell.Generate.PreludeDef: decodeFloat' :: RealFloat a_affh => ExpG (a_affh -> (Integer, Int))

- Language.Haskell.Generate.PreludeDef: div' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)

+ Language.Haskell.Generate.PreludeDef: div' :: Integral a_afej => ExpG (a_afej -> a_afej -> a_afej)

- Language.Haskell.Generate.PreludeDef: divMod' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> (a_a7Fi, a_a7Fi))

+ Language.Haskell.Generate.PreludeDef: divMod' :: Integral a_afej => ExpG (a_afej -> a_afej -> (a_afej, a_afej))

- Language.Haskell.Generate.PreludeDef: divide' :: Fractional a_a7Fk => ExpG (a_a7Fk -> a_a7Fk -> a_a7Fk)

+ Language.Haskell.Generate.PreludeDef: divide' :: Fractional a_afew => ExpG (a_afew -> a_afew -> a_afew)

- Language.Haskell.Generate.PreludeDef: dot' :: ExpG ((b_a3YA -> c_a3YB) -> (a_a3YC -> b_a3YA) -> a_a3YC -> c_a3YB)

+ Language.Haskell.Generate.PreludeDef: dot' :: ExpG ((b_a9BC -> c_a9BD) -> (a_a9BE -> b_a9BC) -> a_a9BE -> c_a9BD)

- Language.Haskell.Generate.PreludeDef: drop' :: ExpG (Int -> [a_a7Gl] -> [a_a7Gl])

+ Language.Haskell.Generate.PreludeDef: drop' :: ExpG (Int -> [a_afgt] -> [a_afgt])

- Language.Haskell.Generate.PreludeDef: dropWhile' :: ExpG ((a_a7Go -> Bool) -> [a_a7Go] -> [a_a7Go])

+ Language.Haskell.Generate.PreludeDef: dropWhile' :: ExpG ((a_afgw -> Bool) -> [a_afgw] -> [a_afgw])

- Language.Haskell.Generate.PreludeDef: either' :: ExpG ((a_a7EW -> c_a7EX) -> (b_a7EY -> c_a7EX) -> Either a_a7EW b_a7EY -> c_a7EX)

+ 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: elem' :: Eq a_a7Gr => ExpG (a_a7Gr -> [a_a7Gr] -> Bool)

+ Language.Haskell.Generate.PreludeDef: elem' :: Eq a_afgz => ExpG (a_afgz -> [a_afgz] -> Bool)

- Language.Haskell.Generate.PreludeDef: encodeFloat' :: RealFloat a_a7Fv => ExpG (Integer -> Int -> a_a7Fv)

+ Language.Haskell.Generate.PreludeDef: encodeFloat' :: RealFloat a_affh => ExpG (Integer -> Int -> a_affh)

- Language.Haskell.Generate.PreludeDef: equal' :: Eq a_a7Gt => ExpG (a_a7Gt -> a_a7Gt -> Bool)

+ Language.Haskell.Generate.PreludeDef: equal' :: Eq a_afgB => ExpG (a_afgB -> a_afgB -> Bool)

- Language.Haskell.Generate.PreludeDef: even' :: Integral a_a7Fx => ExpG (a_a7Fx -> Bool)

+ Language.Haskell.Generate.PreludeDef: even' :: Integral a_affB => ExpG (a_affB -> Bool)

- Language.Haskell.Generate.PreludeDef: exp' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: exp' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: exponent' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Int)

+ Language.Haskell.Generate.PreludeDef: exponent' :: RealFloat a_affh => ExpG (a_affh -> Int)

- Language.Haskell.Generate.PreludeDef: filter' :: ExpG ((a_a7FP -> Bool) -> [a_a7FP] -> [a_a7FP])

+ Language.Haskell.Generate.PreludeDef: filter' :: ExpG ((a_affX -> Bool) -> [a_affX] -> [a_affX])

- Language.Haskell.Generate.PreludeDef: flip' :: ExpG ((a_a6I0 -> b_a6I1 -> c_a6I2) -> b_a6I1 -> a_a6I0 -> c_a6I2)

+ Language.Haskell.Generate.PreludeDef: flip' :: ExpG ((a_aelq -> b_aelr -> c_aels) -> b_aelr -> a_aelq -> c_aels)

- Language.Haskell.Generate.PreludeDef: floatDigits' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Int)

+ Language.Haskell.Generate.PreludeDef: floatDigits' :: RealFloat a_affh => ExpG (a_affh -> Int)

- Language.Haskell.Generate.PreludeDef: floatPow' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: floatPow' :: Floating a_afeE => ExpG (a_afeE -> a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: floatRadix' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Integer)

+ Language.Haskell.Generate.PreludeDef: floatRadix' :: RealFloat a_affh => ExpG (a_affh -> Integer)

- Language.Haskell.Generate.PreludeDef: floatRange' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> (Int, Int))

+ Language.Haskell.Generate.PreludeDef: floatRange' :: RealFloat a_affh => ExpG (a_affh -> (Int, Int))

- Language.Haskell.Generate.PreludeDef: floor' :: RealFrac a_a7Fo => forall b_a7Ft. Integral b_a7Ft => ExpG (a_a7Fo -> b_a7Ft)

+ Language.Haskell.Generate.PreludeDef: floor' :: RealFrac a_aff1 => forall b_afff. Integral b_afff => ExpG (a_aff1 -> b_afff)

- Language.Haskell.Generate.PreludeDef: fmap' :: Functor f_a3LO => forall a_a3YD b_a3YE. ExpG ((a_a3YD -> b_a3YE) -> f_a3LO a_a3YD -> f_a3LO b_a3YE)

+ 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: foldl' :: ExpG ((a_a7FX -> b_a7FY -> a_a7FX) -> a_a7FX -> [b_a7FY] -> a_a7FX)

+ Language.Haskell.Generate.PreludeDef: foldl' :: ExpG ((b_afg5 -> a_afg6 -> b_afg5) -> b_afg5 -> [a_afg6] -> b_afg5)

- Language.Haskell.Generate.PreludeDef: foldl1' :: ExpG ((a_a4i1 -> a_a4i1 -> a_a4i1) -> [a_a4i1] -> a_a4i1)

+ Language.Haskell.Generate.PreludeDef: foldl1' :: ExpG ((a_aac9 -> a_aac9 -> a_aac9) -> [a_aac9] -> a_aac9)

- Language.Haskell.Generate.PreludeDef: foldr' :: ExpG ((a_a7FZ -> b_a7G0 -> b_a7G0) -> b_a7G0 -> [a_a7FZ] -> b_a7G0)

+ Language.Haskell.Generate.PreludeDef: foldr' :: ExpG ((a_afg7 -> b_afg8 -> b_afg8) -> b_afg8 -> [a_afg7] -> b_afg8)

- Language.Haskell.Generate.PreludeDef: foldr1' :: ExpG ((a_a7G1 -> a_a7G1 -> a_a7G1) -> [a_a7G1] -> a_a7G1)

+ Language.Haskell.Generate.PreludeDef: foldr1' :: ExpG ((a_afg9 -> a_afg9 -> a_afg9) -> [a_afg9] -> a_afg9)

- Language.Haskell.Generate.PreludeDef: fromInteger' :: Num a_a4qV => ExpG (Integer -> a_a4qV)

+ Language.Haskell.Generate.PreludeDef: fromInteger' :: Num a_aakB => ExpG (Integer -> a_aakB)

- Language.Haskell.Generate.PreludeDef: fromIntegral' :: (Integral a_a7FB, Num b_a7FC) => ExpG (a_a7FB -> b_a7FC)

+ Language.Haskell.Generate.PreludeDef: fromIntegral' :: (Integral a_affF, Num b_affG) => ExpG (a_affF -> b_affG)

- Language.Haskell.Generate.PreludeDef: fromRational' :: Fractional a_a7Fk => ExpG (Rational -> a_a7Fk)

+ Language.Haskell.Generate.PreludeDef: fromRational' :: Fractional a_afew => ExpG (Rational -> a_afew)

- Language.Haskell.Generate.PreludeDef: fst' :: ExpG ((a_a4r0, b_a4r1) -> a_a4r0)

+ Language.Haskell.Generate.PreludeDef: fst' :: ExpG ((a_aal1, b_aal2) -> a_aal1)

- Language.Haskell.Generate.PreludeDef: gcd' :: Integral a_a7Fz => ExpG (a_a7Fz -> a_a7Fz -> a_a7Fz)

+ Language.Haskell.Generate.PreludeDef: gcd' :: Integral a_affD => ExpG (a_affD -> a_affD -> a_affD)

- Language.Haskell.Generate.PreludeDef: head' :: ExpG ([a_a7FQ] -> a_a7FQ)

+ Language.Haskell.Generate.PreludeDef: head' :: ExpG ([a_affY] -> a_affY)

- Language.Haskell.Generate.PreludeDef: id' :: ExpG (a_a4tj -> a_a4tj)

+ Language.Haskell.Generate.PreludeDef: id' :: ExpG (a_aaAM -> a_aaAM)

- Language.Haskell.Generate.PreludeDef: index' :: ExpG ([a_a7WG] -> Int -> a_a7WG)

+ Language.Haskell.Generate.PreludeDef: index' :: ExpG ([a_agfI] -> Int -> a_agfI)

- Language.Haskell.Generate.PreludeDef: init' :: ExpG ([a_a7FT] -> [a_a7FT])

+ Language.Haskell.Generate.PreludeDef: init' :: ExpG ([a_afg1] -> [a_afg1])

- Language.Haskell.Generate.PreludeDef: isDenormalized' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)

+ Language.Haskell.Generate.PreludeDef: isDenormalized' :: RealFloat a_affh => ExpG (a_affh -> Bool)

- Language.Haskell.Generate.PreludeDef: isIEEE' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)

+ Language.Haskell.Generate.PreludeDef: isIEEE' :: RealFloat a_affh => ExpG (a_affh -> Bool)

- Language.Haskell.Generate.PreludeDef: isInfinite' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)

+ Language.Haskell.Generate.PreludeDef: isInfinite' :: RealFloat a_affh => ExpG (a_affh -> Bool)

- Language.Haskell.Generate.PreludeDef: isNaN' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)

+ Language.Haskell.Generate.PreludeDef: isNaN' :: RealFloat a_affh => ExpG (a_affh -> Bool)

- Language.Haskell.Generate.PreludeDef: isNegativeZero' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)

+ Language.Haskell.Generate.PreludeDef: isNegativeZero' :: RealFloat a_affh => ExpG (a_affh -> Bool)

- Language.Haskell.Generate.PreludeDef: iterate' :: ExpG ((a_a7Gg -> a_a7Gg) -> a_a7Gg -> [a_a7Gg])

+ Language.Haskell.Generate.PreludeDef: iterate' :: ExpG ((a_afgo -> a_afgo) -> a_afgo -> [a_afgo])

- Language.Haskell.Generate.PreludeDef: just' :: ExpG (a_a3aF -> Maybe a_a3aF)

+ Language.Haskell.Generate.PreludeDef: just' :: ExpG (a_a7tq -> Maybe a_a7tq)

- Language.Haskell.Generate.PreludeDef: last' :: ExpG ([a_a7FR] -> a_a7FR)

+ Language.Haskell.Generate.PreludeDef: last' :: ExpG ([a_affZ] -> a_affZ)

- Language.Haskell.Generate.PreludeDef: lcm' :: Integral a_a7FA => ExpG (a_a7FA -> a_a7FA -> a_a7FA)

+ Language.Haskell.Generate.PreludeDef: lcm' :: Integral a_affE => ExpG (a_affE -> a_affE -> a_affE)

- Language.Haskell.Generate.PreludeDef: left' :: ExpG (a_a7F2 -> Either a_a7F2 b_a7F3)

+ Language.Haskell.Generate.PreludeDef: left' :: ExpG (a_a9Cn -> Either a_a9Cn b_a9Co)

- Language.Haskell.Generate.PreludeDef: length' :: ExpG ([a_a7FV] -> Int)

+ Language.Haskell.Generate.PreludeDef: length' :: ExpG ([a_afg3] -> Int)

- Language.Haskell.Generate.PreludeDef: log' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: log' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: logBase' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: logBase' :: Floating a_afeE => ExpG (a_afeE -> a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: lookup' :: Eq a_a7Gv => ExpG (a_a7Gv -> [(a_a7Gv, b_a7Gw)] -> Maybe b_a7Gw)

+ Language.Haskell.Generate.PreludeDef: lookup' :: Eq a_afgH => ExpG (a_afgH -> [(a_afgH, b_afgI)] -> Maybe b_afgI)

- Language.Haskell.Generate.PreludeDef: map' :: ExpG ((a_a3Yw -> b_a3Yx) -> [a_a3Yw] -> [b_a3Yx])

+ Language.Haskell.Generate.PreludeDef: map' :: ExpG ((a_a9Br -> b_a9Bs) -> [a_a9Br] -> [b_a9Bs])

- Language.Haskell.Generate.PreludeDef: mapM' :: Monad m_a4lg => ExpG ((a_a4lf -> m_a4lg b_a4lh) -> [a_a4lf] -> m_a4lg [b_a4lh])

+ 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_' :: Monad m_a7FI => ExpG ((a_a7FH -> m_a7FI b_a7FJ) -> [a_a7FH] -> m_a7FI ())

+ Language.Haskell.Generate.PreludeDef: mapM_' :: Monad m_affR => ExpG ((a_affQ -> m_affR b_affS) -> [a_affQ] -> m_affR ())

- Language.Haskell.Generate.PreludeDef: maximum' :: Ord a_a7G8 => ExpG ([a_a7G8] -> a_a7G8)

+ Language.Haskell.Generate.PreludeDef: maximum' :: Ord a_afgg => ExpG ([a_afgg] -> a_afgg)

- Language.Haskell.Generate.PreludeDef: maybe' :: ExpG (b_a6HN -> (a_a6HO -> b_a6HN) -> Maybe a_a6HO -> b_a6HN)

+ Language.Haskell.Generate.PreludeDef: maybe' :: ExpG (b_aekV -> (a_aekW -> b_aekV) -> Maybe a_aekW -> b_aekV)

- Language.Haskell.Generate.PreludeDef: minimum' :: Ord a_a7G9 => ExpG ([a_a7G9] -> a_a7G9)

+ Language.Haskell.Generate.PreludeDef: minimum' :: Ord a_afgh => ExpG ([a_afgh] -> a_afgh)

- Language.Haskell.Generate.PreludeDef: mod' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)

+ Language.Haskell.Generate.PreludeDef: mod' :: Integral a_afej => ExpG (a_afej -> a_afej -> a_afej)

- Language.Haskell.Generate.PreludeDef: mult' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV -> a_a4qV)

+ Language.Haskell.Generate.PreludeDef: mult' :: Num a_aakB => ExpG (a_aakB -> a_aakB -> a_aakB)

- Language.Haskell.Generate.PreludeDef: negate' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV)

+ Language.Haskell.Generate.PreludeDef: negate' :: Num a_aakB => ExpG (a_aakB -> a_aakB)

- Language.Haskell.Generate.PreludeDef: notElem' :: Eq a_a7Gu => ExpG (a_a7Gu -> [a_a7Gu] -> Bool)

+ Language.Haskell.Generate.PreludeDef: notElem' :: Eq a_afgG => ExpG (a_afgG -> [a_afgG] -> Bool)

- Language.Haskell.Generate.PreludeDef: nothing' :: ExpG (Maybe a_a3aC)

+ Language.Haskell.Generate.PreludeDef: nothing' :: ExpG (Maybe a_a7tk)

- Language.Haskell.Generate.PreludeDef: null' :: ExpG ([a_a7FU] -> Bool)

+ Language.Haskell.Generate.PreludeDef: null' :: ExpG ([a_afg2] -> Bool)

- Language.Haskell.Generate.PreludeDef: odd' :: Integral a_a7Fy => ExpG (a_a7Fy -> Bool)

+ Language.Haskell.Generate.PreludeDef: odd' :: Integral a_affC => ExpG (a_affC -> Bool)

- Language.Haskell.Generate.PreludeDef: pi' :: Floating a_a7Fm => ExpG a_a7Fm

+ Language.Haskell.Generate.PreludeDef: pi' :: Floating a_afeE => ExpG a_afeE

- Language.Haskell.Generate.PreludeDef: print' :: Show a_a7Mn => ExpG (a_a7Mn -> IO ())

+ Language.Haskell.Generate.PreludeDef: print' :: Show a_afsC => ExpG (a_afsC -> IO ())

- Language.Haskell.Generate.PreludeDef: product' :: Num a_a7G5 => ExpG ([a_a7G5] -> a_a7G5)

+ Language.Haskell.Generate.PreludeDef: product' :: Num a_afgd => ExpG ([a_afgd] -> a_afgd)

- Language.Haskell.Generate.PreludeDef: properFraction' :: RealFrac a_a7Fo => forall b_a7Fp. Integral b_a7Fp => ExpG (a_a7Fo -> (b_a7Fp, a_a7Fo))

+ 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: quot' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)

+ Language.Haskell.Generate.PreludeDef: quot' :: Integral a_afej => ExpG (a_afej -> a_afej -> a_afej)

- Language.Haskell.Generate.PreludeDef: quotRem' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> (a_a7Fi, a_a7Fi))

+ Language.Haskell.Generate.PreludeDef: quotRem' :: Integral a_afej => ExpG (a_afej -> a_afej -> (a_afej, a_afej))

- Language.Haskell.Generate.PreludeDef: read' :: Read a_a7GO => ExpG (String -> a_a7GO)

+ Language.Haskell.Generate.PreludeDef: read' :: Read a_afh0 => ExpG (String -> a_afh0)

- Language.Haskell.Generate.PreludeDef: readIO' :: Read a_a7NA => ExpG (String -> IO a_a7NA)

+ Language.Haskell.Generate.PreludeDef: readIO' :: Read a_afuc => ExpG (String -> IO a_afuc)

- Language.Haskell.Generate.PreludeDef: readLn' :: Read a_a7NB => ExpG (IO a_a7NB)

+ Language.Haskell.Generate.PreludeDef: readLn' :: Read a_afud => ExpG (IO a_afud)

- Language.Haskell.Generate.PreludeDef: realToFrac' :: (Real a_a7FD, Fractional b_a7FE) => ExpG (a_a7FD -> b_a7FE)

+ Language.Haskell.Generate.PreludeDef: realToFrac' :: (Real a_affH, Fractional b_affI) => ExpG (a_affH -> b_affI)

- Language.Haskell.Generate.PreludeDef: recip' :: Fractional a_a7Fk => ExpG (a_a7Fk -> a_a7Fk)

+ Language.Haskell.Generate.PreludeDef: recip' :: Fractional a_afew => ExpG (a_afew -> a_afew)

- Language.Haskell.Generate.PreludeDef: rem' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)

+ Language.Haskell.Generate.PreludeDef: rem' :: Integral a_afej => ExpG (a_afej -> a_afej -> a_afej)

- Language.Haskell.Generate.PreludeDef: repeat' :: ExpG (a_a7Gh -> [a_a7Gh])

+ Language.Haskell.Generate.PreludeDef: repeat' :: ExpG (a_afgp -> [a_afgp])

- Language.Haskell.Generate.PreludeDef: replicate' :: ExpG (Int -> a_a7Gi -> [a_a7Gi])

+ Language.Haskell.Generate.PreludeDef: replicate' :: ExpG (Int -> a_afgq -> [a_afgq])

- Language.Haskell.Generate.PreludeDef: return' :: Monad m_a3LS => forall a_a4kv. ExpG (a_a4kv -> m_a3LS a_a4kv)

+ Language.Haskell.Generate.PreludeDef: return' :: Monad m_a8vs => forall a_a9rF. ExpG (a_a9rF -> m_a8vs a_a9rF)

- Language.Haskell.Generate.PreludeDef: reverse' :: ExpG ([a_a7FW] -> [a_a7FW])

+ Language.Haskell.Generate.PreludeDef: reverse' :: ExpG ([a_afg4] -> [a_afg4])

- Language.Haskell.Generate.PreludeDef: right' :: ExpG (b_a7F7 -> Either a_a7F6 b_a7F7)

+ Language.Haskell.Generate.PreludeDef: right' :: ExpG (b_a9Cv -> Either a_a9Cu b_a9Cv)

- Language.Haskell.Generate.PreludeDef: round' :: RealFrac a_a7Fo => forall b_a7Fr. Integral b_a7Fr => ExpG (a_a7Fo -> b_a7Fr)

+ Language.Haskell.Generate.PreludeDef: round' :: RealFrac a_aff1 => forall b_affd. Integral b_affd => ExpG (a_aff1 -> b_affd)

- Language.Haskell.Generate.PreludeDef: scaleFloat' :: RealFloat a_a7Fv => ExpG (Int -> a_a7Fv -> a_a7Fv)

+ Language.Haskell.Generate.PreludeDef: scaleFloat' :: RealFloat a_affh => ExpG (Int -> a_affh -> a_affh)

- Language.Haskell.Generate.PreludeDef: scanl' :: ExpG ((a_a7Ga -> b_a7Gb -> a_a7Ga) -> a_a7Ga -> [b_a7Gb] -> [a_a7Ga])

+ Language.Haskell.Generate.PreludeDef: scanl' :: ExpG ((b_afgi -> a_afgj -> b_afgi) -> b_afgi -> [a_afgj] -> [b_afgi])

- Language.Haskell.Generate.PreludeDef: scanl1' :: ExpG ((a_a7Ge -> a_a7Ge -> a_a7Ge) -> [a_a7Ge] -> [a_a7Ge])

+ Language.Haskell.Generate.PreludeDef: scanl1' :: ExpG ((a_afgm -> a_afgm -> a_afgm) -> [a_afgm] -> [a_afgm])

- Language.Haskell.Generate.PreludeDef: scanr' :: ExpG ((a_a7Gc -> b_a7Gd -> b_a7Gd) -> b_a7Gd -> [a_a7Gc] -> [b_a7Gd])

+ Language.Haskell.Generate.PreludeDef: scanr' :: ExpG ((a_afgk -> b_afgl -> b_afgl) -> b_afgl -> [a_afgk] -> [b_afgl])

- Language.Haskell.Generate.PreludeDef: scanr1' :: ExpG ((a_a7Gf -> a_a7Gf -> a_a7Gf) -> [a_a7Gf] -> [a_a7Gf])

+ Language.Haskell.Generate.PreludeDef: scanr1' :: ExpG ((a_afgn -> a_afgn -> a_afgn) -> [a_afgn] -> [a_afgn])

- Language.Haskell.Generate.PreludeDef: show' :: Show a_a4kA => ExpG (a_a4kA -> String)

+ Language.Haskell.Generate.PreludeDef: show' :: Show a_aahm => ExpG (a_aahm -> String)

- Language.Haskell.Generate.PreludeDef: significand' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> a_a7Fv)

+ Language.Haskell.Generate.PreludeDef: significand' :: RealFloat a_affh => ExpG (a_affh -> a_affh)

- Language.Haskell.Generate.PreludeDef: signum' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV)

+ Language.Haskell.Generate.PreludeDef: signum' :: Num a_aakB => ExpG (a_aakB -> a_aakB)

- Language.Haskell.Generate.PreludeDef: sin' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: sin' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: sinh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: sinh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: snd' :: ExpG ((a_a7F9, b_a7Fa) -> b_a7Fa)

+ Language.Haskell.Generate.PreludeDef: snd' :: ExpG ((a_afea, b_afeb) -> b_afeb)

- Language.Haskell.Generate.PreludeDef: span' :: ExpG ((a_a7Gp -> Bool) -> [a_a7Gp] -> ([a_a7Gp], [a_a7Gp]))

+ Language.Haskell.Generate.PreludeDef: span' :: ExpG ((a_afgx -> Bool) -> [a_afgx] -> ([a_afgx], [a_afgx]))

- Language.Haskell.Generate.PreludeDef: splitAt' :: ExpG (Int -> [a_a7Gm] -> ([a_a7Gm], [a_a7Gm]))

+ Language.Haskell.Generate.PreludeDef: splitAt' :: ExpG (Int -> [a_afgu] -> ([a_afgu], [a_afgu]))

- Language.Haskell.Generate.PreludeDef: sqrt' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: sqrt' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: subtract' :: Num a_a7Fw => ExpG (a_a7Fw -> a_a7Fw -> a_a7Fw)

+ Language.Haskell.Generate.PreludeDef: subtract' :: Num a_affA => ExpG (a_affA -> a_affA -> a_affA)

- Language.Haskell.Generate.PreludeDef: sum' :: Num a_a7G4 => ExpG ([a_a7G4] -> a_a7G4)

+ Language.Haskell.Generate.PreludeDef: sum' :: Num a_afgc => ExpG ([a_afgc] -> a_afgc)

- Language.Haskell.Generate.PreludeDef: tail' :: ExpG ([a_a7FS] -> [a_a7FS])

+ Language.Haskell.Generate.PreludeDef: tail' :: ExpG ([a_afg0] -> [a_afg0])

- Language.Haskell.Generate.PreludeDef: take' :: ExpG (Int -> [a_a7Gk] -> [a_a7Gk])

+ Language.Haskell.Generate.PreludeDef: take' :: ExpG (Int -> [a_afgs] -> [a_afgs])

- Language.Haskell.Generate.PreludeDef: takeWhile' :: ExpG ((a_a7Gn -> Bool) -> [a_a7Gn] -> [a_a7Gn])

+ Language.Haskell.Generate.PreludeDef: takeWhile' :: ExpG ((a_afgv -> Bool) -> [a_afgv] -> [a_afgv])

- Language.Haskell.Generate.PreludeDef: tan' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: tan' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: tanh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)

+ Language.Haskell.Generate.PreludeDef: tanh' :: Floating a_afeE => ExpG (a_afeE -> a_afeE)

- Language.Haskell.Generate.PreludeDef: then' :: Monad m_a3LS => forall a_a4kH b_a4kI. ExpG (m_a3LS a_a4kH -> m_a3LS b_a4kI -> m_a3LS b_a4kI)

+ 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: toInteger' :: Integral a_a7Fi => ExpG (a_a7Fi -> Integer)

+ Language.Haskell.Generate.PreludeDef: toInteger' :: Integral a_afej => ExpG (a_afej -> Integer)

- Language.Haskell.Generate.PreludeDef: truncate' :: RealFrac a_a7Fo => forall b_a7Fq. Integral b_a7Fq => ExpG (a_a7Fo -> b_a7Fq)

+ Language.Haskell.Generate.PreludeDef: truncate' :: RealFrac a_aff1 => forall b_affc. Integral b_affc => ExpG (a_aff1 -> b_affc)

- Language.Haskell.Generate.PreludeDef: uncurry' :: ExpG ((a_a7Fe -> b_a7Ff -> c_a7Fg) -> (a_a7Fe, b_a7Ff) -> c_a7Fg)

+ Language.Haskell.Generate.PreludeDef: uncurry' :: ExpG ((a_afef -> b_afeg -> c_afeh) -> (a_afef, b_afeg) -> c_afeh)

- Language.Haskell.Generate.PreludeDef: undefined' :: ExpG a_a7FO

+ Language.Haskell.Generate.PreludeDef: undefined' :: ExpG a_12

- Language.Haskell.Generate.PreludeDef: until' :: ExpG ((a_a7FM -> Bool) -> (a_a7FM -> a_a7FM) -> a_a7FM -> a_a7FM)

+ Language.Haskell.Generate.PreludeDef: until' :: ExpG ((a_affV -> Bool) -> (a_affV -> a_affV) -> a_affV -> a_affV)

- Language.Haskell.Generate.PreludeDef: unzip' :: ExpG ([(a_a7GJ, b_a7GK)] -> ([a_a7GJ], [b_a7GK]))

+ Language.Haskell.Generate.PreludeDef: unzip' :: ExpG ([(a_afgV, b_afgW)] -> ([a_afgV], [b_afgW]))

- Language.Haskell.Generate.PreludeDef: unzip3' :: ExpG ([(a_a7GL, b_a7GM, c_a7GN)] -> ([a_a7GL], [b_a7GM], [c_a7GN]))

+ Language.Haskell.Generate.PreludeDef: unzip3' :: ExpG ([(a_afgX, b_afgY, c_afgZ)] -> ([a_afgX], [b_afgY], [c_afgZ]))

- Language.Haskell.Generate.PreludeDef: zip' :: ExpG ([a_a7Gx] -> [b_a7Gy] -> [(a_a7Gx, b_a7Gy)])

+ Language.Haskell.Generate.PreludeDef: zip' :: ExpG ([a_afgJ] -> [b_afgK] -> [(a_afgJ, b_afgK)])

- Language.Haskell.Generate.PreludeDef: zip3' :: ExpG ([a_a7Gz] -> [b_a7GA] -> [c_a7GB] -> [(a_a7Gz, b_a7GA, c_a7GB)])

+ Language.Haskell.Generate.PreludeDef: zip3' :: ExpG ([a_afgL] -> [b_afgM] -> [c_afgN] -> [(a_afgL, b_afgM, c_afgN)])

- Language.Haskell.Generate.PreludeDef: zipWith' :: ExpG ((a_a7GC -> b_a7GD -> c_a7GE) -> [a_a7GC] -> [b_a7GD] -> [c_a7GE])

+ Language.Haskell.Generate.PreludeDef: zipWith' :: ExpG ((a_afgO -> b_afgP -> c_afgQ) -> [a_afgO] -> [b_afgP] -> [c_afgQ])

- Language.Haskell.Generate.PreludeDef: zipWith3' :: ExpG ((a_a7GF -> b_a7GG -> c_a7GH -> d_a7GI) -> [a_a7GF] -> [b_a7GG] -> [c_a7GH] -> [d_a7GI])

+ Language.Haskell.Generate.PreludeDef: zipWith3' :: ExpG ((a_afgR -> b_afgS -> c_afgT -> d_afgU) -> [a_afgR] -> [b_afgS] -> [c_afgT] -> [d_afgU])

Files

LICENSE +1/−1
README.md +0/−1
haskell-generate.cabal +7/−4
src/Language/Haskell/Generate/PreludeDef.hs +1/−0

LICENSE view

@@ -1,4 +1,4 @@-Copyright 2013-2014 Benno Fünfstück+Copyright 2013-2015 Benno Fünfstück  All rights reserved.

README.md view

@@ -102,4 +102,3 @@ ## Contributing  If you have an idea, a question or a bug report, open an issue on github. You can also find me on freenode in the #haskell channel, my nick is bennofs.-

haskell-generate.cabal view

@@ -1,5 +1,5 @@ name:          haskell-generate-version:       0.2.2+version:       0.2.3 license:       BSD3 category:      Code Generation, Language cabal-version: >= 1.10@@ -9,9 +9,12 @@ stability:     experimental homepage:      http://github.com/bennofs/haskell-generate/ bug-reports:   http://github.com/bennofs/haskell-generate/issues-copyright:     Copyright (C) 2013 Benno Fünfstück-synopsis:      haskell-generate-description:   haskell-generate+copyright:     Copyright (C) 2013-2015 Benno Fünfstück+synopsis:      Typesafe generation of haskell source code+description:+  This library provides an interface to generate haskell source code, verifying at compile time+  that the resulting code typechecks. See https://github.com/bennofs/haskell-generate for an+  introduction explaining how to use the library. build-type:    Custom  extra-source-files:

src/Language/Haskell/Generate/PreludeDef.hs view

@@ -60,6 +60,7 @@   , ('(++), "append'")   , ('(!!), "index'")   , ('(==), "equal'")+  , ('(/=), "notequal'")   ]  (<>.) :: ExpG (b -> c) -> ExpG (a -> b) -> ExpG (a -> c)