Safe Haskell | None |
---|---|
Language | Haskell98 |
- g_filter :: RefSrcPos -> RefExp -> R (Fun Bool (Fun (Fun (List a) (List a)) (Fun (List a) (List a))))
- a_filter :: RefAtom
- h_filter :: R Bool -> R (Fun (List a) (List a)) -> R (List a) -> RefExp -> R (List a)
- g_foldr :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b b)) (Fun (List a) (Fun b b)))
- a_foldr :: RefAtom
- h_foldr :: R (Fun a (Fun b b)) -> R (List a) -> R b -> RefExp -> R b
- gmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (List a) (List b)))
- amap :: RefAtom
- hmap :: R (Fun a b) -> R (List a) -> RefExp -> R (List b)
- (!++) :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) (List a)))
- (+++) :: RefAtom
- (*++) :: R (List a) -> R (List a) -> RefExp -> R (List a)
- gfilter :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List a)))
- afilter :: RefAtom
- hfilter :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List a)
- gconcat :: RefSrcPos -> RefExp -> R (Fun (List (List a)) (List a))
- aconcat :: RefAtom
- hconcat :: R (List (List a)) -> RefExp -> R (List a)
- ghead :: RefSrcPos -> RefExp -> R (Fun (List a) a)
- ahead :: RefAtom
- hhead :: R (List a) -> RefExp -> R a
- glast :: RefSrcPos -> RefExp -> R (Fun (List a) a)
- alast :: RefAtom
- hlast :: R (List a) -> RefExp -> R a
- gtail :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))
- atail :: RefAtom
- htail :: R (List a) -> RefExp -> R (List a)
- ginit :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))
- ainit :: RefAtom
- hinit :: R (List a) -> RefExp -> R (List a)
- gnull :: RefSrcPos -> RefExp -> R (Fun (List a) Bool)
- anull :: RefAtom
- hnull :: R (List a) -> RefExp -> R Bool
- glength :: RefSrcPos -> RefExp -> R (Fun (List a) Int)
- alength :: RefAtom
- hlength :: R (List a) -> RefExp -> R Int
- (!!!) :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun Int a))
- (+!!) :: RefAtom
- (*!!) :: R (List a) -> R Int -> RefExp -> R a
- gfoldl :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b a)) (Fun a (Fun (List b) a)))
- afoldl :: RefAtom
- 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))
- afoldl1 :: RefAtom
- 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))))
- ascanl :: RefAtom
- 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)))
- ascanl1 :: RefAtom
- 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)))
- afoldr :: RefAtom
- 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))
- afoldr1 :: RefAtom
- 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))))
- ascanr :: RefAtom
- 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)))
- ascanr1 :: RefAtom
- 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)))
- aiterate :: RefAtom
- hiterate :: R (Fun a a) -> R a -> RefExp -> R (List a)
- grepeat :: RefSrcPos -> RefExp -> R (Fun a (List a))
- arepeat :: RefAtom
- hrepeat :: R a -> RefExp -> R (List a)
- greplicate :: RefSrcPos -> RefExp -> R (Fun Int (Fun a (List a)))
- areplicate :: RefAtom
- hreplicate :: R Int -> R a -> RefExp -> R (List a)
- gcycle :: RefSrcPos -> RefExp -> R (Fun (List a) (List a))
- acycle :: RefAtom
- hcycle :: R (List a) -> RefExp -> R (List a)
- gtake :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (List a)))
- atake :: RefAtom
- htake :: R Int -> R (List a) -> RefExp -> R (List a)
- gdrop :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (List a)))
- adrop :: RefAtom
- hdrop :: R Int -> R (List a) -> RefExp -> R (List a)
- gsplitAt :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (Tuple2 (List a) (List a))))
- asplitAt :: RefAtom
- 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)))
- atakeWhile :: RefAtom
- 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)))
- adropWhile :: RefAtom
- 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))))
- aspan :: RefAtom
- 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))))
- abreak :: RefAtom
- hbreak :: R (Fun a Bool) -> RefExp -> R (Fun (List a) (Tuple2 (List a) (List a)))
- glines :: RefSrcPos -> RefExp -> R (Fun String (List String))
- alines :: RefAtom
- hlines :: R String -> RefExp -> R (List String)
- gwords :: RefSrcPos -> RefExp -> R (Fun String (List String))
- awords :: RefAtom
- hwords :: R String -> RefExp -> R (List String)
- gunlines :: RefSrcPos -> RefExp -> R (Fun (List String) String)
- gunwords :: RefSrcPos -> RefExp -> R (Fun (List String) String)
- aunwords :: RefAtom
- 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))
- aany :: RefAtom
- hany :: R (Fun a Bool) -> RefExp -> R (Fun (List a) Bool)
- gall :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) Bool))
- aall :: RefAtom
- hall :: R (Fun a Bool) -> RefExp -> R (Fun (List a) Bool)
- gelem :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) Bool))
- aelem :: RefAtom
- helem :: Eq a => R a -> RefExp -> R (Fun (List a) Bool)
- gnotElem :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) Bool))
- anotElem :: RefAtom
- 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)))
- alookup :: RefAtom
- 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)
- amaximum :: RefAtom
- hmaximum :: Ord a => R (List a) -> RefExp -> R a
- gminimum :: Ord a => RefSrcPos -> RefExp -> R (Fun (List a) a)
- aminimum :: RefAtom
- hminimum :: Ord a => R (List a) -> RefExp -> R a
- gconcatMap :: RefSrcPos -> RefExp -> R (Fun (Fun a (List b)) (Fun (List a) (List b)))
- aconcatMap :: RefAtom
- 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))))
- azipWith :: RefAtom
- 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)))))
- azipWith3 :: RefAtom
- 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)
- aread :: RefAtom
- hread :: Read a => R String -> RefExp -> R a
- glex :: RefSrcPos -> RefExp -> R (ReadS String)
- alex :: RefAtom
- hlex :: R (ReadS___1 String) -> RefExp -> R (ReadS___2 String)
- gshowChar :: RefSrcPos -> RefExp -> R (Fun Char ShowS)
- gshowString :: RefSrcPos -> RefExp -> R (Fun String ShowS)
- greadParen :: RefSrcPos -> RefExp -> R (Fun Bool (Fun (ReadS a) (ReadS a)))
- areadParen :: RefAtom
- hreadParen :: R Bool -> R (ReadS a) -> RefExp -> R (ReadS a)
- gshowParen :: RefSrcPos -> RefExp -> R (Fun Bool (Fun ShowS ShowS))
- ashowParen :: RefAtom
- hshowParen :: R Bool -> R ShowS -> RefExp -> R ShowS
- type FilePath = String
- type IOError = IOException
- 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)
- gputStr :: RefSrcPos -> RefExp -> R (Fun String (IO Tuple0))
- aputStr :: RefAtom
- hputStr :: R String -> RefExp -> R (IO Tuple0)
- gputStrLn :: RefSrcPos -> RefExp -> R (Fun String (IO Tuple0))
- aputStrLn :: RefAtom
- hputStrLn :: R String -> RefExp -> R (IO Tuple0)
- gprint :: Show a => RefSrcPos -> RefExp -> R (Fun a (IO Tuple0))
- aprint :: RefAtom
- hprint :: Show a => R a -> RefExp -> R (IO Tuple0)
- ggetChar :: RefSrcPos -> RefExp -> R (IO Char)
- ggetLine :: RefSrcPos -> RefExp -> R (IO String)
- ggetContents :: RefSrcPos -> RefExp -> R (IO String)
- ginteract :: RefSrcPos -> RefExp -> R (Fun (Fun String String) (IO Tuple0))
- ainteract :: RefAtom
- hinteract :: R (Fun String String) -> RefExp -> R (IO Tuple0)
- 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)
- greadIO :: Read a => RefSrcPos -> RefExp -> R (Fun String (IO a))
- areadIO :: RefAtom
- hreadIO :: Read a => R String -> RefExp -> R (IO a)
- greadLn :: Read a => RefSrcPos -> RefExp -> R (IO a)
- data Bool :: *
- aFalse :: RefAtom
- aTrue :: RefAtom
- data Maybe a
- aNothing :: RefAtom
- aJust :: RefAtom
- data Either a b
- aLeft :: RefAtom
- aRight :: RefAtom
- data Ordering
- aLT :: RefAtom
- aEQ :: RefAtom
- aGT :: RefAtom
- data Char :: *
- type String = List Char
- data Int :: *
- data Integer :: *
- data Float :: *
- data Double :: *
- type Rational = Ratio Integer
- data IO a
- 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))
- 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))
- class Functor f where
- gmapM :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (List a) (m (List b))))
- amapM :: RefAtom
- 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)))
- amapM_ :: RefAtom
- hmapM_ :: Monad m => R (Fun a (m b)) -> R (List a) -> RefExp -> R (m Tuple0)
- 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))
- (!=<<) :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (m a) (m b)))
- (+=<<) :: RefAtom
- (*=<<) :: Monad m => R (Fun a (m b)) -> R (m a) -> RefExp -> R (m b)
- gmaybe :: RefSrcPos -> RefExp -> R (Fun b (Fun (Fun a b) (Fun (Maybe a) b)))
- amaybe :: RefAtom
- hmaybe :: R b -> R (Fun a b) -> R (Maybe a) -> RefExp -> R b
- geither :: RefSrcPos -> RefExp -> R (Fun (Fun a c) (Fun (Fun b c) (Fun (Either a b) c)))
- aeither :: RefAtom
- heither :: R (Fun a c) -> R (Fun b c) -> R (Either a b) -> RefExp -> R c
- (!&&) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))
- (+&&) :: RefAtom
- (*&&) :: R Bool -> R Bool -> RefExp -> R Bool
- (!||) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))
- (+||) :: RefAtom
- (*||) :: R Bool -> R Bool -> RefExp -> R Bool
- gnot :: RefSrcPos -> RefExp -> R (Fun Bool Bool)
- anot :: RefAtom
- hnot :: R Bool -> RefExp -> R Bool
- gotherwise :: RefSrcPos -> RefExp -> R Bool
- gsubtract :: Num a => RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- geven :: Integral a => RefSrcPos -> RefExp -> R (Fun a Bool)
- aeven :: RefAtom
- 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))
- agcd :: RefAtom
- hgcd :: Integral a => R a -> R a -> RefExp -> R a
- glcm :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- alcm :: RefAtom
- hlcm :: Integral a => R a -> R a -> RefExp -> R a
- (!^) :: (Num a, Integral b) => RefSrcPos -> RefExp -> R (Fun a (Fun b a))
- (+^) :: RefAtom
- (*^) :: (Num a, Integral b) => R a -> R b -> RefExp -> R a
- (!^^) :: (Fractional a, Integral b) => RefSrcPos -> RefExp -> R (Fun a (Fun b a))
- (+^^) :: RefAtom
- (*^^) :: (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)
- gfst :: RefSrcPos -> RefExp -> R (Fun (Tuple2 a b) a)
- afst :: RefAtom
- hfst :: R (Tuple2 a b) -> RefExp -> R a
- gsnd :: RefSrcPos -> RefExp -> R (Fun (Tuple2 a b) b)
- asnd :: RefAtom
- hsnd :: R (Tuple2 a b) -> RefExp -> R b
- gcurry :: RefSrcPos -> RefExp -> R (Fun (Fun (Tuple2 a b) c) (Fun a (Fun b c)))
- acurry :: RefAtom
- 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))
- auncurry :: RefAtom
- huncurry :: R (Fun a (Fun b c)) -> R (Tuple2 a b) -> RefExp -> R c
- gid :: RefSrcPos -> RefExp -> R (Fun a a)
- aid :: RefAtom
- hid :: R a -> RefExp -> R a
- gconst :: RefSrcPos -> RefExp -> R (Fun a (Fun b a))
- aconst :: RefAtom
- hconst :: R a -> R b -> RefExp -> R a
- (!.) :: RefSrcPos -> RefExp -> R (Fun (Fun b c) (Fun (Fun a b) (Fun a c)))
- (+.) :: RefAtom
- (*.) :: 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)))
- aflip :: RefAtom
- hflip :: R (Fun a (Fun b c)) -> R b -> R a -> RefExp -> R c
- (!$) :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun a b))
- (+$) :: RefAtom
- (*$) :: R (Fun a b) -> R a -> RefExp -> R b
- guntil :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (Fun a a) (Fun a a)))
- auntil :: RefAtom
- huntil :: R (Fun a Bool) -> R (Fun a a) -> R a -> RefExp -> R a
- gasTypeOf :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))
- 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
- (!$!) :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun a b))
- (+$!) :: RefAtom
- (*$!) :: R (Fun a b) -> R a -> RefExp -> R b
Documentation
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) |
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.
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.
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
(!>>=) :: 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
grealToFrac :: (Real a, Fractional b) => RefSrcPos -> RefExp -> R (Fun a b) Source
gundefined :: RefSrcPos -> RefExp -> R a Source