haskell-generate 0.2.1 → 0.2.2
raw patch · 2 files changed
+5/−3 lines, 2 filesPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
API changes (from Hackage documentation)
- Language.Haskell.Generate.PreludeDef: abs' :: Num a_aajz => ExpG (a_aajz -> a_aajz)
+ Language.Haskell.Generate.PreludeDef: abs' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV)
- Language.Haskell.Generate.PreludeDef: acos' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: acos' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: acosh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: acosh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: add' :: Num a_aajz => ExpG (a_aajz -> a_aajz -> a_aajz)
+ Language.Haskell.Generate.PreludeDef: add' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV -> a_a4qV)
- Language.Haskell.Generate.PreludeDef: all' :: ExpG ((a_ae4f -> Bool) -> [a_ae4f] -> Bool)
+ Language.Haskell.Generate.PreludeDef: all' :: ExpG ((a_a7G3 -> Bool) -> [a_a7G3] -> Bool)
- Language.Haskell.Generate.PreludeDef: any' :: ExpG ((a_ae4e -> Bool) -> [a_ae4e] -> Bool)
+ Language.Haskell.Generate.PreludeDef: any' :: ExpG ((a_a7G2 -> Bool) -> [a_a7G2] -> Bool)
- Language.Haskell.Generate.PreludeDef: append' :: ExpG ([a_aagh] -> [a_aagh] -> [a_aagh])
+ Language.Haskell.Generate.PreludeDef: append' :: ExpG ([a_a4ky] -> [a_a4ky] -> [a_a4ky])
- Language.Haskell.Generate.PreludeDef: asTypeOf' :: ExpG (a_ae40 -> a_ae40 -> a_ae40)
+ Language.Haskell.Generate.PreludeDef: asTypeOf' :: ExpG (a_a7FN -> a_a7FN -> a_a7FN)
- Language.Haskell.Generate.PreludeDef: asin' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: asin' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: asinh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: asinh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: atan' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: atan' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: atan2' :: RealFloat a_ae3l => ExpG (a_ae3l -> a_ae3l -> a_ae3l)
+ Language.Haskell.Generate.PreludeDef: atan2' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> a_a7Fv -> a_a7Fv)
- Language.Haskell.Generate.PreludeDef: atanh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: atanh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: bind' :: Monad m_a8vl => forall a_a9qr b_a9qs. ExpG (m_a8vl a_a9qr -> (a_a9qr -> m_a8vl b_a9qs) -> m_a8vl b_a9qs)
+ 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: break' :: ExpG ((a_ae4C -> Bool) -> [a_ae4C] -> ([a_ae4C], [a_ae4C]))
+ Language.Haskell.Generate.PreludeDef: break' :: ExpG ((a_a7Gq -> Bool) -> [a_a7Gq] -> ([a_a7Gq], [a_a7Gq]))
- Language.Haskell.Generate.PreludeDef: ceiling' :: RealFrac a_ae35 => forall b_ae3i. Integral b_ae3i => ExpG (a_ae35 -> b_ae3i)
+ Language.Haskell.Generate.PreludeDef: ceiling' :: RealFrac a_a7Fo => forall b_a7Fs. Integral b_a7Fs => ExpG (a_a7Fo -> b_a7Fs)
- Language.Haskell.Generate.PreludeDef: concat' :: ExpG ([[a_adQi]] -> [a_adQi])
+ Language.Haskell.Generate.PreludeDef: concat' :: ExpG ([[a_a7cJ]] -> [a_a7cJ])
- Language.Haskell.Generate.PreludeDef: concatMap' :: ExpG ((a_ae4i -> [b_ae4j]) -> [a_ae4i] -> [b_ae4j])
+ Language.Haskell.Generate.PreludeDef: concatMap' :: ExpG ((a_a7G6 -> [b_a7G7]) -> [a_a7G6] -> [b_a7G7])
- Language.Haskell.Generate.PreludeDef: const' :: ExpG (a_ae3X -> b_ae3Y -> a_ae3X)
+ Language.Haskell.Generate.PreludeDef: const' :: ExpG (a_a7FK -> b_a7FL -> a_a7FK)
- Language.Haskell.Generate.PreludeDef: cos' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: cos' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: cosh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: cosh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: curry' :: ExpG (((a_ae2g, b_ae2h) -> c_ae2i) -> a_ae2g -> b_ae2h -> c_ae2i)
+ Language.Haskell.Generate.PreludeDef: curry' :: ExpG (((a_a7Fb, b_a7Fc) -> c_a7Fd) -> a_a7Fb -> b_a7Fc -> c_a7Fd)
- Language.Haskell.Generate.PreludeDef: cycle' :: ExpG ([a_ae4v] -> [a_ae4v])
+ Language.Haskell.Generate.PreludeDef: cycle' :: ExpG ([a_a7Gj] -> [a_a7Gj])
- Language.Haskell.Generate.PreludeDef: decodeFloat' :: RealFloat a_ae3l => ExpG (a_ae3l -> (Integer, Int))
+ Language.Haskell.Generate.PreludeDef: decodeFloat' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> (Integer, Int))
- Language.Haskell.Generate.PreludeDef: div' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> a_ae2n)
+ Language.Haskell.Generate.PreludeDef: div' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)
- Language.Haskell.Generate.PreludeDef: divMod' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> (a_ae2n, a_ae2n))
+ Language.Haskell.Generate.PreludeDef: divMod' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> (a_a7Fi, a_a7Fi))
- Language.Haskell.Generate.PreludeDef: divide' :: Fractional a_ae2A => ExpG (a_ae2A -> a_ae2A -> a_ae2A)
+ Language.Haskell.Generate.PreludeDef: divide' :: Fractional a_a7Fk => ExpG (a_a7Fk -> a_a7Fk -> a_a7Fk)
- Language.Haskell.Generate.PreludeDef: dot' :: ExpG ((b_a9AA -> c_a9AB) -> (a_a9AC -> b_a9AA) -> a_a9AC -> c_a9AB)
+ Language.Haskell.Generate.PreludeDef: dot' :: ExpG ((b_a3YA -> c_a3YB) -> (a_a3YC -> b_a3YA) -> a_a3YC -> c_a3YB)
- Language.Haskell.Generate.PreludeDef: drop' :: ExpG (Int -> [a_ae4x] -> [a_ae4x])
+ Language.Haskell.Generate.PreludeDef: drop' :: ExpG (Int -> [a_a7Gl] -> [a_a7Gl])
- Language.Haskell.Generate.PreludeDef: dropWhile' :: ExpG ((a_ae4A -> Bool) -> [a_ae4A] -> [a_ae4A])
+ Language.Haskell.Generate.PreludeDef: dropWhile' :: ExpG ((a_a7Go -> Bool) -> [a_a7Go] -> [a_a7Go])
- Language.Haskell.Generate.PreludeDef: either' :: ExpG ((a_ae2b -> c_ae2c) -> (b_ae2d -> c_ae2c) -> Either a_ae2b b_ae2d -> c_ae2c)
+ 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: elem' :: Eq a_ae4D => ExpG (a_ae4D -> [a_ae4D] -> Bool)
+ Language.Haskell.Generate.PreludeDef: elem' :: Eq a_a7Gr => ExpG (a_a7Gr -> [a_a7Gr] -> Bool)
- Language.Haskell.Generate.PreludeDef: encodeFloat' :: RealFloat a_ae3l => ExpG (Integer -> Int -> a_ae3l)
+ Language.Haskell.Generate.PreludeDef: encodeFloat' :: RealFloat a_a7Fv => ExpG (Integer -> Int -> a_a7Fv)
- Language.Haskell.Generate.PreludeDef: equal' :: Eq a_ae4F => ExpG (a_ae4F -> a_ae4F -> Bool)
+ Language.Haskell.Generate.PreludeDef: equal' :: Eq a_a7Gt => ExpG (a_a7Gt -> a_a7Gt -> Bool)
- Language.Haskell.Generate.PreludeDef: even' :: Integral a_ae3F => ExpG (a_ae3F -> Bool)
+ Language.Haskell.Generate.PreludeDef: even' :: Integral a_a7Fx => ExpG (a_a7Fx -> Bool)
- Language.Haskell.Generate.PreludeDef: exp' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: exp' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: exponent' :: RealFloat a_ae3l => ExpG (a_ae3l -> Int)
+ Language.Haskell.Generate.PreludeDef: exponent' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Int)
- Language.Haskell.Generate.PreludeDef: filter' :: ExpG ((a_ae41 -> Bool) -> [a_ae41] -> [a_ae41])
+ Language.Haskell.Generate.PreludeDef: filter' :: ExpG ((a_a7FP -> Bool) -> [a_a7FP] -> [a_a7FP])
- Language.Haskell.Generate.PreludeDef: flip' :: ExpG ((a_adsg -> b_adsh -> c_adsi) -> b_adsh -> a_adsg -> c_adsi)
+ Language.Haskell.Generate.PreludeDef: flip' :: ExpG ((a_a6I0 -> b_a6I1 -> c_a6I2) -> b_a6I1 -> a_a6I0 -> c_a6I2)
- Language.Haskell.Generate.PreludeDef: floatDigits' :: RealFloat a_ae3l => ExpG (a_ae3l -> Int)
+ Language.Haskell.Generate.PreludeDef: floatDigits' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Int)
- Language.Haskell.Generate.PreludeDef: floatPow' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: floatPow' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: floatRadix' :: RealFloat a_ae3l => ExpG (a_ae3l -> Integer)
+ Language.Haskell.Generate.PreludeDef: floatRadix' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Integer)
- Language.Haskell.Generate.PreludeDef: floatRange' :: RealFloat a_ae3l => ExpG (a_ae3l -> (Int, Int))
+ Language.Haskell.Generate.PreludeDef: floatRange' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> (Int, Int))
- Language.Haskell.Generate.PreludeDef: floor' :: RealFrac a_ae35 => forall b_ae3j. Integral b_ae3j => ExpG (a_ae35 -> b_ae3j)
+ Language.Haskell.Generate.PreludeDef: floor' :: RealFrac a_a7Fo => forall b_a7Ft. Integral b_a7Ft => ExpG (a_a7Fo -> b_a7Ft)
- Language.Haskell.Generate.PreludeDef: fmap' :: Functor f_a9aQ => forall a_a9bg b_a9bh. ExpG ((a_a9bg -> b_a9bh) -> f_a9aQ a_a9bg -> f_a9aQ b_a9bh)
+ 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: foldl' :: ExpG ((b_ae49 -> a_ae4a -> b_ae49) -> b_ae49 -> [a_ae4a] -> b_ae49)
+ Language.Haskell.Generate.PreludeDef: foldl' :: ExpG ((a_a7FX -> b_a7FY -> a_a7FX) -> a_a7FX -> [b_a7FY] -> a_a7FX)
- Language.Haskell.Generate.PreludeDef: foldl1' :: ExpG ((a_aab7 -> a_aab7 -> a_aab7) -> [a_aab7] -> a_aab7)
+ Language.Haskell.Generate.PreludeDef: foldl1' :: ExpG ((a_a4i1 -> a_a4i1 -> a_a4i1) -> [a_a4i1] -> a_a4i1)
- Language.Haskell.Generate.PreludeDef: foldr' :: ExpG ((a_ae4b -> b_ae4c -> b_ae4c) -> b_ae4c -> [a_ae4b] -> b_ae4c)
+ Language.Haskell.Generate.PreludeDef: foldr' :: ExpG ((a_a7FZ -> b_a7G0 -> b_a7G0) -> b_a7G0 -> [a_a7FZ] -> b_a7G0)
- Language.Haskell.Generate.PreludeDef: foldr1' :: ExpG ((a_ae4d -> a_ae4d -> a_ae4d) -> [a_ae4d] -> a_ae4d)
+ Language.Haskell.Generate.PreludeDef: foldr1' :: ExpG ((a_a7G1 -> a_a7G1 -> a_a7G1) -> [a_a7G1] -> a_a7G1)
- Language.Haskell.Generate.PreludeDef: fromInteger' :: Num a_aajz => ExpG (Integer -> a_aajz)
+ Language.Haskell.Generate.PreludeDef: fromInteger' :: Num a_a4qV => ExpG (Integer -> a_a4qV)
- Language.Haskell.Generate.PreludeDef: fromIntegral' :: (Integral a_ae3J, Num b_ae3K) => ExpG (a_ae3J -> b_ae3K)
+ Language.Haskell.Generate.PreludeDef: fromIntegral' :: (Integral a_a7FB, Num b_a7FC) => ExpG (a_a7FB -> b_a7FC)
- Language.Haskell.Generate.PreludeDef: fromRational' :: Fractional a_ae2A => ExpG (Rational -> a_ae2A)
+ Language.Haskell.Generate.PreludeDef: fromRational' :: Fractional a_a7Fk => ExpG (Rational -> a_a7Fk)
- Language.Haskell.Generate.PreludeDef: fst' :: ExpG ((a_aajZ, b_aak0) -> a_aajZ)
+ Language.Haskell.Generate.PreludeDef: fst' :: ExpG ((a_a4r0, b_a4r1) -> a_a4r0)
- Language.Haskell.Generate.PreludeDef: gcd' :: Integral a_ae3H => ExpG (a_ae3H -> a_ae3H -> a_ae3H)
+ Language.Haskell.Generate.PreludeDef: gcd' :: Integral a_a7Fz => ExpG (a_a7Fz -> a_a7Fz -> a_a7Fz)
- Language.Haskell.Generate.PreludeDef: head' :: ExpG ([a_ae42] -> a_ae42)
+ Language.Haskell.Generate.PreludeDef: head' :: ExpG ([a_a7FQ] -> a_a7FQ)
- Language.Haskell.Generate.PreludeDef: id' :: ExpG (a_aazK -> a_aazK)
+ Language.Haskell.Generate.PreludeDef: id' :: ExpG (a_a4tj -> a_a4tj)
- Language.Haskell.Generate.PreludeDef: index' :: ExpG ([a_af3F] -> Int -> a_af3F)
+ Language.Haskell.Generate.PreludeDef: index' :: ExpG ([a_a7WG] -> Int -> a_a7WG)
- Language.Haskell.Generate.PreludeDef: init' :: ExpG ([a_ae45] -> [a_ae45])
+ Language.Haskell.Generate.PreludeDef: init' :: ExpG ([a_a7FT] -> [a_a7FT])
- Language.Haskell.Generate.PreludeDef: isDenormalized' :: RealFloat a_ae3l => ExpG (a_ae3l -> Bool)
+ Language.Haskell.Generate.PreludeDef: isDenormalized' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)
- Language.Haskell.Generate.PreludeDef: isIEEE' :: RealFloat a_ae3l => ExpG (a_ae3l -> Bool)
+ Language.Haskell.Generate.PreludeDef: isIEEE' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)
- Language.Haskell.Generate.PreludeDef: isInfinite' :: RealFloat a_ae3l => ExpG (a_ae3l -> Bool)
+ Language.Haskell.Generate.PreludeDef: isInfinite' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)
- Language.Haskell.Generate.PreludeDef: isNaN' :: RealFloat a_ae3l => ExpG (a_ae3l -> Bool)
+ Language.Haskell.Generate.PreludeDef: isNaN' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)
- Language.Haskell.Generate.PreludeDef: isNegativeZero' :: RealFloat a_ae3l => ExpG (a_ae3l -> Bool)
+ Language.Haskell.Generate.PreludeDef: isNegativeZero' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> Bool)
- Language.Haskell.Generate.PreludeDef: iterate' :: ExpG ((a_ae4s -> a_ae4s) -> a_ae4s -> [a_ae4s])
+ Language.Haskell.Generate.PreludeDef: iterate' :: ExpG ((a_a7Gg -> a_a7Gg) -> a_a7Gg -> [a_a7Gg])
- Language.Haskell.Generate.PreludeDef: just' :: ExpG (a_a7tj -> Maybe a_a7tj)
+ Language.Haskell.Generate.PreludeDef: just' :: ExpG (a_a3aF -> Maybe a_a3aF)
- Language.Haskell.Generate.PreludeDef: last' :: ExpG ([a_ae43] -> a_ae43)
+ Language.Haskell.Generate.PreludeDef: last' :: ExpG ([a_a7FR] -> a_a7FR)
- Language.Haskell.Generate.PreludeDef: lcm' :: Integral a_ae3I => ExpG (a_ae3I -> a_ae3I -> a_ae3I)
+ Language.Haskell.Generate.PreludeDef: lcm' :: Integral a_a7FA => ExpG (a_a7FA -> a_a7FA -> a_a7FA)
- Language.Haskell.Generate.PreludeDef: left' :: ExpG (a_a9Bl -> Either a_a9Bl b_a9Bm)
+ Language.Haskell.Generate.PreludeDef: left' :: ExpG (a_a7F2 -> Either a_a7F2 b_a7F3)
- Language.Haskell.Generate.PreludeDef: length' :: ExpG ([a_ae47] -> Int)
+ Language.Haskell.Generate.PreludeDef: length' :: ExpG ([a_a7FV] -> Int)
- Language.Haskell.Generate.PreludeDef: log' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: log' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: logBase' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: logBase' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: lookup' :: Eq a_ae4L => ExpG (a_ae4L -> [(a_ae4L, b_ae4M)] -> Maybe b_ae4M)
+ Language.Haskell.Generate.PreludeDef: lookup' :: Eq a_a7Gv => ExpG (a_a7Gv -> [(a_a7Gv, b_a7Gw)] -> Maybe b_a7Gw)
- Language.Haskell.Generate.PreludeDef: map' :: ExpG ((a_a9Ap -> b_a9Aq) -> [a_a9Ap] -> [b_a9Aq])
+ Language.Haskell.Generate.PreludeDef: map' :: ExpG ((a_a3Yw -> b_a3Yx) -> [a_a3Yw] -> [b_a3Yx])
- Language.Haskell.Generate.PreludeDef: mapM' :: Monad m_aai4 => ExpG ((a_aai3 -> m_aai4 b_aai5) -> [a_aai3] -> m_aai4 [b_aai5])
+ 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_ae3V => ExpG ((a_ae3U -> m_ae3V b_ae3W) -> [a_ae3U] -> m_ae3V ())
+ Language.Haskell.Generate.PreludeDef: mapM_' :: Monad m_a7FI => ExpG ((a_a7FH -> m_a7FI b_a7FJ) -> [a_a7FH] -> m_a7FI ())
- Language.Haskell.Generate.PreludeDef: maximum' :: Ord a_ae4k => ExpG ([a_ae4k] -> a_ae4k)
+ Language.Haskell.Generate.PreludeDef: maximum' :: Ord a_a7G8 => ExpG ([a_a7G8] -> a_a7G8)
- Language.Haskell.Generate.PreludeDef: maybe' :: ExpG (b_adrL -> (a_adrM -> b_adrL) -> Maybe a_adrM -> b_adrL)
+ Language.Haskell.Generate.PreludeDef: maybe' :: ExpG (b_a6HN -> (a_a6HO -> b_a6HN) -> Maybe a_a6HO -> b_a6HN)
- Language.Haskell.Generate.PreludeDef: minimum' :: Ord a_ae4l => ExpG ([a_ae4l] -> a_ae4l)
+ Language.Haskell.Generate.PreludeDef: minimum' :: Ord a_a7G9 => ExpG ([a_a7G9] -> a_a7G9)
- Language.Haskell.Generate.PreludeDef: mod' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> a_ae2n)
+ Language.Haskell.Generate.PreludeDef: mod' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)
- Language.Haskell.Generate.PreludeDef: mult' :: Num a_aajz => ExpG (a_aajz -> a_aajz -> a_aajz)
+ Language.Haskell.Generate.PreludeDef: mult' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV -> a_a4qV)
- Language.Haskell.Generate.PreludeDef: negate' :: Num a_aajz => ExpG (a_aajz -> a_aajz)
+ Language.Haskell.Generate.PreludeDef: negate' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV)
- Language.Haskell.Generate.PreludeDef: notElem' :: Eq a_ae4K => ExpG (a_ae4K -> [a_ae4K] -> Bool)
+ Language.Haskell.Generate.PreludeDef: notElem' :: Eq a_a7Gu => ExpG (a_a7Gu -> [a_a7Gu] -> Bool)
- Language.Haskell.Generate.PreludeDef: nothing' :: ExpG (Maybe a_a7td)
+ Language.Haskell.Generate.PreludeDef: nothing' :: ExpG (Maybe a_a3aC)
- Language.Haskell.Generate.PreludeDef: null' :: ExpG ([a_ae46] -> Bool)
+ Language.Haskell.Generate.PreludeDef: null' :: ExpG ([a_a7FU] -> Bool)
- Language.Haskell.Generate.PreludeDef: odd' :: Integral a_ae3G => ExpG (a_ae3G -> Bool)
+ Language.Haskell.Generate.PreludeDef: odd' :: Integral a_a7Fy => ExpG (a_a7Fy -> Bool)
- Language.Haskell.Generate.PreludeDef: pi' :: Floating a_ae2I => ExpG a_ae2I
+ Language.Haskell.Generate.PreludeDef: pi' :: Floating a_a7Fm => ExpG a_a7Fm
- Language.Haskell.Generate.PreludeDef: print' :: Show a_aegG => ExpG (a_aegG -> IO ())
+ Language.Haskell.Generate.PreludeDef: print' :: Show a_a7Mn => ExpG (a_a7Mn -> IO ())
- Language.Haskell.Generate.PreludeDef: product' :: Num a_ae4h => ExpG ([a_ae4h] -> a_ae4h)
+ Language.Haskell.Generate.PreludeDef: product' :: Num a_a7G5 => ExpG ([a_a7G5] -> a_a7G5)
- Language.Haskell.Generate.PreludeDef: properFraction' :: RealFrac a_ae35 => forall b_ae3f. Integral b_ae3f => ExpG (a_ae35 -> (b_ae3f, a_ae35))
+ 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: quot' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> a_ae2n)
+ Language.Haskell.Generate.PreludeDef: quot' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)
- Language.Haskell.Generate.PreludeDef: quotRem' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> (a_ae2n, a_ae2n))
+ Language.Haskell.Generate.PreludeDef: quotRem' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> (a_a7Fi, a_a7Fi))
- Language.Haskell.Generate.PreludeDef: read' :: Read a_ae54 => ExpG (String -> a_ae54)
+ Language.Haskell.Generate.PreludeDef: read' :: Read a_a7GO => ExpG (String -> a_a7GO)
- Language.Haskell.Generate.PreludeDef: readIO' :: Read a_aeig => ExpG (String -> IO a_aeig)
+ Language.Haskell.Generate.PreludeDef: readIO' :: Read a_a7NA => ExpG (String -> IO a_a7NA)
- Language.Haskell.Generate.PreludeDef: readLn' :: Read a_aeih => ExpG (IO a_aeih)
+ Language.Haskell.Generate.PreludeDef: readLn' :: Read a_a7NB => ExpG (IO a_a7NB)
- Language.Haskell.Generate.PreludeDef: realToFrac' :: (Real a_ae3L, Fractional b_ae3M) => ExpG (a_ae3L -> b_ae3M)
+ Language.Haskell.Generate.PreludeDef: realToFrac' :: (Real a_a7FD, Fractional b_a7FE) => ExpG (a_a7FD -> b_a7FE)
- Language.Haskell.Generate.PreludeDef: recip' :: Fractional a_ae2A => ExpG (a_ae2A -> a_ae2A)
+ Language.Haskell.Generate.PreludeDef: recip' :: Fractional a_a7Fk => ExpG (a_a7Fk -> a_a7Fk)
- Language.Haskell.Generate.PreludeDef: rem' :: Integral a_ae2n => ExpG (a_ae2n -> a_ae2n -> a_ae2n)
+ Language.Haskell.Generate.PreludeDef: rem' :: Integral a_a7Fi => ExpG (a_a7Fi -> a_a7Fi -> a_a7Fi)
- Language.Haskell.Generate.PreludeDef: repeat' :: ExpG (a_ae4t -> [a_ae4t])
+ Language.Haskell.Generate.PreludeDef: repeat' :: ExpG (a_a7Gh -> [a_a7Gh])
- Language.Haskell.Generate.PreludeDef: replicate' :: ExpG (Int -> a_ae4u -> [a_ae4u])
+ Language.Haskell.Generate.PreludeDef: replicate' :: ExpG (Int -> a_a7Gi -> [a_a7Gi])
- Language.Haskell.Generate.PreludeDef: return' :: Monad m_a8vl => forall a_a9qD. ExpG (a_a9qD -> m_a8vl a_a9qD)
+ Language.Haskell.Generate.PreludeDef: return' :: Monad m_a3LS => forall a_a4kv. ExpG (a_a4kv -> m_a3LS a_a4kv)
- Language.Haskell.Generate.PreludeDef: reverse' :: ExpG ([a_ae48] -> [a_ae48])
+ Language.Haskell.Generate.PreludeDef: reverse' :: ExpG ([a_a7FW] -> [a_a7FW])
- Language.Haskell.Generate.PreludeDef: right' :: ExpG (b_a9Bt -> Either a_a9Bs b_a9Bt)
+ Language.Haskell.Generate.PreludeDef: right' :: ExpG (b_a7F7 -> Either a_a7F6 b_a7F7)
- Language.Haskell.Generate.PreludeDef: round' :: RealFrac a_ae35 => forall b_ae3h. Integral b_ae3h => ExpG (a_ae35 -> b_ae3h)
+ Language.Haskell.Generate.PreludeDef: round' :: RealFrac a_a7Fo => forall b_a7Fr. Integral b_a7Fr => ExpG (a_a7Fo -> b_a7Fr)
- Language.Haskell.Generate.PreludeDef: scaleFloat' :: RealFloat a_ae3l => ExpG (Int -> a_ae3l -> a_ae3l)
+ Language.Haskell.Generate.PreludeDef: scaleFloat' :: RealFloat a_a7Fv => ExpG (Int -> a_a7Fv -> a_a7Fv)
- Language.Haskell.Generate.PreludeDef: scanl' :: ExpG ((b_ae4m -> a_ae4n -> b_ae4m) -> b_ae4m -> [a_ae4n] -> [b_ae4m])
+ Language.Haskell.Generate.PreludeDef: scanl' :: ExpG ((a_a7Ga -> b_a7Gb -> a_a7Ga) -> a_a7Ga -> [b_a7Gb] -> [a_a7Ga])
- Language.Haskell.Generate.PreludeDef: scanl1' :: ExpG ((a_ae4q -> a_ae4q -> a_ae4q) -> [a_ae4q] -> [a_ae4q])
+ Language.Haskell.Generate.PreludeDef: scanl1' :: ExpG ((a_a7Ge -> a_a7Ge -> a_a7Ge) -> [a_a7Ge] -> [a_a7Ge])
- Language.Haskell.Generate.PreludeDef: scanr' :: ExpG ((a_ae4o -> b_ae4p -> b_ae4p) -> b_ae4p -> [a_ae4o] -> [b_ae4p])
+ Language.Haskell.Generate.PreludeDef: scanr' :: ExpG ((a_a7Gc -> b_a7Gd -> b_a7Gd) -> b_a7Gd -> [a_a7Gc] -> [b_a7Gd])
- Language.Haskell.Generate.PreludeDef: scanr1' :: ExpG ((a_ae4r -> a_ae4r -> a_ae4r) -> [a_ae4r] -> [a_ae4r])
+ Language.Haskell.Generate.PreludeDef: scanr1' :: ExpG ((a_a7Gf -> a_a7Gf -> a_a7Gf) -> [a_a7Gf] -> [a_a7Gf])
- Language.Haskell.Generate.PreludeDef: show' :: Show a_aagk => ExpG (a_aagk -> String)
+ Language.Haskell.Generate.PreludeDef: show' :: Show a_a4kA => ExpG (a_a4kA -> String)
- Language.Haskell.Generate.PreludeDef: significand' :: RealFloat a_ae3l => ExpG (a_ae3l -> a_ae3l)
+ Language.Haskell.Generate.PreludeDef: significand' :: RealFloat a_a7Fv => ExpG (a_a7Fv -> a_a7Fv)
- Language.Haskell.Generate.PreludeDef: signum' :: Num a_aajz => ExpG (a_aajz -> a_aajz)
+ Language.Haskell.Generate.PreludeDef: signum' :: Num a_a4qV => ExpG (a_a4qV -> a_a4qV)
- Language.Haskell.Generate.PreludeDef: sin' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: sin' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: sinh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: sinh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: snd' :: ExpG ((a_ae2e, b_ae2f) -> b_ae2f)
+ Language.Haskell.Generate.PreludeDef: snd' :: ExpG ((a_a7F9, b_a7Fa) -> b_a7Fa)
- Language.Haskell.Generate.PreludeDef: span' :: ExpG ((a_ae4B -> Bool) -> [a_ae4B] -> ([a_ae4B], [a_ae4B]))
+ Language.Haskell.Generate.PreludeDef: span' :: ExpG ((a_a7Gp -> Bool) -> [a_a7Gp] -> ([a_a7Gp], [a_a7Gp]))
- Language.Haskell.Generate.PreludeDef: splitAt' :: ExpG (Int -> [a_ae4y] -> ([a_ae4y], [a_ae4y]))
+ Language.Haskell.Generate.PreludeDef: splitAt' :: ExpG (Int -> [a_a7Gm] -> ([a_a7Gm], [a_a7Gm]))
- Language.Haskell.Generate.PreludeDef: sqrt' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: sqrt' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: subtract' :: Num a_ae3E => ExpG (a_ae3E -> a_ae3E -> a_ae3E)
+ Language.Haskell.Generate.PreludeDef: subtract' :: Num a_a7Fw => ExpG (a_a7Fw -> a_a7Fw -> a_a7Fw)
- Language.Haskell.Generate.PreludeDef: sum' :: Num a_ae4g => ExpG ([a_ae4g] -> a_ae4g)
+ Language.Haskell.Generate.PreludeDef: sum' :: Num a_a7G4 => ExpG ([a_a7G4] -> a_a7G4)
- Language.Haskell.Generate.PreludeDef: tail' :: ExpG ([a_ae44] -> [a_ae44])
+ Language.Haskell.Generate.PreludeDef: tail' :: ExpG ([a_a7FS] -> [a_a7FS])
- Language.Haskell.Generate.PreludeDef: take' :: ExpG (Int -> [a_ae4w] -> [a_ae4w])
+ Language.Haskell.Generate.PreludeDef: take' :: ExpG (Int -> [a_a7Gk] -> [a_a7Gk])
- Language.Haskell.Generate.PreludeDef: takeWhile' :: ExpG ((a_ae4z -> Bool) -> [a_ae4z] -> [a_ae4z])
+ Language.Haskell.Generate.PreludeDef: takeWhile' :: ExpG ((a_a7Gn -> Bool) -> [a_a7Gn] -> [a_a7Gn])
- Language.Haskell.Generate.PreludeDef: tan' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: tan' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: tanh' :: Floating a_ae2I => ExpG (a_ae2I -> a_ae2I)
+ Language.Haskell.Generate.PreludeDef: tanh' :: Floating a_a7Fm => ExpG (a_a7Fm -> a_a7Fm)
- Language.Haskell.Generate.PreludeDef: then' :: Monad m_a8vl => forall a_a9qx b_a9qy. ExpG (m_a8vl a_a9qx -> m_a8vl b_a9qy -> m_a8vl b_a9qy)
+ 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: toInteger' :: Integral a_ae2n => ExpG (a_ae2n -> Integer)
+ Language.Haskell.Generate.PreludeDef: toInteger' :: Integral a_a7Fi => ExpG (a_a7Fi -> Integer)
- Language.Haskell.Generate.PreludeDef: truncate' :: RealFrac a_ae35 => forall b_ae3g. Integral b_ae3g => ExpG (a_ae35 -> b_ae3g)
+ Language.Haskell.Generate.PreludeDef: truncate' :: RealFrac a_a7Fo => forall b_a7Fq. Integral b_a7Fq => ExpG (a_a7Fo -> b_a7Fq)
- Language.Haskell.Generate.PreludeDef: uncurry' :: ExpG ((a_ae2j -> b_ae2k -> c_ae2l) -> (a_ae2j, b_ae2k) -> c_ae2l)
+ Language.Haskell.Generate.PreludeDef: uncurry' :: ExpG ((a_a7Fe -> b_a7Ff -> c_a7Fg) -> (a_a7Fe, b_a7Ff) -> c_a7Fg)
- Language.Haskell.Generate.PreludeDef: undefined' :: ExpG a_12
+ Language.Haskell.Generate.PreludeDef: undefined' :: ExpG a_a7FO
- Language.Haskell.Generate.PreludeDef: until' :: ExpG ((a_ae3Z -> Bool) -> (a_ae3Z -> a_ae3Z) -> a_ae3Z -> a_ae3Z)
+ Language.Haskell.Generate.PreludeDef: until' :: ExpG ((a_a7FM -> Bool) -> (a_a7FM -> a_a7FM) -> a_a7FM -> a_a7FM)
- Language.Haskell.Generate.PreludeDef: unzip' :: ExpG ([(a_ae4Z, b_ae50)] -> ([a_ae4Z], [b_ae50]))
+ Language.Haskell.Generate.PreludeDef: unzip' :: ExpG ([(a_a7GJ, b_a7GK)] -> ([a_a7GJ], [b_a7GK]))
- Language.Haskell.Generate.PreludeDef: unzip3' :: ExpG ([(a_ae51, b_ae52, c_ae53)] -> ([a_ae51], [b_ae52], [c_ae53]))
+ Language.Haskell.Generate.PreludeDef: unzip3' :: ExpG ([(a_a7GL, b_a7GM, c_a7GN)] -> ([a_a7GL], [b_a7GM], [c_a7GN]))
- Language.Haskell.Generate.PreludeDef: zip' :: ExpG ([a_ae4N] -> [b_ae4O] -> [(a_ae4N, b_ae4O)])
+ Language.Haskell.Generate.PreludeDef: zip' :: ExpG ([a_a7Gx] -> [b_a7Gy] -> [(a_a7Gx, b_a7Gy)])
- Language.Haskell.Generate.PreludeDef: zip3' :: ExpG ([a_ae4P] -> [b_ae4Q] -> [c_ae4R] -> [(a_ae4P, b_ae4Q, c_ae4R)])
+ Language.Haskell.Generate.PreludeDef: zip3' :: ExpG ([a_a7Gz] -> [b_a7GA] -> [c_a7GB] -> [(a_a7Gz, b_a7GA, c_a7GB)])
- Language.Haskell.Generate.PreludeDef: zipWith' :: ExpG ((a_ae4S -> b_ae4T -> c_ae4U) -> [a_ae4S] -> [b_ae4T] -> [c_ae4U])
+ Language.Haskell.Generate.PreludeDef: zipWith' :: ExpG ((a_a7GC -> b_a7GD -> c_a7GE) -> [a_a7GC] -> [b_a7GD] -> [c_a7GE])
- Language.Haskell.Generate.PreludeDef: zipWith3' :: ExpG ((a_ae4V -> b_ae4W -> c_ae4X -> d_ae4Y) -> [a_ae4V] -> [b_ae4W] -> [c_ae4X] -> [d_ae4Y])
+ Language.Haskell.Generate.PreludeDef: zipWith3' :: ExpG ((a_a7GF -> b_a7GG -> c_a7GH -> d_a7GI) -> [a_a7GF] -> [b_a7GG] -> [c_a7GH] -> [d_a7GI])
Files
- .travis.yml +3/−2
- haskell-generate.cabal +2/−1
.travis.yml view
@@ -1,7 +1,8 @@ env: - GHCVER=7.4.2 CABALVER=1.16 - GHCVER=7.6.3 CABALVER=1.18- - GHCVER=head CABALVER=1.18 + - GHCVER=7.8.3 CABALVER=1.20+ - GHCVER=head CABALVER=1.20 before_install: - sudo add-apt-repository -y ppa:hvr/ghc@@ -20,5 +21,5 @@ matrix: allow_failures:- - env: GHCVER=head CABALVER=1.18+ - env: GHCVER=head CABALVER=1.20 fast_finish: true
haskell-generate.cabal view
@@ -1,5 +1,5 @@ name: haskell-generate-version: 0.2.1+version: 0.2.2 license: BSD3 category: Code Generation, Language cabal-version: >= 1.10@@ -41,6 +41,7 @@ Language.Haskell.Generate.Expression Language.Haskell.Generate.TH Language.Haskell.Generate.PreludeDef+ other-extensions: TemplateHaskell test-suite doctests type: exitcode-stdio-1.0