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
- class Enum a where
- class Bounded a where
- class (Eq a, Show a) => Num a where
- class (Num a, Ord a) => Real a where
- class (Real a, Enum a) => Integral a where
- class Num a => Fractional a where
- class Fractional a => Floating a where
- class (Real a, Fractional a) => RealFrac a where
- class (RealFrac a, Floating a) => RealFloat a where
- 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
- 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 z => RefSrcPos -> RefExp -> R (Fun z (Fun z (Ratio z)))
- hreduce :: Integral z => R z -> R z -> RefExp -> R (Ratio z)
- (!%) :: 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 Source # | |
Eq Char Source # | |
Eq Double Source # | |
Eq Float Source # | |
Eq Int Source # | |
Eq Integer Source # | |
Eq Tuple0 Source # | |
Eq Ordering Source # | |
Eq SeekMode Source # | |
Eq BufferMode Source # | |
Eq IOMode Source # | |
Eq TimeLocale Source # | |
Eq ExitCode Source # | |
Eq TimeDiff Source # | |
Eq CalendarTime Source # | |
Eq Day Source # | |
Eq Month Source # | |
Eq GeneralCategory Source # | |
Eq a => Eq (List a) Source # | |
Eq a => Eq (Ratio a) Source # | |
Eq a => Eq (Maybe a) Source # | |
Eq a => Eq (Complex a) Source # | |
(Eq a, Eq b) => Eq (Tuple2 a b) Source # | |
(Eq a, Eq b) => Eq (Either a b) Source # | |
(Ix a, Eq b) => Eq (Array a b) Source # | |
(Eq a, Eq b, Eq c) => Eq (Tuple3 a b c) Source # | |
(Eq a, Eq b, Eq c, Eq d) => Eq (Tuple4 a b c d) Source # | |
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (Tuple5 a b c d e) Source # | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (Tuple6 a b c d e f) Source # | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (Tuple7 a b c d e f g) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
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 Source # | |
Ord Char Source # | |
Ord Double Source # | |
Ord Float Source # | |
Ord Int Source # | |
Ord Integer Source # | |
Ord Tuple0 Source # | |
Ord Ordering Source # | |
Ord SeekMode Source # | |
Ord BufferMode Source # | |
Ord IOMode Source # | |
Ord TimeLocale Source # | |
Ord ExitCode Source # | |
Ord TimeDiff Source # | |
Ord CalendarTime Source # | |
Ord Day Source # | |
Ord Month Source # | |
Ord GeneralCategory Source # | |
Ord a => Ord (List a) Source # | |
Integral a => Ord (Ratio a) Source # | |
Ord a => Ord (Maybe a) Source # | |
(Ord a, Ord b) => Ord (Tuple2 a b) Source # | |
(Ord a, Ord b) => Ord (Either a b) Source # | |
(Ix a, Ord b) => Ord (Array a b) Source # | |
(Ord a, Ord b, Ord c) => Ord (Tuple3 a b c) Source # | |
(Ord a, Ord b, Ord c, Ord d) => Ord (Tuple4 a b c d) Source # | |
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (Tuple5 a b c d e) Source # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (Tuple6 a b c d e f) Source # | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (Tuple7 a b c d e f g) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
(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) Source # | |
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 #
Enum Bool Source # | |
Enum Char Source # | |
Enum Double Source # | |
Enum Float Source # | |
Enum Int Source # | |
Enum Integer Source # | |
Enum Tuple0 Source # | |
Enum Ordering Source # | |
Enum SeekMode Source # | |
Enum IOMode Source # | |
Enum Day Source # | |
Enum Month Source # | |
Enum GeneralCategory Source # | |
Integral a => Enum (Ratio a) Source # | |
class Bounded a where 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 #
snegate :: 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 #
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 #
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 #
srecip :: R (Fun a a) Source #
gfromRational :: RefSrcPos -> RefExp -> R (Fun Rational a) Source #
Fractional Double Source # | |
Fractional Float Source # | |
Integral a => Fractional (Ratio a) Source # | |
RealFloat a => Fractional (Complex a) Source # | |
class Fractional a => Floating a where Source #
gpi, gexp, glog, ssqrt, (|**), slogBase, gsin, gcos, stan, gasin, gacos, gatan, gsinh, gcosh, stanh, gasinh, gacosh, gatanh
gpi :: RefSrcPos -> RefExp -> R a Source #
gexp, glog, gsqrt :: RefSrcPos -> RefExp -> R (Fun a a) Source #
sexp, slog, ssqrt :: R (Fun a a) Source #
(!**), glogBase :: RefSrcPos -> RefExp -> R (Fun a (Fun a a)) Source #
(|**), slogBase :: R (Fun a (Fun a a)) Source #
gsin, gcos, gtan :: RefSrcPos -> RefExp -> R (Fun a a) Source #
ssin, scos, stan :: R (Fun a a) Source #
gasin, gacos, gatan :: RefSrcPos -> RefExp -> R (Fun a a) Source #
sasin, sacos, satan :: R (Fun a a) Source #
gsinh, gcosh, gtanh :: RefSrcPos -> RefExp -> R (Fun a a) Source #
ssinh, scosh, stanh :: R (Fun a a) Source #
gasinh, gacosh, gatanh :: 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, gisInfinite, gisDenormalized, gisNegativeZero, gisIEEE, 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, gisInfinite, gisDenormalized, gisNegativeZero, gisIEEE :: RefSrcPos -> RefExp -> R (Fun a Bool) Source #
sisNaN, sisInfinite, sisDenormalized, sisNegativeZero, sisIEEE :: R (Fun a Bool) Source #
gatan2 :: RefSrcPos -> RefExp -> R (Fun a (Fun a a)) 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 #
gfail :: RefSrcPos -> RefExp -> R (Fun String (m a)) Source #
gmapM :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (List a) (m (List b)))) Source #
gmapM_ :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (List a) (m Tuple0))) 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 #
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 #
gprotectEsc :: RefSrcPos -> RefExp -> R (Fun (Fun Char Bool) (Fun (Fun (List Char) c) (Fun (List Char) c))) Source #
hprotectEsc :: R (Fun Char Bool) -> R (Fun (List Char) c) -> RefExp -> R (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 #
hformatRealFloat :: RealFloat a => R FFFormat -> R (Maybe Int) -> R a -> RefExp -> R 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 #
WrapVal (Ratio a) Source # | |
Integral a => Show (Ratio a) Source # | |
(Read a, Integral a) => Read (Ratio a) Source # | |
Integral a => RealFrac (Ratio a) Source # | |
Integral a => Fractional (Ratio a) Source # | |
Integral a => Real (Ratio a) Source # | |
Integral a => Num (Ratio a) Source # | |
Integral a => Enum (Ratio a) Source # | |
Integral a => Ord (Ratio a) Source # | |
Eq a => Eq (Ratio a) Source # | |
type Rational___1 = Ratio Integer Source #
aFFGeneric :: RefAtom Source #
aconcatMap :: RefAtom Source #
adropWhile :: RefAtom Source #
alexDigits :: RefAtom Source #
anumerator :: RefAtom Source #
aotherwise :: RefAtom Source #
areadFloat :: RefAtom Source #
areadParen :: RefAtom Source #
areplicate :: RefAtom Source #
asequence_ :: RefAtom Source #
ashowFloat :: RefAtom Source #
ashowParen :: RefAtom Source #
atakeWhile :: RefAtom Source #
Bounded Bool | |
Enum Bool | |
Eq Bool | |
Ord Bool | |
Read Bool | |
Show Bool | |
Generic Bool | |
Storable Bool | |
Random Bool | |
Show Bool Source # | |
Read Bool Source # | |
Bounded Bool Source # | |
Enum Bool Source # | |
Ord Bool Source # | |
Eq Bool Source # | |
Ix Bool Source # | |
Random Bool Source # | |
SingI Bool False | |
SingI Bool True | |
SingKind Bool (KProxy Bool) | |
type Rep Bool | |
data Sing Bool | |
type (==) Bool a b | |
type DemoteRep Bool (KProxy Bool) | |
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
).
Bounded Char | |
Enum Char | |
Eq Char | |
Ord Char | |
Read Char | |
Show Char | |
Storable Char | |
Random Char | |
Show Char Source # | |
Read Char Source # | |
Bounded Char Source # | |
Enum Char Source # | |
Ord Char Source # | |
Eq Char Source # | |
Ix Char Source # | |
Random Char Source # | |
Functor (URec Char) | |
Foldable (URec Char) | |
Generic1 (URec Char) | |
Eq (URec Char p) | |
Ord (URec Char p) | |
Show (URec Char p) | |
Generic (URec Char p) | |
data URec Char | Used for marking occurrences of |
type Rep1 (URec Char) | |
type Rep (URec Char p) | |
A fixed-precision integer type with at least the range [-2^29 .. 2^29-1]
.
The exact range for a given implementation can be determined by using
minBound
and maxBound
from the Bounded
class.
Bounded Int | |
Enum Int | |
Eq Int | |
Integral Int | |
Num Int | |
Ord Int | |
Read Int | |
Real Int | |
Show Int | |
Storable Int | |
Random Int | |
Show Int Source # | |
Read Int Source # | |
Integral Int Source # | |
Real Int Source # | |
Num Int Source # | |
Bounded Int Source # | |
Enum Int Source # | |
Ord Int Source # | |
Eq Int Source # | |
Ix Int Source # | |
Random Int Source # | |
Functor (URec Int) | |
Foldable (URec Int) | |
Generic1 (URec Int) | |
Eq (URec Int p) | |
Ord (URec Int p) | |
Show (URec Int p) | |
Generic (URec Int p) | |
data URec Int | Used for marking occurrences of |
type Rep1 (URec Int) | |
type Rep (URec Int p) | |
Invariant: Jn#
and Jp#
are used iff value doesn't fit in S#
Useful properties resulting from the invariants:
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.
Eq Float | |
Floating Float | |
Ord Float | |
Read Float | |
RealFloat Float | |
Storable Float | |
Random Float | |
Show Float Source # | |
Read Float Source # | |
RealFloat Float Source # | |
RealFrac Float Source # | |
Floating Float Source # | |
Fractional Float Source # | |
Real Float Source # | |
Num Float Source # | |
Enum Float Source # | |
Ord Float Source # | |
Eq Float Source # | |
Random Float Source # | |
Functor (URec Float) | |
Foldable (URec Float) | |
Generic1 (URec Float) | |
Eq (URec Float p) | |
Ord (URec Float p) | |
Show (URec Float p) | |
Generic (URec Float p) | |
data URec Float | Used for marking occurrences of |
type Rep1 (URec Float) | |
type Rep (URec Float p) | |
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.
Eq Double | |
Floating Double | |
Ord Double | |
Read Double | |
RealFloat Double | |
Storable Double | |
Random Double | |
Show Double Source # | |
Read Double Source # | |
RealFloat Double Source # | |
RealFrac Double Source # | |
Floating Double Source # | |
Fractional Double Source # | |
Real Double Source # | |
Num Double Source # | |
Enum Double Source # | |
Ord Double Source # | |
Eq Double Source # | |
Random Double Source # | |
Functor (URec Double) | |
Foldable (URec Double) | |
Generic1 (URec Double) | |
Eq (URec Double p) | |
Ord (URec Double p) | |
Show (URec Double p) | |
Generic (URec Double p) | |
data URec Double | Used for marking occurrences of |
type Rep1 (URec Double) | |
type Rep (URec Double p) | |
type IOError = IOException #
aisControl :: RefAtom Source #
aprimIntEq :: RefAtom Source #
aprimIntNe :: RefAtom Source #
aprimIntLt :: RefAtom Source #
aprimIntLe :: RefAtom Source #
aprimIntGt :: RefAtom Source #
aprimIntGe :: RefAtom Source #
gprimIntegerQuotRem :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (Tuple2 Integer Integer))) Source #
auserError :: RefAtom Source #
awriteFile :: RefAtom Source #