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)

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

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

gmax, gmin :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))

scompare :: R (Fun a (Fun a Ordering))

(|<), (|>), (|>=), (|<=) :: R (Fun a (Fun a Bool))

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, stoEnum, sfromEnum, senumFrom, senumFromThen, senumFromTo, senumFromThenTo

Methods

gsucc, gpred :: RefSrcPos -> RefExp -> R (Fun a a)

gtoEnum :: RefSrcPos -> RefExp -> R (Fun Int a)

gfromEnum :: RefSrcPos -> RefExp -> R (Fun a Int)

genumFrom :: RefSrcPos -> RefExp -> R (Fun a (List a))

genumFromThen :: RefSrcPos -> RefExp -> R (Fun a (Fun a (List a)))

genumFromTo :: RefSrcPos -> RefExp -> R (Fun a (Fun a (List a)))

genumFromThenTo :: RefSrcPos -> RefExp -> R (Fun a (Fun a (Fun a (List a))))

ssucc, spred :: R (Fun a a)

stoEnum :: R (Fun Int a)

sfromEnum :: R (Fun a Int)

senumFrom :: R (Fun a (List a))

senumFromThen :: R (Fun a (Fun a (List a)))

senumFromTo :: R (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

Methods

gminBound :: RefSrcPos -> RefExp -> R a

gmaxBound :: RefSrcPos -> RefExp -> R a

sminBound :: 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

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

Methods

(!+), (!*), (!-) :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))

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

gabs, gsignum :: RefSrcPos -> RefExp -> R (Fun a a)

gfromInteger :: RefSrcPos -> RefExp -> R (Fun Integer a)

(|+), (|*), (|-) :: R (Fun a (Fun a a))

snegate :: R (Fun a a)

sabs, ssignum :: R (Fun a 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

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

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

Methods

gquot, grem :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))

gdiv, gmod :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))

gquotRem, gdivMod :: RefSrcPos -> RefExp -> R (Fun a (Fun a (Tuple2 a a)))

gtoInteger :: RefSrcPos -> RefExp -> R (Fun a Integer)

squot, srem :: R (Fun a (Fun a a))

sdiv, smod :: R (Fun a (Fun a a))

squotRem, sdivMod :: R (Fun a (Fun a (Tuple2 a a)))

stoInteger :: R (Fun a Integer)

Instances

Integral Int

Integral Integer

class Num a => Fractional a where

Minimal complete definition

gfromRational, (|/), srecip, sfromRational

Methods

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

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

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

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

srecip :: R (Fun a 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, gsin, gcos, gasin, gatan, gacos, gsinh, gcosh, gasinh, gatanh, gacosh, spi, sexp, ssqrt, slog, (|**), slogBase, ssin, stan, scos, sasin, satan, sacos, ssinh, stanh, scosh, sasinh, satanh, sacosh

Methods

gpi :: RefSrcPos -> RefExp -> R a

gexp, gsqrt, glog :: RefSrcPos -> RefExp -> R (Fun a a)

(!**), glogBase :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))

gsin, gtan, gcos :: RefSrcPos -> RefExp -> R (Fun a a)

gasin, gatan, gacos :: RefSrcPos -> RefExp -> R (Fun a a)

gsinh, gtanh, gcosh :: RefSrcPos -> RefExp -> R (Fun a a)

gasinh, gatanh, gacosh :: RefSrcPos -> RefExp -> R (Fun a a)

spi :: R a

sexp, ssqrt, slog :: R (Fun a a)

(|**), slogBase :: R (Fun a (Fun a a))

ssin, stan, scos :: R (Fun a a)

sasin, satan, sacos :: R (Fun a a)

ssinh, stanh, scosh :: 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, sproperFraction, struncate, sround, sceiling, sfloor

Methods

gproperFraction :: Integral b => RefSrcPos -> RefExp -> R (Fun a (Tuple2 b a))

gtruncate, ground :: Integral b => RefSrcPos -> RefExp -> R (Fun a b)

gceiling, gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun a b)

sproperFraction :: Integral b => R (Fun a (Tuple2 b a))

struncate, sround :: Integral b => 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, gisNaN, gisIEEE, gisNegativeZero, gisDenormalized, gisInfinite, sfloatRadix, sfloatDigits, sfloatRange, sdecodeFloat, sencodeFloat, sexponent, ssignificand, sscaleFloat, sisNaN, sisIEEE, sisNegativeZero, sisDenormalized, sisInfinite, satan2

Methods

gfloatRadix :: RefSrcPos -> RefExp -> R (Fun a Integer)

gfloatDigits :: RefSrcPos -> RefExp -> R (Fun a Int)

gfloatRange :: RefSrcPos -> RefExp -> R (Fun a (Tuple2 Int Int))

gdecodeFloat :: RefSrcPos -> RefExp -> R (Fun a (Tuple2 Integer Int))

gencodeFloat :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int a))

gexponent :: RefSrcPos -> RefExp -> R (Fun a Int)

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

gscaleFloat :: RefSrcPos -> RefExp -> R (Fun Int (Fun a a))

gisNaN, gisIEEE, gisNegativeZero, gisDenormalized, gisInfinite :: RefSrcPos -> RefExp -> R (Fun a Bool)

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

sfloatRadix :: R (Fun a Integer)

sfloatDigits :: R (Fun a Int)

sfloatRange :: R (Fun a (Tuple2 Int Int))

sdecodeFloat :: R (Fun a (Tuple2 Integer Int))

sencodeFloat :: R (Fun Integer (Fun Int a))

sexponent :: R (Fun a Int)

ssignificand :: R (Fun a a)

sscaleFloat :: R (Fun Int (Fun a a))

sisNaN, sisIEEE, sisNegativeZero, sisDenormalized, sisInfinite :: R (Fun a Bool)

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

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, (|>>=), (|>>), sreturn, sfail

Methods

(!>>=) :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (Fun a (m b)) (m b)))

(!>>) :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (m b) (m b)))

greturn :: RefSrcPos -> RefExp -> R (Fun a (m a))

gfail :: RefSrcPos -> RefExp -> R (Fun String (m a))

(|>>=) :: R (Fun (m a) (Fun (Fun a (m b)) (m b)))

(|>>) :: R (Fun (m a) (Fun (m b) (m b)))

sreturn :: R (Fun a (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, sreadsPrec

Methods

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

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

sreadsPrec :: R (Fun Int (ReadS 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))

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

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

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

sshow :: R (Fun a String)

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

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

aNothing :: RefAtom

aJust :: RefAtom

aLeft :: RefAtom

aRight :: RefAtom

aLT :: RefAtom

aEQ :: RefAtom

aGT :: RefAtom

aFFExponent :: RefAtom

aFFFixed :: RefAtom

aFFGeneric :: RefAtom

(+:%) :: RefAtom

ayield :: RefAtom

alift :: RefAtom

athenAp :: RefAtom

athenLex :: RefAtom

aalt :: RefAtom

asubtract :: RefAtom

aeven :: RefAtom

aodd :: RefAtom

agcd :: RefAtom

alcm :: RefAtom

(+^) :: RefAtom

(+^^) :: RefAtom

afromIntegral :: RefAtom

arealToFrac :: RefAtom

asequence :: RefAtom

asequence_ :: RefAtom

amapM :: RefAtom

amapM_ :: RefAtom

(+=<<) :: RefAtom

aid :: RefAtom

aconst :: RefAtom

(+.) :: RefAtom

aflip :: RefAtom

(+$) :: RefAtom

(+$!) :: RefAtom

(+&&) :: RefAtom

(+||) :: RefAtom

anot :: RefAtom

aotherwise :: RefAtom

amaybe :: RefAtom

aeither :: RefAtom

aintEnumFromByTo :: RefAtom

anumericEnumFrom :: RefAtom

anumericEnumFromThen :: RefAtom

anumericEnumFromTo :: RefAtom

anumericEnumFromThenTo :: RefAtom

afst :: RefAtom

asnd :: RefAtom

acurry :: RefAtom

auncurry :: RefAtom

auntil :: RefAtom

aasTypeOf :: RefAtom

a_foldr :: RefAtom

a_filter :: RefAtom

amap :: RefAtom

(+++) :: RefAtom

afilter :: RefAtom

aconcat :: RefAtom

ahead :: RefAtom

alast :: RefAtom

atail :: RefAtom

ainit :: RefAtom

anull :: RefAtom

alength :: RefAtom

(+!!) :: RefAtom

afoldl :: RefAtom

afoldl1 :: RefAtom

ascanl :: RefAtom

ascanl1 :: RefAtom

afoldr :: RefAtom

afoldr1 :: RefAtom

ascanr :: RefAtom

ascanr1 :: RefAtom

aiterate :: RefAtom

arepeat :: RefAtom

areplicate :: RefAtom

acycle :: RefAtom

atake :: RefAtom

adrop :: RefAtom

asplitAt :: RefAtom

atakeWhile :: RefAtom

adropWhile :: RefAtom

aspan :: RefAtom

abreak :: RefAtom

alines :: RefAtom

awords :: RefAtom

aunlines :: RefAtom

aunwords :: RefAtom

areverse :: RefAtom

aand :: RefAtom

aor :: RefAtom

aany :: RefAtom

aall :: RefAtom

aelem :: RefAtom

anotElem :: RefAtom

alookup :: RefAtom

asum :: RefAtom

aproduct :: RefAtom

amaximum :: RefAtom

aminimum :: RefAtom

aconcatMap :: RefAtom

azip :: RefAtom

azip3 :: RefAtom

azipWith :: RefAtom

azipWith3 :: RefAtom

aunzip :: RefAtom

aunzip3 :: RefAtom

areads :: RefAtom

ashows :: RefAtom

aread :: RefAtom

ashowChar :: RefAtom

ashowString :: RefAtom

ashowParen :: RefAtom

areadParen :: RefAtom

alex :: RefAtom

aputStr :: RefAtom

aputStrLn :: RefAtom

aprint :: RefAtom

agetLine :: RefAtom

ainteract :: RefAtom

areadIO :: RefAtom

areadLn :: RefAtom

adigitToInt :: RefAtom

aintToDigit :: RefAtom

aord :: RefAtom

achr :: RefAtom

areadLitChar :: RefAtom

ashowLitChar :: RefAtom

aprotectEsc :: RefAtom

aasciiTab :: RefAtom

alexLitChar :: RefAtom

afromRat :: RefAtom

afromRat' :: RefAtom

ascaleRat :: RefAtom

aminExpt :: RefAtom

amaxExpt :: RefAtom

aexpt :: RefAtom

aexpts :: RefAtom

aintegerLogBase :: RefAtom

ashowSigned :: RefAtom

ashowOct :: RefAtom

ashowInt :: RefAtom

ashowHex :: RefAtom

ashowIntAtBase :: RefAtom

areadSigned :: RefAtom

areadInt :: RefAtom

areadDec :: RefAtom

areadOct :: RefAtom

areadHex :: RefAtom

ashowEFloat :: RefAtom

ashowFFloat :: RefAtom

ashowGFloat :: RefAtom

ashowFloat :: RefAtom

aformatRealFloat :: RefAtom

aroundTo :: RefAtom

afloatToDigits :: RefAtom

areadFloat :: RefAtom

alexDigits :: RefAtom

anonnull :: RefAtom

aprec :: RefAtom

areduce :: RefAtom

(+%) :: RefAtom

anumerator :: RefAtom

adenominator :: RefAtom

aapproxRational :: RefAtom

data Fun a b

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

Constructors

Cons (R a) (R (List a))

List

Instances

Monad List

Functor List

MonadPlus List

Show a => Show (List a)

Read a => Read (List a)

Ord a => Ord (List a)

Eq a => Eq (List a)

aCons :: RefAtom

aList :: RefAtom

data IO a

Instances

Monad IO

Functor IO

data Tuple0

Constructors

Tuple0

Instances

Show Tuple0

Read Tuple0

Bounded Tuple0

Enum Tuple0

Ord Tuple0

Eq Tuple0

Ix Tuple0

aTuple0 :: RefAtom

data Tuple2 a b

Constructors

Tuple2 (R a) (R b)

Instances

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

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

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

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

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

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

aTuple2 :: RefAtom

data Tuple3 a b c

Constructors

Tuple3 (R a) (R b) (R c)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3) => Ix (Tuple3 a1 a2 a3)

aTuple3 :: RefAtom

data Tuple4 a b c d

Constructors

Tuple4 (R a) (R b) (R c) (R d)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4) => Ix (Tuple4 a1 a2 a3 a4)

aTuple4 :: RefAtom

data Tuple5 a b c d e

Constructors

Tuple5 (R a) (R b) (R c) (R d) (R e)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5) => Ix (Tuple5 a1 a2 a3 a4 a5)

aTuple5 :: RefAtom

data Tuple6 a b c d e f

Constructors

Tuple6 (R a) (R b) (R c) (R d) (R e) (R f)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6) => Ix (Tuple6 a1 a2 a3 a4 a5 a6)

aTuple6 :: RefAtom

data Tuple7 a b c d e f g

Constructors

Tuple7 (R a) (R b) (R c) (R d) (R e) (R f) (R g)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7) => Ix (Tuple7 a1 a2 a3 a4 a5 a6 a7)

aTuple7 :: RefAtom

data Tuple8 a b c d e f g h

Constructors

Tuple8 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8) => Ix (Tuple8 a1 a2 a3 a4 a5 a6 a7 a8)

aTuple8 :: RefAtom

data Tuple9 a b c d e f g h i

Constructors

Tuple9 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9) => Ix (Tuple9 a1 a2 a3 a4 a5 a6 a7 a8 a9)

aTuple9 :: RefAtom

data Tuple10 a b c d e f g h i j

Constructors

Tuple10 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix a10) => Ix (Tuple10 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10)

aTuple10 :: RefAtom

data Tuple11 a b c d e f g h i j k

Constructors

Tuple11 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j) (R k)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix a10, Ix a11) => Ix (Tuple11 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11)

aTuple11 :: RefAtom

data Tuple12 a b c d e f g h i j k l

Constructors

Tuple12 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j) (R k) (R l)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix a10, Ix a11, Ix a12) => Ix (Tuple12 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12)

aTuple12 :: RefAtom

data Tuple13 a b c d e f g h i j k l m

Constructors

Tuple13 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j) (R k) (R l) (R m)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix a10, Ix a11, Ix a12, Ix a13) => Ix (Tuple13 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13)

aTuple13 :: RefAtom

data Tuple14 a b c d e f g h i j k l m n

Constructors

Tuple14 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j) (R k) (R l) (R m) (R n)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix a10, Ix a11, Ix a12, Ix a13, Ix a14) => Ix (Tuple14 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14)

aTuple14 :: RefAtom

data Tuple15 a b c d e f g h i j k l m n o

Constructors

Tuple15 (R a) (R b) (R c) (R d) (R e) (R f) (R g) (R h) (R i) (R j) (R k) (R l) (R m) (R n) (R o)

Instances

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

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

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

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

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

(Ix a1, Ix a2, Ix a3, Ix a4, Ix a5, Ix a6, Ix a7, Ix a8, Ix a9, Ix a10, Ix a11, Ix a12, Ix a13, Ix a14, Ix a15) => Ix (Tuple15 a1 a2 a3 a4 a5 a6 a7 a8 a9 a10 a11 a12 a13 a14 a15)

aTuple15 :: RefAtom

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