Hat.Prelude

Documentation

g_filter :: RefSrcPos -> RefExp -> R (Fun Bool (Fun (Fun (List a) (List a)) (Fun (List a) (List a))))

a_filter :: RefAtom

h_filter :: R Bool -> R (Fun (List a) (List a)) -> R (List a) -> RefExp -> R (List a)

g_foldr :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b b)) (Fun (List a) (Fun b b)))

a_foldr :: RefAtom

h_foldr :: R (Fun a (Fun b b)) -> R (List a) -> R b -> RefExp -> R b

gmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (List a) (List b)))

amap :: RefAtom

hmap :: R (Fun a b) -> R (List a) -> RefExp -> R (List b)

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

(+++) :: RefAtom

(*++) :: R (List a) -> R (List a) -> RefExp -> R (List a)

gfilter :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List a)))

afilter :: RefAtom

hfilter :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List a)

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

aconcat :: RefAtom

hconcat :: R (List (List a)) -> RefExp -> R (List a)

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

ahead :: RefAtom

hhead :: R (List a) -> RefExp -> R a

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

alast :: RefAtom

hlast :: R (List a) -> RefExp -> R a

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

atail :: RefAtom

htail :: R (List a) -> RefExp -> R (List a)

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

ainit :: RefAtom

hinit :: R (List a) -> RefExp -> R (List a)

gnull :: RefSrcPos -> RefExp -> R (Fun (List a) Bool)

anull :: RefAtom

hnull :: R (List a) -> RefExp -> R Bool

glength :: RefSrcPos -> RefExp -> R (Fun (List a) Int)

alength :: RefAtom

hlength :: R (List a) -> RefExp -> R Int

(!!!) :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun Int a))

(+!!) :: RefAtom

(*!!) :: R (List a) -> R Int -> RefExp -> R a

gfoldl :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b a)) (Fun a (Fun (List b) a)))

afoldl :: RefAtom

hfoldl :: R (Fun a (Fun b a)) -> R a -> R (List b) -> RefExp -> R a

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

afoldl1 :: RefAtom

hfoldl1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R a

gscanl :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b a)) (Fun a (Fun (List b) (List a))))

ascanl :: RefAtom

hscanl :: R (Fun a (Fun b a)) -> R a -> R (List b) -> RefExp -> R (List a)

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

ascanl1 :: RefAtom

hscanl1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R (List a)

gfoldr :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b b)) (Fun b (Fun (List a) b)))

afoldr :: RefAtom

hfoldr :: R (Fun a (Fun b b)) -> R b -> R (List a) -> RefExp -> R b

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

afoldr1 :: RefAtom

hfoldr1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R a

gscanr :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b b)) (Fun b (Fun (List a) (List b))))

ascanr :: RefAtom

hscanr :: R (Fun a (Fun b b)) -> R b -> R (List a) -> RefExp -> R (List b)

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

ascanr1 :: RefAtom

hscanr1 :: R (Fun a (Fun a a)) -> R (List a) -> RefExp -> R (List a)

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

aiterate :: RefAtom

hiterate :: R (Fun a a) -> R a -> RefExp -> R (List a)

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

arepeat :: RefAtom

hrepeat :: R a -> RefExp -> R (List a)

greplicate :: RefSrcPos -> RefExp -> R (Fun Int (Fun a (List a)))

areplicate :: RefAtom

hreplicate :: R Int -> R a -> RefExp -> R (List a)

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

acycle :: RefAtom

hcycle :: R (List a) -> RefExp -> R (List a)

gtake :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (List a)))

atake :: RefAtom

htake :: R Int -> R (List a) -> RefExp -> R (List a)

gdrop :: RefSrcPos -> RefExp -> R (Fun Int (Fun (List a) (List a)))

adrop :: RefAtom

hdrop :: R Int -> R (List a) -> RefExp -> R (List a)

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

asplitAt :: RefAtom

hsplitAt :: R Int -> R (List a) -> RefExp -> R (Tuple2 (List a) (List a))

gtakeWhile :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List a)))

atakeWhile :: RefAtom

htakeWhile :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List a)

gdropWhile :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (List a)))

adropWhile :: RefAtom

hdropWhile :: R (Fun a Bool) -> R (List a) -> RefExp -> R (List a)

gspan :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Tuple2 (List a) (List a))))

aspan :: RefAtom

hspan :: R (Fun a Bool) -> R (List a) -> RefExp -> R (Tuple2 (List a) (List a))

gbreak :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) (Tuple2 (List a) (List a))))

abreak :: RefAtom

hbreak :: R (Fun a Bool) -> RefExp -> R (Fun (List a) (Tuple2 (List a) (List a)))

glines :: RefSrcPos -> RefExp -> R (Fun String (List String))

alines :: RefAtom

hlines :: R String -> RefExp -> R (List String)

gwords :: RefSrcPos -> RefExp -> R (Fun String (List String))

awords :: RefAtom

hwords :: R String -> RefExp -> R (List String)

gunlines :: RefSrcPos -> RefExp -> R (Fun (List String) String)

gunwords :: RefSrcPos -> RefExp -> R (Fun (List String) String)

aunwords :: RefAtom

hunwords :: R (List String) -> RefExp -> R String

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

gand :: RefSrcPos -> RefExp -> R (Fun (List Bool) Bool)

gor :: RefSrcPos -> RefExp -> R (Fun (List Bool) Bool)

gany :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) Bool))

aany :: RefAtom

hany :: R (Fun a Bool) -> RefExp -> R (Fun (List a) Bool)

gall :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (List a) Bool))

aall :: RefAtom

hall :: R (Fun a Bool) -> RefExp -> R (Fun (List a) Bool)

gelem :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) Bool))

aelem :: RefAtom

helem :: Eq a => R a -> RefExp -> R (Fun (List a) Bool)

gnotElem :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List a) Bool))

anotElem :: RefAtom

hnotElem :: Eq a => R a -> RefExp -> R (Fun (List a) Bool)

glookup :: Eq a => RefSrcPos -> RefExp -> R (Fun a (Fun (List (Tuple2 a b)) (Maybe b)))

alookup :: RefAtom

hlookup :: Eq a => R a -> R (List (Tuple2 a b)) -> RefExp -> R (Maybe b)

gsum :: Num a => RefSrcPos -> RefExp -> R (Fun (List a) a)

gproduct :: Num a => RefSrcPos -> RefExp -> R (Fun (List a) a)

gmaximum :: Ord a => RefSrcPos -> RefExp -> R (Fun (List a) a)

amaximum :: RefAtom

hmaximum :: Ord a => R (List a) -> RefExp -> R a

gminimum :: Ord a => RefSrcPos -> RefExp -> R (Fun (List a) a)

aminimum :: RefAtom

hminimum :: Ord a => R (List a) -> RefExp -> R a

gconcatMap :: RefSrcPos -> RefExp -> R (Fun (Fun a (List b)) (Fun (List a) (List b)))

aconcatMap :: RefAtom

hconcatMap :: R (Fun a (List b)) -> RefExp -> R (Fun (List a) (List b))

gzip :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (List (Tuple2 a b))))

gzip3 :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (Fun (List c) (List (Tuple3 a b c)))))

gzipWith :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b c)) (Fun (List a) (Fun (List b) (List c))))

azipWith :: RefAtom

hzipWith :: R (Fun a (Fun b c)) -> R (List a) -> R (List b) -> RefExp -> R (List c)

gzipWith3 :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b (Fun c d))) (Fun (List a) (Fun (List b) (Fun (List c) (List d)))))

azipWith3 :: RefAtom

hzipWith3 :: R (Fun a (Fun b (Fun c d))) -> R (List a) -> R (List b) -> R (List c) -> RefExp -> R (List d)

gunzip :: RefSrcPos -> RefExp -> R (Fun (List (Tuple2 a b)) (Tuple2 (List a) (List b)))

gunzip3 :: RefSrcPos -> RefExp -> R (Fun (List (Tuple3 a b c)) (Tuple3 (List a) (List b) (List c)))

type ReadS a = Fun String (List (Tuple2 a String))

type ReadS___1 a = String

type ReadS___2 a = List (Tuple2 a String)

type ShowS = Fun String String

type ShowS___1 = String

type ShowS___2 = String

class Read a where

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)

aread :: RefAtom

hread :: Read a => R String -> RefExp -> R a

glex :: RefSrcPos -> RefExp -> R (ReadS String)

alex :: RefAtom

hlex :: R (ReadS___1 String) -> RefExp -> R (ReadS___2 String)

gshowChar :: RefSrcPos -> RefExp -> R (Fun Char ShowS)

gshowString :: RefSrcPos -> RefExp -> R (Fun String ShowS)

greadParen :: RefSrcPos -> RefExp -> R (Fun Bool (Fun (ReadS a) (ReadS a)))

areadParen :: RefAtom

hreadParen :: R Bool -> R (ReadS a) -> RefExp -> R (ReadS a)

gshowParen :: RefSrcPos -> RefExp -> R (Fun Bool (Fun ShowS ShowS))

ashowParen :: RefAtom

hshowParen :: R Bool -> R ShowS -> RefExp -> R ShowS

type FilePath = String

type IOError = IOException

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.

gioError :: RefSrcPos -> RefExp -> R (Fun IOError (IO a))

aioError :: RefAtom

hioError :: R IOError -> RefExp -> R (IO b)

guserError :: RefSrcPos -> RefExp -> R (Fun String IOError)

auserError :: RefAtom

huserError :: R String -> RefExp -> R IOError

gcatch :: RefSrcPos -> RefExp -> R (Fun (IO a) (Fun (Fun IOError (IO a)) (IO a)))

acatch :: RefAtom

hcatch :: R (IO b) -> R (Fun IOError (IO b)) -> RefExp -> R (IO b)

gputChar :: RefSrcPos -> RefExp -> R (Fun Char (IO Tuple0))

aputChar :: RefAtom

hputChar :: R Char -> RefExp -> R (IO Tuple0)

gputStr :: RefSrcPos -> RefExp -> R (Fun String (IO Tuple0))

aputStr :: RefAtom

hputStr :: R String -> RefExp -> R (IO Tuple0)

gputStrLn :: RefSrcPos -> RefExp -> R (Fun String (IO Tuple0))

aputStrLn :: RefAtom

hputStrLn :: R String -> RefExp -> R (IO Tuple0)

gprint :: Show a => RefSrcPos -> RefExp -> R (Fun a (IO Tuple0))

aprint :: RefAtom

hprint :: Show a => R a -> RefExp -> R (IO Tuple0)

ggetChar :: RefSrcPos -> RefExp -> R (IO Char)

ggetLine :: RefSrcPos -> RefExp -> R (IO String)

ggetContents :: RefSrcPos -> RefExp -> R (IO String)

ginteract :: RefSrcPos -> RefExp -> R (Fun (Fun String String) (IO Tuple0))

ainteract :: RefAtom

hinteract :: R (Fun String String) -> RefExp -> R (IO Tuple0)

greadFile :: RefSrcPos -> RefExp -> R (Fun String (IO String))

areadFile :: RefAtom

hreadFile :: R String -> RefExp -> R (IO String)

gwriteFile :: RefSrcPos -> RefExp -> R (Fun String (Fun String (IO Tuple0)))

awriteFile :: RefAtom

hwriteFile :: R String -> R String -> RefExp -> R (IO Tuple0)

gappendFile :: RefSrcPos -> RefExp -> R (Fun String (Fun String (IO Tuple0)))

aappendFile :: RefAtom

happendFile :: R String -> R String -> RefExp -> R (IO Tuple0)

greadIO :: Read a => RefSrcPos -> RefExp -> R (Fun String (IO a))

areadIO :: RefAtom

hreadIO :: Read a => R String -> RefExp -> R (IO a)

greadLn :: Read a => RefSrcPos -> RefExp -> R (IO a)

data Bool :: *

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

aFalse :: RefAtom

aTrue :: RefAtom

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)

aNothing :: RefAtom

aJust :: RefAtom

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)

aLeft :: RefAtom

aRight :: RefAtom

data Ordering

Constructors

LT

EQ

GT

Instances

WrapVal Ordering

Show Ordering

Read Ordering

Bounded Ordering

Enum Ordering

Ord Ordering

Eq Ordering

Ix Ordering

aLT :: RefAtom

aEQ :: RefAtom

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

type String = List 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 Rational = Ratio Integer

data IO a

Instances

Monad IO

Functor IO

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

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

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)

gmapM :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (List a) (m (List b))))

amapM :: RefAtom

hmapM :: Monad m => R (Fun a (m b)) -> R (List a) -> RefExp -> R (m (List b))

gmapM_ :: Monad m => RefSrcPos -> RefExp -> R (Fun (Fun a (m b)) (Fun (List a) (m Tuple0)))

amapM_ :: RefAtom

hmapM_ :: Monad m => R (Fun a (m b)) -> R (List a) -> RefExp -> R (m Tuple0)

gsequence :: Monad m => RefSrcPos -> RefExp -> R (Fun (List (m a)) (m (List a)))

gsequence_ :: Monad m => RefSrcPos -> RefExp -> R (Fun (List (m a)) (m Tuple0))

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

(+=<<) :: RefAtom

(*=<<) :: Monad m => R (Fun a (m b)) -> R (m a) -> RefExp -> R (m b)

gmaybe :: RefSrcPos -> RefExp -> R (Fun b (Fun (Fun a b) (Fun (Maybe a) b)))

amaybe :: RefAtom

hmaybe :: R b -> R (Fun a b) -> R (Maybe a) -> RefExp -> R b

geither :: RefSrcPos -> RefExp -> R (Fun (Fun a c) (Fun (Fun b c) (Fun (Either a b) c)))

aeither :: RefAtom

heither :: R (Fun a c) -> R (Fun b c) -> R (Either a b) -> RefExp -> R c

(!&&) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))

(+&&) :: RefAtom

(*&&) :: R Bool -> R Bool -> RefExp -> R Bool

(!||) :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Bool))

(+||) :: RefAtom

(*||) :: R Bool -> R Bool -> RefExp -> R Bool

gnot :: RefSrcPos -> RefExp -> R (Fun Bool Bool)

anot :: RefAtom

hnot :: R Bool -> RefExp -> R Bool

gotherwise :: RefSrcPos -> RefExp -> R Bool

gsubtract :: Num a => RefSrcPos -> RefExp -> R (Fun a (Fun a a))

geven :: Integral a => RefSrcPos -> RefExp -> R (Fun a Bool)

aeven :: RefAtom

heven :: Integral a => R a -> RefExp -> R Bool

godd :: Integral a => RefSrcPos -> RefExp -> R (Fun a Bool)

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

agcd :: RefAtom

hgcd :: Integral a => R a -> R a -> RefExp -> R a

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

alcm :: RefAtom

hlcm :: Integral a => R a -> R a -> RefExp -> R a

(!^) :: (Num a, Integral b) => RefSrcPos -> RefExp -> R (Fun a (Fun b a))

(+^) :: RefAtom

(*^) :: (Num a, Integral b) => R a -> R b -> RefExp -> R a

(!^^) :: (Fractional a, Integral b) => RefSrcPos -> RefExp -> R (Fun a (Fun b a))

(+^^) :: RefAtom

(*^^) :: (Fractional a, Integral b) => R a -> R b -> RefExp -> R a

gfromIntegral :: (Integral a, Num b) => RefSrcPos -> RefExp -> R (Fun a b)

grealToFrac :: (Real a, Fractional b) => RefSrcPos -> RefExp -> R (Fun a b)

gfst :: RefSrcPos -> RefExp -> R (Fun (Tuple2 a b) a)

afst :: RefAtom

hfst :: R (Tuple2 a b) -> RefExp -> R a

gsnd :: RefSrcPos -> RefExp -> R (Fun (Tuple2 a b) b)

asnd :: RefAtom

hsnd :: R (Tuple2 a b) -> RefExp -> R b

gcurry :: RefSrcPos -> RefExp -> R (Fun (Fun (Tuple2 a b) c) (Fun a (Fun b c)))

acurry :: RefAtom

hcurry :: R (Fun (Tuple2 a b) c) -> R a -> R b -> RefExp -> R c

guncurry :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b c)) (Fun (Tuple2 a b) c))

auncurry :: RefAtom

huncurry :: R (Fun a (Fun b c)) -> R (Tuple2 a b) -> RefExp -> R c

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

aid :: RefAtom

hid :: R a -> RefExp -> R a

gconst :: RefSrcPos -> RefExp -> R (Fun a (Fun b a))

aconst :: RefAtom

hconst :: R a -> R b -> RefExp -> R a

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

(+.) :: RefAtom

(*.) :: R (Fun b c) -> R (Fun a b) -> R a -> RefExp -> R c

gflip :: RefSrcPos -> RefExp -> R (Fun (Fun a (Fun b c)) (Fun b (Fun a c)))

aflip :: RefAtom

hflip :: R (Fun a (Fun b c)) -> R b -> R a -> RefExp -> R c

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

(+$) :: RefAtom

(*$) :: R (Fun a b) -> R a -> RefExp -> R b

guntil :: RefSrcPos -> RefExp -> R (Fun (Fun a Bool) (Fun (Fun a a) (Fun a a)))

auntil :: RefAtom

huntil :: R (Fun a Bool) -> R (Fun a a) -> R a -> RefExp -> R a

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

gerror :: RefSrcPos -> RefExp -> R (Fun String z)

aerror :: RefAtom

herror :: R String -> RefExp -> a

gundefined :: RefSrcPos -> RefExp -> R a

gseq :: RefSrcPos -> RefExp -> R (Fun a (Fun b b))

aseq :: RefAtom

hseq :: R a1 -> R a -> RefExp -> R a

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

(+$!) :: RefAtom

(*$!) :: R (Fun a b) -> R a -> RefExp -> R b