Safe Haskell | None |
---|---|
Language | Haskell98 |
- gyield :: RefSrcPos -> RefExp -> R (Fun a (ReadS a))
- hyield :: R a -> R (ReadS___1 a) -> RefExp -> R (ReadS___2 a)
- glift :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (ReadS c))) (Fun (ReadS a) (Fun (ReadS b) (ReadS c))))
- hlift :: R (Fun a (Fun b (ReadS c))) -> R (ReadS a) -> R (ReadS b) -> R (ReadS___1 c) -> RefExp -> R (ReadS___2 c)
- gthenAp :: RefSrcPos -> RefExp -> R (Fun (ReadS (Fun a b)) (Fun (ReadS a) (ReadS b)))
- gthenLex :: RefSrcPos -> RefExp -> R (Fun (ReadS a) (Fun String (ReadS a)))
- hthenLex :: R (ReadS a) -> R String -> RefExp -> R (ReadS a)
- galt :: RefSrcPos -> RefExp -> R (Fun (ReadS a) (Fun (ReadS a) (ReadS a)))
- halt :: R (ReadS a) -> R (ReadS a) -> R (ReadS___1 a) -> RefExp -> R (ReadS___2 a)
- gguard :: RefSrcPos -> RefExp -> R (Fun Bool (List Tuple0))
- hguard :: R Bool -> RefExp -> R (List Tuple0)
- class Eq a where
- class Eq a => Ord a where
- gcompare :: RefSrcPos -> RefExp -> R (Fun a (Fun a Ordering))
- scompare :: R (Fun a (Fun a Ordering))
- (!<), (!>), (!>=), (!<=) :: RefSrcPos -> RefExp -> R (Fun a (Fun a Bool))
- (|<), (|>), (|>=), (|<=) :: R (Fun a (Fun a Bool))
- gmax, gmin :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- smax, smin :: R (Fun a (Fun a a))
- class Enum a where
- gsucc, gpred :: RefSrcPos -> RefExp -> R (Fun a a)
- ssucc, spred :: R (Fun a a)
- gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int a)
- stoEnum :: R (Fun Int a)
- gfromEnum :: RefSrcPos -> RefExp -> R (Fun a Int)
- sfromEnum :: R (Fun a Int)
- genumFrom :: RefSrcPos -> RefExp -> R (Fun a (List a))
- senumFrom :: R (Fun a (List a))
- genumFromThen :: RefSrcPos -> RefExp -> R (Fun a (Fun a (List a)))
- senumFromThen :: R (Fun a (Fun a (List a)))
- genumFromTo :: RefSrcPos -> RefExp -> R (Fun a (Fun a (List a)))
- senumFromTo :: R (Fun a (Fun a (List a)))
- genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun a (Fun a (Fun a (List a))))
- senumFromThenTo :: R (Fun a (Fun a (Fun a (List a))))
- class Bounded a where
- class (Eq a, Show a) => Num a where
- (!+), (!*), (!-) :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- (|+), (|*), (|-) :: R (Fun a (Fun a a))
- gnegate :: RefSrcPos -> RefExp -> R (Fun a a)
- snegate :: R (Fun a a)
- gabs, gsignum :: RefSrcPos -> RefExp -> R (Fun a a)
- sabs, ssignum :: R (Fun a a)
- gfromInteger :: RefSrcPos -> RefExp -> R (Fun Integer a)
- sfromInteger :: R (Fun Integer a)
- class (Num a, Ord a) => Real a where
- gtoRational :: RefSrcPos -> RefExp -> R (Fun a Rational)
- stoRational :: R (Fun a Rational)
- class (Real a, Enum a) => Integral a where
- gquot, grem :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- squot, srem :: R (Fun a (Fun a a))
- gdiv, gmod :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- sdiv, smod :: R (Fun a (Fun a a))
- gquotRem, gdivMod :: RefSrcPos -> RefExp -> R (Fun a (Fun a (Tuple2 a a)))
- squotRem, sdivMod :: R (Fun a (Fun a (Tuple2 a a)))
- gtoInteger :: RefSrcPos -> RefExp -> R (Fun a Integer)
- stoInteger :: R (Fun a Integer)
- class Num a => Fractional a where
- class Fractional a => Floating a where
- gpi :: RefSrcPos -> RefExp -> R a
- spi :: R a
- gexp, gsqrt, glog :: RefSrcPos -> RefExp -> R (Fun a a)
- sexp, ssqrt, slog :: R (Fun a a)
- (!**), glogBase :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- (|**), slogBase :: R (Fun a (Fun a a))
- gsin, gtan, gcos :: RefSrcPos -> RefExp -> R (Fun a a)
- ssin, stan, scos :: R (Fun a a)
- gasin, gatan, gacos :: RefSrcPos -> RefExp -> R (Fun a a)
- sasin, satan, sacos :: R (Fun a a)
- gsinh, gtanh, gcosh :: RefSrcPos -> RefExp -> R (Fun a a)
- ssinh, stanh, scosh :: R (Fun a a)
- gasinh, gatanh, gacosh :: RefSrcPos -> RefExp -> R (Fun a a)
- sasinh, satanh, sacosh :: R (Fun a a)
- class (Real a, Fractional a) => RealFrac a where
- gproperFraction :: Integral b => RefSrcPos -> RefExp -> R (Fun a (Tuple2 b a))
- sproperFraction :: Integral b => R (Fun a (Tuple2 b a))
- gtruncate, ground :: Integral b => RefSrcPos -> RefExp -> R (Fun a b)
- struncate, sround :: Integral b => R (Fun a b)
- gceiling, gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun a b)
- sceiling, sfloor :: Integral b => R (Fun a b)
- class (RealFrac a, Floating a) => RealFloat a where
- gfloatRadix :: RefSrcPos -> RefExp -> R (Fun a Integer)
- sfloatRadix :: R (Fun a Integer)
- gfloatDigits :: RefSrcPos -> RefExp -> R (Fun a Int)
- sfloatDigits :: R (Fun a Int)
- gfloatRange :: RefSrcPos -> RefExp -> R (Fun a (Tuple2 Int Int))
- sfloatRange :: R (Fun a (Tuple2 Int Int))
- gdecodeFloat :: RefSrcPos -> RefExp -> R (Fun a (Tuple2 Integer Int))
- sdecodeFloat :: R (Fun a (Tuple2 Integer Int))
- gencodeFloat :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int a))
- sencodeFloat :: R (Fun Integer (Fun Int a))
- gexponent :: RefSrcPos -> RefExp -> R (Fun a Int)
- sexponent :: R (Fun a Int)
- gsignificand :: RefSrcPos -> RefExp -> R (Fun a a)
- ssignificand :: R (Fun a a)
- gscaleFloat :: RefSrcPos -> RefExp -> R (Fun Int (Fun a a))
- sscaleFloat :: R (Fun Int (Fun a a))
- gisNaN, gisIEEE, gisNegativeZero, gisDenormalized, gisInfinite :: RefSrcPos -> RefExp -> R (Fun a Bool)
- sisNaN, sisIEEE, sisNegativeZero, sisDenormalized, sisInfinite :: R (Fun a Bool)
- gatan2 :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- satan2 :: R (Fun a (Fun a a))
- gsubtract :: Num a => RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- geven :: Integral a => RefSrcPos -> RefExp -> R (Fun a Bool)
- heven :: Integral a => R a -> RefExp -> R Bool
- godd :: Integral a => RefSrcPos -> RefExp -> R (Fun a Bool)
- ggcd :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- hgcd :: Integral a => R a -> R a -> RefExp -> R a
- glcm :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- hlcm :: Integral a => R a -> R a -> RefExp -> R a
- (!^) :: (Num a, Integral b) => RefSrcPos -> RefExp -> R (Fun a (Fun b a))
- (*^) :: (Num a, Integral b) => R a -> R b -> RefExp -> R a
- (!^^) :: (Fractional a, Integral b) => RefSrcPos -> RefExp -> R (Fun a (Fun b a))
- (*^^) :: (Fractional a, Integral b) => R a -> R b -> RefExp -> R a
- gfromIntegral :: (Integral a, Num b) => RefSrcPos -> RefExp -> R (Fun a b)
- grealToFrac :: (Real a, Fractional b) => RefSrcPos -> RefExp -> R (Fun a b)
- class Functor f where
- class Monad m where
- (!>>=) :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (Fun a (m b)) (m b)))
- (|>>=) :: R (Fun (m a) (Fun (Fun a (m b)) (m b)))
- (!>>) :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (m b) (m b)))
- (|>>) :: R (Fun (m a) (Fun (m b) (m b)))
- greturn :: RefSrcPos -> RefExp -> R (Fun a (m a))
- sreturn :: R (Fun a (m a))
- gfail :: RefSrcPos -> RefExp -> R (Fun String (m a))
- sfail :: R (Fun String (m a))
- gsequence :: Monad m => RefSrcPos -> RefExp -> R (Fun (List (m a)) (m (List a)))
- gsequence_ :: Monad m => RefSrcPos -> RefExp -> R (Fun (List (m a)) (m Tuple0))
- gmapM :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (List a) (m (List b))))
- hmapM :: Monad m => R (Fun a (m b)) -> R (List a) -> RefExp -> R (m (List b))
- gmapM_ :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (List a) (m Tuple0)))
- hmapM_ :: Monad m => R (Fun a (m b)) -> R (List a) -> RefExp -> R (m Tuple0)
- (!=<<) :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (m a) (m b)))
- (*=<<) :: Monad m => R (Fun a (m b)) -> R (m a) -> RefExp -> R (m b)
- gid :: RefSrcPos -> RefExp -> R (Fun a a)
- hid :: R a -> RefExp -> R a
- gconst :: RefSrcPos -> RefExp -> R (Fun a (Fun b a))
- hconst :: R a -> R b -> RefExp -> R a
- (!.) :: RefSrcPos -> RefExp -> R (Fun (Fun b c) (Fun (Fun a b) (Fun a c)))
- (*.) :: R (Fun b c) -> R (Fun a b) -> R a -> RefExp -> R c
- gflip :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b c)) (Fun b (Fun a c)))
- hflip :: R (Fun a (Fun b c)) -> R b -> R a -> RefExp -> R c
- (!$) :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun a b))
- (*$) :: R (Fun a b) -> R a -> RefExp -> R b
- (!$!) :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun a b))
- (*$!) :: R (Fun a b) -> R a -> RefExp -> R b
- (!&&) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))
- (*&&) :: R Bool -> R Bool -> RefExp -> R Bool
- (!||) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))
- (*||) :: R Bool -> R Bool -> RefExp -> R Bool
- gnot :: RefSrcPos -> RefExp -> R (Fun Bool Bool)
- hnot :: R Bool -> RefExp -> R Bool
- gotherwise :: RefSrcPos -> RefExp -> R Bool
- data Maybe a
- gmaybe :: RefSrcPos -> RefExp -> R (Fun b (Fun (Fun a b) (Fun (Maybe a) b)))
- hmaybe :: R b -> R (Fun a b) -> R (Maybe a) -> RefExp -> R b
- data Either a b
- geither :: RefSrcPos -> RefExp -> R (Fun (Fun a c) (Fun (Fun b c) (Fun (Either a b) c)))
- heither :: R (Fun a c) -> R (Fun b c) -> R (Either a b) -> RefExp -> R c
- data Ordering
- gintEnumFromByTo :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (Fun Int (List Int))))
- hintEnumFromByTo :: R Int -> R Int -> R Int -> RefExp -> R (List Int)
- gnumericEnumFrom :: Fractional a => RefSrcPos -> RefExp -> R (Fun a (List a))
- gnumericEnumFromThen :: Fractional a => RefSrcPos -> RefExp -> R (Fun a (Fun a (List a)))
- hnumericEnumFromThen :: Fractional a => R a -> R a -> RefExp -> R (List a)
- gnumericEnumFromTo :: (Fractional a, Ord a) => RefSrcPos -> RefExp -> R (Fun a (Fun a (List a)))
- hnumericEnumFromTo :: (Fractional a, Ord a) => R a -> R a -> RefExp -> R (List a)
- gnumericEnumFromThenTo :: (Fractional a, Ord a) => RefSrcPos -> RefExp -> R (Fun a (Fun a (Fun a (List a))))
- hnumericEnumFromThenTo :: (Fractional a, Ord a) => R a -> R a -> R a -> RefExp -> R (List a)
- gfst :: RefSrcPos -> RefExp -> R (Fun (Tuple2 a b) a)
- hfst :: R (Tuple2 a b) -> RefExp -> R a
- gsnd :: RefSrcPos -> RefExp -> R (Fun (Tuple2 a b) b)
- hsnd :: R (Tuple2 a b) -> RefExp -> R b
- gcurry :: RefSrcPos -> RefExp -> R (Fun (Fun (Tuple2 a b) c) (Fun a (Fun b c)))
- hcurry :: R (Fun (Tuple2 a b) c) -> R a -> R b -> RefExp -> R c
- guncurry :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b c)) (Fun (Tuple2 a b) c))
- huncurry :: R (Fun a (Fun b c)) -> R (Tuple2 a b) -> RefExp -> R c
- guntil :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (Fun a a) (Fun a a)))
- huntil :: R (Fun a Bool) -> R (Fun a a) -> R a -> RefExp -> R a
- gasTypeOf :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- g_foldr :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b b)) (Fun (List a) (Fun b b)))
- h_foldr :: R (Fun a (Fun b b)) -> R (List a) -> R b -> RefExp -> R b
- g_filter :: RefSrcPos -> RefExp -> R (Fun Bool (Fun (Fun (List a) (List a)) (Fun (List a) (List a))))
- h_filter :: R Bool -> R (Fun (List a) (List a)) -> R (List a) -> RefExp -> R (List a)
- gmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (List a) (List b)))
- hmap :: R (Fun a b) -> R (List a) -> RefExp -> R (List b)
- (!++) :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) (List a)))
- (*++) :: R (List a) -> R (List a) -> RefExp -> R (List a)
- gfilter :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List a)))
- hfilter :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List a)
- gconcat :: RefSrcPos -> RefExp -> R (Fun (List (List a)) (List a))
- hconcat :: R (List (List a)) -> RefExp -> R (List a)
- ghead :: RefSrcPos -> RefExp -> R (Fun (List a) a)
- hhead :: R (List a) -> RefExp -> R a
- glast :: RefSrcPos -> RefExp -> R (Fun (List a) a)
- hlast :: R (List a) -> RefExp -> R a
- gtail :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))
- htail :: R (List a) -> RefExp -> R (List a)
- ginit :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))
- hinit :: R (List a) -> RefExp -> R (List a)
- gnull :: RefSrcPos -> RefExp -> R (Fun (List a) Bool)
- hnull :: R (List a) -> RefExp -> R Bool
- glength :: RefSrcPos -> RefExp -> R (Fun (List a) Int)
- hlength :: R (List a) -> RefExp -> R Int
- (!!!) :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun Int a))
- (*!!) :: R (List a) -> R Int -> RefExp -> R a
- gfoldl :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b a)) (Fun a (Fun (List b) a)))
- hfoldl :: R (Fun a (Fun b a)) -> R a -> R (List b) -> RefExp -> R a
- gfoldl1 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a a)) (Fun (List a) a))
- hfoldl1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R a
- gscanl :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b a)) (Fun a (Fun (List b) (List a))))
- hscanl :: R (Fun a (Fun b a)) -> R a -> R (List b) -> RefExp -> R (List a)
- gscanl1 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a a)) (Fun (List a) (List a)))
- hscanl1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R (List a)
- gfoldr :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b b)) (Fun b (Fun (List a) b)))
- hfoldr :: R (Fun a (Fun b b)) -> R b -> R (List a) -> RefExp -> R b
- gfoldr1 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a a)) (Fun (List a) a))
- hfoldr1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R a
- gscanr :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b b)) (Fun b (Fun (List a) (List b))))
- hscanr :: R (Fun a (Fun b b)) -> R b -> R (List a) -> RefExp -> R (List b)
- gscanr1 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun a a)) (Fun (List a) (List a)))
- hscanr1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R (List a)
- giterate :: RefSrcPos -> RefExp -> R (Fun (Fun a a) (Fun a (List a)))
- hiterate :: R (Fun a a) -> R a -> RefExp -> R (List a)
- grepeat :: RefSrcPos -> RefExp -> R (Fun a (List a))
- hrepeat :: R a -> RefExp -> R (List a)
- greplicate :: RefSrcPos -> RefExp -> R (Fun Int (Fun a (List a)))
- hreplicate :: R Int -> R a -> RefExp -> R (List a)
- gcycle :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))
- hcycle :: R (List a) -> RefExp -> R (List a)
- gtake :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (List a)))
- htake :: R Int -> R (List a) -> RefExp -> R (List a)
- gdrop :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (List a)))
- hdrop :: R Int -> R (List a) -> RefExp -> R (List a)
- gsplitAt :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (Tuple2 (List a) (List a))))
- hsplitAt :: R Int -> R (List a) -> RefExp -> R (Tuple2 (List a) (List a))
- gtakeWhile :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List a)))
- htakeWhile :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List a)
- gdropWhile :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List a)))
- hdropWhile :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List a)
- gspan :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Tuple2 (List a) (List a))))
- hspan :: R (Fun a Bool) -> R (List a) -> RefExp -> R (Tuple2 (List a) (List a))
- gbreak :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Tuple2 (List a) (List a))))
- hbreak :: R (Fun a Bool) -> RefExp -> R (Fun (List a) (Tuple2 (List a) (List a)))
- glines :: RefSrcPos -> RefExp -> R (Fun String (List String))
- hlines :: R String -> RefExp -> R (List String)
- gwords :: RefSrcPos -> RefExp -> R (Fun String (List String))
- hwords :: R String -> RefExp -> R (List String)
- gunlines :: RefSrcPos -> RefExp -> R (Fun (List String) String)
- gunwords :: RefSrcPos -> RefExp -> R (Fun (List String) String)
- hunwords :: R (List String) -> RefExp -> R String
- greverse :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))
- gand :: RefSrcPos -> RefExp -> R (Fun (List Bool) Bool)
- gor :: RefSrcPos -> RefExp -> R (Fun (List Bool) Bool)
- gany :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) Bool))
- hany :: R (Fun a Bool) -> RefExp -> R (Fun (List a) Bool)
- gall :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) Bool))
- hall :: R (Fun a Bool) -> RefExp -> R (Fun (List a) Bool)
- gelem :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) Bool))
- helem :: Eq a => R a -> RefExp -> R (Fun (List a) Bool)
- gnotElem :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) Bool))
- hnotElem :: Eq a => R a -> RefExp -> R (Fun (List a) Bool)
- glookup :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List (Tuple2 a b)) (Maybe b)))
- hlookup :: Eq a => R a -> R (List (Tuple2 a b)) -> RefExp -> R (Maybe b)
- gsum :: Num a => RefSrcPos -> RefExp -> R (Fun (List a) a)
- gproduct :: Num a => RefSrcPos -> RefExp -> R (Fun (List a) a)
- gmaximum :: Ord a => RefSrcPos -> RefExp -> R (Fun (List a) a)
- hmaximum :: Ord a => R (List a) -> RefExp -> R a
- gminimum :: Ord a => RefSrcPos -> RefExp -> R (Fun (List a) a)
- hminimum :: Ord a => R (List a) -> RefExp -> R a
- gconcatMap :: RefSrcPos -> RefExp -> R (Fun (Fun a (List b)) (Fun (List a) (List b)))
- hconcatMap :: R (Fun a (List b)) -> RefExp -> R (Fun (List a) (List b))
- gzip :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (List (Tuple2 a b))))
- gzip3 :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (Fun (List c) (List (Tuple3 a b c)))))
- gzipWith :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b c)) (Fun (List a) (Fun (List b) (List c))))
- hzipWith :: R (Fun a (Fun b c)) -> R (List a) -> R (List b) -> RefExp -> R (List c)
- gzipWith3 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c d))) (Fun (List a) (Fun (List b) (Fun (List c) (List d)))))
- hzipWith3 :: R (Fun a (Fun b (Fun c d))) -> R (List a) -> R (List b) -> R (List c) -> RefExp -> R (List d)
- gunzip :: RefSrcPos -> RefExp -> R (Fun (List (Tuple2 a b)) (Tuple2 (List a) (List b)))
- gunzip3 :: RefSrcPos -> RefExp -> R (Fun (List (Tuple3 a b c)) (Tuple3 (List a) (List b) (List c)))
- type ReadS a = Fun String (List (Tuple2 a String))
- type ReadS___1 a = String
- type ReadS___2 a = List (Tuple2 a String)
- type ShowS = Fun String String
- type ShowS___1 = String
- type ShowS___2 = String
- class Read a where
- class Show a where
- greads :: Read a => RefSrcPos -> RefExp -> R (ReadS a)
- gshows :: Show a => RefSrcPos -> RefExp -> R (Fun a ShowS)
- gread :: Read a => RefSrcPos -> RefExp -> R (Fun String a)
- hread :: Read a => R String -> RefExp -> R a
- gshowChar :: RefSrcPos -> RefExp -> R (Fun Char ShowS)
- gshowString :: RefSrcPos -> RefExp -> R (Fun String ShowS)
- gshowParen :: RefSrcPos -> RefExp -> R (Fun Bool (Fun ShowS ShowS))
- hshowParen :: R Bool -> R ShowS -> RefExp -> R ShowS
- greadParen :: RefSrcPos -> RefExp -> R (Fun Bool (Fun (ReadS a) (ReadS a)))
- hreadParen :: R Bool -> R (ReadS a) -> RefExp -> R (ReadS a)
- glex :: RefSrcPos -> RefExp -> R (ReadS String)
- hlex :: R (ReadS___1 String) -> RefExp -> R (ReadS___2 String)
- type FilePath = String
- gputStr :: RefSrcPos -> RefExp -> R (Fun String (IO Tuple0))
- hputStr :: R String -> RefExp -> R (IO Tuple0)
- gputStrLn :: RefSrcPos -> RefExp -> R (Fun String (IO Tuple0))
- hputStrLn :: R String -> RefExp -> R (IO Tuple0)
- gprint :: Show a => RefSrcPos -> RefExp -> R (Fun a (IO Tuple0))
- hprint :: Show a => R a -> RefExp -> R (IO Tuple0)
- ggetLine :: RefSrcPos -> RefExp -> R (IO String)
- ginteract :: RefSrcPos -> RefExp -> R (Fun (Fun String String) (IO Tuple0))
- hinteract :: R (Fun String String) -> RefExp -> R (IO Tuple0)
- greadIO :: Read a => RefSrcPos -> RefExp -> R (Fun String (IO a))
- hreadIO :: Read a => R String -> RefExp -> R (IO a)
- greadLn :: Read a => RefSrcPos -> RefExp -> R (IO a)
- gdigitToInt :: RefSrcPos -> RefExp -> R (Fun Char Int)
- hdigitToInt :: R Char -> RefExp -> R Int
- gintToDigit :: RefSrcPos -> RefExp -> R (Fun Int Char)
- hintToDigit :: R Int -> RefExp -> R Char
- gord :: RefSrcPos -> RefExp -> R (Fun Char Int)
- gchr :: RefSrcPos -> RefExp -> R (Fun Int Char)
- greadLitChar :: RefSrcPos -> RefExp -> R (ReadS Char)
- hreadLitChar :: R (ReadS___1 Char) -> RefExp -> R (ReadS___2 Char)
- gshowLitChar :: RefSrcPos -> RefExp -> R (Fun Char ShowS)
- hshowLitChar :: R Char -> RefExp -> R ShowS
- gprotectEsc :: RefSrcPos -> RefExp -> R (Fun (Fun Char Bool) (Fun (Fun (List Char) c) (Fun (List Char) c)))
- hprotectEsc :: R (Fun Char Bool) -> R (Fun (List Char) c) -> RefExp -> R (Fun (List Char) c)
- gasciiTab :: RefSrcPos -> RefExp -> R (List (Tuple2 Char (List Char)))
- glexLitChar :: RefSrcPos -> RefExp -> R (ReadS String)
- hlexLitChar :: R (ReadS___1 String) -> RefExp -> R (ReadS___2 String)
- gfromRat :: RealFloat a => RefSrcPos -> RefExp -> R (Fun Rational a)
- hfromRat :: RealFloat a => R Rational -> RefExp -> R a
- gfromRat' :: RealFloat a => RefSrcPos -> RefExp -> R (Fun Rational a)
- hfromRat' :: RealFloat a => R Rational -> RefExp -> R a
- gscaleRat :: RefSrcPos -> RefExp -> R (Fun Rational (Fun Int (Fun Rational (Fun Rational (Fun Int (Fun Rational (Tuple2 Rational Int)))))))
- hscaleRat :: R Rational -> R Int -> R Rational -> R Rational -> R Int -> R Rational -> RefExp -> R (Tuple2 Rational Int)
- gminExpt :: RefSrcPos -> RefExp -> R Int
- gmaxExpt :: RefSrcPos -> RefExp -> R Int
- gexpt :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int Integer))
- hexpt :: R Integer -> R Int -> RefExp -> R Integer
- gexpts :: RefSrcPos -> RefExp -> R (List Integer)
- gintegerLogBase :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Int))
- hintegerLogBase :: R Integer -> R Integer -> RefExp -> R Int
- gshowSigned :: Real a => RefSrcPos -> RefExp -> R (Fun (Fun a ShowS) (Fun Int (Fun a ShowS)))
- hshowSigned :: Real a => R (Fun a ShowS) -> R Int -> R a -> RefExp -> R ShowS
- gshowOct :: Integral a => RefSrcPos -> RefExp -> R (Fun a ShowS)
- gshowInt :: Integral a => RefSrcPos -> RefExp -> R (Fun a ShowS)
- gshowHex :: Integral a => RefSrcPos -> RefExp -> R (Fun a ShowS)
- gshowIntAtBase :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun (Fun Int Char) (Fun a ShowS)))
- hshowIntAtBase :: Integral a => R a -> R (Fun Int Char) -> R a -> R ShowS___1 -> RefExp -> R ShowS___2
- greadSigned :: Real a => RefSrcPos -> RefExp -> R (Fun (ReadS a) (ReadS a))
- hreadSigned :: Real a => R (ReadS a) -> RefExp -> R (ReadS a)
- greadInt :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun (Fun Char Bool) (Fun (Fun Char Int) (ReadS a))))
- hreadInt :: Integral a => R a -> R (Fun Char Bool) -> R (Fun Char Int) -> R (ReadS___1 a) -> RefExp -> R (ReadS___2 a)
- greadDec :: Integral a => RefSrcPos -> RefExp -> R (ReadS a)
- greadOct :: Integral a => RefSrcPos -> RefExp -> R (ReadS a)
- greadHex :: Integral a => RefSrcPos -> RefExp -> R (ReadS a)
- gshowEFloat :: RealFloat a => RefSrcPos -> RefExp -> R (Fun (Maybe Int) (Fun a ShowS))
- hshowEFloat :: RealFloat a => R (Maybe Int) -> R a -> RefExp -> R ShowS
- gshowFFloat :: RealFloat a => RefSrcPos -> RefExp -> R (Fun (Maybe Int) (Fun a ShowS))
- hshowFFloat :: RealFloat a => R (Maybe Int) -> R a -> RefExp -> R ShowS
- gshowGFloat :: RealFloat a => RefSrcPos -> RefExp -> R (Fun (Maybe Int) (Fun a ShowS))
- hshowGFloat :: RealFloat a => R (Maybe Int) -> R a -> RefExp -> R ShowS
- gshowFloat :: RealFloat a => RefSrcPos -> RefExp -> R (Fun a ShowS)
- data FFFormat
- gformatRealFloat :: RealFloat a => RefSrcPos -> RefExp -> R (Fun FFFormat (Fun (Maybe Int) (Fun a String)))
- hformatRealFloat :: RealFloat a => R FFFormat -> R (Maybe Int) -> R a -> RefExp -> R String
- groundTo :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (Fun (List Int) (Tuple2 Int (List Int)))))
- hroundTo :: R Int -> R Int -> R (List Int) -> RefExp -> R (Tuple2 Int (List Int))
- gfloatToDigits :: RealFloat a => RefSrcPos -> RefExp -> R (Fun Integer (Fun a (Tuple2 (List Int) Int)))
- hfloatToDigits :: RealFloat a => R Integer -> R a -> RefExp -> R (Tuple2 (List Int) Int)
- greadFloat :: RealFloat a => RefSrcPos -> RefExp -> R (ReadS a)
- hreadFloat :: RealFloat a => R (ReadS___1 a) -> RefExp -> R (ReadS___2 a)
- glexDigits :: RefSrcPos -> RefExp -> R (ReadS String)
- gnonnull :: RefSrcPos -> RefExp -> R (Fun (Fun Char Bool) (ReadS String))
- hnonnull :: R (Fun Char Bool) -> R (ReadS___1 String) -> RefExp -> R (ReadS___2 String)
- gprec :: RefSrcPos -> RefExp -> R Int
- data Ratio a = !(R a) :% !(R a)
- type Rational = Ratio Integer
- type Rational___1 = Ratio Integer
- greduce :: Integral b => RefSrcPos -> RefExp -> R (Fun b (Fun b (Ratio b)))
- hreduce :: Integral b => R b -> R b -> RefExp -> R (Ratio b)
- (!%) :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun a (Ratio a)))
- (*%) :: Integral a => R a -> R a -> RefExp -> R (Ratio a)
- gnumerator :: Integral a => RefSrcPos -> RefExp -> R (Fun (Ratio a) a)
- hnumerator :: Integral a => R (Ratio a) -> RefExp -> R a
- gdenominator :: Integral a => RefSrcPos -> RefExp -> R (Fun (Ratio a) a)
- hdenominator :: Integral a => R (Ratio a) -> RefExp -> R a
- gapproxRational :: RealFrac a => RefSrcPos -> RefExp -> R (Fun a (Fun a Rational))
- happroxRational :: RealFrac a => R a -> R a -> RefExp -> R Rational
- aEQ :: RefAtom
- aFFExponent :: RefAtom
- aFFFixed :: RefAtom
- aFFGeneric :: RefAtom
- aGT :: RefAtom
- aJust :: RefAtom
- aLT :: RefAtom
- aLeft :: RefAtom
- aNothing :: RefAtom
- aRight :: RefAtom
- a_filter :: RefAtom
- a_foldr :: RefAtom
- aall :: RefAtom
- aalt :: RefAtom
- aand :: RefAtom
- aany :: RefAtom
- aapproxRational :: RefAtom
- aasTypeOf :: RefAtom
- aasciiTab :: RefAtom
- abreak :: RefAtom
- achr :: RefAtom
- aconcat :: RefAtom
- aconcatMap :: RefAtom
- aconst :: RefAtom
- acurry :: RefAtom
- acycle :: RefAtom
- adenominator :: RefAtom
- adigitToInt :: RefAtom
- adrop :: RefAtom
- adropWhile :: RefAtom
- aeither :: RefAtom
- aelem :: RefAtom
- aeven :: RefAtom
- aexpt :: RefAtom
- aexpts :: RefAtom
- afilter :: RefAtom
- aflip :: RefAtom
- afloatToDigits :: RefAtom
- afoldl :: RefAtom
- afoldl1 :: RefAtom
- afoldr :: RefAtom
- afoldr1 :: RefAtom
- aformatRealFloat :: RefAtom
- afromIntegral :: RefAtom
- afromRat :: RefAtom
- afromRat' :: RefAtom
- afst :: RefAtom
- agcd :: RefAtom
- agetLine :: RefAtom
- aguard :: RefAtom
- ahead :: RefAtom
- aid :: RefAtom
- ainit :: RefAtom
- aintEnumFromByTo :: RefAtom
- aintToDigit :: RefAtom
- aintegerLogBase :: RefAtom
- ainteract :: RefAtom
- aiterate :: RefAtom
- alast :: RefAtom
- alcm :: RefAtom
- alength :: RefAtom
- alex :: RefAtom
- alexDigits :: RefAtom
- alexLitChar :: RefAtom
- alift :: RefAtom
- alines :: RefAtom
- alookup :: RefAtom
- amap :: RefAtom
- amapM :: RefAtom
- amapM_ :: RefAtom
- amaxExpt :: RefAtom
- amaximum :: RefAtom
- amaybe :: RefAtom
- aminExpt :: RefAtom
- aminimum :: RefAtom
- anonnull :: RefAtom
- anot :: RefAtom
- anotElem :: RefAtom
- anull :: RefAtom
- anumerator :: RefAtom
- anumericEnumFrom :: RefAtom
- anumericEnumFromThen :: RefAtom
- anumericEnumFromThenTo :: RefAtom
- anumericEnumFromTo :: RefAtom
- aodd :: RefAtom
- aor :: RefAtom
- aord :: RefAtom
- aotherwise :: RefAtom
- aprec :: RefAtom
- aprint :: RefAtom
- aproduct :: RefAtom
- aprotectEsc :: RefAtom
- aputStr :: RefAtom
- aputStrLn :: RefAtom
- aread :: RefAtom
- areadDec :: RefAtom
- areadFloat :: RefAtom
- areadHex :: RefAtom
- areadIO :: RefAtom
- areadInt :: RefAtom
- areadLitChar :: RefAtom
- areadLn :: RefAtom
- areadOct :: RefAtom
- areadParen :: RefAtom
- areadSigned :: RefAtom
- areads :: RefAtom
- arealToFrac :: RefAtom
- areduce :: RefAtom
- arepeat :: RefAtom
- areplicate :: RefAtom
- areverse :: RefAtom
- aroundTo :: RefAtom
- ascaleRat :: RefAtom
- ascanl :: RefAtom
- ascanl1 :: RefAtom
- ascanr :: RefAtom
- ascanr1 :: RefAtom
- asequence :: RefAtom
- asequence_ :: RefAtom
- ashowChar :: RefAtom
- ashowEFloat :: RefAtom
- ashowFFloat :: RefAtom
- ashowFloat :: RefAtom
- ashowGFloat :: RefAtom
- ashowHex :: RefAtom
- ashowInt :: RefAtom
- ashowIntAtBase :: RefAtom
- ashowLitChar :: RefAtom
- ashowOct :: RefAtom
- ashowParen :: RefAtom
- ashowSigned :: RefAtom
- ashowString :: RefAtom
- ashows :: RefAtom
- asnd :: RefAtom
- aspan :: RefAtom
- asplitAt :: RefAtom
- asubtract :: RefAtom
- asum :: RefAtom
- atail :: RefAtom
- atake :: RefAtom
- atakeWhile :: RefAtom
- athenAp :: RefAtom
- athenLex :: RefAtom
- auncurry :: RefAtom
- aunlines :: RefAtom
- auntil :: RefAtom
- aunwords :: RefAtom
- aunzip :: RefAtom
- aunzip3 :: RefAtom
- awords :: RefAtom
- ayield :: RefAtom
- azip :: RefAtom
- azip3 :: RefAtom
- azipWith :: RefAtom
- azipWith3 :: RefAtom
- (+!!) :: RefAtom
- (+$) :: RefAtom
- (+$!) :: RefAtom
- (+%) :: RefAtom
- (+&&) :: RefAtom
- (+#>#=*=#>#=%>**) :: RefAtom
- (+++) :: RefAtom
- (+#&#=*=#&#=%+-) :: RefAtom
- (+.) :: RefAtom
- (+#^*=*=#^*=%*/) :: RefAtom
- (++>=*=+>=%+/=) :: RefAtom
- (+:%) :: RefAtom
- (+@^=*=@^=&#<) :: RefAtom
- (+@+=*=@+=&#<=) :: RefAtom
- (+=<<) :: RefAtom
- (+^!=*=^!=%+==) :: RefAtom
- (+@>=*=@>=&#>) :: RefAtom
- (+@@=*=@@=&#>=) :: RefAtom
- (+%$^=*=%$^=$@>>) :: RefAtom
- (+^) :: RefAtom
- (+^^) :: RefAtom
- (+||) :: RefAtom
- (+%+!=%=%+!=#^==) :: RefAtom
- (+&#^=%=&#>=$&==) :: RefAtom
- (+&^@=*=&^@=&>==) :: RefAtom
- (+&@$=*=&@$=&><=) :: RefAtom
- (+*!+=*#=*!+=*$==) :: RefAtom
- (+*$!=*=*$#=%#>>=) :: RefAtom
- (+*$@=*#=*$@=*$==) :: RefAtom
- (+*&+=&=*&+=$$>>=) :: RefAtom
- (+**&=$#=**&=$$==) :: RefAtom
- (+*++=%=*++=$&/=) :: RefAtom
- (+*+*=%=*+*=$&==) :: RefAtom
- (+*+>=%=*+>=$&<) :: RefAtom
- (+*^!=%=*^!=$&<=) :: RefAtom
- (+*^$=%=*^$=$&>) :: RefAtom
- (+*^#=%=*^#=$&>=) :: RefAtom
- (+*^^=$=*^^=$@*) :: RefAtom
- (+*^*=$=*^*=$^+) :: RefAtom
- (+*^+=$=*^+=$@-) :: RefAtom
- (++$&=%=+$&=$@/=) :: RefAtom
- (++$%=%=+$%=$@==) :: RefAtom
- (++$^=%=+$^=$@<) :: RefAtom
- (++$@=%=+$@=$@<=) :: RefAtom
- (++%!=%=+%!=$@>) :: RefAtom
- (++$>=%=+$>=$@>=) :: RefAtom
- (++%*=$=+%*=%!*) :: RefAtom
- (++%%=$=+%%=%!+) :: RefAtom
- (++%&=$=+%&=%!-) :: RefAtom
- (++^+=%=+^+=$+/=) :: RefAtom
- (++^*=%=+^*=$+==) :: RefAtom
- (++^>=%=+^>=$+<) :: RefAtom
- (++@!=%=+@!=$+<=) :: RefAtom
- (++@$=%=+@$=$+>) :: RefAtom
- (++@#=%=+@#=$+>=) :: RefAtom
- (++@^=$=+@^=$@*) :: RefAtom
- (++@*=$=+@*=$@+) :: RefAtom
- (++@+=$=+@+=$@-) :: RefAtom
- (++>@=%=+>@=$+/) :: RefAtom
- (+^*&=%=^*&=$^/=) :: RefAtom
- (+^*%=%=^*%=$^==) :: RefAtom
- (+^*^=%=^*^=$^<) :: RefAtom
- (+^*@=%=^*@=$^<=) :: RefAtom
- (+^+!=%=^+!=$^>) :: RefAtom
- (+^*>=%=^*>=$^>=) :: RefAtom
- (+^+*=$=^+*=$>*) :: RefAtom
- (+^+%=$=^+%=$>+) :: RefAtom
- (+^+&=$=^+&=$>-) :: RefAtom
- (+^^+=%=^^+=$^/) :: RefAtom
- (+@@%=%=@@*=$+==) :: RefAtom
- (+>!%=*=>!%=%>>>=) :: RefAtom
- (+>#+=%=>#+=%>==) :: RefAtom
- (+>%#=%=>%#=**==) :: RefAtom
- (+>&^=%=>&^=^#==) :: RefAtom
- (+>+*=%=>++=**==) :: RefAtom
- (+>@^=%=>@@=++==) :: RefAtom
- (+#!##=%=#!#$=^^==) :: RefAtom
- (+#!&!=%=#!&$=#&==) :: RefAtom
- (+#!^$=%=#!^&=$*==) :: RefAtom
- (+##!^=%=##!>=%+==) :: RefAtom
- (+##&&=%=##&+=&^==) :: RefAtom
- (+##@%=%=##@*=*@==) :: RefAtom
- (+#$$*=%=#$$^=+>==) :: RefAtom
- (+#$^#=%=#$^*=#&==) :: RefAtom
- (+#%$$=%=#%$+=$*==) :: RefAtom
- (+%#>*=%^=%#>*=%@==) :: RefAtom
- (+%$$&=*=%$$&=&%<) :: RefAtom
- (+%$$%=*=%$$%=&%<=) :: RefAtom
- (+%$$@=*=%$$@=*#*) :: RefAtom
- (+%$$^=*=%$$^=*&+) :: RefAtom
- (+%$%@=*=%$%@=&$/) :: RefAtom
- data Bool :: *
- aTrue :: RefAtom
- aFalse :: RefAtom
- data Char :: *
- data Int :: *
- data Integer :: *
- data Float :: *
- data Double :: *
- type IOError = IOException
- data IO a
- type String = List Char
- gerror :: RefSrcPos -> RefExp -> R (Fun String z)
- aerror :: RefAtom
- herror :: R String -> RefExp -> a
- gundefined :: RefSrcPos -> RefExp -> R a
- gseq :: RefSrcPos -> RefExp -> R (Fun a (Fun b b))
- aseq :: RefAtom
- hseq :: R a1 -> R a -> RefExp -> R a
- gisAscii :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisAscii :: RefAtom
- hisAscii :: R Char -> RefExp -> R Bool
- gisLatin1 :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisLatin1 :: RefAtom
- hisLatin1 :: R Char -> RefExp -> R Bool
- gisControl :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisControl :: RefAtom
- hisControl :: R Char -> RefExp -> R Bool
- gisPrint :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisPrint :: RefAtom
- hisPrint :: R Char -> RefExp -> R Bool
- gisSpace :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisSpace :: RefAtom
- hisSpace :: R Char -> RefExp -> R Bool
- gisUpper :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisUpper :: RefAtom
- hisUpper :: R Char -> RefExp -> R Bool
- gisLower :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisLower :: RefAtom
- hisLower :: R Char -> RefExp -> R Bool
- gisAlpha :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisAlpha :: RefAtom
- hisAlpha :: R Char -> RefExp -> R Bool
- gisDigit :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisDigit :: RefAtom
- hisDigit :: R Char -> RefExp -> R Bool
- gisOctDigit :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisOctDigit :: RefAtom
- hisOctDigit :: R Char -> RefExp -> R Bool
- gisHexDigit :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisHexDigit :: RefAtom
- hisHexDigit :: R Char -> RefExp -> R Bool
- gisAlphaNum :: RefSrcPos -> RefExp -> R (Fun Char Bool)
- aisAlphaNum :: RefAtom
- hisAlphaNum :: R Char -> RefExp -> R Bool
- gtoUpper :: RefSrcPos -> RefExp -> R (Fun Char Char)
- atoUpper :: RefAtom
- htoUpper :: R Char -> RefExp -> R Char
- gtoLower :: RefSrcPos -> RefExp -> R (Fun Char Char)
- atoLower :: RefAtom
- htoLower :: R Char -> RefExp -> R Char
- gprimIntToChar :: RefSrcPos -> RefExp -> R (Fun Int Char)
- aprimIntToChar :: RefAtom
- hprimIntToChar :: R Int -> RefExp -> R Char
- gprimCharToInt :: RefSrcPos -> RefExp -> R (Fun Char Int)
- aprimCharToInt :: RefAtom
- hprimCharToInt :: R Char -> RefExp -> R Int
- gprimUnicodeMaxBound :: RefSrcPos -> RefExp -> R Char
- gprimIntMinBound :: RefSrcPos -> RefExp -> R Int
- gprimIntMaxBound :: RefSrcPos -> RefExp -> R Int
- gprimIntEq :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))
- aprimIntEq :: RefAtom
- hprimIntEq :: R Int -> R Int -> RefExp -> R Bool
- gprimIntNe :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))
- aprimIntNe :: RefAtom
- hprimIntNe :: R Int -> R Int -> RefExp -> R Bool
- gprimIntLt :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))
- aprimIntLt :: RefAtom
- hprimIntLt :: R Int -> R Int -> RefExp -> R Bool
- gprimIntLe :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))
- aprimIntLe :: RefAtom
- hprimIntLe :: R Int -> R Int -> RefExp -> R Bool
- gprimIntGt :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))
- aprimIntGt :: RefAtom
- hprimIntGt :: R Int -> R Int -> RefExp -> R Bool
- gprimIntGe :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))
- aprimIntGe :: RefAtom
- hprimIntGe :: R Int -> R Int -> RefExp -> R Bool
- gprimIntQuot :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))
- aprimIntQuot :: RefAtom
- hprimIntQuot :: R Int -> R Int -> RefExp -> R Int
- gprimIntRem :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))
- aprimIntRem :: RefAtom
- hprimIntRem :: R Int -> R Int -> RefExp -> R Int
- gprimIntPlus :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))
- aprimIntPlus :: RefAtom
- hprimIntPlus :: R Int -> R Int -> RefExp -> R Int
- gprimIntMinus :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))
- aprimIntMinus :: RefAtom
- hprimIntMinus :: R Int -> R Int -> RefExp -> R Int
- gprimIntTimes :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))
- aprimIntTimes :: RefAtom
- hprimIntTimes :: R Int -> R Int -> RefExp -> R Int
- gprimIntNegate :: RefSrcPos -> RefExp -> R (Fun Int Int)
- aprimIntNegate :: RefAtom
- hprimIntNegate :: R Int -> RefExp -> R Int
- gprimIntAbs :: RefSrcPos -> RefExp -> R (Fun Int Int)
- aprimIntAbs :: RefAtom
- hprimIntAbs :: R Int -> RefExp -> R Int
- gprimIntSignum :: RefSrcPos -> RefExp -> R (Fun Int Int)
- aprimIntSignum :: RefAtom
- hprimIntSignum :: R Int -> RefExp -> R Int
- gprimIntegerFromInt :: RefSrcPos -> RefExp -> R (Fun Int Integer)
- aprimIntegerFromInt :: RefAtom
- hprimIntegerFromInt :: R Int -> RefExp -> R Integer
- gprimIntFromInteger :: RefSrcPos -> RefExp -> R (Fun Integer Int)
- aprimIntFromInteger :: RefAtom
- hprimIntFromInteger :: R Integer -> RefExp -> R Int
- gprimIntegerEq :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))
- aprimIntegerEq :: RefAtom
- hprimIntegerEq :: R Integer -> R Integer -> RefExp -> R Bool
- gprimIntegerNe :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))
- aprimIntegerNe :: RefAtom
- hprimIntegerNe :: R Integer -> R Integer -> RefExp -> R Bool
- gprimIntegerLt :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))
- aprimIntegerLt :: RefAtom
- hprimIntegerLt :: R Integer -> R Integer -> RefExp -> R Bool
- gprimIntegerLe :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))
- aprimIntegerLe :: RefAtom
- hprimIntegerLe :: R Integer -> R Integer -> RefExp -> R Bool
- gprimIntegerGt :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))
- aprimIntegerGt :: RefAtom
- hprimIntegerGt :: R Integer -> R Integer -> RefExp -> R Bool
- gprimIntegerGe :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))
- aprimIntegerGe :: RefAtom
- hprimIntegerGe :: R Integer -> R Integer -> RefExp -> R Bool
- gprimIntegerQuot :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))
- aprimIntegerQuot :: RefAtom
- hprimIntegerQuot :: R Integer -> R Integer -> RefExp -> R Integer
- gprimIntegerRem :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))
- aprimIntegerRem :: RefAtom
- hprimIntegerRem :: R Integer -> R Integer -> RefExp -> R Integer
- gprimIntegerQuotRem :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))
- aprimIntegerQuotRem :: RefAtom
- hprimIntegerQuotRem :: R Integer -> R Integer -> RefExp -> R (Tuple2 Integer Integer)
- gprimIntegerAdd :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))
- aprimIntegerAdd :: RefAtom
- hprimIntegerAdd :: R Integer -> R Integer -> RefExp -> R Integer
- gprimIntegerSub :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))
- aprimIntegerSub :: RefAtom
- hprimIntegerSub :: R Integer -> R Integer -> RefExp -> R Integer
- gprimIntegerMul :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))
- aprimIntegerMul :: RefAtom
- hprimIntegerMul :: R Integer -> R Integer -> RefExp -> R Integer
- gprimIntegerNeg :: RefSrcPos -> RefExp -> R (Fun Integer Integer)
- aprimIntegerNeg :: RefAtom
- hprimIntegerNeg :: R Integer -> RefExp -> R Integer
- gprimFloatFromInteger :: RefSrcPos -> RefExp -> R (Fun Integer Float)
- aprimFloatFromInteger :: RefAtom
- hprimFloatFromInteger :: R Integer -> RefExp -> R Float
- gprimFloatRadix :: RefSrcPos -> RefExp -> R (Fun Float Integer)
- aprimFloatRadix :: RefAtom
- hprimFloatRadix :: R Float -> RefExp -> R Integer
- gprimFloatDigits :: RefSrcPos -> RefExp -> R (Fun Float Int)
- aprimFloatDigits :: RefAtom
- hprimFloatDigits :: R Float -> RefExp -> R Int
- gprimFloatRange :: RefSrcPos -> RefExp -> R (Fun Float (Tuple2 Int Int))
- aprimFloatRange :: RefAtom
- hprimFloatRange :: R Float -> RefExp -> R (Tuple2 Int Int)
- gprimDecodeFloat :: RefSrcPos -> RefExp -> R (Fun Float (Tuple2 Integer Int))
- aprimDecodeFloat :: RefAtom
- hprimDecodeFloat :: R Float -> RefExp -> R (Tuple2 Integer Int)
- gprimEncodeFloat :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int Float))
- aprimEncodeFloat :: RefAtom
- hprimEncodeFloat :: R Integer -> R Int -> RefExp -> R Float
- gprimFloatIsNaN :: RefSrcPos -> RefExp -> R (Fun Float Bool)
- aprimFloatIsNaN :: RefAtom
- hprimFloatIsNaN :: R Float -> RefExp -> R Bool
- gprimFloatIsInfinite :: RefSrcPos -> RefExp -> R (Fun Float Bool)
- aprimFloatIsInfinite :: RefAtom
- hprimFloatIsInfinite :: R Float -> RefExp -> R Bool
- gprimFloatIsDenormalized :: RefSrcPos -> RefExp -> R (Fun Float Bool)
- aprimFloatIsDenormalized :: RefAtom
- hprimFloatIsDenormalized :: R Float -> RefExp -> R Bool
- gprimFloatIsNegativeZero :: RefSrcPos -> RefExp -> R (Fun Float Bool)
- aprimFloatIsNegativeZero :: RefAtom
- hprimFloatIsNegativeZero :: R Float -> RefExp -> R Bool
- gprimFloatIsIEEE :: RefSrcPos -> RefExp -> R (Fun Float Bool)
- aprimFloatIsIEEE :: RefAtom
- hprimFloatIsIEEE :: R Float -> RefExp -> R Bool
- gprimFloatEq :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))
- aprimFloatEq :: RefAtom
- hprimFloatEq :: R Float -> R Float -> RefExp -> R Bool
- gprimFloatNe :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))
- aprimFloatNe :: RefAtom
- hprimFloatNe :: R Float -> R Float -> RefExp -> R Bool
- gprimFloatLt :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))
- aprimFloatLt :: RefAtom
- hprimFloatLt :: R Float -> R Float -> RefExp -> R Bool
- gprimFloatLe :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))
- aprimFloatLe :: RefAtom
- hprimFloatLe :: R Float -> R Float -> RefExp -> R Bool
- gprimFloatGt :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))
- aprimFloatGt :: RefAtom
- hprimFloatGt :: R Float -> R Float -> RefExp -> R Bool
- gprimFloatGe :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))
- aprimFloatGe :: RefAtom
- hprimFloatGe :: R Float -> R Float -> RefExp -> R Bool
- gprimFloatPi :: RefSrcPos -> RefExp -> R Float
- gprimFloatExp :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatExp :: RefAtom
- hprimFloatExp :: R Float -> RefExp -> R Float
- gprimFloatLog :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatLog :: RefAtom
- hprimFloatLog :: R Float -> RefExp -> R Float
- gprimFloatSqrt :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatSqrt :: RefAtom
- hprimFloatSqrt :: R Float -> RefExp -> R Float
- gprimFloatSin :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatSin :: RefAtom
- hprimFloatSin :: R Float -> RefExp -> R Float
- gprimFloatCos :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatCos :: RefAtom
- hprimFloatCos :: R Float -> RefExp -> R Float
- gprimFloatTan :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatTan :: RefAtom
- hprimFloatTan :: R Float -> RefExp -> R Float
- gprimFloatAsin :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatAsin :: RefAtom
- hprimFloatAsin :: R Float -> RefExp -> R Float
- gprimFloatAcos :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatAcos :: RefAtom
- hprimFloatAcos :: R Float -> RefExp -> R Float
- gprimFloatAtan :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatAtan :: RefAtom
- hprimFloatAtan :: R Float -> RefExp -> R Float
- gprimFloatDiv :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))
- aprimFloatDiv :: RefAtom
- hprimFloatDiv :: R Float -> R Float -> RefExp -> R Float
- gprimFloatAdd :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))
- aprimFloatAdd :: RefAtom
- hprimFloatAdd :: R Float -> R Float -> RefExp -> R Float
- gprimFloatSub :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))
- aprimFloatSub :: RefAtom
- hprimFloatSub :: R Float -> R Float -> RefExp -> R Float
- gprimFloatMul :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))
- aprimFloatMul :: RefAtom
- hprimFloatMul :: R Float -> R Float -> RefExp -> R Float
- gprimFloatAbs :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatAbs :: RefAtom
- hprimFloatAbs :: R Float -> RefExp -> R Float
- gprimFloatSignum :: RefSrcPos -> RefExp -> R (Fun Float Float)
- aprimFloatSignum :: RefAtom
- hprimFloatSignum :: R Float -> RefExp -> R Float
- gprimDoubleFromInteger :: RefSrcPos -> RefExp -> R (Fun Integer Double)
- aprimDoubleFromInteger :: RefAtom
- hprimDoubleFromInteger :: R Integer -> RefExp -> R Double
- gprimDoubleRadix :: RefSrcPos -> RefExp -> R (Fun Double Integer)
- aprimDoubleRadix :: RefAtom
- hprimDoubleRadix :: R Double -> RefExp -> R Integer
- gprimDoubleDigits :: RefSrcPos -> RefExp -> R (Fun Double Int)
- aprimDoubleDigits :: RefAtom
- hprimDoubleDigits :: R Double -> RefExp -> R Int
- gprimDoubleRange :: RefSrcPos -> RefExp -> R (Fun Double (Tuple2 Int Int))
- aprimDoubleRange :: RefAtom
- hprimDoubleRange :: R Double -> RefExp -> R (Tuple2 Int Int)
- gprimDecodeDouble :: RefSrcPos -> RefExp -> R (Fun Double (Tuple2 Integer Int))
- aprimDecodeDouble :: RefAtom
- hprimDecodeDouble :: R Double -> RefExp -> R (Tuple2 Integer Int)
- gprimEncodeDouble :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int Double))
- aprimEncodeDouble :: RefAtom
- hprimEncodeDouble :: R Integer -> R Int -> RefExp -> R Double
- gprimDoubleIsNaN :: RefSrcPos -> RefExp -> R (Fun Double Bool)
- aprimDoubleIsNaN :: RefAtom
- hprimDoubleIsNaN :: R Double -> RefExp -> R Bool
- gprimDoubleIsInfinite :: RefSrcPos -> RefExp -> R (Fun Double Bool)
- aprimDoubleIsInfinite :: RefAtom
- hprimDoubleIsInfinite :: R Double -> RefExp -> R Bool
- gprimDoubleIsDenormalized :: RefSrcPos -> RefExp -> R (Fun Double Bool)
- aprimDoubleIsDenormalized :: RefAtom
- hprimDoubleIsDenormalized :: R Double -> RefExp -> R Bool
- gprimDoubleIsNegativeZero :: RefSrcPos -> RefExp -> R (Fun Double Bool)
- aprimDoubleIsNegativeZero :: RefAtom
- hprimDoubleIsNegativeZero :: R Double -> RefExp -> R Bool
- gprimDoubleIsIEEE :: RefSrcPos -> RefExp -> R (Fun Double Bool)
- aprimDoubleIsIEEE :: RefAtom
- hprimDoubleIsIEEE :: R Double -> RefExp -> R Bool
- gprimDoubleEq :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))
- aprimDoubleEq :: RefAtom
- hprimDoubleEq :: R Double -> R Double -> RefExp -> R Bool
- gprimDoubleNe :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))
- aprimDoubleNe :: RefAtom
- hprimDoubleNe :: R Double -> R Double -> RefExp -> R Bool
- gprimDoubleLt :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))
- aprimDoubleLt :: RefAtom
- hprimDoubleLt :: R Double -> R Double -> RefExp -> R Bool
- gprimDoubleLe :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))
- aprimDoubleLe :: RefAtom
- hprimDoubleLe :: R Double -> R Double -> RefExp -> R Bool
- gprimDoubleGt :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))
- aprimDoubleGt :: RefAtom
- hprimDoubleGt :: R Double -> R Double -> RefExp -> R Bool
- gprimDoubleGe :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))
- aprimDoubleGe :: RefAtom
- hprimDoubleGe :: R Double -> R Double -> RefExp -> R Bool
- gprimDoublePi :: RefSrcPos -> RefExp -> R Double
- gprimDoubleExp :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleExp :: RefAtom
- hprimDoubleExp :: R Double -> RefExp -> R Double
- gprimDoubleLog :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleLog :: RefAtom
- hprimDoubleLog :: R Double -> RefExp -> R Double
- gprimDoubleSqrt :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleSqrt :: RefAtom
- hprimDoubleSqrt :: R Double -> RefExp -> R Double
- gprimDoubleSin :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleSin :: RefAtom
- hprimDoubleSin :: R Double -> RefExp -> R Double
- gprimDoubleCos :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleCos :: RefAtom
- hprimDoubleCos :: R Double -> RefExp -> R Double
- gprimDoubleTan :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleTan :: RefAtom
- hprimDoubleTan :: R Double -> RefExp -> R Double
- gprimDoubleAsin :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleAsin :: RefAtom
- hprimDoubleAsin :: R Double -> RefExp -> R Double
- gprimDoubleAcos :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleAcos :: RefAtom
- hprimDoubleAcos :: R Double -> RefExp -> R Double
- gprimDoubleAtan :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleAtan :: RefAtom
- hprimDoubleAtan :: R Double -> RefExp -> R Double
- gprimDoubleDiv :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))
- aprimDoubleDiv :: RefAtom
- hprimDoubleDiv :: R Double -> R Double -> RefExp -> R Double
- gprimDoubleAdd :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))
- aprimDoubleAdd :: RefAtom
- hprimDoubleAdd :: R Double -> R Double -> RefExp -> R Double
- gprimDoubleSub :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))
- aprimDoubleSub :: RefAtom
- hprimDoubleSub :: R Double -> R Double -> RefExp -> R Double
- gprimDoubleMul :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))
- aprimDoubleMul :: RefAtom
- hprimDoubleMul :: R Double -> R Double -> RefExp -> R Double
- gprimDoubleAbs :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleAbs :: RefAtom
- hprimDoubleAbs :: R Double -> RefExp -> R Double
- gprimDoubleSignum :: RefSrcPos -> RefExp -> R (Fun Double Double)
- aprimDoubleSignum :: RefAtom
- hprimDoubleSignum :: R Double -> RefExp -> R Double
- gprimIOBind :: RefSrcPos -> RefExp -> R (Fun (IO a) (Fun (Fun a (IO b)) (IO b)))
- aprimIOBind :: RefAtom
- hprimIOBind :: R (IO a) -> R (Fun a (IO b)) -> RefExp -> R (IO b)
- gprimIOReturn :: RefSrcPos -> RefExp -> R (Fun a (IO a))
- aprimIOReturn :: RefAtom
- hprimIOReturn :: R b -> RefExp -> R (IO b)
- gioError :: RefSrcPos -> RefExp -> R (Fun IOError (IO a))
- aioError :: RefAtom
- hioError :: R IOError -> RefExp -> R (IO b)
- guserError :: RefSrcPos -> RefExp -> R (Fun String IOError)
- auserError :: RefAtom
- huserError :: R String -> RefExp -> R IOError
- gcatch :: RefSrcPos -> RefExp -> R (Fun (IO a) (Fun (Fun IOError (IO a)) (IO a)))
- acatch :: RefAtom
- hcatch :: R (IO b) -> R (Fun IOError (IO b)) -> RefExp -> R (IO b)
- gputChar :: RefSrcPos -> RefExp -> R (Fun Char (IO Tuple0))
- aputChar :: RefAtom
- hputChar :: R Char -> RefExp -> R (IO Tuple0)
- ggetChar :: RefSrcPos -> RefExp -> R (IO Char)
- ggetContents :: RefSrcPos -> RefExp -> R (IO String)
- greadFile :: RefSrcPos -> RefExp -> R (Fun String (IO String))
- areadFile :: RefAtom
- hreadFile :: R String -> RefExp -> R (IO String)
- gwriteFile :: RefSrcPos -> RefExp -> R (Fun String (Fun String (IO Tuple0)))
- awriteFile :: RefAtom
- hwriteFile :: R String -> R String -> RefExp -> R (IO Tuple0)
- gappendFile :: RefSrcPos -> RefExp -> R (Fun String (Fun String (IO Tuple0)))
- aappendFile :: RefAtom
- happendFile :: R String -> R String -> RefExp -> R (IO Tuple0)
- gprimIOErrorShow :: RefSrcPos -> RefExp -> R (Fun IOError String)
- aprimIOErrorShow :: RefAtom
- hprimIOErrorShow :: R IOError -> RefExp -> R String
Documentation
glift :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (ReadS c))) (Fun (ReadS a) (Fun (ReadS b) (ReadS c)))) Source
hlift :: R (Fun a (Fun b (ReadS c))) -> R (ReadS a) -> R (ReadS b) -> R (ReadS___1 c) -> RefExp -> R (ReadS___2 c) Source
Eq Bool | |
Eq Char | |
Eq Double | |
Eq Float | |
Eq Int | |
Eq Integer | |
Eq Handle | |
Eq HandlePosn | |
Eq ClockTime | |
Eq Tuple0 | |
Eq Ordering | |
Eq Permissions | |
Eq TimeLocale | |
Eq ExitCode | |
Eq SeekMode | |
Eq BufferMode | |
Eq IOMode | |
Eq TimeDiff | |
Eq CalendarTime | |
Eq Day | |
Eq Month | |
Eq GeneralCategory | |
Eq a => Eq (List a) | |
Eq a => Eq (Ratio a) | |
Eq a => Eq (Maybe a) | |
Eq a => Eq (Complex a) | |
(Eq a, Eq b) => Eq (Tuple2 a b) | |
(Eq a, Eq b) => Eq (Either a b) | |
(Ix a, Eq b) => Eq (Array a b) | |
(Eq a, Eq b, Eq c) => Eq (Tuple3 a b c) | |
(Eq a, Eq b, Eq c, Eq d) => Eq (Tuple4 a b c d) | |
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (Tuple5 a b c d e) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (Tuple6 a b c d e f) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (Tuple7 a b c d e f g) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (Tuple8 a b c d e f g h) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (Tuple9 a b c d e f g h i) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (Tuple10 a b c d e f g h i j) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (Tuple11 a b c d e f g h i j k) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (Tuple12 a b c d e f g h i j k l) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (Tuple13 a b c d e f g h i j k l m) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (Tuple14 a b c d e f g h i j k l m n) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (Tuple15 a b c d e f g h i j k l m n o) |
class Eq a => Ord a where Source
gcompare :: RefSrcPos -> RefExp -> R (Fun a (Fun a Ordering)) Source
scompare :: R (Fun a (Fun a Ordering)) Source
(!<), (!>), (!>=), (!<=) :: RefSrcPos -> RefExp -> R (Fun a (Fun a Bool)) Source
(|<), (|>), (|>=), (|<=) :: R (Fun a (Fun a Bool)) Source
gmax, gmin :: RefSrcPos -> RefExp -> R (Fun a (Fun a a)) Source
Ord Bool | |
Ord Char | |
Ord Double | |
Ord Float | |
Ord Int | |
Ord Integer | |
Ord ClockTime | |
Ord Tuple0 | |
Ord Ordering | |
Ord Permissions | |
Ord TimeLocale | |
Ord ExitCode | |
Ord SeekMode | |
Ord BufferMode | |
Ord IOMode | |
Ord TimeDiff | |
Ord CalendarTime | |
Ord Day | |
Ord Month | |
Ord GeneralCategory | |
Ord a => Ord (List a) | |
Integral a => Ord (Ratio a) | |
Ord a => Ord (Maybe a) | |
(Ord a, Ord b) => Ord (Tuple2 a b) | |
(Ord a, Ord b) => Ord (Either a b) | |
(Ix a, Ord b) => Ord (Array a b) | |
(Ord a, Ord b, Ord c) => Ord (Tuple3 a b c) | |
(Ord a, Ord b, Ord c, Ord d) => Ord (Tuple4 a b c d) | |
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (Tuple5 a b c d e) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (Tuple6 a b c d e f) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (Tuple7 a b c d e f g) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (Tuple8 a b c d e f g h) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (Tuple9 a b c d e f g h i) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (Tuple10 a b c d e f g h i j) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (Tuple11 a b c d e f g h i j k) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (Tuple12 a b c d e f g h i j k l) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (Tuple13 a b c d e f g h i j k l m) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (Tuple14 a b c d e f g h i j k l m n) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (Tuple15 a b c d e f g h i j k l m n o) |
gsucc, gpred :: RefSrcPos -> RefExp -> R (Fun a a) Source
ssucc, spred :: R (Fun a a) Source
gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int a) Source
stoEnum :: R (Fun Int a) Source
gfromEnum :: RefSrcPos -> RefExp -> R (Fun a Int) Source
sfromEnum :: R (Fun a Int) Source
genumFrom :: RefSrcPos -> RefExp -> R (Fun a (List a)) Source
senumFrom :: R (Fun a (List a)) Source
genumFromThen :: RefSrcPos -> RefExp -> R (Fun a (Fun a (List a))) Source
senumFromThen :: R (Fun a (Fun a (List a))) Source
genumFromTo :: RefSrcPos -> RefExp -> R (Fun a (Fun a (List a))) Source
senumFromTo :: R (Fun a (Fun a (List a))) Source
genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun a (Fun a (Fun a (List a)))) Source
senumFromThenTo :: R (Fun a (Fun a (Fun a (List a)))) Source
class (Eq a, Show a) => Num a where Source
(!+), (!*), (!-) :: RefSrcPos -> RefExp -> R (Fun a (Fun a a)) Source
(|+), (|*), (|-) :: R (Fun a (Fun a a)) Source
gnegate :: RefSrcPos -> RefExp -> R (Fun a a) Source
gabs, gsignum :: RefSrcPos -> RefExp -> R (Fun a a) Source
sabs, ssignum :: R (Fun a a) Source
gfromInteger :: RefSrcPos -> RefExp -> R (Fun Integer a) Source
sfromInteger :: R (Fun Integer a) Source
class (Real a, Enum a) => Integral a where Source
gquot, grem :: RefSrcPos -> RefExp -> R (Fun a (Fun a a)) Source
squot, srem :: R (Fun a (Fun a a)) Source
gdiv, gmod :: RefSrcPos -> RefExp -> R (Fun a (Fun a a)) Source
sdiv, smod :: R (Fun a (Fun a a)) Source
gquotRem, gdivMod :: RefSrcPos -> RefExp -> R (Fun a (Fun a (Tuple2 a a))) Source
squotRem, sdivMod :: R (Fun a (Fun a (Tuple2 a a))) Source
gtoInteger :: RefSrcPos -> RefExp -> R (Fun a Integer) Source
stoInteger :: R (Fun a Integer) Source
class Num a => Fractional a where Source
(!/) :: RefSrcPos -> RefExp -> R (Fun a (Fun a a)) Source
(|/) :: R (Fun a (Fun a a)) Source
grecip :: RefSrcPos -> RefExp -> R (Fun a a) Source
gfromRational :: RefSrcPos -> RefExp -> R (Fun Rational a) Source
sfromRational :: R (Fun Rational a) Source
Fractional Double | |
Fractional Float | |
Integral a => Fractional (Ratio a) | |
RealFloat a => Fractional (Complex a) |
class Fractional a => Floating a where Source
gpi, gexp, glog, ssqrt, (|**), slogBase, gsin, gcos, stan, gasin, gatan, gacos, gsinh, gcosh, stanh, gasinh, gatanh, gacosh
gpi :: RefSrcPos -> RefExp -> R a Source
gexp, gsqrt, glog :: RefSrcPos -> RefExp -> R (Fun a a) Source
sexp, ssqrt, slog :: R (Fun a a) Source
(!**), glogBase :: RefSrcPos -> RefExp -> R (Fun a (Fun a a)) Source
(|**), slogBase :: R (Fun a (Fun a a)) Source
gsin, gtan, gcos :: RefSrcPos -> RefExp -> R (Fun a a) Source
ssin, stan, scos :: R (Fun a a) Source
gasin, gatan, gacos :: RefSrcPos -> RefExp -> R (Fun a a) Source
sasin, satan, sacos :: R (Fun a a) Source
gsinh, gtanh, gcosh :: RefSrcPos -> RefExp -> R (Fun a a) Source
ssinh, stanh, scosh :: R (Fun a a) Source
gasinh, gatanh, gacosh :: RefSrcPos -> RefExp -> R (Fun a a) Source
class (Real a, Fractional a) => RealFrac a where Source
gproperFraction :: Integral b => RefSrcPos -> RefExp -> R (Fun a (Tuple2 b a)) Source
sproperFraction :: Integral b => R (Fun a (Tuple2 b a)) Source
gtruncate, ground :: Integral b => RefSrcPos -> RefExp -> R (Fun a b) Source
struncate, sround :: Integral b => R (Fun a b) Source
gceiling, gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun a b) Source
class (RealFrac a, Floating a) => RealFloat a where Source
gfloatRadix, gfloatDigits, gfloatRange, gdecodeFloat, gencodeFloat, sexponent, ssignificand, sscaleFloat, gisNaN, gisIEEE, gisNegativeZero, gisDenormalized, gisInfinite, satan2
gfloatRadix :: RefSrcPos -> RefExp -> R (Fun a Integer) Source
sfloatRadix :: R (Fun a Integer) Source
gfloatDigits :: RefSrcPos -> RefExp -> R (Fun a Int) Source
sfloatDigits :: R (Fun a Int) Source
gfloatRange :: RefSrcPos -> RefExp -> R (Fun a (Tuple2 Int Int)) Source
sfloatRange :: R (Fun a (Tuple2 Int Int)) Source
gdecodeFloat :: RefSrcPos -> RefExp -> R (Fun a (Tuple2 Integer Int)) Source
sdecodeFloat :: R (Fun a (Tuple2 Integer Int)) Source
gencodeFloat :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int a)) Source
sencodeFloat :: R (Fun Integer (Fun Int a)) Source
gexponent :: RefSrcPos -> RefExp -> R (Fun a Int) Source
sexponent :: R (Fun a Int) Source
gsignificand :: RefSrcPos -> RefExp -> R (Fun a a) Source
ssignificand :: R (Fun a a) Source
gscaleFloat :: RefSrcPos -> RefExp -> R (Fun Int (Fun a a)) Source
sscaleFloat :: R (Fun Int (Fun a a)) Source
gisNaN, gisIEEE, gisNegativeZero, gisDenormalized, gisInfinite :: RefSrcPos -> RefExp -> R (Fun a Bool) Source
sisNaN, sisIEEE, sisNegativeZero, sisDenormalized, sisInfinite :: R (Fun a Bool) Source
grealToFrac :: (Real a, Fractional b) => RefSrcPos -> RefExp -> R (Fun a b) Source
(!>>=) :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (Fun a (m b)) (m b))) Source
(|>>=) :: R (Fun (m a) (Fun (Fun a (m b)) (m b))) Source
(!>>) :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (m b) (m b))) Source
(|>>) :: R (Fun (m a) (Fun (m b) (m b))) Source
greturn :: RefSrcPos -> RefExp -> R (Fun a (m a)) Source
sreturn :: R (Fun a (m a)) Source
gnumericEnumFrom :: Fractional a => RefSrcPos -> RefExp -> R (Fun a (List a)) Source
gnumericEnumFromThen :: Fractional a => RefSrcPos -> RefExp -> R (Fun a (Fun a (List a))) Source
hnumericEnumFromThen :: Fractional a => R a -> R a -> RefExp -> R (List a) Source
gnumericEnumFromTo :: (Fractional a, Ord a) => RefSrcPos -> RefExp -> R (Fun a (Fun a (List a))) Source
hnumericEnumFromTo :: (Fractional a, Ord a) => R a -> R a -> RefExp -> R (List a) Source
gnumericEnumFromThenTo :: (Fractional a, Ord a) => RefSrcPos -> RefExp -> R (Fun a (Fun a (Fun a (List a)))) Source
hnumericEnumFromThenTo :: (Fractional a, Ord a) => R a -> R a -> R a -> RefExp -> R (List a) Source
g_filter :: RefSrcPos -> RefExp -> R (Fun Bool (Fun (Fun (List a) (List a)) (Fun (List a) (List a)))) Source
gspan :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Tuple2 (List a) (List a)))) Source
gbreak :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Tuple2 (List a) (List a)))) Source
gzip3 :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (Fun (List c) (List (Tuple3 a b c))))) Source
gzipWith :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b c)) (Fun (List a) (Fun (List b) (List c)))) Source
gzipWith3 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c d))) (Fun (List a) (Fun (List b) (Fun (List c) (List d))))) Source
hzipWith3 :: R (Fun a (Fun b (Fun c d))) -> R (List a) -> R (List b) -> R (List c) -> RefExp -> R (List d) Source
gunzip3 :: RefSrcPos -> RefExp -> R (Fun (List (Tuple3 a b c)) (Tuple3 (List a) (List b) (List c))) Source
greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS a)) Source
sreadsPrec :: R (Fun Int (ReadS a)) Source
greadList :: RefSrcPos -> RefExp -> R (ReadS (List a)) Source
Read Bool | |
Read Char | |
Read Double | |
Read Float | |
Read Int | |
Read Integer | |
Read StdGen | |
Read Tuple0 | |
Read Ordering | |
Read Permissions | |
Read ExitCode | |
Read SeekMode | |
Read BufferMode | |
Read IOMode | |
Read TimeDiff | |
Read CalendarTime | |
Read Day | |
Read Month | |
Read GeneralCategory | |
Read a => Read (List a) | |
(Read a, Integral a) => Read (Ratio a) | |
Read a => Read (Maybe a) | |
Read a => Read (Complex a) | |
(Read a, Read b) => Read (Tuple2 a b) | |
(Read a, Read b) => Read (Either a b) | |
(Ix a, Read a, Read b) => Read (Array a b) | |
(Read a, Read b, Read c) => Read (Tuple3 a b c) | |
(Read a, Read b, Read c, Read d) => Read (Tuple4 a b c d) | |
(Read a, Read b, Read c, Read d, Read e) => Read (Tuple5 a b c d e) | |
(Read a, Read b, Read c, Read d, Read e, Read f) => Read (Tuple6 a b c d e f) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (Tuple7 a b c d e f g) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (Tuple8 a b c d e f g h) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (Tuple9 a b c d e f g h i) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (Tuple10 a b c d e f g h i j) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (Tuple11 a b c d e f g h i j k) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (Tuple12 a b c d e f g h i j k l) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (Tuple13 a b c d e f g h i j k l m) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (Tuple14 a b c d e f g h i j k l m n) | |
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (Tuple15 a b c d e f g h i j k l m n o) |
gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun a ShowS)) Source
sshowsPrec :: R (Fun Int (Fun a ShowS)) Source
gshow :: RefSrcPos -> RefExp -> R (Fun a String) Source
sshow :: R (Fun a String) Source
gshowList :: RefSrcPos -> RefExp -> R (Fun (List a) ShowS) Source
Show Bool | |
Show Char | |
Show Double | |
Show Float | |
Show Int | |
Show Integer | |
Show Handle | |
Show StdGen | |
Show Tuple0 | |
Show Ordering | |
Show Permissions | |
Show TimeLocale | |
Show ExitCode | |
Show SeekMode | |
Show BufferMode | |
Show IOMode | |
Show TimeDiff | |
Show CalendarTime | |
Show Day | |
Show Month | |
Show GeneralCategory | |
Show a => Show (List a) | |
Integral a => Show (Ratio a) | |
Show a => Show (Maybe a) | |
Show a => Show (Complex a) | |
(Show a, Show b) => Show (Tuple2 a b) | |
(Show a, Show b) => Show (Either a b) | |
(Ix a, Show a, Show b) => Show (Array a b) | |
(Show a, Show b, Show c) => Show (Tuple3 a b c) | |
(Show a, Show b, Show c, Show d) => Show (Tuple4 a b c d) | |
(Show a, Show b, Show c, Show d, Show e) => Show (Tuple5 a b c d e) | |
(Show a, Show b, Show c, Show d, Show e, Show f) => Show (Tuple6 a b c d e f) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (Tuple7 a b c d e f g) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (Tuple8 a b c d e f g h) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (Tuple9 a b c d e f g h i) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (Tuple10 a b c d e f g h i j) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (Tuple11 a b c d e f g h i j k) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (Tuple12 a b c d e f g h i j k l) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (Tuple13 a b c d e f g h i j k l m) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (Tuple14 a b c d e f g h i j k l m n) | |
(Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (Tuple15 a b c d e f g h i j k l m n o) |
gprotectEsc :: RefSrcPos -> RefExp -> R (Fun (Fun Char Bool) (Fun (Fun (List Char) c) (Fun (List Char) c))) Source
gscaleRat :: RefSrcPos -> RefExp -> R (Fun Rational (Fun Int (Fun Rational (Fun Rational (Fun Int (Fun Rational (Tuple2 Rational Int))))))) Source
hscaleRat :: R Rational -> R Int -> R Rational -> R Rational -> R Int -> R Rational -> RefExp -> R (Tuple2 Rational Int) Source
gshowSigned :: Real a => RefSrcPos -> RefExp -> R (Fun (Fun a ShowS) (Fun Int (Fun a ShowS))) Source
gshowIntAtBase :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun (Fun Int Char) (Fun a ShowS))) Source
hshowIntAtBase :: Integral a => R a -> R (Fun Int Char) -> R a -> R ShowS___1 -> RefExp -> R ShowS___2 Source
greadInt :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun (Fun Char Bool) (Fun (Fun Char Int) (ReadS a)))) Source
hreadInt :: Integral a => R a -> R (Fun Char Bool) -> R (Fun Char Int) -> R (ReadS___1 a) -> RefExp -> R (ReadS___2 a) Source
gformatRealFloat :: RealFloat a => RefSrcPos -> RefExp -> R (Fun FFFormat (Fun (Maybe Int) (Fun a String))) Source
groundTo :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (Fun (List Int) (Tuple2 Int (List Int))))) Source
gfloatToDigits :: RealFloat a => RefSrcPos -> RefExp -> R (Fun Integer (Fun a (Tuple2 (List Int) Int))) Source
type Rational___1 = Ratio Integer Source
data Bool :: *
data Char :: *
The character type Char
is an enumeration whose values represent
Unicode (or equivalently ISO/IEC 10646) characters (see
http://www.unicode.org/ for details). This set extends the ISO 8859-1
(Latin-1) character set (the first 256 characters), which is itself an extension
of the ASCII character set (the first 128 characters). A character literal in
Haskell has type Char
.
To convert a Char
to or from the corresponding Int
value defined
by Unicode, use toEnum
and fromEnum
from the
Enum
class respectively (or equivalently ord
and chr
).
data Int :: *
data Integer :: *
Arbitrary-precision integers.
data Float :: *
Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.
data Double :: *
Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.
type IOError = IOException
The Haskell 2010 type for exceptions in the IO
monad.
Any I/O operation may raise an IOError
instead of returning a result.
For a more general type of exception, including also those that arise
in pure code, see Control.Exception.Exception.
In Haskell 2010, this is an opaque type.
gundefined :: RefSrcPos -> RefExp -> R a Source