Hat.PreludeBasic

Documentation

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

Minimal complete definition

(|==), (|/=)

Methods

(!==), (!/=) :: RefSrcPos -> RefExp -> R (Fun a (Fun a Bool))

(|==), (|/=) :: R (Fun a (Fun a Bool))

Instances

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

Minimal complete definition

scompare, (|<), (|>), (|>=), (|<=), smax, smin

Methods

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))

Instances

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)

class Enum a where

Minimal complete definition

gtoEnum, gfromEnum, senumFrom, senumFromThen, senumFromTo, senumFromThenTo

Methods

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))))

Instances

Enum Bool

Enum Char

Enum Double

Enum Float

Enum Int

Enum Integer

Enum Tuple0

Enum Ordering

Enum SeekMode

Enum IOMode

Enum Day

Enum Month

Enum GeneralCategory

Integral a => Enum (Ratio a)

class Bounded a where

Minimal complete definition

gminBound, gmaxBound

Methods

gminBound :: RefSrcPos -> RefExp -> R a

sminBound :: R a

gmaxBound :: RefSrcPos -> RefExp -> R a

smaxBound :: R a

Instances

Bounded Bool

Bounded Char

Bounded Int

Bounded Tuple0

Bounded Ordering

Bounded SeekMode

Bounded IOMode

Bounded Day

Bounded Month

Bounded GeneralCategory

(Bounded a, Bounded b) => Bounded (Tuple2 a b)

(Bounded a, Bounded b, Bounded c) => Bounded (Tuple3 a b c)

(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (Tuple4 a b c d)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (Tuple5 a b c d e)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (Tuple6 a b c d e f)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (Tuple7 a b c d e f g)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (Tuple8 a b c d e f g h)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (Tuple9 a b c d e f g h i)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (Tuple10 a b c d e f g h i j)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (Tuple11 a b c d e f g h i j k)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (Tuple12 a b c d e f g h i j k l)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (Tuple13 a b c d e f g h i j k l m)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (Tuple14 a b c d e f g h i j k l m n)

(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (Tuple15 a b c d e f g h i j k l m n o)

class (Eq a, Show a) => Num a where

Minimal complete definition

(!+), (!*), (|-), snegate, gabs, gsignum, gfromInteger

Methods

(!+), (!*), (!-) :: 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)

Instances

Num Double

Num Float

Num Int

Num Integer

Integral a => Num (Ratio a)

RealFloat a => Num (Complex a)

class (Num a, Ord a) => Real a where

Minimal complete definition

gtoRational

Methods

gtoRational :: RefSrcPos -> RefExp -> R (Fun a Rational)

stoRational :: R (Fun a Rational)

Instances

Real Double

Real Float

Real Int

Real Integer

Integral a => Real (Ratio a)

class (Real a, Enum a) => Integral a where

Minimal complete definition

squot, srem, sdiv, smod, gquotRem, sdivMod, gtoInteger

Methods

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)

Instances

Integral Int

Integral Integer

class Num a => Fractional a where

Minimal complete definition

(|/), srecip, gfromRational

Methods

(!/) :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))

(|/) :: R (Fun a (Fun a a))

grecip :: RefSrcPos -> RefExp -> R (Fun a a)

srecip :: R (Fun a a)

gfromRational :: RefSrcPos -> RefExp -> R (Fun Rational a)

sfromRational :: R (Fun Rational a)

Instances

Fractional Double

Fractional Float

Integral a => Fractional (Ratio a)

RealFloat a => Fractional (Complex a)

class Fractional a => Floating a where

Minimal complete definition

gpi, gexp, glog, ssqrt, (|**), slogBase, gsin, gcos, stan, gasin, gatan, gacos, gsinh, gcosh, stanh, gasinh, gatanh, gacosh

Methods

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)

Instances

Floating Double

Floating Float

RealFloat a => Floating (Complex a)

class (Real a, Fractional a) => RealFrac a where

Minimal complete definition

gproperFraction, struncate, sround, sceiling, sfloor

Methods

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)

Instances

RealFrac Double

RealFrac Float

Integral a => RealFrac (Ratio a)

class (RealFrac a, Floating a) => RealFloat a where

Minimal complete definition

gfloatRadix, gfloatDigits, gfloatRange, gdecodeFloat, gencodeFloat, sexponent, ssignificand, sscaleFloat, gisNaN, gisIEEE, gisNegativeZero, gisDenormalized, gisInfinite, satan2

Methods

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))

Instances

RealFloat Double

RealFloat Float

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

Minimal complete definition

gfmap

Methods

gfmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (f a) (f b)))

sfmap :: R (Fun (Fun a b) (Fun (f a) (f b)))

Instances

Functor List

Functor IO

Functor Maybe

Ix a => Functor (Array a)

class Monad m where

Minimal complete definition

(!>>=), (|>>), greturn, sfail

Methods

(!>>=) :: 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))

Instances

Monad List

Monad IO

Monad Maybe

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

Constructors

Nothing

Just (R a)

Instances

Monad Maybe

Functor Maybe

MonadPlus Maybe

WrapVal (Maybe a)

Show a => Show (Maybe a)

Read a => Read (Maybe a)

Ord a => Ord (Maybe a)

Eq a => Eq (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

Constructors

Left (R a)

Right (R b)

Instances

WrapVal (Either a b)

(Show a, Show b) => Show (Either a b)

(Read a, Read b) => Read (Either a b)

(Ord a, Ord b) => Ord (Either a b)

(Eq a, Eq b) => Eq (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

Constructors

LT

EQ

GT

Instances

WrapVal Ordering

Show Ordering

Read Ordering

Bounded Ordering

Enum Ordering

Ord Ordering

Eq Ordering

Ix 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

Minimal complete definition

greadsPrec

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS a))

sreadsPrec :: R (Fun Int (ReadS a))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List a))

sreadList :: R (ReadS (List a))

Instances

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)

class Show a where

Minimal complete definition

sshowsPrec, sshow, sshowList

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun a ShowS))

sshowsPrec :: R (Fun Int (Fun a ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun a String)

sshow :: R (Fun a String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List a) ShowS)

sshowList :: R (Fun (List a) ShowS)

Instances

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)

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

Constructors

FFExponent

FFFixed

FFGeneric

Instances

WrapVal 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

Constructors

!(R a) :% !(R a)

Instances

WrapVal (Ratio a)

Integral a => Show (Ratio a)

(Read a, Integral a) => Read (Ratio a)

Integral a => RealFrac (Ratio a)

Integral a => Fractional (Ratio a)

Integral a => Real (Ratio a)

Integral a => Num (Ratio a)

Integral a => Enum (Ratio a)

Integral a => Ord (Ratio a)

Eq a => Eq (Ratio a)

type Rational = Ratio Integer

type Rational___1 = Ratio Integer

greduce :: Integral b => RefSrcPos -> RefExp -> R (Fun b (Fun b (Ratio b)))

hreduce :: Integral b => R b -> R b -> RefExp -> R (Ratio b)

(!%) :: Integral a => RefSrcPos -> RefExp -> R (Fun a (Fun a (Ratio a)))

(*%) :: Integral a => R a -> R a -> RefExp -> R (Ratio a)

gnumerator :: Integral a => RefSrcPos -> RefExp -> R (Fun (Ratio a) a)

hnumerator :: Integral a => R (Ratio a) -> RefExp -> R a

gdenominator :: Integral a => RefSrcPos -> RefExp -> R (Fun (Ratio a) a)

hdenominator :: Integral a => R (Ratio a) -> RefExp -> R a

gapproxRational :: RealFrac a => RefSrcPos -> RefExp -> R (Fun a (Fun a Rational))

happroxRational :: RealFrac a => R a -> R a -> RefExp -> R Rational

aEQ :: RefAtom

aFFExponent :: RefAtom

aFFFixed :: RefAtom

aFFGeneric :: RefAtom

aGT :: RefAtom

aJust :: RefAtom

aLT :: RefAtom

aLeft :: RefAtom

aNothing :: RefAtom

aRight :: RefAtom

a_filter :: RefAtom

a_foldr :: RefAtom

aall :: RefAtom

aalt :: RefAtom

aand :: RefAtom

aany :: RefAtom

aapproxRational :: RefAtom

aasTypeOf :: RefAtom

aasciiTab :: RefAtom

abreak :: RefAtom

achr :: RefAtom

aconcat :: RefAtom

aconcatMap :: RefAtom

aconst :: RefAtom

acurry :: RefAtom

acycle :: RefAtom

adenominator :: RefAtom

adigitToInt :: RefAtom

adrop :: RefAtom

adropWhile :: RefAtom

aeither :: RefAtom

aelem :: RefAtom

aeven :: RefAtom

aexpt :: RefAtom

aexpts :: RefAtom

afilter :: RefAtom

aflip :: RefAtom

afloatToDigits :: RefAtom

afoldl :: RefAtom

afoldl1 :: RefAtom

afoldr :: RefAtom

afoldr1 :: RefAtom

aformatRealFloat :: RefAtom

afromIntegral :: RefAtom

afromRat :: RefAtom

afromRat' :: RefAtom

afst :: RefAtom

agcd :: RefAtom

agetLine :: RefAtom

aguard :: RefAtom

ahead :: RefAtom

aid :: RefAtom

ainit :: RefAtom

aintEnumFromByTo :: RefAtom

aintToDigit :: RefAtom

aintegerLogBase :: RefAtom

ainteract :: RefAtom

aiterate :: RefAtom

alast :: RefAtom

alcm :: RefAtom

alength :: RefAtom

alex :: RefAtom

alexDigits :: RefAtom

alexLitChar :: RefAtom

alift :: RefAtom

alines :: RefAtom

alookup :: RefAtom

amap :: RefAtom

amapM :: RefAtom

amapM_ :: RefAtom

amaxExpt :: RefAtom

amaximum :: RefAtom

amaybe :: RefAtom

aminExpt :: RefAtom

aminimum :: RefAtom

anonnull :: RefAtom

anot :: RefAtom

anotElem :: RefAtom

anull :: RefAtom

anumerator :: RefAtom

anumericEnumFrom :: RefAtom

anumericEnumFromThen :: RefAtom

anumericEnumFromThenTo :: RefAtom

anumericEnumFromTo :: RefAtom

aodd :: RefAtom

aor :: RefAtom

aord :: RefAtom

aotherwise :: RefAtom

aprec :: RefAtom

aprint :: RefAtom

aproduct :: RefAtom

aprotectEsc :: RefAtom

aputStr :: RefAtom

aputStrLn :: RefAtom

aread :: RefAtom

areadDec :: RefAtom

areadFloat :: RefAtom

areadHex :: RefAtom

areadIO :: RefAtom

areadInt :: RefAtom

areadLitChar :: RefAtom

areadLn :: RefAtom

areadOct :: RefAtom

areadParen :: RefAtom

areadSigned :: RefAtom

areads :: RefAtom

arealToFrac :: RefAtom

areduce :: RefAtom

arepeat :: RefAtom

areplicate :: RefAtom

areverse :: RefAtom

aroundTo :: RefAtom

ascaleRat :: RefAtom

ascanl :: RefAtom

ascanl1 :: RefAtom

ascanr :: RefAtom

ascanr1 :: RefAtom

asequence :: RefAtom

asequence_ :: RefAtom

ashowChar :: RefAtom

ashowEFloat :: RefAtom

ashowFFloat :: RefAtom

ashowFloat :: RefAtom

ashowGFloat :: RefAtom

ashowHex :: RefAtom

ashowInt :: RefAtom

ashowIntAtBase :: RefAtom

ashowLitChar :: RefAtom

ashowOct :: RefAtom

ashowParen :: RefAtom

ashowSigned :: RefAtom

ashowString :: RefAtom

ashows :: RefAtom

asnd :: RefAtom

aspan :: RefAtom

asplitAt :: RefAtom

asubtract :: RefAtom

asum :: RefAtom

atail :: RefAtom

atake :: RefAtom

atakeWhile :: RefAtom

athenAp :: RefAtom

athenLex :: RefAtom

auncurry :: RefAtom

aunlines :: RefAtom

auntil :: RefAtom

aunwords :: RefAtom

aunzip :: RefAtom

aunzip3 :: RefAtom

awords :: RefAtom

ayield :: RefAtom

azip :: RefAtom

azip3 :: RefAtom

azipWith :: RefAtom

azipWith3 :: RefAtom

(+!!) :: RefAtom

(+$) :: RefAtom

(+$!) :: RefAtom

(+%) :: RefAtom

(+&&) :: RefAtom

(+#>#=*=#>#=%>**) :: RefAtom

(+++) :: RefAtom

(+#&#=*=#&#=%+-) :: RefAtom

(+.) :: RefAtom

(+#^*=*=#^*=%*/) :: RefAtom

(++>=*=+>=%+/=) :: RefAtom

(+:%) :: RefAtom

(+@^=*=@^=&#<) :: RefAtom

(+@+=*=@+=&#<=) :: RefAtom

(+=<<) :: RefAtom

(+^!=*=^!=%+==) :: RefAtom

(+@>=*=@>=&#>) :: RefAtom

(+@@=*=@@=&#>=) :: RefAtom

(+%$^=*=%$^=$@>>) :: RefAtom

(+^) :: RefAtom

(+^^) :: RefAtom

(+||) :: RefAtom

(+%+!=%=%+!=#^==) :: RefAtom

(+&#^=%=&#>=$&==) :: RefAtom

(+&^@=*=&^@=&>==) :: RefAtom

(+&@$=*=&@$=&><=) :: RefAtom

(+*!+=*#=*!+=*$==) :: RefAtom

(+*$!=*=*$#=%#>>=) :: RefAtom

(+*$@=*#=*$@=*$==) :: RefAtom

(+*&+=&=*&+=$$>>=) :: RefAtom

(+**&=$#=**&=$$==) :: RefAtom

(+*++=%=*++=$&/=) :: RefAtom

(+*+*=%=*+*=$&==) :: RefAtom

(+*+>=%=*+>=$&<) :: RefAtom

(+*^!=%=*^!=$&<=) :: RefAtom

(+*^$=%=*^$=$&>) :: RefAtom

(+*^#=%=*^#=$&>=) :: RefAtom

(+*^^=$=*^^=$@*) :: RefAtom

(+*^*=$=*^*=$^+) :: RefAtom

(+*^+=$=*^+=$@-) :: RefAtom

(++$&=%=+$&=$@/=) :: RefAtom

(++$%=%=+$%=$@==) :: RefAtom

(++$^=%=+$^=$@<) :: RefAtom

(++$@=%=+$@=$@<=) :: RefAtom

(++%!=%=+%!=$@>) :: RefAtom

(++$>=%=+$>=$@>=) :: RefAtom

(++%*=$=+%*=%!*) :: RefAtom

(++%%=$=+%%=%!+) :: RefAtom

(++%&=$=+%&=%!-) :: RefAtom

(++^+=%=+^+=$+/=) :: RefAtom

(++^*=%=+^*=$+==) :: RefAtom

(++^>=%=+^>=$+<) :: RefAtom

(++@!=%=+@!=$+<=) :: RefAtom

(++@$=%=+@$=$+>) :: RefAtom

(++@#=%=+@#=$+>=) :: RefAtom

(++@^=$=+@^=$@*) :: RefAtom

(++@*=$=+@*=$@+) :: RefAtom

(++@+=$=+@+=$@-) :: RefAtom

(++>@=%=+>@=$+/) :: RefAtom

(+^*&=%=^*&=$^/=) :: RefAtom

(+^*%=%=^*%=$^==) :: RefAtom

(+^*^=%=^*^=$^<) :: RefAtom

(+^*@=%=^*@=$^<=) :: RefAtom

(+^+!=%=^+!=$^>) :: RefAtom

(+^*>=%=^*>=$^>=) :: RefAtom

(+^+*=$=^+*=$>*) :: RefAtom

(+^+%=$=^+%=$>+) :: RefAtom

(+^+&=$=^+&=$>-) :: RefAtom

(+^^+=%=^^+=$^/) :: RefAtom

(+@@%=%=@@*=$+==) :: RefAtom

(+>!%=*=>!%=%>>>=) :: RefAtom

(+>#+=%=>#+=%>==) :: RefAtom

(+>%#=%=>%#=**==) :: RefAtom

(+>&^=%=>&^=^#==) :: RefAtom

(+>+*=%=>++=**==) :: RefAtom

(+>@^=%=>@@=++==) :: RefAtom

(+#!##=%=#!#$=^^==) :: RefAtom

(+#!&!=%=#!&$=#&==) :: RefAtom

(+#!^$=%=#!^&=$*==) :: RefAtom

(+##!^=%=##!>=%+==) :: RefAtom

(+##&&=%=##&+=&^==) :: RefAtom

(+##@%=%=##@*=*@==) :: RefAtom

(+#$$*=%=#$$^=+>==) :: RefAtom

(+#$^#=%=#$^*=#&==) :: RefAtom

(+#%$$=%=#%$+=$*==) :: RefAtom

(+%#>*=%^=%#>*=%@==) :: RefAtom

(+%$$&=*=%$$&=&%<) :: RefAtom

(+%$$%=*=%$$%=&%<=) :: RefAtom

(+%$$@=*=%$$@=*#*) :: RefAtom

(+%$$^=*=%$$^=*&+) :: RefAtom

(+%$%@=*=%$%@=&$/) :: RefAtom

data Bool :: *

Constructors

False

True

Instances

Bounded Bool

Enum Bool

Eq Bool

Ord Bool

Read Bool

Show Bool

Storable Bool

Random Bool

Show Bool

Read Bool

Bounded Bool

Enum Bool

Ord Bool

Eq Bool

Random Bool

Ix Bool

aTrue :: RefAtom

aFalse :: RefAtom

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).

Instances

Bounded Char

Enum Char

Eq Char

Ord Char

Read Char

Show Char

Storable Char

Random Char

Show Char

Read Char

Bounded Char

Enum Char

Ord Char

Eq Char

Random Char

Ix Char

data Int :: *

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.

Instances

Bounded Int

Enum Int

Eq Int

Integral Int

Num Int

Ord Int

Read Int

Real Int

Show Int

Storable Int

Random Int

Show Int

Read Int

Integral Int

Real Int

Num Int

Bounded Int

Enum Int

Ord Int

Eq Int

Random Int

Ix Int

data Integer :: *

Arbitrary-precision integers.

Instances

Enum Integer

Eq Integer

Integral Integer

Num Integer

Ord Integer

Read Integer

Real Integer

Show Integer

Random Integer

Show Integer

Read Integer

Integral Integer

Real Integer

Num Integer

Enum Integer

Ord Integer

Eq Integer

Random Integer

Ix Integer

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.

Instances

Enum Float

Eq Float

Floating Float

Fractional Float

Num Float

Ord Float

Read Float

Real Float

RealFloat Float

RealFrac Float

Show Float

Storable Float

Random Float

Show Float

Read Float

RealFloat Float

RealFrac Float

Floating Float

Fractional Float

Real Float

Num Float

Enum Float

Ord Float

Eq Float

Random Float

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.

Instances

Enum Double

Eq Double

Floating Double

Fractional Double

Num Double

Ord Double

Read Double

Real Double

RealFloat Double

RealFrac Double

Show Double

Storable Double

Random Double

Show Double

Read Double

RealFloat Double

RealFrac Double

Floating Double

Fractional Double

Real Double

Num Double

Enum Double

Ord Double

Eq Double

Random Double

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 IO a

Instances

Monad IO

Functor IO

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