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

Methods

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

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

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

sreadList :: R (ReadS (List a))

Instances

Read Bool

Methods

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

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

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

sreadList :: R (ReadS (List Bool))

Read Char

Methods

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

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

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

sreadList :: R (ReadS (List Char))

Read Double

Methods

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

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

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

sreadList :: R (ReadS (List Double))

Read Float

Methods

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

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

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

sreadList :: R (ReadS (List Float))

Read Int

Methods

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

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

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

sreadList :: R (ReadS (List Int))

Read Integer

Methods

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

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

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

sreadList :: R (ReadS (List Integer))

Read Tuple0

Methods

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

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

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

sreadList :: R (ReadS (List Tuple0))

Read Ordering

Methods

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

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

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

sreadList :: R (ReadS (List Ordering))

Read SeekMode

Methods

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

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

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

sreadList :: R (ReadS (List SeekMode))

Read BufferMode

Methods

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

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

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

sreadList :: R (ReadS (List BufferMode))

Read IOMode

Methods

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

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

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

sreadList :: R (ReadS (List IOMode))

Read ExitCode

Methods

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

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

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

sreadList :: R (ReadS (List ExitCode))

Read TimeDiff

Methods

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

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

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

sreadList :: R (ReadS (List TimeDiff))

Read CalendarTime

Methods

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

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

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

sreadList :: R (ReadS (List CalendarTime))

Read Day

Methods

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

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

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

sreadList :: R (ReadS (List Day))

Read Month

Methods

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

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

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

sreadList :: R (ReadS (List Month))

Read GeneralCategory

Methods

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

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

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

sreadList :: R (ReadS (List GeneralCategory))

Read a => Read (List a)

Methods

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

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

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

sreadList :: R (ReadS (List (List a)))

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

Methods

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

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

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

sreadList :: R (ReadS (List (Ratio a)))

Read a => Read (Maybe a)

Methods

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

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

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

sreadList :: R (ReadS (List (Maybe a)))

Read a => Read (Complex a)

Methods

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

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

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

sreadList :: R (ReadS (List (Complex a)))

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

Methods

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

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

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

sreadList :: R (ReadS (List (Tuple2 a b)))

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

Methods

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

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

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

sreadList :: R (ReadS (List (Either a b)))

(Ix a, Read a, Read b) => Read (Array a b)

Methods

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

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

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

sreadList :: R (ReadS (List (Array a b)))

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

Methods

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

sreadsPrec :: R (Fun Int (ReadS (Tuple3 a b c)))

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

sreadList :: R (ReadS (List (Tuple3 a b c)))

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

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple4 a b c d)))

sreadsPrec :: R (Fun Int (ReadS (Tuple4 a b c d)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple4 a b c d)))

sreadList :: R (ReadS (List (Tuple4 a b c d)))

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

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple5 a b c d e)))

sreadsPrec :: R (Fun Int (ReadS (Tuple5 a b c d e)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple5 a b c d e)))

sreadList :: R (ReadS (List (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)

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple6 a b c d e f)))

sreadsPrec :: R (Fun Int (ReadS (Tuple6 a b c d e f)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple6 a b c d e f)))

sreadList :: R (ReadS (List (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)

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple7 a b c d e f g)))

sreadsPrec :: R (Fun Int (ReadS (Tuple7 a b c d e f g)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple7 a b c d e f g)))

sreadList :: R (ReadS (List (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)

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple8 a b c d e f g h)))

sreadsPrec :: R (Fun Int (ReadS (Tuple8 a b c d e f g h)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple8 a b c d e f g h)))

sreadList :: R (ReadS (List (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)

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple9 a b c d e f g h i)))

sreadsPrec :: R (Fun Int (ReadS (Tuple9 a b c d e f g h i)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple9 a b c d e f g h i)))

sreadList :: R (ReadS (List (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)

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple10 a b c d e f g h i j)))

sreadsPrec :: R (Fun Int (ReadS (Tuple10 a b c d e f g h i j)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple10 a b c d e f g h i j)))

sreadList :: R (ReadS (List (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)

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple11 a b c d e f g h i j k)))

sreadsPrec :: R (Fun Int (ReadS (Tuple11 a b c d e f g h i j k)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple11 a b c d e f g h i j k)))

sreadList :: R (ReadS (List (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)

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple12 a b c d e f g h i j k l)))

sreadsPrec :: R (Fun Int (ReadS (Tuple12 a b c d e f g h i j k l)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple12 a b c d e f g h i j k l)))

sreadList :: R (ReadS (List (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)

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple13 a b c d e f g h i j k l m)))

sreadsPrec :: R (Fun Int (ReadS (Tuple13 a b c d e f g h i j k l m)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple13 a b c d e f g h i j k l m)))

sreadList :: R (ReadS (List (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)

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple14 a b c d e f g h i j k l m n)))

sreadsPrec :: R (Fun Int (ReadS (Tuple14 a b c d e f g h i j k l m n)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple14 a b c d e f g h i j k l m n)))

sreadList :: R (ReadS (List (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)

Methods

greadsPrec :: RefSrcPos -> RefExp -> R (Fun Int (ReadS (Tuple15 a b c d e f g h i j k l m n o)))

sreadsPrec :: R (Fun Int (ReadS (Tuple15 a b c d e f g h i j k l m n o)))

greadList :: RefSrcPos -> RefExp -> R (ReadS (List (Tuple15 a b c d e f g h i j k l m n o)))

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

class Show a where

Minimal complete definition

sshowsPrec, sshow, sshowList

Methods

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

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

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

sshow :: R (Fun a String)

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

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

Instances

Show Bool

Methods

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

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

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

sshow :: R (Fun Bool String)

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

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

Show Char

Methods

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

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

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

sshow :: R (Fun Char String)

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

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

Show Double

Methods

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

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

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

sshow :: R (Fun Double String)

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

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

Show Float

Methods

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

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

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

sshow :: R (Fun Float String)

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

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

Show Int

Methods

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

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

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

sshow :: R (Fun Int String)

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

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

Show Integer

Methods

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

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

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

sshow :: R (Fun Integer String)

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

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

Show Tuple0

Methods

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

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

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

sshow :: R (Fun Tuple0 String)

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

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

Show Ordering

Methods

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

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

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

sshow :: R (Fun Ordering String)

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

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

Show SeekMode

Methods

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

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

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

sshow :: R (Fun SeekMode String)

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

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

Show BufferMode

Methods

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

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

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

sshow :: R (Fun BufferMode String)

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

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

Show IOMode

Methods

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

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

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

sshow :: R (Fun IOMode String)

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

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

Show TimeLocale

Methods

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

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

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

sshow :: R (Fun TimeLocale String)

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

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

Show ExitCode

Methods

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

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

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

sshow :: R (Fun ExitCode String)

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

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

Show TimeDiff

Methods

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

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

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

sshow :: R (Fun TimeDiff String)

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

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

Show CalendarTime

Methods

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

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

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

sshow :: R (Fun CalendarTime String)

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

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

Show Day

Methods

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

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

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

sshow :: R (Fun Day String)

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

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

Show Month

Methods

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

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

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

sshow :: R (Fun Month String)

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

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

Show GeneralCategory

Methods

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

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

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

sshow :: R (Fun GeneralCategory String)

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

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

Show a => Show (List a)

Methods

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

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

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

sshow :: R (Fun (List a) String)

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

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

Integral a => Show (Ratio a)

Methods

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

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

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

sshow :: R (Fun (Ratio a) String)

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

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

Show a => Show (Maybe a)

Methods

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

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

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

sshow :: R (Fun (Maybe a) String)

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

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

Show a => Show (Complex a)

Methods

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

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

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

sshow :: R (Fun (Complex a) String)

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

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

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

Methods

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

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

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

sshow :: R (Fun (Tuple2 a b) String)

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

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

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

Methods

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

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

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

sshow :: R (Fun (Either a b) String)

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

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

(Ix a, Show a, Show b) => Show (Array a b)

Methods

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

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

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

sshow :: R (Fun (Array a b) String)

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

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

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

Methods

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

sshowsPrec :: R (Fun Int (Fun (Tuple3 a b c) ShowS))

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

sshow :: R (Fun (Tuple3 a b c) String)

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

sshowList :: R (Fun (List (Tuple3 a b c)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple4 a b c d) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple4 a b c d) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple4 a b c d) String)

sshow :: R (Fun (Tuple4 a b c d) String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple4 a b c d)) ShowS)

sshowList :: R (Fun (List (Tuple4 a b c d)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple5 a b c d e) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple5 a b c d e) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple5 a b c d e) String)

sshow :: R (Fun (Tuple5 a b c d e) String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple5 a b c d e)) ShowS)

sshowList :: R (Fun (List (Tuple5 a b c d e)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple6 a b c d e f) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple6 a b c d e f) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple6 a b c d e f) String)

sshow :: R (Fun (Tuple6 a b c d e f) String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple6 a b c d e f)) ShowS)

sshowList :: R (Fun (List (Tuple6 a b c d e f)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple7 a b c d e f g) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple7 a b c d e f g) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple7 a b c d e f g) String)

sshow :: R (Fun (Tuple7 a b c d e f g) String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple7 a b c d e f g)) ShowS)

sshowList :: R (Fun (List (Tuple7 a b c d e f g)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple8 a b c d e f g h) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple8 a b c d e f g h) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple8 a b c d e f g h) String)

sshow :: R (Fun (Tuple8 a b c d e f g h) String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple8 a b c d e f g h)) ShowS)

sshowList :: R (Fun (List (Tuple8 a b c d e f g h)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple9 a b c d e f g h i) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple9 a b c d e f g h i) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple9 a b c d e f g h i) String)

sshow :: R (Fun (Tuple9 a b c d e f g h i) String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple9 a b c d e f g h i)) ShowS)

sshowList :: R (Fun (List (Tuple9 a b c d e f g h i)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple10 a b c d e f g h i j) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple10 a b c d e f g h i j) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple10 a b c d e f g h i j) String)

sshow :: R (Fun (Tuple10 a b c d e f g h i j) String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple10 a b c d e f g h i j)) ShowS)

sshowList :: R (Fun (List (Tuple10 a b c d e f g h i j)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple11 a b c d e f g h i j k) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple11 a b c d e f g h i j k) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple11 a b c d e f g h i j k) String)

sshow :: R (Fun (Tuple11 a b c d e f g h i j k) String)

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple11 a b c d e f g h i j k)) ShowS)

sshowList :: R (Fun (List (Tuple11 a b c d e f g h i j k)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple12 a b c d e f g h i j k l) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple12 a b c d e f g h i j k l) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple12 a b c d e f g h i j k l) String)

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

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple12 a b c d e f g h i j k l)) ShowS)

sshowList :: R (Fun (List (Tuple12 a b c d e f g h i j k l)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple13 a b c d e f g h i j k l m) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple13 a b c d e f g h i j k l m) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple13 a b c d e f g h i j k l m) String)

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

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple13 a b c d e f g h i j k l m)) ShowS)

sshowList :: R (Fun (List (Tuple13 a b c d e f g h i j k l m)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple14 a b c d e f g h i j k l m n) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple14 a b c d e f g h i j k l m n) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple14 a b c d e f g h i j k l m n) String)

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

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple14 a b c d e f g h i j k l m n)) ShowS)

sshowList :: R (Fun (List (Tuple14 a b c d e f g h i j k l m n)) ShowS)

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

Methods

gshowsPrec :: RefSrcPos -> RefExp -> R (Fun Int (Fun (Tuple15 a b c d e f g h i j k l m n o) ShowS))

sshowsPrec :: R (Fun Int (Fun (Tuple15 a b c d e f g h i j k l m n o) ShowS))

gshow :: RefSrcPos -> RefExp -> R (Fun (Tuple15 a b c d e f g h i j k l m n o) String)

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

gshowList :: RefSrcPos -> RefExp -> R (Fun (List (Tuple15 a b c d e f g h i j k l m n o)) ShowS)

sshowList :: R (Fun (List (Tuple15 a b c d e f g h i j k l m n o)) ShowS)

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

Methods

minBound :: Bool

maxBound :: Bool

Enum Bool

Methods

succ :: Bool -> Bool

pred :: Bool -> Bool

toEnum :: Int -> Bool

fromEnum :: Bool -> Int

enumFrom :: Bool -> [Bool]

enumFromThen :: Bool -> Bool -> [Bool]

enumFromTo :: Bool -> Bool -> [Bool]

enumFromThenTo :: Bool -> Bool -> Bool -> [Bool]

Eq Bool

Methods

(==) :: Bool -> Bool -> Bool

(/=) :: Bool -> Bool -> Bool

Ord Bool

Methods

compare :: Bool -> Bool -> Ordering

(<) :: Bool -> Bool -> Bool

(<=) :: Bool -> Bool -> Bool

(>) :: Bool -> Bool -> Bool

(>=) :: Bool -> Bool -> Bool

max :: Bool -> Bool -> Bool

min :: Bool -> Bool -> Bool

Read Bool

Methods

readsPrec :: Int -> ReadS Bool

readList :: ReadS [Bool]

readPrec :: ReadPrec Bool

readListPrec :: ReadPrec [Bool]

Show Bool

Methods

showsPrec :: Int -> Bool -> ShowS

show :: Bool -> String

showList :: [Bool] -> ShowS

Generic Bool

Associated Types

type Rep Bool :: * -> *

Methods

from :: Bool -> Rep Bool x

to :: Rep Bool x -> Bool

Storable Bool

Methods

sizeOf :: Bool -> Int

alignment :: Bool -> Int

peekElemOff :: Ptr Bool -> Int -> IO Bool

pokeElemOff :: Ptr Bool -> Int -> Bool -> IO ()

peekByteOff :: Ptr b -> Int -> IO Bool

pokeByteOff :: Ptr b -> Int -> Bool -> IO ()

peek :: Ptr Bool -> IO Bool

poke :: Ptr Bool -> Bool -> IO ()

Random Bool

Methods

randomR :: RandomGen g => (Bool, Bool) -> g -> (Bool, g)

random :: RandomGen g => g -> (Bool, g)

randomRs :: RandomGen g => (Bool, Bool) -> g -> [Bool]

randoms :: RandomGen g => g -> [Bool]

randomRIO :: (Bool, Bool) -> IO Bool

randomIO :: IO Bool

Show Bool

Methods

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

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

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

sshow :: R (Fun Bool String)

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

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

Read Bool

Methods

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

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

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

sreadList :: R (ReadS (List Bool))

Bounded Bool

Methods

gminBound :: RefSrcPos -> RefExp -> R Bool

sminBound :: R Bool

gmaxBound :: RefSrcPos -> RefExp -> R Bool

smaxBound :: R Bool

Enum Bool

Methods

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

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

ssucc :: R (Fun Bool Bool)

spred :: R (Fun Bool Bool)

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

stoEnum :: R (Fun Int Bool)

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

sfromEnum :: R (Fun Bool Int)

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

senumFrom :: R (Fun Bool (List Bool))

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

senumFromThen :: R (Fun Bool (Fun Bool (List Bool)))

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

senumFromTo :: R (Fun Bool (Fun Bool (List Bool)))

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

senumFromThenTo :: R (Fun Bool (Fun Bool (Fun Bool (List Bool))))

Ord Bool

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Ordering))

scompare :: R (Fun Bool (Fun Bool Ordering))

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

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

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

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

(|<) :: R (Fun Bool (Fun Bool Bool))

(|<=) :: R (Fun Bool (Fun Bool Bool))

(|>=) :: R (Fun Bool (Fun Bool Bool))

(|>) :: R (Fun Bool (Fun Bool Bool))

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

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

smax :: R (Fun Bool (Fun Bool Bool))

smin :: R (Fun Bool (Fun Bool Bool))

Eq Bool

Methods

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

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

(|==) :: R (Fun Bool (Fun Bool Bool))

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

Ix Bool

Methods

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

srange :: R (Fun (Tuple2 Bool Bool) (List Bool))

gindex :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (Fun Bool Int))

sindex :: R (Fun (Tuple2 Bool Bool) (Fun Bool Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (Fun Bool Bool))

sinRange :: R (Fun (Tuple2 Bool Bool) (Fun Bool Bool))

grangeSize :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) Int)

srangeSize :: R (Fun (Tuple2 Bool Bool) Int)

Random Bool

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (Fun g (Tuple2 Bool g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Bool Bool) (Fun g (Tuple2 Bool g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Bool g))

srandom :: RandomGen g => R (Fun g (Tuple2 Bool g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (Fun g (List Bool)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Bool Bool) (Fun g (List Bool)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Bool))

srandoms :: RandomGen g => R (Fun g (List Bool))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Bool Bool) (IO Bool))

srandomRIO :: R (Fun (Tuple2 Bool Bool) (IO Bool))

grandomIO :: RefSrcPos -> RefExp -> R (IO Bool)

srandomIO :: R (IO Bool)

SingI Bool False

Methods

sing :: Sing False a

SingI Bool True

Methods

sing :: Sing True a

SingKind Bool (KProxy Bool)

Associated Types

type DemoteRep (KProxy Bool) (kparam :: KProxy (KProxy Bool)) :: *

Methods

fromSing :: Sing (KProxy Bool) a -> DemoteRep (KProxy Bool) kparam

type Rep Bool

type Rep Bool = D1 (MetaData "Bool" "GHC.Types" "ghc-prim" False) ((:+:) (C1 (MetaCons "False" PrefixI False) U1) (C1 (MetaCons "True" PrefixI False) U1))

data Sing Bool

data Sing Bool where

• STrue :: Sing Bool True
• SFalse :: Sing Bool False

type (==) Bool a b

type (==) Bool a b = EqBool a b

type DemoteRep Bool (KProxy Bool)

type DemoteRep Bool (KProxy Bool) = Bool

aFalse :: RefAtom

aTrue :: RefAtom

data Maybe a

Constructors

Nothing

Just (R a)

Instances

Monad Maybe

Methods

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

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

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

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

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

sreturn :: R (Fun a (Maybe a))

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

sfail :: R (Fun String (Maybe a))

Functor Maybe

Methods

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

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

MonadPlus Maybe

Methods

gmzero :: RefSrcPos -> RefExp -> R (Maybe a)

smzero :: R (Maybe a)

gmplus :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

smplus :: R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

WrapVal (Maybe a)

Methods

wrapVal :: RefSrcPos -> Maybe a -> RefExp -> R (Maybe a)

Show a => Show (Maybe a)

Methods

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

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

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

sshow :: R (Fun (Maybe a) String)

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

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

Read a => Read (Maybe a)

Methods

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

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

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

sreadList :: R (ReadS (List (Maybe a)))

Ord a => Ord (Maybe a)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Maybe a) Ordering))

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

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

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

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

(!>) :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Maybe a) Bool))

(|<) :: R (Fun (Maybe a) (Fun (Maybe a) Bool))

(|<=) :: R (Fun (Maybe a) (Fun (Maybe a) Bool))

(|>=) :: R (Fun (Maybe a) (Fun (Maybe a) Bool))

(|>) :: R (Fun (Maybe a) (Fun (Maybe a) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

smax :: R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

smin :: R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

Eq a => Eq (Maybe a)

Methods

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

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

(|==) :: R (Fun (Maybe a) (Fun (Maybe a) Bool))

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

aNothing :: RefAtom

aJust :: RefAtom

data Either a b

Constructors

Left (R a)

Right (R b)

Instances

WrapVal (Either a b)

Methods

wrapVal :: RefSrcPos -> Either a b -> RefExp -> R (Either a b)

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

Methods

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

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

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

sshow :: R (Fun (Either a b) String)

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

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

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

Methods

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

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

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

sreadList :: R (ReadS (List (Either a b)))

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

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Either a b) (Fun (Either a b) Ordering))

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

(!<) :: RefSrcPos -> RefExp -> R (Fun (Either a b) (Fun (Either a b) Bool))

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

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

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

(|<) :: R (Fun (Either a b) (Fun (Either a b) Bool))

(|<=) :: R (Fun (Either a b) (Fun (Either a b) Bool))

(|>=) :: R (Fun (Either a b) (Fun (Either a b) Bool))

(|>) :: R (Fun (Either a b) (Fun (Either a b) Bool))

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

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

smax :: R (Fun (Either a b) (Fun (Either a b) (Either a b)))

smin :: R (Fun (Either a b) (Fun (Either a b) (Either a b)))

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

Methods

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

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

(|==) :: R (Fun (Either a b) (Fun (Either a b) Bool))

(|/=) :: R (Fun (Either a b) (Fun (Either a b) Bool))

aLeft :: RefAtom

aRight :: RefAtom

data Ordering

Constructors

LT

EQ

GT

Instances

WrapVal Ordering

Methods

wrapVal :: RefSrcPos -> Ordering -> RefExp -> R Ordering

Show Ordering

Methods

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

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

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

sshow :: R (Fun Ordering String)

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

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

Read Ordering

Methods

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

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

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

sreadList :: R (ReadS (List Ordering))

Bounded Ordering

Methods

gminBound :: RefSrcPos -> RefExp -> R Ordering

sminBound :: R Ordering

gmaxBound :: RefSrcPos -> RefExp -> R Ordering

smaxBound :: R Ordering

Enum Ordering

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Ordering Ordering)

gpred :: RefSrcPos -> RefExp -> R (Fun Ordering Ordering)

ssucc :: R (Fun Ordering Ordering)

spred :: R (Fun Ordering Ordering)

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

stoEnum :: R (Fun Int Ordering)

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

sfromEnum :: R (Fun Ordering Int)

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

senumFrom :: R (Fun Ordering (List Ordering))

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

senumFromThen :: R (Fun Ordering (Fun Ordering (List Ordering)))

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

senumFromTo :: R (Fun Ordering (Fun Ordering (List Ordering)))

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

senumFromThenTo :: R (Fun Ordering (Fun Ordering (Fun Ordering (List Ordering))))

Ord Ordering

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Ordering))

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

(!<) :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Bool))

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

(|<) :: R (Fun Ordering (Fun Ordering Bool))

(|<=) :: R (Fun Ordering (Fun Ordering Bool))

(|>=) :: R (Fun Ordering (Fun Ordering Bool))

(|>) :: R (Fun Ordering (Fun Ordering Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Ordering))

gmin :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Ordering))

smax :: R (Fun Ordering (Fun Ordering Ordering))

smin :: R (Fun Ordering (Fun Ordering Ordering))

Eq Ordering

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Bool))

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

(|==) :: R (Fun Ordering (Fun Ordering Bool))

(|/=) :: R (Fun Ordering (Fun Ordering Bool))

Ix Ordering

Methods

grange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Ordering Ordering) (List Ordering))

srange :: R (Fun (Tuple2 Ordering Ordering) (List Ordering))

gindex :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Ordering Ordering) (Fun Ordering Int))

sindex :: R (Fun (Tuple2 Ordering Ordering) (Fun Ordering Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Ordering Ordering) (Fun Ordering Bool))

sinRange :: R (Fun (Tuple2 Ordering Ordering) (Fun Ordering Bool))

grangeSize :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Ordering Ordering) Int)

srangeSize :: R (Fun (Tuple2 Ordering Ordering) Int)

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

Methods

minBound :: Char

maxBound :: Char

Enum Char

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Eq Char

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Ord Char

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Read Char

Methods

readsPrec :: Int -> ReadS Char

readList :: ReadS [Char]

readPrec :: ReadPrec Char

readListPrec :: ReadPrec [Char]

Show Char

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Storable Char

Methods

sizeOf :: Char -> Int

alignment :: Char -> Int

peekElemOff :: Ptr Char -> Int -> IO Char

pokeElemOff :: Ptr Char -> Int -> Char -> IO ()

peekByteOff :: Ptr b -> Int -> IO Char

pokeByteOff :: Ptr b -> Int -> Char -> IO ()

peek :: Ptr Char -> IO Char

poke :: Ptr Char -> Char -> IO ()

Random Char

Methods

randomR :: RandomGen g => (Char, Char) -> g -> (Char, g)

random :: RandomGen g => g -> (Char, g)

randomRs :: RandomGen g => (Char, Char) -> g -> [Char]

randoms :: RandomGen g => g -> [Char]

randomRIO :: (Char, Char) -> IO Char

randomIO :: IO Char

Show Char

Methods

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

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

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

sshow :: R (Fun Char String)

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

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

Read Char

Methods

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

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

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

sreadList :: R (ReadS (List Char))

Bounded Char

Methods

gminBound :: RefSrcPos -> RefExp -> R Char

sminBound :: R Char

gmaxBound :: RefSrcPos -> RefExp -> R Char

smaxBound :: R Char

Enum Char

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Char Char)

gpred :: RefSrcPos -> RefExp -> R (Fun Char Char)

ssucc :: R (Fun Char Char)

spred :: R (Fun Char Char)

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

stoEnum :: R (Fun Int Char)

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

sfromEnum :: R (Fun Char Int)

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

senumFrom :: R (Fun Char (List Char))

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

senumFromThen :: R (Fun Char (Fun Char (List Char)))

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

senumFromTo :: R (Fun Char (Fun Char (List Char)))

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

senumFromThenTo :: R (Fun Char (Fun Char (Fun Char (List Char))))

Ord Char

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Ordering))

scompare :: R (Fun Char (Fun Char Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

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

(|<) :: R (Fun Char (Fun Char Bool))

(|<=) :: R (Fun Char (Fun Char Bool))

(|>=) :: R (Fun Char (Fun Char Bool))

(|>) :: R (Fun Char (Fun Char Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Char))

gmin :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Char))

smax :: R (Fun Char (Fun Char Char))

smin :: R (Fun Char (Fun Char Char))

Eq Char

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

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

(|==) :: R (Fun Char (Fun Char Bool))

(|/=) :: R (Fun Char (Fun Char Bool))

Ix Char

Methods

grange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (List Char))

srange :: R (Fun (Tuple2 Char Char) (List Char))

gindex :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (Fun Char Int))

sindex :: R (Fun (Tuple2 Char Char) (Fun Char Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (Fun Char Bool))

sinRange :: R (Fun (Tuple2 Char Char) (Fun Char Bool))

grangeSize :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) Int)

srangeSize :: R (Fun (Tuple2 Char Char) Int)

Random Char

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (Fun g (Tuple2 Char g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Char Char) (Fun g (Tuple2 Char g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Char g))

srandom :: RandomGen g => R (Fun g (Tuple2 Char g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (Fun g (List Char)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Char Char) (Fun g (List Char)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Char))

srandoms :: RandomGen g => R (Fun g (List Char))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Char Char) (IO Char))

srandomRIO :: R (Fun (Tuple2 Char Char) (IO Char))

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

srandomIO :: R (IO Char)

Functor (URec Char)

Methods

fmap :: (a -> b) -> URec Char a -> URec Char b

(<$) :: a -> URec Char b -> URec Char a

Foldable (URec Char)

Methods

fold :: Monoid m => URec Char m -> m

foldMap :: Monoid m => (a -> m) -> URec Char a -> m

foldr :: (a -> b -> b) -> b -> URec Char a -> b

foldr' :: (a -> b -> b) -> b -> URec Char a -> b

foldl :: (b -> a -> b) -> b -> URec Char a -> b

foldl' :: (b -> a -> b) -> b -> URec Char a -> b

foldr1 :: (a -> a -> a) -> URec Char a -> a

foldl1 :: (a -> a -> a) -> URec Char a -> a

toList :: URec Char a -> [a]

null :: URec Char a -> Bool

length :: URec Char a -> Int

elem :: Eq a => a -> URec Char a -> Bool

maximum :: Ord a => URec Char a -> a

minimum :: Ord a => URec Char a -> a

sum :: Num a => URec Char a -> a

product :: Num a => URec Char a -> a

Generic1 (URec Char)

Associated Types

type Rep1 (URec Char :: * -> *) :: * -> *

Methods

from1 :: URec Char a -> Rep1 (URec Char) a

to1 :: Rep1 (URec Char) a -> URec Char a

Eq (URec Char p)

Methods

(==) :: URec Char p -> URec Char p -> Bool

(/=) :: URec Char p -> URec Char p -> Bool

Ord (URec Char p)

Methods

compare :: URec Char p -> URec Char p -> Ordering

(<) :: URec Char p -> URec Char p -> Bool

(<=) :: URec Char p -> URec Char p -> Bool

(>) :: URec Char p -> URec Char p -> Bool

(>=) :: URec Char p -> URec Char p -> Bool

max :: URec Char p -> URec Char p -> URec Char p

min :: URec Char p -> URec Char p -> URec Char p

Show (URec Char p)

Methods

showsPrec :: Int -> URec Char p -> ShowS

show :: URec Char p -> String

showList :: [URec Char p] -> ShowS

Generic (URec Char p)

Associated Types

type Rep (URec Char p) :: * -> *

Methods

from :: URec Char p -> Rep (URec Char p) x

to :: Rep (URec Char p) x -> URec Char p

data URec Char

Used for marking occurrences of Char#

data URec Char = UChar {

• uChar# :: Char#

}

type Rep1 (URec Char)

type Rep1 (URec Char) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))

type Rep (URec Char p)

type Rep (URec Char p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UChar" PrefixI True) (S1 (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UChar))

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

Methods

minBound :: Int

maxBound :: Int

Enum Int

Methods

succ :: Int -> Int

pred :: Int -> Int

toEnum :: Int -> Int

fromEnum :: Int -> Int

enumFrom :: Int -> [Int]

enumFromThen :: Int -> Int -> [Int]

enumFromTo :: Int -> Int -> [Int]

enumFromThenTo :: Int -> Int -> Int -> [Int]

Eq Int

Methods

(==) :: Int -> Int -> Bool

(/=) :: Int -> Int -> Bool

Integral Int

Methods

quot :: Int -> Int -> Int

rem :: Int -> Int -> Int

div :: Int -> Int -> Int

mod :: Int -> Int -> Int

quotRem :: Int -> Int -> (Int, Int)

divMod :: Int -> Int -> (Int, Int)

toInteger :: Int -> Integer

Num Int

Methods

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

(*) :: Int -> Int -> Int

negate :: Int -> Int

abs :: Int -> Int

signum :: Int -> Int

fromInteger :: Integer -> Int

Ord Int

Methods

compare :: Int -> Int -> Ordering

(<) :: Int -> Int -> Bool

(<=) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(>=) :: Int -> Int -> Bool

max :: Int -> Int -> Int

min :: Int -> Int -> Int

Read Int

Methods

readsPrec :: Int -> ReadS Int

readList :: ReadS [Int]

readPrec :: ReadPrec Int

readListPrec :: ReadPrec [Int]

Real Int

Methods

toRational :: Int -> Rational

Show Int

Methods

showsPrec :: Int -> Int -> ShowS

show :: Int -> String

showList :: [Int] -> ShowS

Storable Int

Methods

sizeOf :: Int -> Int

alignment :: Int -> Int

peekElemOff :: Ptr Int -> Int -> IO Int

pokeElemOff :: Ptr Int -> Int -> Int -> IO ()

peekByteOff :: Ptr b -> Int -> IO Int

pokeByteOff :: Ptr b -> Int -> Int -> IO ()

peek :: Ptr Int -> IO Int

poke :: Ptr Int -> Int -> IO ()

Random Int

Methods

randomR :: RandomGen g => (Int, Int) -> g -> (Int, g)

random :: RandomGen g => g -> (Int, g)

randomRs :: RandomGen g => (Int, Int) -> g -> [Int]

randoms :: RandomGen g => g -> [Int]

randomRIO :: (Int, Int) -> IO Int

randomIO :: IO Int

Show Int

Methods

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

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

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

sshow :: R (Fun Int String)

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

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

Read Int

Methods

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

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

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

sreadList :: R (ReadS (List Int))

Integral Int

Methods

gquot :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

grem :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

squot :: R (Fun Int (Fun Int Int))

srem :: R (Fun Int (Fun Int Int))

gdiv :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

gmod :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

sdiv :: R (Fun Int (Fun Int Int))

smod :: R (Fun Int (Fun Int Int))

gquotRem :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (Tuple2 Int Int)))

gdivMod :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (Tuple2 Int Int)))

squotRem :: R (Fun Int (Fun Int (Tuple2 Int Int)))

sdivMod :: R (Fun Int (Fun Int (Tuple2 Int Int)))

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

stoInteger :: R (Fun Int Integer)

Real Int

Methods

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

stoRational :: R (Fun Int Rational)

Num Int

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

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

(!*) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

(|+) :: R (Fun Int (Fun Int Int))

(|-) :: R (Fun Int (Fun Int Int))

(|*) :: R (Fun Int (Fun Int Int))

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

snegate :: R (Fun Int Int)

gabs :: RefSrcPos -> RefExp -> R (Fun Int Int)

gsignum :: RefSrcPos -> RefExp -> R (Fun Int Int)

sabs :: R (Fun Int Int)

ssignum :: R (Fun Int Int)

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

sfromInteger :: R (Fun Integer Int)

Bounded Int

Methods

gminBound :: RefSrcPos -> RefExp -> R Int

sminBound :: R Int

gmaxBound :: RefSrcPos -> RefExp -> R Int

smaxBound :: R Int

Enum Int

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Int Int)

gpred :: RefSrcPos -> RefExp -> R (Fun Int Int)

ssucc :: R (Fun Int Int)

spred :: R (Fun Int Int)

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

stoEnum :: R (Fun Int Int)

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

sfromEnum :: R (Fun Int Int)

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

senumFrom :: R (Fun Int (List Int))

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

senumFromThen :: R (Fun Int (Fun Int (List Int)))

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

senumFromTo :: R (Fun Int (Fun Int (List Int)))

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

senumFromThenTo :: R (Fun Int (Fun Int (Fun Int (List Int))))

Ord Int

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Ordering))

scompare :: R (Fun Int (Fun Int Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

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

(|<) :: R (Fun Int (Fun Int Bool))

(|<=) :: R (Fun Int (Fun Int Bool))

(|>=) :: R (Fun Int (Fun Int Bool))

(|>) :: R (Fun Int (Fun Int Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

gmin :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

smax :: R (Fun Int (Fun Int Int))

smin :: R (Fun Int (Fun Int Int))

Eq Int

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

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

(|==) :: R (Fun Int (Fun Int Bool))

(|/=) :: R (Fun Int (Fun Int Bool))

Ix Int

Methods

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

srange :: R (Fun (Tuple2 Int Int) (List Int))

gindex :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (Fun Int Int))

sindex :: R (Fun (Tuple2 Int Int) (Fun Int Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (Fun Int Bool))

sinRange :: R (Fun (Tuple2 Int Int) (Fun Int Bool))

grangeSize :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) Int)

srangeSize :: R (Fun (Tuple2 Int Int) Int)

Random Int

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (Fun g (Tuple2 Int g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Int Int) (Fun g (Tuple2 Int g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Int g))

srandom :: RandomGen g => R (Fun g (Tuple2 Int g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (Fun g (List Int)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Int Int) (Fun g (List Int)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Int))

srandoms :: RandomGen g => R (Fun g (List Int))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Int Int) (IO Int))

srandomRIO :: R (Fun (Tuple2 Int Int) (IO Int))

grandomIO :: RefSrcPos -> RefExp -> R (IO Int)

srandomIO :: R (IO Int)

Functor (URec Int)

Methods

fmap :: (a -> b) -> URec Int a -> URec Int b

(<$) :: a -> URec Int b -> URec Int a

Foldable (URec Int)

Methods

fold :: Monoid m => URec Int m -> m

foldMap :: Monoid m => (a -> m) -> URec Int a -> m

foldr :: (a -> b -> b) -> b -> URec Int a -> b

foldr' :: (a -> b -> b) -> b -> URec Int a -> b

foldl :: (b -> a -> b) -> b -> URec Int a -> b

foldl' :: (b -> a -> b) -> b -> URec Int a -> b

foldr1 :: (a -> a -> a) -> URec Int a -> a

foldl1 :: (a -> a -> a) -> URec Int a -> a

toList :: URec Int a -> [a]

null :: URec Int a -> Bool

length :: URec Int a -> Int

elem :: Eq a => a -> URec Int a -> Bool

maximum :: Ord a => URec Int a -> a

minimum :: Ord a => URec Int a -> a

sum :: Num a => URec Int a -> a

product :: Num a => URec Int a -> a

Generic1 (URec Int)

Associated Types

type Rep1 (URec Int :: * -> *) :: * -> *

Methods

from1 :: URec Int a -> Rep1 (URec Int) a

to1 :: Rep1 (URec Int) a -> URec Int a

Eq (URec Int p)

Methods

(==) :: URec Int p -> URec Int p -> Bool

(/=) :: URec Int p -> URec Int p -> Bool

Ord (URec Int p)

Methods

compare :: URec Int p -> URec Int p -> Ordering

(<) :: URec Int p -> URec Int p -> Bool

(<=) :: URec Int p -> URec Int p -> Bool

(>) :: URec Int p -> URec Int p -> Bool

(>=) :: URec Int p -> URec Int p -> Bool

max :: URec Int p -> URec Int p -> URec Int p

min :: URec Int p -> URec Int p -> URec Int p

Show (URec Int p)

Methods

showsPrec :: Int -> URec Int p -> ShowS

show :: URec Int p -> String

showList :: [URec Int p] -> ShowS

Generic (URec Int p)

Associated Types

type Rep (URec Int p) :: * -> *

Methods

from :: URec Int p -> Rep (URec Int p) x

to :: Rep (URec Int p) x -> URec Int p

data URec Int

Used for marking occurrences of Int#

data URec Int = UInt {

• uInt# :: Int#

}

type Rep1 (URec Int)

type Rep1 (URec Int) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UInt))

type Rep (URec Int p)

type Rep (URec Int p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UInt" PrefixI True) (S1 (MetaSel (Just Symbol "uInt#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UInt))

data Integer :: *

Invariant: Jn# and Jp# are used iff value doesn't fit in S#

Useful properties resulting from the invariants:

• abs (S# _) <= abs (Jp# _)

• abs (S# _) <  abs (Jn# _)

Instances

Enum Integer

Methods

succ :: Integer -> Integer

pred :: Integer -> Integer

toEnum :: Int -> Integer

fromEnum :: Integer -> Int

enumFrom :: Integer -> [Integer]

enumFromThen :: Integer -> Integer -> [Integer]

enumFromTo :: Integer -> Integer -> [Integer]

enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]

Eq Integer

Methods

(==) :: Integer -> Integer -> Bool

(/=) :: Integer -> Integer -> Bool

Integral Integer

Methods

quot :: Integer -> Integer -> Integer

rem :: Integer -> Integer -> Integer

div :: Integer -> Integer -> Integer

mod :: Integer -> Integer -> Integer

quotRem :: Integer -> Integer -> (Integer, Integer)

divMod :: Integer -> Integer -> (Integer, Integer)

toInteger :: Integer -> Integer

Num Integer

Methods

(+) :: Integer -> Integer -> Integer

(-) :: Integer -> Integer -> Integer

(*) :: Integer -> Integer -> Integer

negate :: Integer -> Integer

abs :: Integer -> Integer

signum :: Integer -> Integer

fromInteger :: Integer -> Integer

Ord Integer

Methods

compare :: Integer -> Integer -> Ordering

(<) :: Integer -> Integer -> Bool

(<=) :: Integer -> Integer -> Bool

(>) :: Integer -> Integer -> Bool

(>=) :: Integer -> Integer -> Bool

max :: Integer -> Integer -> Integer

min :: Integer -> Integer -> Integer

Read Integer

Methods

readsPrec :: Int -> ReadS Integer

readList :: ReadS [Integer]

readPrec :: ReadPrec Integer

readListPrec :: ReadPrec [Integer]

Real Integer

Methods

toRational :: Integer -> Rational

Show Integer

Methods

showsPrec :: Int -> Integer -> ShowS

show :: Integer -> String

showList :: [Integer] -> ShowS

Random Integer

Methods

randomR :: RandomGen g => (Integer, Integer) -> g -> (Integer, g)

random :: RandomGen g => g -> (Integer, g)

randomRs :: RandomGen g => (Integer, Integer) -> g -> [Integer]

randoms :: RandomGen g => g -> [Integer]

randomRIO :: (Integer, Integer) -> IO Integer

randomIO :: IO Integer

Show Integer

Methods

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

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

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

sshow :: R (Fun Integer String)

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

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

Read Integer

Methods

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

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

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

sreadList :: R (ReadS (List Integer))

Integral Integer

Methods

gquot :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

grem :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

squot :: R (Fun Integer (Fun Integer Integer))

srem :: R (Fun Integer (Fun Integer Integer))

gdiv :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

gmod :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

sdiv :: R (Fun Integer (Fun Integer Integer))

smod :: R (Fun Integer (Fun Integer Integer))

gquotRem :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

gdivMod :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

squotRem :: R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

sdivMod :: R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

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

stoInteger :: R (Fun Integer Integer)

Real Integer

Methods

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

stoRational :: R (Fun Integer Rational)

Num Integer

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

(!-) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

(!*) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

(|+) :: R (Fun Integer (Fun Integer Integer))

(|-) :: R (Fun Integer (Fun Integer Integer))

(|*) :: R (Fun Integer (Fun Integer Integer))

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

snegate :: R (Fun Integer Integer)

gabs :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

gsignum :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

sabs :: R (Fun Integer Integer)

ssignum :: R (Fun Integer Integer)

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

sfromInteger :: R (Fun Integer Integer)

Enum Integer

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

gpred :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

ssucc :: R (Fun Integer Integer)

spred :: R (Fun Integer Integer)

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

stoEnum :: R (Fun Int Integer)

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

sfromEnum :: R (Fun Integer Int)

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

senumFrom :: R (Fun Integer (List Integer))

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

senumFromThen :: R (Fun Integer (Fun Integer (List Integer)))

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

senumFromTo :: R (Fun Integer (Fun Integer (List Integer)))

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

senumFromThenTo :: R (Fun Integer (Fun Integer (Fun Integer (List Integer))))

Ord Integer

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Ordering))

scompare :: R (Fun Integer (Fun Integer Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

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

(|<) :: R (Fun Integer (Fun Integer Bool))

(|<=) :: R (Fun Integer (Fun Integer Bool))

(|>=) :: R (Fun Integer (Fun Integer Bool))

(|>) :: R (Fun Integer (Fun Integer Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

gmin :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

smax :: R (Fun Integer (Fun Integer Integer))

smin :: R (Fun Integer (Fun Integer Integer))

Eq Integer

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

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

(|==) :: R (Fun Integer (Fun Integer Bool))

(|/=) :: R (Fun Integer (Fun Integer Bool))

Ix Integer

Methods

grange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (List Integer))

srange :: R (Fun (Tuple2 Integer Integer) (List Integer))

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

sindex :: R (Fun (Tuple2 Integer Integer) (Fun Integer Int))

ginRange :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (Fun Integer Bool))

sinRange :: R (Fun (Tuple2 Integer Integer) (Fun Integer Bool))

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

srangeSize :: R (Fun (Tuple2 Integer Integer) Int)

Random Integer

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (Fun g (Tuple2 Integer g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Integer Integer) (Fun g (Tuple2 Integer g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Integer g))

srandom :: RandomGen g => R (Fun g (Tuple2 Integer g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (Fun g (List Integer)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Integer Integer) (Fun g (List Integer)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Integer))

srandoms :: RandomGen g => R (Fun g (List Integer))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Integer Integer) (IO Integer))

srandomRIO :: R (Fun (Tuple2 Integer Integer) (IO Integer))

grandomIO :: RefSrcPos -> RefExp -> R (IO Integer)

srandomIO :: R (IO 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

Eq Float

Methods

(==) :: Float -> Float -> Bool

(/=) :: Float -> Float -> Bool

Floating Float

Methods

pi :: Float

exp :: Float -> Float

log :: Float -> Float

sqrt :: Float -> Float

(**) :: Float -> Float -> Float

logBase :: Float -> Float -> Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

log1p :: Float -> Float

expm1 :: Float -> Float

log1pexp :: Float -> Float

log1mexp :: Float -> Float

Ord Float

Methods

compare :: Float -> Float -> Ordering

(<) :: Float -> Float -> Bool

(<=) :: Float -> Float -> Bool

(>) :: Float -> Float -> Bool

(>=) :: Float -> Float -> Bool

max :: Float -> Float -> Float

min :: Float -> Float -> Float

Read Float

Methods

readsPrec :: Int -> ReadS Float

readList :: ReadS [Float]

readPrec :: ReadPrec Float

readListPrec :: ReadPrec [Float]

RealFloat Float

Methods

floatRadix :: Float -> Integer

floatDigits :: Float -> Int

floatRange :: Float -> (Int, Int)

decodeFloat :: Float -> (Integer, Int)

encodeFloat :: Integer -> Int -> Float

exponent :: Float -> Int

significand :: Float -> Float

scaleFloat :: Int -> Float -> Float

isNaN :: Float -> Bool

isInfinite :: Float -> Bool

isDenormalized :: Float -> Bool

isNegativeZero :: Float -> Bool

isIEEE :: Float -> Bool

atan2 :: Float -> Float -> Float

Storable Float

Methods

sizeOf :: Float -> Int

alignment :: Float -> Int

peekElemOff :: Ptr Float -> Int -> IO Float

pokeElemOff :: Ptr Float -> Int -> Float -> IO ()

peekByteOff :: Ptr b -> Int -> IO Float

pokeByteOff :: Ptr b -> Int -> Float -> IO ()

peek :: Ptr Float -> IO Float

poke :: Ptr Float -> Float -> IO ()

Random Float

Methods

randomR :: RandomGen g => (Float, Float) -> g -> (Float, g)

random :: RandomGen g => g -> (Float, g)

randomRs :: RandomGen g => (Float, Float) -> g -> [Float]

randoms :: RandomGen g => g -> [Float]

randomRIO :: (Float, Float) -> IO Float

randomIO :: IO Float

Show Float

Methods

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

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

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

sshow :: R (Fun Float String)

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

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

Read Float

Methods

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

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

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

sreadList :: R (ReadS (List Float))

RealFloat Float

Methods

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

sfloatRadix :: R (Fun Float Integer)

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

sfloatDigits :: R (Fun Float Int)

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

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

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

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

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

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

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

sexponent :: R (Fun Float Int)

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

ssignificand :: R (Fun Float Float)

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

sscaleFloat :: R (Fun Int (Fun Float Float))

gisNaN :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisInfinite :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisDenormalized :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisNegativeZero :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisIEEE :: RefSrcPos -> RefExp -> R (Fun Float Bool)

sisNaN :: R (Fun Float Bool)

sisInfinite :: R (Fun Float Bool)

sisDenormalized :: R (Fun Float Bool)

sisNegativeZero :: R (Fun Float Bool)

sisIEEE :: R (Fun Float Bool)

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

satan2 :: R (Fun Float (Fun Float Float))

RealFrac Float

Methods

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

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

gtruncate :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

ground :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

struncate :: Integral b => R (Fun Float b)

sround :: Integral b => R (Fun Float b)

gceiling :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

sceiling :: Integral b => R (Fun Float b)

sfloor :: Integral b => R (Fun Float b)

Floating Float

Methods

gpi :: RefSrcPos -> RefExp -> R Float

spi :: R Float

gexp :: RefSrcPos -> RefExp -> R (Fun Float Float)

glog :: RefSrcPos -> RefExp -> R (Fun Float Float)

gsqrt :: RefSrcPos -> RefExp -> R (Fun Float Float)

sexp :: R (Fun Float Float)

slog :: R (Fun Float Float)

ssqrt :: R (Fun Float Float)

(!**) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

glogBase :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(|**) :: R (Fun Float (Fun Float Float))

slogBase :: R (Fun Float (Fun Float Float))

gsin :: RefSrcPos -> RefExp -> R (Fun Float Float)

gcos :: RefSrcPos -> RefExp -> R (Fun Float Float)

gtan :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssin :: R (Fun Float Float)

scos :: R (Fun Float Float)

stan :: R (Fun Float Float)

gasin :: RefSrcPos -> RefExp -> R (Fun Float Float)

gacos :: RefSrcPos -> RefExp -> R (Fun Float Float)

gatan :: RefSrcPos -> RefExp -> R (Fun Float Float)

sasin :: R (Fun Float Float)

sacos :: R (Fun Float Float)

satan :: R (Fun Float Float)

gsinh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gcosh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gtanh :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssinh :: R (Fun Float Float)

scosh :: R (Fun Float Float)

stanh :: R (Fun Float Float)

gasinh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gacosh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gatanh :: RefSrcPos -> RefExp -> R (Fun Float Float)

sasinh :: R (Fun Float Float)

sacosh :: R (Fun Float Float)

satanh :: R (Fun Float Float)

Fractional Float

Methods

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

(|/) :: R (Fun Float (Fun Float Float))

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

srecip :: R (Fun Float Float)

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

sfromRational :: R (Fun Rational Float)

Real Float

Methods

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

stoRational :: R (Fun Float Rational)

Num Float

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(!-) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(!*) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(|+) :: R (Fun Float (Fun Float Float))

(|-) :: R (Fun Float (Fun Float Float))

(|*) :: R (Fun Float (Fun Float Float))

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

snegate :: R (Fun Float Float)

gabs :: RefSrcPos -> RefExp -> R (Fun Float Float)

gsignum :: RefSrcPos -> RefExp -> R (Fun Float Float)

sabs :: R (Fun Float Float)

ssignum :: R (Fun Float Float)

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

sfromInteger :: R (Fun Integer Float)

Enum Float

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Float Float)

gpred :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssucc :: R (Fun Float Float)

spred :: R (Fun Float Float)

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

stoEnum :: R (Fun Int Float)

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

sfromEnum :: R (Fun Float Int)

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

senumFrom :: R (Fun Float (List Float))

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

senumFromThen :: R (Fun Float (Fun Float (List Float)))

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

senumFromTo :: R (Fun Float (Fun Float (List Float)))

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

senumFromThenTo :: R (Fun Float (Fun Float (Fun Float (List Float))))

Ord Float

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Ordering))

scompare :: R (Fun Float (Fun Float Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

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

(|<) :: R (Fun Float (Fun Float Bool))

(|<=) :: R (Fun Float (Fun Float Bool))

(|>=) :: R (Fun Float (Fun Float Bool))

(|>) :: R (Fun Float (Fun Float Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

gmin :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

smax :: R (Fun Float (Fun Float Float))

smin :: R (Fun Float (Fun Float Float))

Eq Float

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

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

(|==) :: R (Fun Float (Fun Float Bool))

(|/=) :: R (Fun Float (Fun Float Bool))

Random Float

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Float Float) (Fun g (Tuple2 Float g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Float Float) (Fun g (Tuple2 Float g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Float g))

srandom :: RandomGen g => R (Fun g (Tuple2 Float g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Float Float) (Fun g (List Float)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Float Float) (Fun g (List Float)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Float))

srandoms :: RandomGen g => R (Fun g (List Float))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Float Float) (IO Float))

srandomRIO :: R (Fun (Tuple2 Float Float) (IO Float))

grandomIO :: RefSrcPos -> RefExp -> R (IO Float)

srandomIO :: R (IO Float)

Functor (URec Float)

Methods

fmap :: (a -> b) -> URec Float a -> URec Float b

(<$) :: a -> URec Float b -> URec Float a

Foldable (URec Float)

Methods

fold :: Monoid m => URec Float m -> m

foldMap :: Monoid m => (a -> m) -> URec Float a -> m

foldr :: (a -> b -> b) -> b -> URec Float a -> b

foldr' :: (a -> b -> b) -> b -> URec Float a -> b

foldl :: (b -> a -> b) -> b -> URec Float a -> b

foldl' :: (b -> a -> b) -> b -> URec Float a -> b

foldr1 :: (a -> a -> a) -> URec Float a -> a

foldl1 :: (a -> a -> a) -> URec Float a -> a

toList :: URec Float a -> [a]

null :: URec Float a -> Bool

length :: URec Float a -> Int

elem :: Eq a => a -> URec Float a -> Bool

maximum :: Ord a => URec Float a -> a

minimum :: Ord a => URec Float a -> a

sum :: Num a => URec Float a -> a

product :: Num a => URec Float a -> a

Generic1 (URec Float)

Associated Types

type Rep1 (URec Float :: * -> *) :: * -> *

Methods

from1 :: URec Float a -> Rep1 (URec Float) a

to1 :: Rep1 (URec Float) a -> URec Float a

Eq (URec Float p)

Methods

(==) :: URec Float p -> URec Float p -> Bool

(/=) :: URec Float p -> URec Float p -> Bool

Ord (URec Float p)

Methods

compare :: URec Float p -> URec Float p -> Ordering

(<) :: URec Float p -> URec Float p -> Bool

(<=) :: URec Float p -> URec Float p -> Bool

(>) :: URec Float p -> URec Float p -> Bool

(>=) :: URec Float p -> URec Float p -> Bool

max :: URec Float p -> URec Float p -> URec Float p

min :: URec Float p -> URec Float p -> URec Float p

Show (URec Float p)

Methods

showsPrec :: Int -> URec Float p -> ShowS

show :: URec Float p -> String

showList :: [URec Float p] -> ShowS

Generic (URec Float p)

Associated Types

type Rep (URec Float p) :: * -> *

Methods

from :: URec Float p -> Rep (URec Float p) x

to :: Rep (URec Float p) x -> URec Float p

data URec Float

Used for marking occurrences of Float#

data URec Float = UFloat {

• uFloat# :: Float#

}

type Rep1 (URec Float)

type Rep1 (URec Float) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))

type Rep (URec Float p)

type Rep (URec Float p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UFloat" PrefixI True) (S1 (MetaSel (Just Symbol "uFloat#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UFloat))

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

Eq Double

Methods

(==) :: Double -> Double -> Bool

(/=) :: Double -> Double -> Bool

Floating Double

Methods

pi :: Double

exp :: Double -> Double

log :: Double -> Double

sqrt :: Double -> Double

(**) :: Double -> Double -> Double

logBase :: Double -> Double -> Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

log1p :: Double -> Double

expm1 :: Double -> Double

log1pexp :: Double -> Double

log1mexp :: Double -> Double

Ord Double

Methods

compare :: Double -> Double -> Ordering

(<) :: Double -> Double -> Bool

(<=) :: Double -> Double -> Bool

(>) :: Double -> Double -> Bool

(>=) :: Double -> Double -> Bool

max :: Double -> Double -> Double

min :: Double -> Double -> Double

Read Double

Methods

readsPrec :: Int -> ReadS Double

readList :: ReadS [Double]

readPrec :: ReadPrec Double

readListPrec :: ReadPrec [Double]

RealFloat Double

Methods

floatRadix :: Double -> Integer

floatDigits :: Double -> Int

floatRange :: Double -> (Int, Int)

decodeFloat :: Double -> (Integer, Int)

encodeFloat :: Integer -> Int -> Double

exponent :: Double -> Int

significand :: Double -> Double

scaleFloat :: Int -> Double -> Double

isNaN :: Double -> Bool

isInfinite :: Double -> Bool

isDenormalized :: Double -> Bool

isNegativeZero :: Double -> Bool

isIEEE :: Double -> Bool

atan2 :: Double -> Double -> Double

Storable Double

Methods

sizeOf :: Double -> Int

alignment :: Double -> Int

peekElemOff :: Ptr Double -> Int -> IO Double

pokeElemOff :: Ptr Double -> Int -> Double -> IO ()

peekByteOff :: Ptr b -> Int -> IO Double

pokeByteOff :: Ptr b -> Int -> Double -> IO ()

peek :: Ptr Double -> IO Double

poke :: Ptr Double -> Double -> IO ()

Random Double

Methods

randomR :: RandomGen g => (Double, Double) -> g -> (Double, g)

random :: RandomGen g => g -> (Double, g)

randomRs :: RandomGen g => (Double, Double) -> g -> [Double]

randoms :: RandomGen g => g -> [Double]

randomRIO :: (Double, Double) -> IO Double

randomIO :: IO Double

Show Double

Methods

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

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

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

sshow :: R (Fun Double String)

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

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

Read Double

Methods

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

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

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

sreadList :: R (ReadS (List Double))

RealFloat Double

Methods

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

sfloatRadix :: R (Fun Double Integer)

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

sfloatDigits :: R (Fun Double Int)

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

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

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

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

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

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

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

sexponent :: R (Fun Double Int)

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

ssignificand :: R (Fun Double Double)

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

sscaleFloat :: R (Fun Int (Fun Double Double))

gisNaN :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisInfinite :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisDenormalized :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisNegativeZero :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisIEEE :: RefSrcPos -> RefExp -> R (Fun Double Bool)

sisNaN :: R (Fun Double Bool)

sisInfinite :: R (Fun Double Bool)

sisDenormalized :: R (Fun Double Bool)

sisNegativeZero :: R (Fun Double Bool)

sisIEEE :: R (Fun Double Bool)

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

satan2 :: R (Fun Double (Fun Double Double))

RealFrac Double

Methods

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

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

gtruncate :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

ground :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

struncate :: Integral b => R (Fun Double b)

sround :: Integral b => R (Fun Double b)

gceiling :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

sceiling :: Integral b => R (Fun Double b)

sfloor :: Integral b => R (Fun Double b)

Floating Double

Methods

gpi :: RefSrcPos -> RefExp -> R Double

spi :: R Double

gexp :: RefSrcPos -> RefExp -> R (Fun Double Double)

glog :: RefSrcPos -> RefExp -> R (Fun Double Double)

gsqrt :: RefSrcPos -> RefExp -> R (Fun Double Double)

sexp :: R (Fun Double Double)

slog :: R (Fun Double Double)

ssqrt :: R (Fun Double Double)

(!**) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

glogBase :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(|**) :: R (Fun Double (Fun Double Double))

slogBase :: R (Fun Double (Fun Double Double))

gsin :: RefSrcPos -> RefExp -> R (Fun Double Double)

gcos :: RefSrcPos -> RefExp -> R (Fun Double Double)

gtan :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssin :: R (Fun Double Double)

scos :: R (Fun Double Double)

stan :: R (Fun Double Double)

gasin :: RefSrcPos -> RefExp -> R (Fun Double Double)

gacos :: RefSrcPos -> RefExp -> R (Fun Double Double)

gatan :: RefSrcPos -> RefExp -> R (Fun Double Double)

sasin :: R (Fun Double Double)

sacos :: R (Fun Double Double)

satan :: R (Fun Double Double)

gsinh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gcosh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gtanh :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssinh :: R (Fun Double Double)

scosh :: R (Fun Double Double)

stanh :: R (Fun Double Double)

gasinh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gacosh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gatanh :: RefSrcPos -> RefExp -> R (Fun Double Double)

sasinh :: R (Fun Double Double)

sacosh :: R (Fun Double Double)

satanh :: R (Fun Double Double)

Fractional Double

Methods

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

(|/) :: R (Fun Double (Fun Double Double))

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

srecip :: R (Fun Double Double)

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

sfromRational :: R (Fun Rational Double)

Real Double

Methods

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

stoRational :: R (Fun Double Rational)

Num Double

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(!-) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(!*) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(|+) :: R (Fun Double (Fun Double Double))

(|-) :: R (Fun Double (Fun Double Double))

(|*) :: R (Fun Double (Fun Double Double))

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

snegate :: R (Fun Double Double)

gabs :: RefSrcPos -> RefExp -> R (Fun Double Double)

gsignum :: RefSrcPos -> RefExp -> R (Fun Double Double)

sabs :: R (Fun Double Double)

ssignum :: R (Fun Double Double)

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

sfromInteger :: R (Fun Integer Double)

Enum Double

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Double Double)

gpred :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssucc :: R (Fun Double Double)

spred :: R (Fun Double Double)

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

stoEnum :: R (Fun Int Double)

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

sfromEnum :: R (Fun Double Int)

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

senumFrom :: R (Fun Double (List Double))

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

senumFromThen :: R (Fun Double (Fun Double (List Double)))

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

senumFromTo :: R (Fun Double (Fun Double (List Double)))

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

senumFromThenTo :: R (Fun Double (Fun Double (Fun Double (List Double))))

Ord Double

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Ordering))

scompare :: R (Fun Double (Fun Double Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

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

(|<) :: R (Fun Double (Fun Double Bool))

(|<=) :: R (Fun Double (Fun Double Bool))

(|>=) :: R (Fun Double (Fun Double Bool))

(|>) :: R (Fun Double (Fun Double Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

gmin :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

smax :: R (Fun Double (Fun Double Double))

smin :: R (Fun Double (Fun Double Double))

Eq Double

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

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

(|==) :: R (Fun Double (Fun Double Bool))

(|/=) :: R (Fun Double (Fun Double Bool))

Random Double

Methods

grandomR :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Double Double) (Fun g (Tuple2 Double g)))

srandomR :: RandomGen g => R (Fun (Tuple2 Double Double) (Fun g (Tuple2 Double g)))

grandom :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (Tuple2 Double g))

srandom :: RandomGen g => R (Fun g (Tuple2 Double g))

grandomRs :: RandomGen g => RefSrcPos -> RefExp -> R (Fun (Tuple2 Double Double) (Fun g (List Double)))

srandomRs :: RandomGen g => R (Fun (Tuple2 Double Double) (Fun g (List Double)))

grandoms :: RandomGen g => RefSrcPos -> RefExp -> R (Fun g (List Double))

srandoms :: RandomGen g => R (Fun g (List Double))

grandomRIO :: RefSrcPos -> RefExp -> R (Fun (Tuple2 Double Double) (IO Double))

srandomRIO :: R (Fun (Tuple2 Double Double) (IO Double))

grandomIO :: RefSrcPos -> RefExp -> R (IO Double)

srandomIO :: R (IO Double)

Functor (URec Double)

Methods

fmap :: (a -> b) -> URec Double a -> URec Double b

(<$) :: a -> URec Double b -> URec Double a

Foldable (URec Double)

Methods

fold :: Monoid m => URec Double m -> m

foldMap :: Monoid m => (a -> m) -> URec Double a -> m

foldr :: (a -> b -> b) -> b -> URec Double a -> b

foldr' :: (a -> b -> b) -> b -> URec Double a -> b

foldl :: (b -> a -> b) -> b -> URec Double a -> b

foldl' :: (b -> a -> b) -> b -> URec Double a -> b

foldr1 :: (a -> a -> a) -> URec Double a -> a

foldl1 :: (a -> a -> a) -> URec Double a -> a

toList :: URec Double a -> [a]

null :: URec Double a -> Bool

length :: URec Double a -> Int

elem :: Eq a => a -> URec Double a -> Bool

maximum :: Ord a => URec Double a -> a

minimum :: Ord a => URec Double a -> a

sum :: Num a => URec Double a -> a

product :: Num a => URec Double a -> a

Generic1 (URec Double)

Associated Types

type Rep1 (URec Double :: * -> *) :: * -> *

Methods

from1 :: URec Double a -> Rep1 (URec Double) a

to1 :: Rep1 (URec Double) a -> URec Double a

Eq (URec Double p)

Methods

(==) :: URec Double p -> URec Double p -> Bool

(/=) :: URec Double p -> URec Double p -> Bool

Ord (URec Double p)

Methods

compare :: URec Double p -> URec Double p -> Ordering

(<) :: URec Double p -> URec Double p -> Bool

(<=) :: URec Double p -> URec Double p -> Bool

(>) :: URec Double p -> URec Double p -> Bool

(>=) :: URec Double p -> URec Double p -> Bool

max :: URec Double p -> URec Double p -> URec Double p

min :: URec Double p -> URec Double p -> URec Double p

Show (URec Double p)

Methods

showsPrec :: Int -> URec Double p -> ShowS

show :: URec Double p -> String

showList :: [URec Double p] -> ShowS

Generic (URec Double p)

Associated Types

type Rep (URec Double p) :: * -> *

Methods

from :: URec Double p -> Rep (URec Double p) x

to :: Rep (URec Double p) x -> URec Double p

data URec Double

Used for marking occurrences of Double#

data URec Double = UDouble {

• uDouble# :: Double#

}

type Rep1 (URec Double)

type Rep1 (URec Double) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))

type Rep (URec Double p)

type Rep (URec Double p) = D1 (MetaData "URec" "GHC.Generics" "base" False) (C1 (MetaCons "UDouble" PrefixI True) (S1 (MetaSel (Just Symbol "uDouble#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) UDouble))

type Rational = Ratio Integer

data IO a

Instances

Monad IO

Methods

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

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

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

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

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

sreturn :: R (Fun a (IO a))

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

sfail :: R (Fun String (IO a))

Functor IO

Methods

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

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

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

Methods

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

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

(|==) :: R (Fun Bool (Fun Bool Bool))

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

Eq Char

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

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

(|==) :: R (Fun Char (Fun Char Bool))

(|/=) :: R (Fun Char (Fun Char Bool))

Eq Double

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

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

(|==) :: R (Fun Double (Fun Double Bool))

(|/=) :: R (Fun Double (Fun Double Bool))

Eq Float

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

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

(|==) :: R (Fun Float (Fun Float Bool))

(|/=) :: R (Fun Float (Fun Float Bool))

Eq Int

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

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

(|==) :: R (Fun Int (Fun Int Bool))

(|/=) :: R (Fun Int (Fun Int Bool))

Eq Integer

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

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

(|==) :: R (Fun Integer (Fun Integer Bool))

(|/=) :: R (Fun Integer (Fun Integer Bool))

Eq Tuple0

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Tuple0 (Fun Tuple0 Bool))

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

(|==) :: R (Fun Tuple0 (Fun Tuple0 Bool))

(|/=) :: R (Fun Tuple0 (Fun Tuple0 Bool))

Eq Ordering

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Bool))

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

(|==) :: R (Fun Ordering (Fun Ordering Bool))

(|/=) :: R (Fun Ordering (Fun Ordering Bool))

Eq SeekMode

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Bool))

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

(|==) :: R (Fun SeekMode (Fun SeekMode Bool))

(|/=) :: R (Fun SeekMode (Fun SeekMode Bool))

Eq BufferMode

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Bool))

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

(|==) :: R (Fun BufferMode (Fun BufferMode Bool))

(|/=) :: R (Fun BufferMode (Fun BufferMode Bool))

Eq IOMode

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Bool))

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

(|==) :: R (Fun IOMode (Fun IOMode Bool))

(|/=) :: R (Fun IOMode (Fun IOMode Bool))

Eq TimeLocale

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun TimeLocale (Fun TimeLocale Bool))

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

(|==) :: R (Fun TimeLocale (Fun TimeLocale Bool))

(|/=) :: R (Fun TimeLocale (Fun TimeLocale Bool))

Eq ExitCode

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun ExitCode (Fun ExitCode Bool))

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

(|==) :: R (Fun ExitCode (Fun ExitCode Bool))

(|/=) :: R (Fun ExitCode (Fun ExitCode Bool))

Eq TimeDiff

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun TimeDiff (Fun TimeDiff Bool))

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

(|==) :: R (Fun TimeDiff (Fun TimeDiff Bool))

(|/=) :: R (Fun TimeDiff (Fun TimeDiff Bool))

Eq CalendarTime

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun CalendarTime (Fun CalendarTime Bool))

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

(|==) :: R (Fun CalendarTime (Fun CalendarTime Bool))

(|/=) :: R (Fun CalendarTime (Fun CalendarTime Bool))

Eq Day

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Day (Fun Day Bool))

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

(|==) :: R (Fun Day (Fun Day Bool))

(|/=) :: R (Fun Day (Fun Day Bool))

Eq Month

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun Month (Fun Month Bool))

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

(|==) :: R (Fun Month (Fun Month Bool))

(|/=) :: R (Fun Month (Fun Month Bool))

Eq GeneralCategory

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun GeneralCategory (Fun GeneralCategory Bool))

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

(|==) :: R (Fun GeneralCategory (Fun GeneralCategory Bool))

(|/=) :: R (Fun GeneralCategory (Fun GeneralCategory Bool))

Eq a => Eq (List a)

Methods

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

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

(|==) :: R (Fun (List a) (Fun (List a) Bool))

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

Eq a => Eq (Ratio a)

Methods

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

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

(|==) :: R (Fun (Ratio a) (Fun (Ratio a) Bool))

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

Eq a => Eq (Maybe a)

Methods

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

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

(|==) :: R (Fun (Maybe a) (Fun (Maybe a) Bool))

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

Eq a => Eq (Complex a)

Methods

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

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

(|==) :: R (Fun (Complex a) (Fun (Complex a) Bool))

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

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

Methods

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

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

(|==) :: R (Fun (Tuple2 a b) (Fun (Tuple2 a b) Bool))

(|/=) :: R (Fun (Tuple2 a b) (Fun (Tuple2 a b) Bool))

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

Methods

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

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

(|==) :: R (Fun (Either a b) (Fun (Either a b) Bool))

(|/=) :: R (Fun (Either a b) (Fun (Either a b) Bool))

(Ix a, Eq b) => Eq (Array a b)

Methods

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

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

(|==) :: R (Fun (Array a b) (Fun (Array a b) Bool))

(|/=) :: R (Fun (Array a b) (Fun (Array a b) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

(|==) :: R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

(|/=) :: R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

(|==) :: R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

(|/=) :: R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

(|==) :: R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

(|/=) :: R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

(|==) :: R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

(|/=) :: R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

(|==) :: R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

(|/=) :: R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

(|==) :: R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

(|/=) :: R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

(|==) :: R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

(|/=) :: R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

(|==) :: R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

(|/=) :: R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

(|==) :: R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

(|/=) :: R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

(|==) :: R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

(|/=) :: R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

(|==) :: R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

(|/=) :: R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

(|==) :: R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

(|/=) :: R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

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

Methods

(!==) :: RefSrcPos -> RefExp -> R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

(!/=) :: RefSrcPos -> RefExp -> R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

(|==) :: R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

(|/=) :: R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

class Eq a => Ord a where

Minimal complete definition

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

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun a (Fun a Ordering))

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

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

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

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

smax, smin :: R (Fun a (Fun a a))

Instances

Ord Bool

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Bool (Fun Bool Ordering))

scompare :: R (Fun Bool (Fun Bool Ordering))

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

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

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

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

(|<) :: R (Fun Bool (Fun Bool Bool))

(|<=) :: R (Fun Bool (Fun Bool Bool))

(|>=) :: R (Fun Bool (Fun Bool Bool))

(|>) :: R (Fun Bool (Fun Bool Bool))

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

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

smax :: R (Fun Bool (Fun Bool Bool))

smin :: R (Fun Bool (Fun Bool Bool))

Ord Char

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Ordering))

scompare :: R (Fun Char (Fun Char Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Bool))

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

(|<) :: R (Fun Char (Fun Char Bool))

(|<=) :: R (Fun Char (Fun Char Bool))

(|>=) :: R (Fun Char (Fun Char Bool))

(|>) :: R (Fun Char (Fun Char Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Char))

gmin :: RefSrcPos -> RefExp -> R (Fun Char (Fun Char Char))

smax :: R (Fun Char (Fun Char Char))

smin :: R (Fun Char (Fun Char Char))

Ord Double

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Ordering))

scompare :: R (Fun Double (Fun Double Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Bool))

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

(|<) :: R (Fun Double (Fun Double Bool))

(|<=) :: R (Fun Double (Fun Double Bool))

(|>=) :: R (Fun Double (Fun Double Bool))

(|>) :: R (Fun Double (Fun Double Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

gmin :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

smax :: R (Fun Double (Fun Double Double))

smin :: R (Fun Double (Fun Double Double))

Ord Float

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Ordering))

scompare :: R (Fun Float (Fun Float Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Bool))

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

(|<) :: R (Fun Float (Fun Float Bool))

(|<=) :: R (Fun Float (Fun Float Bool))

(|>=) :: R (Fun Float (Fun Float Bool))

(|>) :: R (Fun Float (Fun Float Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

gmin :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

smax :: R (Fun Float (Fun Float Float))

smin :: R (Fun Float (Fun Float Float))

Ord Int

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Ordering))

scompare :: R (Fun Int (Fun Int Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Bool))

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

(|<) :: R (Fun Int (Fun Int Bool))

(|<=) :: R (Fun Int (Fun Int Bool))

(|>=) :: R (Fun Int (Fun Int Bool))

(|>) :: R (Fun Int (Fun Int Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

gmin :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

smax :: R (Fun Int (Fun Int Int))

smin :: R (Fun Int (Fun Int Int))

Ord Integer

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Ordering))

scompare :: R (Fun Integer (Fun Integer Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Bool))

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

(|<) :: R (Fun Integer (Fun Integer Bool))

(|<=) :: R (Fun Integer (Fun Integer Bool))

(|>=) :: R (Fun Integer (Fun Integer Bool))

(|>) :: R (Fun Integer (Fun Integer Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

gmin :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

smax :: R (Fun Integer (Fun Integer Integer))

smin :: R (Fun Integer (Fun Integer Integer))

Ord Tuple0

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Tuple0 (Fun Tuple0 Ordering))

scompare :: R (Fun Tuple0 (Fun Tuple0 Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Tuple0 (Fun Tuple0 Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Tuple0 (Fun Tuple0 Bool))

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

(|<) :: R (Fun Tuple0 (Fun Tuple0 Bool))

(|<=) :: R (Fun Tuple0 (Fun Tuple0 Bool))

(|>=) :: R (Fun Tuple0 (Fun Tuple0 Bool))

(|>) :: R (Fun Tuple0 (Fun Tuple0 Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Tuple0 (Fun Tuple0 Tuple0))

gmin :: RefSrcPos -> RefExp -> R (Fun Tuple0 (Fun Tuple0 Tuple0))

smax :: R (Fun Tuple0 (Fun Tuple0 Tuple0))

smin :: R (Fun Tuple0 (Fun Tuple0 Tuple0))

Ord Ordering

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Ordering))

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

(!<) :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Bool))

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

(|<) :: R (Fun Ordering (Fun Ordering Bool))

(|<=) :: R (Fun Ordering (Fun Ordering Bool))

(|>=) :: R (Fun Ordering (Fun Ordering Bool))

(|>) :: R (Fun Ordering (Fun Ordering Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Ordering))

gmin :: RefSrcPos -> RefExp -> R (Fun Ordering (Fun Ordering Ordering))

smax :: R (Fun Ordering (Fun Ordering Ordering))

smin :: R (Fun Ordering (Fun Ordering Ordering))

Ord SeekMode

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Ordering))

scompare :: R (Fun SeekMode (Fun SeekMode Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode Bool))

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

(|<) :: R (Fun SeekMode (Fun SeekMode Bool))

(|<=) :: R (Fun SeekMode (Fun SeekMode Bool))

(|>=) :: R (Fun SeekMode (Fun SeekMode Bool))

(|>) :: R (Fun SeekMode (Fun SeekMode Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode SeekMode))

gmin :: RefSrcPos -> RefExp -> R (Fun SeekMode (Fun SeekMode SeekMode))

smax :: R (Fun SeekMode (Fun SeekMode SeekMode))

smin :: R (Fun SeekMode (Fun SeekMode SeekMode))

Ord BufferMode

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Ordering))

scompare :: R (Fun BufferMode (Fun BufferMode Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode Bool))

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

(|<) :: R (Fun BufferMode (Fun BufferMode Bool))

(|<=) :: R (Fun BufferMode (Fun BufferMode Bool))

(|>=) :: R (Fun BufferMode (Fun BufferMode Bool))

(|>) :: R (Fun BufferMode (Fun BufferMode Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode BufferMode))

gmin :: RefSrcPos -> RefExp -> R (Fun BufferMode (Fun BufferMode BufferMode))

smax :: R (Fun BufferMode (Fun BufferMode BufferMode))

smin :: R (Fun BufferMode (Fun BufferMode BufferMode))

Ord IOMode

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Ordering))

scompare :: R (Fun IOMode (Fun IOMode Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode Bool))

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

(|<) :: R (Fun IOMode (Fun IOMode Bool))

(|<=) :: R (Fun IOMode (Fun IOMode Bool))

(|>=) :: R (Fun IOMode (Fun IOMode Bool))

(|>) :: R (Fun IOMode (Fun IOMode Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode IOMode))

gmin :: RefSrcPos -> RefExp -> R (Fun IOMode (Fun IOMode IOMode))

smax :: R (Fun IOMode (Fun IOMode IOMode))

smin :: R (Fun IOMode (Fun IOMode IOMode))

Ord TimeLocale

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun TimeLocale (Fun TimeLocale Ordering))

scompare :: R (Fun TimeLocale (Fun TimeLocale Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun TimeLocale (Fun TimeLocale Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun TimeLocale (Fun TimeLocale Bool))

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

(|<) :: R (Fun TimeLocale (Fun TimeLocale Bool))

(|<=) :: R (Fun TimeLocale (Fun TimeLocale Bool))

(|>=) :: R (Fun TimeLocale (Fun TimeLocale Bool))

(|>) :: R (Fun TimeLocale (Fun TimeLocale Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun TimeLocale (Fun TimeLocale TimeLocale))

gmin :: RefSrcPos -> RefExp -> R (Fun TimeLocale (Fun TimeLocale TimeLocale))

smax :: R (Fun TimeLocale (Fun TimeLocale TimeLocale))

smin :: R (Fun TimeLocale (Fun TimeLocale TimeLocale))

Ord ExitCode

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun ExitCode (Fun ExitCode Ordering))

scompare :: R (Fun ExitCode (Fun ExitCode Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun ExitCode (Fun ExitCode Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun ExitCode (Fun ExitCode Bool))

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

(|<) :: R (Fun ExitCode (Fun ExitCode Bool))

(|<=) :: R (Fun ExitCode (Fun ExitCode Bool))

(|>=) :: R (Fun ExitCode (Fun ExitCode Bool))

(|>) :: R (Fun ExitCode (Fun ExitCode Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun ExitCode (Fun ExitCode ExitCode))

gmin :: RefSrcPos -> RefExp -> R (Fun ExitCode (Fun ExitCode ExitCode))

smax :: R (Fun ExitCode (Fun ExitCode ExitCode))

smin :: R (Fun ExitCode (Fun ExitCode ExitCode))

Ord TimeDiff

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun TimeDiff (Fun TimeDiff Ordering))

scompare :: R (Fun TimeDiff (Fun TimeDiff Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun TimeDiff (Fun TimeDiff Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun TimeDiff (Fun TimeDiff Bool))

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

(|<) :: R (Fun TimeDiff (Fun TimeDiff Bool))

(|<=) :: R (Fun TimeDiff (Fun TimeDiff Bool))

(|>=) :: R (Fun TimeDiff (Fun TimeDiff Bool))

(|>) :: R (Fun TimeDiff (Fun TimeDiff Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun TimeDiff (Fun TimeDiff TimeDiff))

gmin :: RefSrcPos -> RefExp -> R (Fun TimeDiff (Fun TimeDiff TimeDiff))

smax :: R (Fun TimeDiff (Fun TimeDiff TimeDiff))

smin :: R (Fun TimeDiff (Fun TimeDiff TimeDiff))

Ord CalendarTime

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun CalendarTime (Fun CalendarTime Ordering))

scompare :: R (Fun CalendarTime (Fun CalendarTime Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun CalendarTime (Fun CalendarTime Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun CalendarTime (Fun CalendarTime Bool))

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

(|<) :: R (Fun CalendarTime (Fun CalendarTime Bool))

(|<=) :: R (Fun CalendarTime (Fun CalendarTime Bool))

(|>=) :: R (Fun CalendarTime (Fun CalendarTime Bool))

(|>) :: R (Fun CalendarTime (Fun CalendarTime Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun CalendarTime (Fun CalendarTime CalendarTime))

gmin :: RefSrcPos -> RefExp -> R (Fun CalendarTime (Fun CalendarTime CalendarTime))

smax :: R (Fun CalendarTime (Fun CalendarTime CalendarTime))

smin :: R (Fun CalendarTime (Fun CalendarTime CalendarTime))

Ord Day

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Day (Fun Day Ordering))

scompare :: R (Fun Day (Fun Day Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Day (Fun Day Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Day (Fun Day Bool))

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

(|<) :: R (Fun Day (Fun Day Bool))

(|<=) :: R (Fun Day (Fun Day Bool))

(|>=) :: R (Fun Day (Fun Day Bool))

(|>) :: R (Fun Day (Fun Day Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Day (Fun Day Day))

gmin :: RefSrcPos -> RefExp -> R (Fun Day (Fun Day Day))

smax :: R (Fun Day (Fun Day Day))

smin :: R (Fun Day (Fun Day Day))

Ord Month

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun Month (Fun Month Ordering))

scompare :: R (Fun Month (Fun Month Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun Month (Fun Month Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun Month (Fun Month Bool))

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

(|<) :: R (Fun Month (Fun Month Bool))

(|<=) :: R (Fun Month (Fun Month Bool))

(|>=) :: R (Fun Month (Fun Month Bool))

(|>) :: R (Fun Month (Fun Month Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun Month (Fun Month Month))

gmin :: RefSrcPos -> RefExp -> R (Fun Month (Fun Month Month))

smax :: R (Fun Month (Fun Month Month))

smin :: R (Fun Month (Fun Month Month))

Ord GeneralCategory

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun GeneralCategory (Fun GeneralCategory Ordering))

scompare :: R (Fun GeneralCategory (Fun GeneralCategory Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun GeneralCategory (Fun GeneralCategory Bool))

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

(!>=) :: RefSrcPos -> RefExp -> R (Fun GeneralCategory (Fun GeneralCategory Bool))

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

(|<) :: R (Fun GeneralCategory (Fun GeneralCategory Bool))

(|<=) :: R (Fun GeneralCategory (Fun GeneralCategory Bool))

(|>=) :: R (Fun GeneralCategory (Fun GeneralCategory Bool))

(|>) :: R (Fun GeneralCategory (Fun GeneralCategory Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun GeneralCategory (Fun GeneralCategory GeneralCategory))

gmin :: RefSrcPos -> RefExp -> R (Fun GeneralCategory (Fun GeneralCategory GeneralCategory))

smax :: R (Fun GeneralCategory (Fun GeneralCategory GeneralCategory))

smin :: R (Fun GeneralCategory (Fun GeneralCategory GeneralCategory))

Ord a => Ord (List a)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List a) Ordering))

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

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

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

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

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

(|<) :: R (Fun (List a) (Fun (List a) Bool))

(|<=) :: R (Fun (List a) (Fun (List a) Bool))

(|>=) :: R (Fun (List a) (Fun (List a) Bool))

(|>) :: R (Fun (List a) (Fun (List a) Bool))

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

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

smax :: R (Fun (List a) (Fun (List a) (List a)))

smin :: R (Fun (List a) (Fun (List a) (List a)))

Integral a => Ord (Ratio a)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Ratio a) (Fun (Ratio a) Ordering))

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

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

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

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

(!>) :: RefSrcPos -> RefExp -> R (Fun (Ratio a) (Fun (Ratio a) Bool))

(|<) :: R (Fun (Ratio a) (Fun (Ratio a) Bool))

(|<=) :: R (Fun (Ratio a) (Fun (Ratio a) Bool))

(|>=) :: R (Fun (Ratio a) (Fun (Ratio a) Bool))

(|>) :: R (Fun (Ratio a) (Fun (Ratio a) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Ratio a) (Fun (Ratio a) (Ratio a)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Ratio a) (Fun (Ratio a) (Ratio a)))

smax :: R (Fun (Ratio a) (Fun (Ratio a) (Ratio a)))

smin :: R (Fun (Ratio a) (Fun (Ratio a) (Ratio a)))

Ord a => Ord (Maybe a)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Maybe a) Ordering))

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

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

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

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

(!>) :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Maybe a) Bool))

(|<) :: R (Fun (Maybe a) (Fun (Maybe a) Bool))

(|<=) :: R (Fun (Maybe a) (Fun (Maybe a) Bool))

(|>=) :: R (Fun (Maybe a) (Fun (Maybe a) Bool))

(|>) :: R (Fun (Maybe a) (Fun (Maybe a) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

smax :: R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

smin :: R (Fun (Maybe a) (Fun (Maybe a) (Maybe a)))

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

Methods

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

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

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple2 a b) (Fun (Tuple2 a b) Bool))

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

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

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

(|<) :: R (Fun (Tuple2 a b) (Fun (Tuple2 a b) Bool))

(|<=) :: R (Fun (Tuple2 a b) (Fun (Tuple2 a b) Bool))

(|>=) :: R (Fun (Tuple2 a b) (Fun (Tuple2 a b) Bool))

(|>) :: R (Fun (Tuple2 a b) (Fun (Tuple2 a b) Bool))

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

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

smax :: R (Fun (Tuple2 a b) (Fun (Tuple2 a b) (Tuple2 a b)))

smin :: R (Fun (Tuple2 a b) (Fun (Tuple2 a b) (Tuple2 a b)))

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

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Either a b) (Fun (Either a b) Ordering))

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

(!<) :: RefSrcPos -> RefExp -> R (Fun (Either a b) (Fun (Either a b) Bool))

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

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

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

(|<) :: R (Fun (Either a b) (Fun (Either a b) Bool))

(|<=) :: R (Fun (Either a b) (Fun (Either a b) Bool))

(|>=) :: R (Fun (Either a b) (Fun (Either a b) Bool))

(|>) :: R (Fun (Either a b) (Fun (Either a b) Bool))

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

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

smax :: R (Fun (Either a b) (Fun (Either a b) (Either a b)))

smin :: R (Fun (Either a b) (Fun (Either a b) (Either a b)))

(Ix a, Ord b) => Ord (Array a b)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Array a b) (Fun (Array a b) Ordering))

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

(!<) :: RefSrcPos -> RefExp -> R (Fun (Array a b) (Fun (Array a b) Bool))

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

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

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

(|<) :: R (Fun (Array a b) (Fun (Array a b) Bool))

(|<=) :: R (Fun (Array a b) (Fun (Array a b) Bool))

(|>=) :: R (Fun (Array a b) (Fun (Array a b) Bool))

(|>) :: R (Fun (Array a b) (Fun (Array a b) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Array a b) (Fun (Array a b) (Array a b)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Array a b) (Fun (Array a b) (Array a b)))

smax :: R (Fun (Array a b) (Fun (Array a b) (Array a b)))

smin :: R (Fun (Array a b) (Fun (Array a b) (Array a b)))

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

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Ordering))

scompare :: R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

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

(|<) :: R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

(|<=) :: R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

(|>=) :: R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

(|>) :: R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) Bool))

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

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

smax :: R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) (Tuple3 a b c)))

smin :: R (Fun (Tuple3 a b c) (Fun (Tuple3 a b c) (Tuple3 a b c)))

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

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Ordering))

scompare :: R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

(|<) :: R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

(|<=) :: R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

(|>=) :: R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

(|>) :: R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) (Tuple4 a b c d)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) (Tuple4 a b c d)))

smax :: R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) (Tuple4 a b c d)))

smin :: R (Fun (Tuple4 a b c d) (Fun (Tuple4 a b c d) (Tuple4 a b c d)))

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

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Ordering))

scompare :: R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

(|<) :: R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

(|<=) :: R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

(|>=) :: R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

(|>) :: R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) (Tuple5 a b c d e)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) (Tuple5 a b c d e)))

smax :: R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) (Tuple5 a b c d e)))

smin :: R (Fun (Tuple5 a b c d e) (Fun (Tuple5 a b c d e) (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)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Ordering))

scompare :: R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

(|<) :: R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

(|<=) :: R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

(|>=) :: R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

(|>) :: R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) (Tuple6 a b c d e f)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) (Tuple6 a b c d e f)))

smax :: R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) (Tuple6 a b c d e f)))

smin :: R (Fun (Tuple6 a b c d e f) (Fun (Tuple6 a b c d e f) (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)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Ordering))

scompare :: R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

(|<) :: R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

(|<=) :: R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

(|>=) :: R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

(|>) :: R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) (Tuple7 a b c d e f g)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) (Tuple7 a b c d e f g)))

smax :: R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) (Tuple7 a b c d e f g)))

smin :: R (Fun (Tuple7 a b c d e f g) (Fun (Tuple7 a b c d e f g) (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)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Ordering))

scompare :: R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

(|<) :: R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

(|<=) :: R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

(|>=) :: R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

(|>) :: R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) (Tuple8 a b c d e f g h)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) (Tuple8 a b c d e f g h)))

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

smin :: R (Fun (Tuple8 a b c d e f g h) (Fun (Tuple8 a b c d e f g h) (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)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Ordering))

scompare :: R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

(|<) :: R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

(|<=) :: R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

(|>=) :: R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

(|>) :: R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) (Tuple9 a b c d e f g h i)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) (Tuple9 a b c d e f g h i)))

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

smin :: R (Fun (Tuple9 a b c d e f g h i) (Fun (Tuple9 a b c d e f g h i) (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)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Ordering))

scompare :: R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

(|<) :: R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

(|<=) :: R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

(|>=) :: R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

(|>) :: R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) (Tuple10 a b c d e f g h i j)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) (Tuple10 a b c d e f g h i j)))

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

smin :: R (Fun (Tuple10 a b c d e f g h i j) (Fun (Tuple10 a b c d e f g h i j) (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)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Ordering))

scompare :: R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Ordering))

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

(|<) :: R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

(|<=) :: R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

(|>=) :: R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

(|>) :: R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) (Tuple11 a b c d e f g h i j k)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) (Tuple11 a b c d e f g h i j k)))

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

smin :: R (Fun (Tuple11 a b c d e f g h i j k) (Fun (Tuple11 a b c d e f g h i j k) (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)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Ordering))

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

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

(|<) :: R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

(|<=) :: R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

(|>=) :: R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

(|>) :: R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) (Tuple12 a b c d e f g h i j k l)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) (Tuple12 a b c d e f g h i j k l)))

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

smin :: R (Fun (Tuple12 a b c d e f g h i j k l) (Fun (Tuple12 a b c d e f g h i j k l) (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)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Ordering))

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

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

(|<) :: R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

(|<=) :: R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

(|>=) :: R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

(|>) :: R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) (Tuple13 a b c d e f g h i j k l m)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) (Tuple13 a b c d e f g h i j k l m)))

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

smin :: R (Fun (Tuple13 a b c d e f g h i j k l m) (Fun (Tuple13 a b c d e f g h i j k l m) (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)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Ordering))

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

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

(|<) :: R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

(|<=) :: R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

(|>=) :: R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

(|>) :: R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) (Tuple14 a b c d e f g h i j k l m n)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) (Tuple14 a b c d e f g h i j k l m n)))

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

smin :: R (Fun (Tuple14 a b c d e f g h i j k l m n) (Fun (Tuple14 a b c d e f g h i j k l m n) (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)

Methods

gcompare :: RefSrcPos -> RefExp -> R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Ordering))

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

(!<) :: RefSrcPos -> RefExp -> R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

(!<=) :: RefSrcPos -> RefExp -> R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

(!>=) :: RefSrcPos -> RefExp -> R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

(!>) :: RefSrcPos -> RefExp -> R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

(|<) :: R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

(|<=) :: R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

(|>=) :: R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

(|>) :: R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) Bool))

gmax :: RefSrcPos -> RefExp -> R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) (Tuple15 a b c d e f g h i j k l m n o)))

gmin :: RefSrcPos -> RefExp -> R (Fun (Tuple15 a b c d e f g h i j k l m n o) (Fun (Tuple15 a b c d e f g h i j k l m n o) (Tuple15 a b c d e f g h i j k l m n o)))

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

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

class Enum a where

Minimal complete definition

gtoEnum, gfromEnum, senumFrom, senumFromThen, senumFromTo, senumFromThenTo

Methods

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

ssucc, spred :: R (Fun a a)

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

stoEnum :: R (Fun Int a)

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

sfromEnum :: R (Fun a Int)

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

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

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

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

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

senumFromTo :: R (Fun a (Fun a (List a)))

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

senumFromThenTo :: R (Fun a (Fun a (Fun a (List a))))

Instances

Enum Bool

Methods

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

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

ssucc :: R (Fun Bool Bool)

spred :: R (Fun Bool Bool)

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

stoEnum :: R (Fun Int Bool)

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

sfromEnum :: R (Fun Bool Int)

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

senumFrom :: R (Fun Bool (List Bool))

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

senumFromThen :: R (Fun Bool (Fun Bool (List Bool)))

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

senumFromTo :: R (Fun Bool (Fun Bool (List Bool)))

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

senumFromThenTo :: R (Fun Bool (Fun Bool (Fun Bool (List Bool))))

Enum Char

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Char Char)

gpred :: RefSrcPos -> RefExp -> R (Fun Char Char)

ssucc :: R (Fun Char Char)

spred :: R (Fun Char Char)

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

stoEnum :: R (Fun Int Char)

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

sfromEnum :: R (Fun Char Int)

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

senumFrom :: R (Fun Char (List Char))

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

senumFromThen :: R (Fun Char (Fun Char (List Char)))

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

senumFromTo :: R (Fun Char (Fun Char (List Char)))

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

senumFromThenTo :: R (Fun Char (Fun Char (Fun Char (List Char))))

Enum Double

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Double Double)

gpred :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssucc :: R (Fun Double Double)

spred :: R (Fun Double Double)

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

stoEnum :: R (Fun Int Double)

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

sfromEnum :: R (Fun Double Int)

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

senumFrom :: R (Fun Double (List Double))

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

senumFromThen :: R (Fun Double (Fun Double (List Double)))

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

senumFromTo :: R (Fun Double (Fun Double (List Double)))

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

senumFromThenTo :: R (Fun Double (Fun Double (Fun Double (List Double))))

Enum Float

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Float Float)

gpred :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssucc :: R (Fun Float Float)

spred :: R (Fun Float Float)

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

stoEnum :: R (Fun Int Float)

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

sfromEnum :: R (Fun Float Int)

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

senumFrom :: R (Fun Float (List Float))

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

senumFromThen :: R (Fun Float (Fun Float (List Float)))

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

senumFromTo :: R (Fun Float (Fun Float (List Float)))

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

senumFromThenTo :: R (Fun Float (Fun Float (Fun Float (List Float))))

Enum Int

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Int Int)

gpred :: RefSrcPos -> RefExp -> R (Fun Int Int)

ssucc :: R (Fun Int Int)

spred :: R (Fun Int Int)

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

stoEnum :: R (Fun Int Int)

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

sfromEnum :: R (Fun Int Int)

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

senumFrom :: R (Fun Int (List Int))

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

senumFromThen :: R (Fun Int (Fun Int (List Int)))

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

senumFromTo :: R (Fun Int (Fun Int (List Int)))

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

senumFromThenTo :: R (Fun Int (Fun Int (Fun Int (List Int))))

Enum Integer

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

gpred :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

ssucc :: R (Fun Integer Integer)

spred :: R (Fun Integer Integer)

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

stoEnum :: R (Fun Int Integer)

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

sfromEnum :: R (Fun Integer Int)

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

senumFrom :: R (Fun Integer (List Integer))

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

senumFromThen :: R (Fun Integer (Fun Integer (List Integer)))

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

senumFromTo :: R (Fun Integer (Fun Integer (List Integer)))

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

senumFromThenTo :: R (Fun Integer (Fun Integer (Fun Integer (List Integer))))

Enum Tuple0

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Tuple0 Tuple0)

gpred :: RefSrcPos -> RefExp -> R (Fun Tuple0 Tuple0)

ssucc :: R (Fun Tuple0 Tuple0)

spred :: R (Fun Tuple0 Tuple0)

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

stoEnum :: R (Fun Int Tuple0)

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

sfromEnum :: R (Fun Tuple0 Int)

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

senumFrom :: R (Fun Tuple0 (List Tuple0))

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

senumFromThen :: R (Fun Tuple0 (Fun Tuple0 (List Tuple0)))

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

senumFromTo :: R (Fun Tuple0 (Fun Tuple0 (List Tuple0)))

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

senumFromThenTo :: R (Fun Tuple0 (Fun Tuple0 (Fun Tuple0 (List Tuple0))))

Enum Ordering

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Ordering Ordering)

gpred :: RefSrcPos -> RefExp -> R (Fun Ordering Ordering)

ssucc :: R (Fun Ordering Ordering)

spred :: R (Fun Ordering Ordering)

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

stoEnum :: R (Fun Int Ordering)

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

sfromEnum :: R (Fun Ordering Int)

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

senumFrom :: R (Fun Ordering (List Ordering))

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

senumFromThen :: R (Fun Ordering (Fun Ordering (List Ordering)))

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

senumFromTo :: R (Fun Ordering (Fun Ordering (List Ordering)))

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

senumFromThenTo :: R (Fun Ordering (Fun Ordering (Fun Ordering (List Ordering))))

Enum SeekMode

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun SeekMode SeekMode)

gpred :: RefSrcPos -> RefExp -> R (Fun SeekMode SeekMode)

ssucc :: R (Fun SeekMode SeekMode)

spred :: R (Fun SeekMode SeekMode)

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

stoEnum :: R (Fun Int SeekMode)

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

sfromEnum :: R (Fun SeekMode Int)

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

senumFrom :: R (Fun SeekMode (List SeekMode))

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

senumFromThen :: R (Fun SeekMode (Fun SeekMode (List SeekMode)))

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

senumFromTo :: R (Fun SeekMode (Fun SeekMode (List SeekMode)))

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

senumFromThenTo :: R (Fun SeekMode (Fun SeekMode (Fun SeekMode (List SeekMode))))

Enum IOMode

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun IOMode IOMode)

gpred :: RefSrcPos -> RefExp -> R (Fun IOMode IOMode)

ssucc :: R (Fun IOMode IOMode)

spred :: R (Fun IOMode IOMode)

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

stoEnum :: R (Fun Int IOMode)

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

sfromEnum :: R (Fun IOMode Int)

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

senumFrom :: R (Fun IOMode (List IOMode))

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

senumFromThen :: R (Fun IOMode (Fun IOMode (List IOMode)))

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

senumFromTo :: R (Fun IOMode (Fun IOMode (List IOMode)))

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

senumFromThenTo :: R (Fun IOMode (Fun IOMode (Fun IOMode (List IOMode))))

Enum Day

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Day Day)

gpred :: RefSrcPos -> RefExp -> R (Fun Day Day)

ssucc :: R (Fun Day Day)

spred :: R (Fun Day Day)

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

stoEnum :: R (Fun Int Day)

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

sfromEnum :: R (Fun Day Int)

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

senumFrom :: R (Fun Day (List Day))

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

senumFromThen :: R (Fun Day (Fun Day (List Day)))

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

senumFromTo :: R (Fun Day (Fun Day (List Day)))

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

senumFromThenTo :: R (Fun Day (Fun Day (Fun Day (List Day))))

Enum Month

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun Month Month)

gpred :: RefSrcPos -> RefExp -> R (Fun Month Month)

ssucc :: R (Fun Month Month)

spred :: R (Fun Month Month)

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

stoEnum :: R (Fun Int Month)

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

sfromEnum :: R (Fun Month Int)

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

senumFrom :: R (Fun Month (List Month))

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

senumFromThen :: R (Fun Month (Fun Month (List Month)))

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

senumFromTo :: R (Fun Month (Fun Month (List Month)))

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

senumFromThenTo :: R (Fun Month (Fun Month (Fun Month (List Month))))

Enum GeneralCategory

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun GeneralCategory GeneralCategory)

gpred :: RefSrcPos -> RefExp -> R (Fun GeneralCategory GeneralCategory)

ssucc :: R (Fun GeneralCategory GeneralCategory)

spred :: R (Fun GeneralCategory GeneralCategory)

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

stoEnum :: R (Fun Int GeneralCategory)

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

sfromEnum :: R (Fun GeneralCategory Int)

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

senumFrom :: R (Fun GeneralCategory (List GeneralCategory))

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

senumFromThen :: R (Fun GeneralCategory (Fun GeneralCategory (List GeneralCategory)))

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

senumFromTo :: R (Fun GeneralCategory (Fun GeneralCategory (List GeneralCategory)))

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

senumFromThenTo :: R (Fun GeneralCategory (Fun GeneralCategory (Fun GeneralCategory (List GeneralCategory))))

Integral a => Enum (Ratio a)

Methods

gsucc :: RefSrcPos -> RefExp -> R (Fun (Ratio a) (Ratio a))

gpred :: RefSrcPos -> RefExp -> R (Fun (Ratio a) (Ratio a))

ssucc :: R (Fun (Ratio a) (Ratio a))

spred :: R (Fun (Ratio a) (Ratio a))

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

stoEnum :: R (Fun Int (Ratio a))

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

sfromEnum :: R (Fun (Ratio a) Int)

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

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

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

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

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

senumFromTo :: R (Fun (Ratio a) (Fun (Ratio a) (List (Ratio a))))

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

senumFromThenTo :: R (Fun (Ratio a) (Fun (Ratio a) (Fun (Ratio a) (List (Ratio a)))))

class Bounded a where

Minimal complete definition

gminBound, gmaxBound

Methods

gminBound :: RefSrcPos -> RefExp -> R a

sminBound :: R a

gmaxBound :: RefSrcPos -> RefExp -> R a

smaxBound :: R a

Instances

Bounded Bool

Methods

gminBound :: RefSrcPos -> RefExp -> R Bool

sminBound :: R Bool

gmaxBound :: RefSrcPos -> RefExp -> R Bool

smaxBound :: R Bool

Bounded Char

Methods

gminBound :: RefSrcPos -> RefExp -> R Char

sminBound :: R Char

gmaxBound :: RefSrcPos -> RefExp -> R Char

smaxBound :: R Char

Bounded Int

Methods

gminBound :: RefSrcPos -> RefExp -> R Int

sminBound :: R Int

gmaxBound :: RefSrcPos -> RefExp -> R Int

smaxBound :: R Int

Bounded Tuple0

Methods

gminBound :: RefSrcPos -> RefExp -> R Tuple0

sminBound :: R Tuple0

gmaxBound :: RefSrcPos -> RefExp -> R Tuple0

smaxBound :: R Tuple0

Bounded Ordering

Methods

gminBound :: RefSrcPos -> RefExp -> R Ordering

sminBound :: R Ordering

gmaxBound :: RefSrcPos -> RefExp -> R Ordering

smaxBound :: R Ordering

Bounded SeekMode

Methods

gminBound :: RefSrcPos -> RefExp -> R SeekMode

sminBound :: R SeekMode

gmaxBound :: RefSrcPos -> RefExp -> R SeekMode

smaxBound :: R SeekMode

Bounded IOMode

Methods

gminBound :: RefSrcPos -> RefExp -> R IOMode

sminBound :: R IOMode

gmaxBound :: RefSrcPos -> RefExp -> R IOMode

smaxBound :: R IOMode

Bounded Day

Methods

gminBound :: RefSrcPos -> RefExp -> R Day

sminBound :: R Day

gmaxBound :: RefSrcPos -> RefExp -> R Day

smaxBound :: R Day

Bounded Month

Methods

gminBound :: RefSrcPos -> RefExp -> R Month

sminBound :: R Month

gmaxBound :: RefSrcPos -> RefExp -> R Month

smaxBound :: R Month

Bounded GeneralCategory

Methods

gminBound :: RefSrcPos -> RefExp -> R GeneralCategory

sminBound :: R GeneralCategory

gmaxBound :: RefSrcPos -> RefExp -> R GeneralCategory

smaxBound :: R GeneralCategory

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

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple2 a b)

sminBound :: R (Tuple2 a b)

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple2 a b)

smaxBound :: R (Tuple2 a b)

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

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple3 a b c)

sminBound :: R (Tuple3 a b c)

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple3 a b c)

smaxBound :: R (Tuple3 a b c)

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

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple4 a b c d)

sminBound :: R (Tuple4 a b c d)

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple4 a b c d)

smaxBound :: R (Tuple4 a b c d)

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

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple5 a b c d e)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple5 a b c d e)

smaxBound :: R (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)

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple6 a b c d e f)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple6 a b c d e f)

smaxBound :: R (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)

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple7 a b c d e f g)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple7 a b c d e f g)

smaxBound :: R (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)

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple8 a b c d e f g h)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple8 a b c d e f g h)

smaxBound :: R (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)

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple9 a b c d e f g h i)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple9 a b c d e f g h i)

smaxBound :: R (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)

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple10 a b c d e f g h i j)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple10 a b c d e f g h i j)

smaxBound :: R (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)

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple11 a b c d e f g h i j k)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple11 a b c d e f g h i j k)

smaxBound :: R (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)

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple12 a b c d e f g h i j k l)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple12 a b c d e f g h i j k l)

smaxBound :: R (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)

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple13 a b c d e f g h i j k l m)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple13 a b c d e f g h i j k l m)

smaxBound :: R (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)

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple14 a b c d e f g h i j k l m n)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple14 a b c d e f g h i j k l m n)

smaxBound :: R (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)

Methods

gminBound :: RefSrcPos -> RefExp -> R (Tuple15 a b c d e f g h i j k l m n o)

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

gmaxBound :: RefSrcPos -> RefExp -> R (Tuple15 a b c d e f g h i j k l m n o)

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

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

Minimal complete definition

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

Methods

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

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

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

snegate :: R (Fun a a)

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

sabs, ssignum :: R (Fun a a)

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

sfromInteger :: R (Fun Integer a)

Instances

Num Double

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(!-) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(!*) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(|+) :: R (Fun Double (Fun Double Double))

(|-) :: R (Fun Double (Fun Double Double))

(|*) :: R (Fun Double (Fun Double Double))

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

snegate :: R (Fun Double Double)

gabs :: RefSrcPos -> RefExp -> R (Fun Double Double)

gsignum :: RefSrcPos -> RefExp -> R (Fun Double Double)

sabs :: R (Fun Double Double)

ssignum :: R (Fun Double Double)

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

sfromInteger :: R (Fun Integer Double)

Num Float

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(!-) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(!*) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(|+) :: R (Fun Float (Fun Float Float))

(|-) :: R (Fun Float (Fun Float Float))

(|*) :: R (Fun Float (Fun Float Float))

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

snegate :: R (Fun Float Float)

gabs :: RefSrcPos -> RefExp -> R (Fun Float Float)

gsignum :: RefSrcPos -> RefExp -> R (Fun Float Float)

sabs :: R (Fun Float Float)

ssignum :: R (Fun Float Float)

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

sfromInteger :: R (Fun Integer Float)

Num Int

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

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

(!*) :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

(|+) :: R (Fun Int (Fun Int Int))

(|-) :: R (Fun Int (Fun Int Int))

(|*) :: R (Fun Int (Fun Int Int))

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

snegate :: R (Fun Int Int)

gabs :: RefSrcPos -> RefExp -> R (Fun Int Int)

gsignum :: RefSrcPos -> RefExp -> R (Fun Int Int)

sabs :: R (Fun Int Int)

ssignum :: R (Fun Int Int)

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

sfromInteger :: R (Fun Integer Int)

Num Integer

Methods

(!+) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

(!-) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

(!*) :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

(|+) :: R (Fun Integer (Fun Integer Integer))

(|-) :: R (Fun Integer (Fun Integer Integer))

(|*) :: R (Fun Integer (Fun Integer Integer))

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

snegate :: R (Fun Integer Integer)

gabs :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

gsignum :: RefSrcPos -> RefExp -> R (Fun Integer Integer)

sabs :: R (Fun Integer Integer)

ssignum :: R (Fun Integer Integer)

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

sfromInteger :: R (Fun Integer Integer)

Integral a => Num (Ratio a)

Methods

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

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

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

(|+) :: R (Fun (Ratio a) (Fun (Ratio a) (Ratio a)))

(|-) :: R (Fun (Ratio a) (Fun (Ratio a) (Ratio a)))

(|*) :: R (Fun (Ratio a) (Fun (Ratio a) (Ratio a)))

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

snegate :: R (Fun (Ratio a) (Ratio a))

gabs :: RefSrcPos -> RefExp -> R (Fun (Ratio a) (Ratio a))

gsignum :: RefSrcPos -> RefExp -> R (Fun (Ratio a) (Ratio a))

sabs :: R (Fun (Ratio a) (Ratio a))

ssignum :: R (Fun (Ratio a) (Ratio a))

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

sfromInteger :: R (Fun Integer (Ratio a))

RealFloat a => Num (Complex a)

Methods

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

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

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

(|+) :: R (Fun (Complex a) (Fun (Complex a) (Complex a)))

(|-) :: R (Fun (Complex a) (Fun (Complex a) (Complex a)))

(|*) :: R (Fun (Complex a) (Fun (Complex a) (Complex a)))

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

snegate :: R (Fun (Complex a) (Complex a))

gabs :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

gsignum :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

sabs :: R (Fun (Complex a) (Complex a))

ssignum :: R (Fun (Complex a) (Complex a))

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

sfromInteger :: R (Fun Integer (Complex a))

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

Minimal complete definition

gtoRational

Methods

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

stoRational :: R (Fun a Rational)

Instances

Real Double

Methods

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

stoRational :: R (Fun Double Rational)

Real Float

Methods

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

stoRational :: R (Fun Float Rational)

Real Int

Methods

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

stoRational :: R (Fun Int Rational)

Real Integer

Methods

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

stoRational :: R (Fun Integer Rational)

Integral a => Real (Ratio a)

Methods

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

stoRational :: R (Fun (Ratio a) Rational)

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

Minimal complete definition

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

Methods

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

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

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

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

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

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

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

stoInteger :: R (Fun a Integer)

Instances

Integral Int

Methods

gquot :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

grem :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

squot :: R (Fun Int (Fun Int Int))

srem :: R (Fun Int (Fun Int Int))

gdiv :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

gmod :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int Int))

sdiv :: R (Fun Int (Fun Int Int))

smod :: R (Fun Int (Fun Int Int))

gquotRem :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (Tuple2 Int Int)))

gdivMod :: RefSrcPos -> RefExp -> R (Fun Int (Fun Int (Tuple2 Int Int)))

squotRem :: R (Fun Int (Fun Int (Tuple2 Int Int)))

sdivMod :: R (Fun Int (Fun Int (Tuple2 Int Int)))

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

stoInteger :: R (Fun Int Integer)

Integral Integer

Methods

gquot :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

grem :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

squot :: R (Fun Integer (Fun Integer Integer))

srem :: R (Fun Integer (Fun Integer Integer))

gdiv :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

gmod :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer Integer))

sdiv :: R (Fun Integer (Fun Integer Integer))

smod :: R (Fun Integer (Fun Integer Integer))

gquotRem :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

gdivMod :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

squotRem :: R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

sdivMod :: R (Fun Integer (Fun Integer (Tuple2 Integer Integer)))

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

stoInteger :: R (Fun Integer Integer)

class Num a => Fractional a where

Minimal complete definition

(|/), srecip, gfromRational

Methods

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

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

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

srecip :: R (Fun a a)

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

sfromRational :: R (Fun Rational a)

Instances

Fractional Double

Methods

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

(|/) :: R (Fun Double (Fun Double Double))

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

srecip :: R (Fun Double Double)

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

sfromRational :: R (Fun Rational Double)

Fractional Float

Methods

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

(|/) :: R (Fun Float (Fun Float Float))

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

srecip :: R (Fun Float Float)

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

sfromRational :: R (Fun Rational Float)

Integral a => Fractional (Ratio a)

Methods

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

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

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

srecip :: R (Fun (Ratio a) (Ratio a))

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

sfromRational :: R (Fun Rational (Ratio a))

RealFloat a => Fractional (Complex a)

Methods

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

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

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

srecip :: R (Fun (Complex a) (Complex a))

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

sfromRational :: R (Fun Rational (Complex a))

class Fractional a => Floating a where

Minimal complete definition

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

Methods

gpi :: RefSrcPos -> RefExp -> R a

spi :: R a

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

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

(!**), glogBase :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))

(|**), slogBase :: R (Fun a (Fun a a))

gsin, gcos, gtan :: RefSrcPos -> RefExp -> R (Fun a a)

ssin, scos, stan :: R (Fun a a)

gasin, gacos, gatan :: RefSrcPos -> RefExp -> R (Fun a a)

sasin, sacos, satan :: R (Fun a a)

gsinh, gcosh, gtanh :: RefSrcPos -> RefExp -> R (Fun a a)

ssinh, scosh, stanh :: R (Fun a a)

gasinh, gacosh, gatanh :: RefSrcPos -> RefExp -> R (Fun a a)

sasinh, sacosh, satanh :: R (Fun a a)

Instances

Floating Double

Methods

gpi :: RefSrcPos -> RefExp -> R Double

spi :: R Double

gexp :: RefSrcPos -> RefExp -> R (Fun Double Double)

glog :: RefSrcPos -> RefExp -> R (Fun Double Double)

gsqrt :: RefSrcPos -> RefExp -> R (Fun Double Double)

sexp :: R (Fun Double Double)

slog :: R (Fun Double Double)

ssqrt :: R (Fun Double Double)

(!**) :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

glogBase :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

(|**) :: R (Fun Double (Fun Double Double))

slogBase :: R (Fun Double (Fun Double Double))

gsin :: RefSrcPos -> RefExp -> R (Fun Double Double)

gcos :: RefSrcPos -> RefExp -> R (Fun Double Double)

gtan :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssin :: R (Fun Double Double)

scos :: R (Fun Double Double)

stan :: R (Fun Double Double)

gasin :: RefSrcPos -> RefExp -> R (Fun Double Double)

gacos :: RefSrcPos -> RefExp -> R (Fun Double Double)

gatan :: RefSrcPos -> RefExp -> R (Fun Double Double)

sasin :: R (Fun Double Double)

sacos :: R (Fun Double Double)

satan :: R (Fun Double Double)

gsinh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gcosh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gtanh :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssinh :: R (Fun Double Double)

scosh :: R (Fun Double Double)

stanh :: R (Fun Double Double)

gasinh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gacosh :: RefSrcPos -> RefExp -> R (Fun Double Double)

gatanh :: RefSrcPos -> RefExp -> R (Fun Double Double)

sasinh :: R (Fun Double Double)

sacosh :: R (Fun Double Double)

satanh :: R (Fun Double Double)

Floating Float

Methods

gpi :: RefSrcPos -> RefExp -> R Float

spi :: R Float

gexp :: RefSrcPos -> RefExp -> R (Fun Float Float)

glog :: RefSrcPos -> RefExp -> R (Fun Float Float)

gsqrt :: RefSrcPos -> RefExp -> R (Fun Float Float)

sexp :: R (Fun Float Float)

slog :: R (Fun Float Float)

ssqrt :: R (Fun Float Float)

(!**) :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

glogBase :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

(|**) :: R (Fun Float (Fun Float Float))

slogBase :: R (Fun Float (Fun Float Float))

gsin :: RefSrcPos -> RefExp -> R (Fun Float Float)

gcos :: RefSrcPos -> RefExp -> R (Fun Float Float)

gtan :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssin :: R (Fun Float Float)

scos :: R (Fun Float Float)

stan :: R (Fun Float Float)

gasin :: RefSrcPos -> RefExp -> R (Fun Float Float)

gacos :: RefSrcPos -> RefExp -> R (Fun Float Float)

gatan :: RefSrcPos -> RefExp -> R (Fun Float Float)

sasin :: R (Fun Float Float)

sacos :: R (Fun Float Float)

satan :: R (Fun Float Float)

gsinh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gcosh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gtanh :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssinh :: R (Fun Float Float)

scosh :: R (Fun Float Float)

stanh :: R (Fun Float Float)

gasinh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gacosh :: RefSrcPos -> RefExp -> R (Fun Float Float)

gatanh :: RefSrcPos -> RefExp -> R (Fun Float Float)

sasinh :: R (Fun Float Float)

sacosh :: R (Fun Float Float)

satanh :: R (Fun Float Float)

RealFloat a => Floating (Complex a)

Methods

gpi :: RefSrcPos -> RefExp -> R (Complex a)

spi :: R (Complex a)

gexp :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

glog :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

gsqrt :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

sexp :: R (Fun (Complex a) (Complex a))

slog :: R (Fun (Complex a) (Complex a))

ssqrt :: R (Fun (Complex a) (Complex a))

(!**) :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Fun (Complex a) (Complex a)))

glogBase :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Fun (Complex a) (Complex a)))

(|**) :: R (Fun (Complex a) (Fun (Complex a) (Complex a)))

slogBase :: R (Fun (Complex a) (Fun (Complex a) (Complex a)))

gsin :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

gcos :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

gtan :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

ssin :: R (Fun (Complex a) (Complex a))

scos :: R (Fun (Complex a) (Complex a))

stan :: R (Fun (Complex a) (Complex a))

gasin :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

gacos :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

gatan :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

sasin :: R (Fun (Complex a) (Complex a))

sacos :: R (Fun (Complex a) (Complex a))

satan :: R (Fun (Complex a) (Complex a))

gsinh :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

gcosh :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

gtanh :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

ssinh :: R (Fun (Complex a) (Complex a))

scosh :: R (Fun (Complex a) (Complex a))

stanh :: R (Fun (Complex a) (Complex a))

gasinh :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

gacosh :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

gatanh :: RefSrcPos -> RefExp -> R (Fun (Complex a) (Complex a))

sasinh :: R (Fun (Complex a) (Complex a))

sacosh :: R (Fun (Complex a) (Complex a))

satanh :: R (Fun (Complex a) (Complex a))

class (Real a, Fractional a) => RealFrac a where

Minimal complete definition

gproperFraction, struncate, sround, sceiling, sfloor

Methods

gproperFraction :: Integral b => RefSrcPos -> RefExp -> R (Fun a (Tuple2 b a))

sproperFraction :: Integral b => R (Fun a (Tuple2 b a))

gtruncate, ground :: Integral b => RefSrcPos -> RefExp -> R (Fun a b)

struncate, sround :: Integral b => R (Fun a b)

gceiling, gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun a b)

sceiling, sfloor :: Integral b => R (Fun a b)

Instances

RealFrac Double

Methods

gproperFraction :: Integral b => RefSrcPos -> RefExp -> R (Fun Double (Tuple2 b Double))

sproperFraction :: Integral b => R (Fun Double (Tuple2 b Double))

gtruncate :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

ground :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

struncate :: Integral b => R (Fun Double b)

sround :: Integral b => R (Fun Double b)

gceiling :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun Double b)

sceiling :: Integral b => R (Fun Double b)

sfloor :: Integral b => R (Fun Double b)

RealFrac Float

Methods

gproperFraction :: Integral b => RefSrcPos -> RefExp -> R (Fun Float (Tuple2 b Float))

sproperFraction :: Integral b => R (Fun Float (Tuple2 b Float))

gtruncate :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

ground :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

struncate :: Integral b => R (Fun Float b)

sround :: Integral b => R (Fun Float b)

gceiling :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun Float b)

sceiling :: Integral b => R (Fun Float b)

sfloor :: Integral b => R (Fun Float b)

Integral a => RealFrac (Ratio a)

Methods

gproperFraction :: Integral b => RefSrcPos -> RefExp -> R (Fun (Ratio a) (Tuple2 b (Ratio a)))

sproperFraction :: Integral b => R (Fun (Ratio a) (Tuple2 b (Ratio a)))

gtruncate :: Integral b => RefSrcPos -> RefExp -> R (Fun (Ratio a) b)

ground :: Integral b => RefSrcPos -> RefExp -> R (Fun (Ratio a) b)

struncate :: Integral b => R (Fun (Ratio a) b)

sround :: Integral b => R (Fun (Ratio a) b)

gceiling :: Integral b => RefSrcPos -> RefExp -> R (Fun (Ratio a) b)

gfloor :: Integral b => RefSrcPos -> RefExp -> R (Fun (Ratio a) b)

sceiling :: Integral b => R (Fun (Ratio a) b)

sfloor :: Integral b => R (Fun (Ratio a) b)

class (RealFrac a, Floating a) => RealFloat a where

Minimal complete definition

gfloatRadix, gfloatDigits, gfloatRange, gdecodeFloat, gencodeFloat, sexponent, ssignificand, sscaleFloat, gisNaN, gisInfinite, gisDenormalized, gisNegativeZero, gisIEEE, satan2

Methods

gfloatRadix :: RefSrcPos -> RefExp -> R (Fun a Integer)

sfloatRadix :: R (Fun a Integer)

gfloatDigits :: RefSrcPos -> RefExp -> R (Fun a Int)

sfloatDigits :: R (Fun a Int)

gfloatRange :: RefSrcPos -> RefExp -> R (Fun a (Tuple2 Int Int))

sfloatRange :: R (Fun a (Tuple2 Int Int))

gdecodeFloat :: RefSrcPos -> RefExp -> R (Fun a (Tuple2 Integer Int))

sdecodeFloat :: R (Fun a (Tuple2 Integer Int))

gencodeFloat :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int a))

sencodeFloat :: R (Fun Integer (Fun Int a))

gexponent :: RefSrcPos -> RefExp -> R (Fun a Int)

sexponent :: R (Fun a Int)

gsignificand :: RefSrcPos -> RefExp -> R (Fun a a)

ssignificand :: R (Fun a a)

gscaleFloat :: RefSrcPos -> RefExp -> R (Fun Int (Fun a a))

sscaleFloat :: R (Fun Int (Fun a a))

gisNaN, gisInfinite, gisDenormalized, gisNegativeZero, gisIEEE :: RefSrcPos -> RefExp -> R (Fun a Bool)

sisNaN, sisInfinite, sisDenormalized, sisNegativeZero, sisIEEE :: R (Fun a Bool)

gatan2 :: RefSrcPos -> RefExp -> R (Fun a (Fun a a))

satan2 :: R (Fun a (Fun a a))

Instances

RealFloat Double

Methods

gfloatRadix :: RefSrcPos -> RefExp -> R (Fun Double Integer)

sfloatRadix :: R (Fun Double Integer)

gfloatDigits :: RefSrcPos -> RefExp -> R (Fun Double Int)

sfloatDigits :: R (Fun Double Int)

gfloatRange :: RefSrcPos -> RefExp -> R (Fun Double (Tuple2 Int Int))

sfloatRange :: R (Fun Double (Tuple2 Int Int))

gdecodeFloat :: RefSrcPos -> RefExp -> R (Fun Double (Tuple2 Integer Int))

sdecodeFloat :: R (Fun Double (Tuple2 Integer Int))

gencodeFloat :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int Double))

sencodeFloat :: R (Fun Integer (Fun Int Double))

gexponent :: RefSrcPos -> RefExp -> R (Fun Double Int)

sexponent :: R (Fun Double Int)

gsignificand :: RefSrcPos -> RefExp -> R (Fun Double Double)

ssignificand :: R (Fun Double Double)

gscaleFloat :: RefSrcPos -> RefExp -> R (Fun Int (Fun Double Double))

sscaleFloat :: R (Fun Int (Fun Double Double))

gisNaN :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisInfinite :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisDenormalized :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisNegativeZero :: RefSrcPos -> RefExp -> R (Fun Double Bool)

gisIEEE :: RefSrcPos -> RefExp -> R (Fun Double Bool)

sisNaN :: R (Fun Double Bool)

sisInfinite :: R (Fun Double Bool)

sisDenormalized :: R (Fun Double Bool)

sisNegativeZero :: R (Fun Double Bool)

sisIEEE :: R (Fun Double Bool)

gatan2 :: RefSrcPos -> RefExp -> R (Fun Double (Fun Double Double))

satan2 :: R (Fun Double (Fun Double Double))

RealFloat Float

Methods

gfloatRadix :: RefSrcPos -> RefExp -> R (Fun Float Integer)

sfloatRadix :: R (Fun Float Integer)

gfloatDigits :: RefSrcPos -> RefExp -> R (Fun Float Int)

sfloatDigits :: R (Fun Float Int)

gfloatRange :: RefSrcPos -> RefExp -> R (Fun Float (Tuple2 Int Int))

sfloatRange :: R (Fun Float (Tuple2 Int Int))

gdecodeFloat :: RefSrcPos -> RefExp -> R (Fun Float (Tuple2 Integer Int))

sdecodeFloat :: R (Fun Float (Tuple2 Integer Int))

gencodeFloat :: RefSrcPos -> RefExp -> R (Fun Integer (Fun Int Float))

sencodeFloat :: R (Fun Integer (Fun Int Float))

gexponent :: RefSrcPos -> RefExp -> R (Fun Float Int)

sexponent :: R (Fun Float Int)

gsignificand :: RefSrcPos -> RefExp -> R (Fun Float Float)

ssignificand :: R (Fun Float Float)

gscaleFloat :: RefSrcPos -> RefExp -> R (Fun Int (Fun Float Float))

sscaleFloat :: R (Fun Int (Fun Float Float))

gisNaN :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisInfinite :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisDenormalized :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisNegativeZero :: RefSrcPos -> RefExp -> R (Fun Float Bool)

gisIEEE :: RefSrcPos -> RefExp -> R (Fun Float Bool)

sisNaN :: R (Fun Float Bool)

sisInfinite :: R (Fun Float Bool)

sisDenormalized :: R (Fun Float Bool)

sisNegativeZero :: R (Fun Float Bool)

sisIEEE :: R (Fun Float Bool)

gatan2 :: RefSrcPos -> RefExp -> R (Fun Float (Fun Float Float))

satan2 :: R (Fun Float (Fun Float Float))

class Monad m where

Minimal complete definition

(!>>=), (|>>), greturn, sfail

Methods

(!>>=) :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (Fun a (m b)) (m b)))

(|>>=) :: R (Fun (m a) (Fun (Fun a (m b)) (m b)))

(!>>) :: RefSrcPos -> RefExp -> R (Fun (m a) (Fun (m b) (m b)))

(|>>) :: R (Fun (m a) (Fun (m b) (m b)))

greturn :: RefSrcPos -> RefExp -> R (Fun a (m a))

sreturn :: R (Fun a (m a))

gfail :: RefSrcPos -> RefExp -> R (Fun String (m a))

sfail :: R (Fun String (m a))

Instances

Monad List

Methods

(!>>=) :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (Fun a (List b)) (List b)))

(|>>=) :: R (Fun (List a) (Fun (Fun a (List b)) (List b)))

(!>>) :: RefSrcPos -> RefExp -> R (Fun (List a) (Fun (List b) (List b)))

(|>>) :: R (Fun (List a) (Fun (List b) (List b)))

greturn :: RefSrcPos -> RefExp -> R (Fun a (List a))

sreturn :: R (Fun a (List a))

gfail :: RefSrcPos -> RefExp -> R (Fun String (List a))

sfail :: R (Fun String (List a))

Monad IO

Methods

(!>>=) :: RefSrcPos -> RefExp -> R (Fun (IO a) (Fun (Fun a (IO b)) (IO b)))

(|>>=) :: R (Fun (IO a) (Fun (Fun a (IO b)) (IO b)))

(!>>) :: RefSrcPos -> RefExp -> R (Fun (IO a) (Fun (IO b) (IO b)))

(|>>) :: R (Fun (IO a) (Fun (IO b) (IO b)))

greturn :: RefSrcPos -> RefExp -> R (Fun a (IO a))

sreturn :: R (Fun a (IO a))

gfail :: RefSrcPos -> RefExp -> R (Fun String (IO a))

sfail :: R (Fun String (IO a))

Monad Maybe

Methods

(!>>=) :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Fun a (Maybe b)) (Maybe b)))

(|>>=) :: R (Fun (Maybe a) (Fun (Fun a (Maybe b)) (Maybe b)))

(!>>) :: RefSrcPos -> RefExp -> R (Fun (Maybe a) (Fun (Maybe b) (Maybe b)))

(|>>) :: R (Fun (Maybe a) (Fun (Maybe b) (Maybe b)))

greturn :: RefSrcPos -> RefExp -> R (Fun a (Maybe a))

sreturn :: R (Fun a (Maybe a))

gfail :: RefSrcPos -> RefExp -> R (Fun String (Maybe a))

sfail :: R (Fun String (Maybe a))

class Functor f where

Minimal complete definition

gfmap

Methods

gfmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (f a) (f b)))

sfmap :: R (Fun (Fun a b) (Fun (f a) (f b)))

Instances

Functor List

Methods

gfmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (List a) (List b)))

sfmap :: R (Fun (Fun a b) (Fun (List a) (List b)))

Functor IO

Methods

gfmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (IO a) (IO b)))

sfmap :: R (Fun (Fun a b) (Fun (IO a) (IO b)))

Functor Maybe

Methods

gfmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (Maybe a) (Maybe b)))

sfmap :: R (Fun (Fun a b) (Fun (Maybe a) (Maybe b)))

Ix a => Functor (Array a)

Methods

gfmap :: RefSrcPos -> RefExp -> R (Fun (Fun a b) (Fun (Array a a) (Array a b)))

sfmap :: R (Fun (Fun a b) (Fun (Array a a) (Array a b)))

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