Feldspar

Documentation

module Prelude.EDSL

module Control.Monad

Types

Syntax

data Data a

Instances

FreeExp Data

Associated Types

type FreePred (Data :: * -> *) :: * -> Constraint

Methods

constExp :: FreePred Data a => a -> Data a

varExp :: FreePred Data a => VarId -> Data a

EvalExp Data

Methods

evalExp :: Data a -> a

Syntactic (Data a)

Declaring Data as syntactic sugar

Associated Types

type Domain (Data a) :: * -> *

type Internal (Data a) :: *

Methods

desugar :: Data a -> ASTF (Domain (Data a)) (Internal (Data a))

sugar :: ASTF (Domain (Data a)) (Internal (Data a)) -> Data a

PrimType' a => BulkTransferable (Data a)

Associated Types

type ContainerType (Data a) :: *

Methods

readChanBuf :: Chan * * t (Data a) -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

untypedReadChanBuf :: proxy (Data a) -> Chan * * t c -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

writeChanBuf :: Chan * * t (Data a) -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

untypedWriteChanBuf :: proxy (Data a) -> Chan * * t c -> Data Index -> Data Index -> ContainerType (Data a) -> Run (Data Bool)

PrimType' a => Transferable (Data a)

Associated Types

type SizeSpec (Data a) :: *

Methods

calcChanSize :: proxy (Data a) -> SizeSpec (Data a) -> ChanSize * Data PrimType' Length

newChan :: SizeSpec (Data a) -> Run (Chan * * Uncloseable (Data a))

newCloseableChan :: SizeSpec (Data a) -> Run (Chan * * Closeable (Data a))

readChan :: Chan * * t (Data a) -> Run (Data a)

untypedReadChan :: Chan * * t c -> Run (Data a)

writeChan :: Chan * * t (Data a) -> Data a -> Run (Data Bool)

untypedWriteChan :: Chan * * t c -> Data a -> Run (Data Bool)

MarshalFeld (Data Double)

Associated Types

type HaskellRep (Data Double) :: *

Methods

fwrite :: Handle -> Data Double -> Run ()

fread :: Handle -> Run (Data Double)

MarshalFeld (Data Float)

Associated Types

type HaskellRep (Data Float) :: *

Methods

fwrite :: Handle -> Data Float -> Run ()

fread :: Handle -> Run (Data Float)

MarshalFeld (Data Int8)

Associated Types

type HaskellRep (Data Int8) :: *

Methods

fwrite :: Handle -> Data Int8 -> Run ()

fread :: Handle -> Run (Data Int8)

MarshalFeld (Data Int16)

Associated Types

type HaskellRep (Data Int16) :: *

Methods

fwrite :: Handle -> Data Int16 -> Run ()

fread :: Handle -> Run (Data Int16)

MarshalFeld (Data Int32)

Associated Types

type HaskellRep (Data Int32) :: *

Methods

fwrite :: Handle -> Data Int32 -> Run ()

fread :: Handle -> Run (Data Int32)

MarshalFeld (Data Int64)

Associated Types

type HaskellRep (Data Int64) :: *

Methods

fwrite :: Handle -> Data Int64 -> Run ()

fread :: Handle -> Run (Data Int64)

MarshalFeld (Data Word8)

Associated Types

type HaskellRep (Data Word8) :: *

Methods

fwrite :: Handle -> Data Word8 -> Run ()

fread :: Handle -> Run (Data Word8)

MarshalFeld (Data Word16)

Associated Types

type HaskellRep (Data Word16) :: *

Methods

fwrite :: Handle -> Data Word16 -> Run ()

fread :: Handle -> Run (Data Word16)

MarshalFeld (Data Word32)

Associated Types

type HaskellRep (Data Word32) :: *

Methods

fwrite :: Handle -> Data Word32 -> Run ()

fread :: Handle -> Run (Data Word32)

MarshalFeld (Data Word64)

Associated Types

type HaskellRep (Data Word64) :: *

Methods

fwrite :: Handle -> Data Word64 -> Run ()

fread :: Handle -> Run (Data Word64)

MarshalFeld (Data (Complex Double))

Associated Types

type HaskellRep (Data (Complex Double)) :: *

Methods

fwrite :: Handle -> Data (Complex Double) -> Run ()

fread :: Handle -> Run (Data (Complex Double))

MarshalFeld (Data (Complex Float))

Associated Types

type HaskellRep (Data (Complex Float)) :: *

Methods

fwrite :: Handle -> Data (Complex Float) -> Run ()

fread :: Handle -> Run (Data (Complex Float))

Type a => Storable (Data a)

Associated Types

type StoreRep (Data a) :: *

type StoreSize (Data a) :: *

Methods

newStoreRep :: MonadComp m => proxy (Data a) -> StoreSize (Data a) -> m (StoreRep (Data a))

initStoreRep :: MonadComp m => Data a -> m (StoreRep (Data a))

readStoreRep :: MonadComp m => StoreRep (Data a) -> m (Data a)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (Data a) -> m (Data a)

writeStoreRep :: MonadComp m => StoreRep (Data a) -> Data a -> m ()

Type a => Forcible (Data a)

Associated Types

type ValueRep (Data a) :: *

Methods

toValue :: MonadComp m => Data a -> m (ValueRep (Data a))

fromValue :: ValueRep (Data a) -> Data a

(Formattable a, PrimType a, PrintfType r) => PrintfType (Data a -> r)

Methods

fprf :: Handle -> String -> [PrintfArg Data] -> Data a -> r

Syntactic (Struct PrimType' Data a)

Associated Types

type Domain (Struct PrimType' Data a) :: * -> *

type Internal (Struct PrimType' Data a) :: *

Methods

desugar :: Struct PrimType' Data a -> ASTF (Domain (Struct PrimType' Data a)) (Internal (Struct PrimType' Data a))

sugar :: ASTF (Domain (Struct PrimType' Data a)) (Internal (Struct PrimType' Data a)) -> Struct PrimType' Data a

type FreePred Data

type FreePred Data = PrimType'

type Internal (Data a)

type Internal (Data a) = a

type Domain (Data a)

type Domain (Data a) = FeldDomain

type ContainerType (Data a)

type ContainerType (Data a) = DArr a

type SizeSpec (Data a)

type SizeSpec (Data a) = Data Length

type HaskellRep (Data Double)

type HaskellRep (Data Double) = Double

type HaskellRep (Data Float)

type HaskellRep (Data Float) = Float

type HaskellRep (Data Int8)

type HaskellRep (Data Int8) = Int8

type HaskellRep (Data Int16)

type HaskellRep (Data Int16) = Int16

type HaskellRep (Data Int32)

type HaskellRep (Data Int32) = Int32

type HaskellRep (Data Int64)

type HaskellRep (Data Int64) = Int64

type HaskellRep (Data Word8)

type HaskellRep (Data Word8) = Word8

type HaskellRep (Data Word16)

type HaskellRep (Data Word16) = Word16

type HaskellRep (Data Word32)

type HaskellRep (Data Word32) = Word32

type HaskellRep (Data Word64)

type HaskellRep (Data Word64) = Word64

type HaskellRep (Data (Complex Double))

type HaskellRep (Data (Complex Double)) = Complex Double

type HaskellRep (Data (Complex Float))

type HaskellRep (Data (Complex Float)) = Complex Float

type StoreRep (Data a)

type StoreRep (Data a) = DRef a

type StoreSize (Data a)

type StoreSize (Data a) = ()

type ValueRep (Data a)

type ValueRep (Data a) = Data a

type Internal (Struct PrimType' Data a)

type Internal (Struct PrimType' Data a) = a

type Domain (Struct PrimType' Data a)

type Domain (Struct PrimType' Data a) = FeldDomain

class (Syntactic a, Domain a ~ FeldDomain, Type (Internal a)) => Syntax a

Specialization of the Syntactic class for the Feldspar domain

Instances

(Syntactic a, (~) (* -> *) (Domain a) FeldDomain, Type (Internal a)) => Syntax a

data Comp a

Monad for computational effects: mutable data structures and control flow

Instances

Monad Comp

Methods

(>>=) :: Comp a -> (a -> Comp b) -> Comp b

(>>) :: Comp a -> Comp b -> Comp b

return :: a -> Comp a

fail :: String -> Comp a

Functor Comp

Methods

fmap :: (a -> b) -> Comp a -> Comp b

(<$) :: a -> Comp b -> Comp a

Applicative Comp

Methods

pure :: a -> Comp a

(<*>) :: Comp (a -> b) -> Comp a -> Comp b

(*>) :: Comp a -> Comp b -> Comp b

(<*) :: Comp a -> Comp b -> Comp a

MonadComp Comp

Methods

liftComp :: Comp a -> Comp a

iff :: Data Bool -> Comp () -> Comp () -> Comp ()

for :: (Integral n, PrimType n) => IxRange (Data n) -> (Data n -> Comp ()) -> Comp ()

while :: Comp (Data Bool) -> Comp () -> Comp ()

MonadRun Comp

Methods

liftRun :: Comp a -> Run a

Syntax a => Storable (Push Comp a)

Associated Types

type StoreRep (Push Comp a) :: *

type StoreSize (Push Comp a) :: *

Methods

newStoreRep :: MonadComp m => proxy (Push Comp a) -> StoreSize (Push Comp a) -> m (StoreRep (Push Comp a))

initStoreRep :: MonadComp m => Push Comp a -> m (StoreRep (Push Comp a))

readStoreRep :: MonadComp m => StoreRep (Push Comp a) -> m (Push Comp a)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (Push Comp a) -> m (Push Comp a)

writeStoreRep :: MonadComp m => StoreRep (Push Comp a) -> Push Comp a -> m ()

type StoreRep (Push Comp a)

type StoreRep (Push Comp a) = (DRef Length, Arr a)

type StoreSize (Push Comp a)

type StoreSize (Push Comp a) = Data Length

Object-language types

module Data.Int

module Data.Word

data Complex a :: * -> *

Complex numbers are an algebraic type.

For a complex number z, abs z is a number with the magnitude of z, but oriented in the positive real direction, whereas signum z has the phase of z, but unit magnitude.

The Foldable and Traversable instances traverse the real part first.

Constructors

~a :+ ~a infix 6

forms a complex number from its real and imaginary rectangular components.

Instances

Monad Complex

Methods

(>>=) :: Complex a -> (a -> Complex b) -> Complex b

(>>) :: Complex a -> Complex b -> Complex b

return :: a -> Complex a

fail :: String -> Complex a

Functor Complex

Methods

fmap :: (a -> b) -> Complex a -> Complex b

(<$) :: a -> Complex b -> Complex a

Applicative Complex

Methods

pure :: a -> Complex a

(<*>) :: Complex (a -> b) -> Complex a -> Complex b

(*>) :: Complex a -> Complex b -> Complex b

(<*) :: Complex a -> Complex b -> Complex a

Foldable Complex

Methods

fold :: Monoid m => Complex m -> m

foldMap :: Monoid m => (a -> m) -> Complex a -> m

foldr :: (a -> b -> b) -> b -> Complex a -> b

foldr' :: (a -> b -> b) -> b -> Complex a -> b

foldl :: (b -> a -> b) -> b -> Complex a -> b

foldl' :: (b -> a -> b) -> b -> Complex a -> b

foldr1 :: (a -> a -> a) -> Complex a -> a

foldl1 :: (a -> a -> a) -> Complex a -> a

toList :: Complex a -> [a]

null :: Complex a -> Bool

length :: Complex a -> Int

elem :: Eq a => a -> Complex a -> Bool

maximum :: Ord a => Complex a -> a

minimum :: Ord a => Complex a -> a

sum :: Num a => Complex a -> a

product :: Num a => Complex a -> a

Traversable Complex

Methods

traverse :: Applicative f => (a -> f b) -> Complex a -> f (Complex b)

sequenceA :: Applicative f => Complex (f a) -> f (Complex a)

mapM :: Monad m => (a -> m b) -> Complex a -> m (Complex b)

sequence :: Monad m => Complex (m a) -> m (Complex a)

Generic1 Complex

Associated Types

type Rep1 (Complex :: * -> *) :: * -> *

Methods

from1 :: Complex a -> Rep1 Complex a

to1 :: Rep1 Complex a -> Complex a

(RealFloat a, Unbox a) => Vector Vector (Complex a)

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> m (Vector (Complex a))

basicUnsafeThaw :: PrimMonad m => Vector (Complex a) -> m (Mutable Vector (PrimState m) (Complex a))

basicLength :: Vector (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> Vector (Complex a) -> Vector (Complex a)

basicUnsafeIndexM :: Monad m => Vector (Complex a) -> Int -> m (Complex a)

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) (Complex a) -> Vector (Complex a) -> m ()

elemseq :: Vector (Complex a) -> Complex a -> b -> b

(RealFloat a, Unbox a) => MVector MVector (Complex a)

Methods

basicLength :: MVector s (Complex a) -> Int

basicUnsafeSlice :: Int -> Int -> MVector s (Complex a) -> MVector s (Complex a)

basicOverlaps :: MVector s (Complex a) -> MVector s (Complex a) -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) (Complex a))

basicInitialize :: PrimMonad m => MVector (PrimState m) (Complex a) -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Complex a -> m (MVector (PrimState m) (Complex a))

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (Complex a)

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> Complex a -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) (Complex a) -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) (Complex a) -> Complex a -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) (Complex a) -> MVector (PrimState m) (Complex a) -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) (Complex a) -> Int -> m (MVector (PrimState m) (Complex a))

Eq a => Eq (Complex a)

Methods

(==) :: Complex a -> Complex a -> Bool

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

RealFloat a => Floating (Complex a)

Methods

pi :: Complex a

exp :: Complex a -> Complex a

log :: Complex a -> Complex a

sqrt :: Complex a -> Complex a

(**) :: Complex a -> Complex a -> Complex a

logBase :: Complex a -> Complex a -> Complex a

sin :: Complex a -> Complex a

cos :: Complex a -> Complex a

tan :: Complex a -> Complex a

asin :: Complex a -> Complex a

acos :: Complex a -> Complex a

atan :: Complex a -> Complex a

sinh :: Complex a -> Complex a

cosh :: Complex a -> Complex a

tanh :: Complex a -> Complex a

asinh :: Complex a -> Complex a

acosh :: Complex a -> Complex a

atanh :: Complex a -> Complex a

log1p :: Complex a -> Complex a

expm1 :: Complex a -> Complex a

log1pexp :: Complex a -> Complex a

log1mexp :: Complex a -> Complex a

RealFloat a => Fractional (Complex a)

Methods

(/) :: Complex a -> Complex a -> Complex a

recip :: Complex a -> Complex a

fromRational :: Rational -> Complex a

Data a => Data (Complex a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a)

toConstr :: Complex a -> Constr

dataTypeOf :: Complex a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a))

gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r

gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a)

RealFloat a => Num (Complex a)

Methods

(+) :: Complex a -> Complex a -> Complex a

(-) :: Complex a -> Complex a -> Complex a

(*) :: Complex a -> Complex a -> Complex a

negate :: Complex a -> Complex a

abs :: Complex a -> Complex a

signum :: Complex a -> Complex a

fromInteger :: Integer -> Complex a

Read a => Read (Complex a)

Methods

readsPrec :: Int -> ReadS (Complex a)

readList :: ReadS [Complex a]

readPrec :: ReadPrec (Complex a)

readListPrec :: ReadPrec [Complex a]

Show a => Show (Complex a)

Methods

showsPrec :: Int -> Complex a -> ShowS

show :: Complex a -> String

showList :: [Complex a] -> ShowS

Generic (Complex a)

Associated Types

type Rep (Complex a) :: * -> *

Methods

from :: Complex a -> Rep (Complex a) x

to :: Rep (Complex a) x -> Complex a

Storable a => Storable (Complex a)

Methods

sizeOf :: Complex a -> Int

alignment :: Complex a -> Int

peekElemOff :: Ptr (Complex a) -> Int -> IO (Complex a)

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

peekByteOff :: Ptr b -> Int -> IO (Complex a)

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

peek :: Ptr (Complex a) -> IO (Complex a)

poke :: Ptr (Complex a) -> Complex a -> IO ()

(Default a, RealFloat a) => Default (Complex a)

Methods

def :: Complex a

(RealFloat a, Unbox a) => Unbox (Complex a)

PrimType' (Complex Double)

Methods

primTypeRep :: PrimTypeRep (Complex Double)

PrimType' (Complex Float)

Methods

primTypeRep :: PrimTypeRep (Complex Float)

Inhabited (Complex Double)

Methods

example :: Complex Double

Inhabited (Complex Float)

Methods

example :: Complex Float

Type (Complex Double)

Methods

typeRep :: TypeRep (Complex Double)

Type (Complex Float)

Methods

typeRep :: TypeRep (Complex Float)

MarshalFeld (Data (Complex Double))

Associated Types

type HaskellRep (Data (Complex Double)) :: *

Methods

fwrite :: Handle -> Data (Complex Double) -> Run ()

fread :: Handle -> Run (Data (Complex Double))

MarshalFeld (Data (Complex Float))

Associated Types

type HaskellRep (Data (Complex Float)) :: *

Methods

fwrite :: Handle -> Data (Complex Float) -> Run ()

fread :: Handle -> Run (Data (Complex Float))

MarshalHaskell (Complex Double)

Methods

fromHaskell :: Complex Double -> String

toHaskell :: Parser (Complex Double)

MarshalHaskell (Complex Float)

Methods

fromHaskell :: Complex Float -> String

toHaskell :: Parser (Complex Float)

(Eq a) :=> (Eq (Complex a))

Methods

ins :: Eq a :- Eq (Complex a)

(Read a) :=> (Read (Complex a))

Methods

ins :: Read a :- Read (Complex a)

(RealFloat a) :=> (Num (Complex a))

Methods

ins :: RealFloat a :- Num (Complex a)

(RealFloat a) :=> (Fractional (Complex a))

Methods

ins :: RealFloat a :- Fractional (Complex a)

(RealFloat a) :=> (Floating (Complex a))

Methods

ins :: RealFloat a :- Floating (Complex a)

(Show a) :=> (Show (Complex a))

Methods

ins :: Show a :- Show (Complex a)

Each (Complex a) (Complex b) a b

Methods

each :: Traversal (Complex a) (Complex b) a b

type Rep1 Complex

type Rep1 Complex = D1 (MetaData "Complex" "Data.Complex" "base" False) (C1 (MetaCons ":+" (InfixI NotAssociative 6) False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) Par1)))

data MVector s (Complex a)

data MVector s (Complex a) = MV_Complex (MVector s (a, a))

type Rep (Complex a)

type Rep (Complex a) = D1 (MetaData "Complex" "Data.Complex" "base" False) (C1 (MetaCons ":+" (InfixI NotAssociative 6) False) ((:*:) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a)) (S1 (MetaSel (Nothing Symbol) NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 a))))

data Vector (Complex a)

data Vector (Complex a) = V_Complex (Vector (a, a))

type HaskellRep (Data (Complex Double))

type HaskellRep (Data (Complex Double)) = Complex Double

type HaskellRep (Data (Complex Float))

type HaskellRep (Data (Complex Float)) = Complex Float

class (Eq a, Show a, Typeable a) => PrimType' a

Primitive supported types

Minimal complete definition

primTypeRep

Instances

PrimType' Bool

Methods

primTypeRep :: PrimTypeRep Bool

PrimType' Double

Methods

primTypeRep :: PrimTypeRep Double

PrimType' Float

Methods

primTypeRep :: PrimTypeRep Float

PrimType' Int8

Methods

primTypeRep :: PrimTypeRep Int8

PrimType' Int16

Methods

primTypeRep :: PrimTypeRep Int16

PrimType' Int32

Methods

primTypeRep :: PrimTypeRep Int32

PrimType' Int64

Methods

primTypeRep :: PrimTypeRep Int64

PrimType' Word8

Methods

primTypeRep :: PrimTypeRep Word8

PrimType' Word16

Methods

primTypeRep :: PrimTypeRep Word16

PrimType' Word32

Methods

primTypeRep :: PrimTypeRep Word32

PrimType' Word64

Methods

primTypeRep :: PrimTypeRep Word64

PrimType' (Complex Double)

Methods

primTypeRep :: PrimTypeRep (Complex Double)

PrimType' (Complex Float)

Methods

primTypeRep :: PrimTypeRep (Complex Float)

InterpBi * (* -> Constraint, *) (AssertCMD (* -> *) (* -> Constraint)) IO (Param1 (* -> Constraint) PrimType')

Methods

interpBi :: Param1 (* -> Constraint) PrimType' ((AssertCMD (* -> *) (* -> Constraint) -> *, (AssertCMD (* -> *) (* -> Constraint) -> *, IO)) m ((AssertCMD (* -> *) (* -> Constraint) -> *, IO) m fs)) a -> m a

Syntactic (Struct PrimType' Data a)

Associated Types

type Domain (Struct PrimType' Data a) :: * -> *

type Internal (Struct PrimType' Data a) :: *

Methods

desugar :: Struct PrimType' Data a -> ASTF (Domain (Struct PrimType' Data a)) (Internal (Struct PrimType' Data a))

sugar :: ASTF (Domain (Struct PrimType' Data a)) (Internal (Struct PrimType' Data a)) -> Struct PrimType' Data a

type Internal (Struct PrimType' Data a)

type Internal (Struct PrimType' Data a) = a

type Domain (Struct PrimType' Data a)

type Domain (Struct PrimType' Data a) = FeldDomain

class (PrimType' a, Type a) => PrimType a

Alias for the conjunction of PrimType' and Type

Instances

CompTypeClass PrimType

Methods

compType :: (PrimType a, MonadC m) => proxy1 PrimType -> proxy2 a -> m Type

compLit :: (PrimType a, MonadC m) => proxy PrimType -> a -> m Exp

(PrimType' a, Type a) => PrimType a

class (Eq a, Show a, Typeable a, Inhabited a) => Type a

Supported types

Minimal complete definition

typeRep

Instances

Type Bool

Methods

typeRep :: TypeRep Bool

Type Double

Methods

typeRep :: TypeRep Double

Type Float

Methods

typeRep :: TypeRep Float

Type Int8

Methods

typeRep :: TypeRep Int8

Type Int16

Methods

typeRep :: TypeRep Int16

Type Int32

Methods

typeRep :: TypeRep Int32

Type Int64

Methods

typeRep :: TypeRep Int64

Type Word8

Methods

typeRep :: TypeRep Word8

Type Word16

Methods

typeRep :: TypeRep Word16

Type Word32

Methods

typeRep :: TypeRep Word32

Type Word64

Methods

typeRep :: TypeRep Word64

Type (Complex Double)

Methods

typeRep :: TypeRep (Complex Double)

Type (Complex Float)

Methods

typeRep :: TypeRep (Complex Float)

(Type a, Type b) => Type (a, b)

Methods

typeRep :: TypeRep (a, b)

type Length = Word32

type Index = Word32

data Ref a

Mutable variable

Instances

Eq (Ref a)

Methods

(==) :: Ref a -> Ref a -> Bool

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

type DRef a = Ref (Data a)

Reference specialized to Data elements

data Arr a

Mutable array

Instances

Eq (Arr a)

== checks if two Arr use the same physical array. The length and offset are ignored.

Methods

(==) :: Arr a -> Arr a -> Bool

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

Slicable (Arr a)

Methods

slice :: Data Index -> Data Length -> Arr a -> Arr a

Finite (Arr a)

Methods

length :: Arr a -> Data Length

(MarshalHaskell (Internal a), MarshalFeld a, Syntax a) => MarshalFeld (Arr a)

Associated Types

type HaskellRep (Arr a) :: *

Methods

fwrite :: Handle -> Arr a -> Run ()

fread :: Handle -> Run (Arr a)

type SizeSpec (Arr a)

type SizeSpec (Arr a) = VecChanSizeSpec (SizeSpec a)

type HaskellRep (Arr a)

type HaskellRep (Arr a) = [Internal a]

type DArr a = Arr (Data a)

Array specialized to Data elements

data IArr a

Immutable array

Instances

MonadComp m => Manifestable2 m (Manifest2 a) a

manifest2 and manifestFresh2 are no-ops. manifestStore2 does a proper arrCopy.

Methods

manifest2 :: Arr a -> Manifest2 a -> m (Manifest2 a)

manifestFresh2 :: Manifest2 a -> m (Manifest2 a)

manifestStore2 :: Arr a -> Manifest2 a -> m ()

MonadComp m => Manifestable m (Manifest a) a

manifest and manifestFresh are no-ops. manifestStore does a proper arrCopy.

Methods

manifest :: Arr a -> Manifest a -> m (Manifest a)

manifestFresh :: Manifest a -> m (Manifest a)

manifestStore :: Arr a -> Manifest a -> m ()

(Syntax a, MonadComp m) => Seqy m (Manifest a) a

Methods

toSeq :: Manifest a -> Seq m a

(Syntax a, MonadComp m) => Pushy2 m (Manifest2 a) a

Methods

toPush2 :: Manifest2 a -> Push2 m a

(Syntax a, MonadComp m) => Pushy2 m (Manifest a) a

Convert to a Push2 with a single row

Methods

toPush2 :: Manifest a -> Push2 m a

(Syntax a, MonadComp m) => Pushy m (Manifest a) a

Methods

toPush :: Manifest a -> Push m a

Slicable (IArr a)

Methods

slice :: Data Index -> Data Length -> IArr a -> IArr a

Finite (IArr a)

Methods

length :: IArr a -> Data Length

Syntax a => Indexed (IArr a)

Associated Types

type IndexedElem (IArr a) :: *

Methods

(!) :: IArr a -> Data Index -> IndexedElem (IArr a)

(MarshalHaskell (Internal a), MarshalFeld a, Syntax a) => MarshalFeld (IArr a)

Associated Types

type HaskellRep (IArr a) :: *

Methods

fwrite :: Handle -> IArr a -> Run ()

fread :: Handle -> Run (IArr a)

Syntax a => Storable (Manifest2 a)

Associated Types

type StoreRep (Manifest2 a) :: *

type StoreSize (Manifest2 a) :: *

Methods

newStoreRep :: MonadComp m => proxy (Manifest2 a) -> StoreSize (Manifest2 a) -> m (StoreRep (Manifest2 a))

initStoreRep :: MonadComp m => Manifest2 a -> m (StoreRep (Manifest2 a))

readStoreRep :: MonadComp m => StoreRep (Manifest2 a) -> m (Manifest2 a)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (Manifest2 a) -> m (Manifest2 a)

writeStoreRep :: MonadComp m => StoreRep (Manifest2 a) -> Manifest2 a -> m ()

Syntax a => Storable (Manifest a)

Associated Types

type StoreRep (Manifest a) :: *

type StoreSize (Manifest a) :: *

Methods

newStoreRep :: MonadComp m => proxy (Manifest a) -> StoreSize (Manifest a) -> m (StoreRep (Manifest a))

initStoreRep :: MonadComp m => Manifest a -> m (StoreRep (Manifest a))

readStoreRep :: MonadComp m => StoreRep (Manifest a) -> m (Manifest a)

unsafeFreezeStoreRep :: MonadComp m => StoreRep (Manifest a) -> m (Manifest a)

writeStoreRep :: MonadComp m => StoreRep (Manifest a) -> Manifest a -> m ()

ViewManifest2 (Manifest2 a) a

Methods

viewManifest2 :: Manifest2 a -> Maybe (Manifest2 a)

ViewManifest (Manifest a) a

Methods

viewManifest :: Manifest a -> Maybe (Manifest a)

Syntax a => Pully2 (Manifest a) a

Convert to a Pull2 with a single row

Methods

toPull2 :: Manifest a -> Pull2 a

type IndexedElem (IArr a)

type IndexedElem (IArr a) = a

type SizeSpec (IArr a)

type SizeSpec (IArr a) = VecChanSizeSpec (SizeSpec a)

type HaskellRep (IArr a)

type HaskellRep (IArr a) = [Internal a]

type StoreRep (Manifest2 a)

type StoreRep (Manifest2 a) = (DRef Length, DRef Length, Arr a)

type StoreRep (Manifest a)

type StoreRep (Manifest a) = (DRef Length, Arr a)

type StoreSize (Manifest2 a)

type StoreSize (Manifest2 a) = (Data Length, Data Length)

type StoreSize (Manifest a)

type StoreSize (Manifest a) = Data Length

type DIArr a = IArr (Data a)

Immutable array specialized to Data elements

class Inhabited a

Inhabited types

Minimal complete definition

example

Instances

Inhabited Bool

Methods

example :: Bool

Inhabited Double

Methods

example :: Double

Inhabited Float

Methods

example :: Float

Inhabited Int8

Methods

example :: Int8

Inhabited Int16

Methods

example :: Int16

Inhabited Int32

Methods

example :: Int32

Inhabited Int64

Methods

example :: Int64

Inhabited Word8

Methods

example :: Word8

Inhabited Word16

Methods

example :: Word16

Inhabited Word32

Methods

example :: Word32

Inhabited Word64

Methods

example :: Word64

Inhabited (Complex Double)

Methods

example :: Complex Double

Inhabited (Complex Float)

Methods

example :: Complex Float

(Inhabited a, Inhabited b) => Inhabited (a, b)

Methods

example :: (a, b)

(Inhabited a, Inhabited b, Inhabited c) => Inhabited (a, b, c)

Methods

example :: (a, b, c)

(Inhabited a, Inhabited b, Inhabited c, Inhabited d) => Inhabited (a, b, c, d)

Methods

example :: (a, b, c, d)

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e) => Inhabited (a, b, c, d, e)

Methods

example :: (a, b, c, d, e)

(Inhabited a, Inhabited b, Inhabited c, Inhabited d, Inhabited e, Inhabited f) => Inhabited (a, b, c, d, e, f)

Methods

example :: (a, b, c, d, e, f)

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

Methods

example :: (a, b, c, d, e, f, g)

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

Methods

example :: (a, b, c, d, e, f, g, h)

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

Methods

example :: (a, b, c, d, e, f, g, h, i)

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

Methods

example :: (a, b, c, d, e, f, g, h, i, j)

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

Methods

example :: (a, b, c, d, e, f, g, h, i, j, k)

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

Methods

example :: (a, b, c, d, e, f, g, h, i, j, k, l)

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

Methods

example :: (a, b, c, d, e, f, g, h, i, j, k, l, m)

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

Methods

example :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

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

Methods

example :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Syntactic a

It is usually assumed that (desugar (sugar a)) has the same meaning as a.

Minimal complete definition

desugar, sugar

Associated Types

type Domain a :: * -> *

type Internal a :: *

Instances

Syntactic (Prim a)

Associated Types

type Domain (Prim a) :: * -> *

type Internal (Prim a) :: *

Methods

desugar :: Prim a -> ASTF (Domain (Prim a)) (Internal (Prim a))

sugar :: ASTF (Domain (Prim a)) (Internal (Prim a)) -> Prim a

Syntactic (Data a)

Declaring Data as syntactic sugar

Associated Types

type Domain (Data a) :: * -> *

type Internal (Data a) :: *

Methods

desugar :: Data a -> ASTF (Domain (Data a)) (Internal (Data a))

sugar :: ASTF (Domain (Data a)) (Internal (Data a)) -> Data a

Syntax a => Syntactic (Option a)

Associated Types

type Domain (Option a) :: * -> *

type Internal (Option a) :: *

Methods

desugar :: Option a -> ASTF (Domain (Option a)) (Internal (Option a))

sugar :: ASTF (Domain (Option a)) (Internal (Option a)) -> Option a

Syntax a => Syntactic (Validated a)

Associated Types

type Domain (Validated a) :: * -> *

type Internal (Validated a) :: *

Methods

desugar :: Validated a -> ASTF (Domain (Validated a)) (Internal (Validated a))

sugar :: ASTF (Domain (Validated a)) (Internal (Validated a)) -> Validated a

Syntactic (ASTF sym a)

Associated Types

type Domain (ASTF sym a) :: * -> *

type Internal (ASTF sym a) :: *

Methods

desugar :: ASTF sym a -> ASTF (Domain (ASTF sym a)) (Internal (ASTF sym a))

sugar :: ASTF (Domain (ASTF sym a)) (Internal (ASTF sym a)) -> ASTF sym a

Syntactic (ASTFull sym a)

Associated Types

type Domain (ASTFull sym a) :: * -> *

type Internal (ASTFull sym a) :: *

Methods

desugar :: ASTFull sym a -> ASTF (Domain (ASTFull sym a)) (Internal (ASTFull sym a))

sugar :: ASTF (Domain (ASTFull sym a)) (Internal (ASTFull sym a)) -> ASTFull sym a

Syntactic (Struct PrimType' Data a)

Associated Types

type Domain (Struct PrimType' Data a) :: * -> *

type Internal (Struct PrimType' Data a) :: *

Methods

desugar :: Struct PrimType' Data a -> ASTF (Domain (Struct PrimType' Data a)) (Internal (Struct PrimType' Data a))

sugar :: ASTF (Domain (Struct PrimType' Data a)) (Internal (Struct PrimType' Data a)) -> Struct PrimType' Data a

type family Domain a :: * -> *

Instances

type Domain ()

type Domain () = FeldDomain

type Domain (Prim a)

type Domain (Prim a) = PrimDomain

type Domain (Data a)

type Domain (Data a) = FeldDomain

type Domain (Option a)

type Domain (Option a) = FeldDomain

type Domain (Validated a)

type Domain (Validated a) = FeldDomain

type Domain (a -> b)

type Domain (a -> b) = FeldDomain

type Domain (a, b)

type Domain (a, b) = FeldDomain

type Domain (ASTF sym a)

type Domain (ASTF sym a) = sym

type Domain (ASTFull sym a)

type Domain (ASTFull sym a) = sym

type Domain (a, b, c)

type Domain (a, b, c) = Domain a

type Domain (Struct PrimType' Data a)

type Domain (Struct PrimType' Data a) = FeldDomain

type Domain (a, b, c, d)

type Domain (a, b, c, d) = Domain a

type Domain (a, b, c, d, e)

type Domain (a, b, c, d, e) = Domain a

type Domain (a, b, c, d, e, f)

type Domain (a, b, c, d, e, f) = Domain a

type Domain (a, b, c, d, e, f, g)

type Domain (a, b, c, d, e, f, g) = Domain a

type Domain (a, b, c, d, e, f, g, h)

type Domain (a, b, c, d, e, f, g, h) = Domain a

type Domain (a, b, c, d, e, f, g, h, i)

type Domain (a, b, c, d, e, f, g, h, i) = Domain a

type Domain (a, b, c, d, e, f, g, h, i, j)

type Domain (a, b, c, d, e, f, g, h, i, j) = Domain a

type Domain (a, b, c, d, e, f, g, h, i, j, k)

type Domain (a, b, c, d, e, f, g, h, i, j, k) = Domain a

type Domain (a, b, c, d, e, f, g, h, i, j, k, l)

type Domain (a, b, c, d, e, f, g, h, i, j, k, l) = Domain a

type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m)

type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m) = Domain a

type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = Domain a

type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

type Domain (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = Domain a

type family Internal a :: *

Instances

type Internal ()

type Internal () = Int32

type Internal (Prim a)

type Internal (Prim a) = a

type Internal (Data a)

type Internal (Data a) = a

type Internal (Option a)

type Internal (Option a) = (Bool, Internal a)

type Internal (Validated a)

type Internal (Validated a) = (Bool, Internal a)

type Internal (a -> b)

type Internal (a -> b) = Internal a -> Internal b

type Internal (a, b)

type Internal (a, b) = (Internal a, Internal b)

type Internal (ASTF sym a)

type Internal (ASTF sym a) = a

type Internal (ASTFull sym a)

type Internal (ASTFull sym a) = a

type Internal (a, b, c)

type Internal (a, b, c) = ((Internal a, Internal b), Internal c)

type Internal (Struct PrimType' Data a)

type Internal (Struct PrimType' Data a) = a

type Internal (a, b, c, d)

type Internal (a, b, c, d) = ((Internal a, Internal b), (Internal c, Internal d))

type Internal (a, b, c, d, e)

type Internal (a, b, c, d, e) = (((Internal a, Internal b), Internal c), (Internal d, Internal e))

type Internal (a, b, c, d, e, f)

type Internal (a, b, c, d, e, f) = (((Internal a, Internal b), Internal c), ((Internal d, Internal e), Internal f))

type Internal (a, b, c, d, e, f, g)

type Internal (a, b, c, d, e, f, g) = (((Internal a, Internal b), (Internal c, Internal d)), ((Internal e, Internal f), Internal g))

type Internal (a, b, c, d, e, f, g, h)

type Internal (a, b, c, d, e, f, g, h) = (((Internal a, Internal b), (Internal c, Internal d)), ((Internal e, Internal f), (Internal g, Internal h)))

type Internal (a, b, c, d, e, f, g, h, i)

type Internal (a, b, c, d, e, f, g, h, i) = ((((Internal a, Internal b), Internal c), (Internal d, Internal e)), ((Internal f, Internal g), (Internal h, Internal i)))

type Internal (a, b, c, d, e, f, g, h, i, j)

type Internal (a, b, c, d, e, f, g, h, i, j) = ((((Internal a, Internal b), Internal c), (Internal d, Internal e)), (((Internal f, Internal g), Internal h), (Internal i, Internal j)))

type Internal (a, b, c, d, e, f, g, h, i, j, k)

type Internal (a, b, c, d, e, f, g, h, i, j, k) = ((((Internal a, Internal b), Internal c), ((Internal d, Internal e), Internal f)), (((Internal g, Internal h), Internal i), (Internal j, Internal k)))

type Internal (a, b, c, d, e, f, g, h, i, j, k, l)

type Internal (a, b, c, d, e, f, g, h, i, j, k, l) = ((((Internal a, Internal b), Internal c), ((Internal d, Internal e), Internal f)), (((Internal g, Internal h), Internal i), ((Internal j, Internal k), Internal l)))

type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m)

type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m) = ((((Internal a, Internal b), (Internal c, Internal d)), ((Internal e, Internal f), Internal g)), (((Internal h, Internal i), Internal j), ((Internal k, Internal l), Internal m)))

type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m, n) = ((((Internal a, Internal b), (Internal c, Internal d)), ((Internal e, Internal f), Internal g)), (((Internal h, Internal i), (Internal j, Internal k)), ((Internal l, Internal m), Internal n)))

type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

type Internal (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) = ((((Internal a, Internal b), (Internal c, Internal d)), ((Internal e, Internal f), (Internal g, Internal h))), (((Internal i, Internal j), (Internal k, Internal l)), ((Internal m, Internal n), Internal o)))

Front end

eval :: (Syntactic a, Domain a ~ FeldDomain) => a -> Internal a

Evaluate a closed expression

showAST :: (Syntactic a, Domain a ~ FeldDomain) => a -> String

Show the syntax tree using Unicode art

Only user assertions will be included.

drawAST :: (Syntactic a, Domain a ~ FeldDomain) => a -> IO ()

Draw the syntax tree on the terminal using Unicode art

Only user assertions will be included.

module Feldspar.Frontend

class Eq a => Bits a

The Bits class defines bitwise operations over integral types.

• Bits are numbered from 0 with bit 0 being the least significant bit.

Minimal complete definition

(.&.), (.|.), xor, complement, (shift | shiftL, shiftR), (rotate | rotateL, rotateR), bitSize, bitSizeMaybe, isSigned, testBit, bit, popCount

Instances

Bits Bool

Methods

(.&.) :: Bool -> Bool -> Bool

(.|.) :: Bool -> Bool -> Bool

xor :: Bool -> Bool -> Bool

complement :: Bool -> Bool

shift :: Bool -> Int -> Bool

rotate :: Bool -> Int -> Bool

zeroBits :: Bool

bit :: Int -> Bool

setBit :: Bool -> Int -> Bool

clearBit :: Bool -> Int -> Bool

complementBit :: Bool -> Int -> Bool

testBit :: Bool -> Int -> Bool

bitSizeMaybe :: Bool -> Maybe Int

bitSize :: Bool -> Int

isSigned :: Bool -> Bool

shiftL :: Bool -> Int -> Bool

unsafeShiftL :: Bool -> Int -> Bool

shiftR :: Bool -> Int -> Bool

unsafeShiftR :: Bool -> Int -> Bool

rotateL :: Bool -> Int -> Bool

rotateR :: Bool -> Int -> Bool

popCount :: Bool -> Int

Bits Int

Methods

(.&.) :: Int -> Int -> Int

(.|.) :: Int -> Int -> Int

xor :: Int -> Int -> Int

complement :: Int -> Int

shift :: Int -> Int -> Int

rotate :: Int -> Int -> Int

zeroBits :: Int

bit :: Int -> Int

setBit :: Int -> Int -> Int

clearBit :: Int -> Int -> Int

complementBit :: Int -> Int -> Int

testBit :: Int -> Int -> Bool

bitSizeMaybe :: Int -> Maybe Int

bitSize :: Int -> Int

isSigned :: Int -> Bool

shiftL :: Int -> Int -> Int

unsafeShiftL :: Int -> Int -> Int

shiftR :: Int -> Int -> Int

unsafeShiftR :: Int -> Int -> Int

rotateL :: Int -> Int -> Int

rotateR :: Int -> Int -> Int

popCount :: Int -> Int

Bits Int8

Methods

(.&.) :: Int8 -> Int8 -> Int8

(.|.) :: Int8 -> Int8 -> Int8

xor :: Int8 -> Int8 -> Int8

complement :: Int8 -> Int8

shift :: Int8 -> Int -> Int8

rotate :: Int8 -> Int -> Int8

zeroBits :: Int8

bit :: Int -> Int8

setBit :: Int8 -> Int -> Int8

clearBit :: Int8 -> Int -> Int8

complementBit :: Int8 -> Int -> Int8

testBit :: Int8 -> Int -> Bool

bitSizeMaybe :: Int8 -> Maybe Int

bitSize :: Int8 -> Int

isSigned :: Int8 -> Bool

shiftL :: Int8 -> Int -> Int8

unsafeShiftL :: Int8 -> Int -> Int8

shiftR :: Int8 -> Int -> Int8

unsafeShiftR :: Int8 -> Int -> Int8

rotateL :: Int8 -> Int -> Int8

rotateR :: Int8 -> Int -> Int8

popCount :: Int8 -> Int

Bits Int16

Methods

(.&.) :: Int16 -> Int16 -> Int16

(.|.) :: Int16 -> Int16 -> Int16

xor :: Int16 -> Int16 -> Int16

complement :: Int16 -> Int16

shift :: Int16 -> Int -> Int16

rotate :: Int16 -> Int -> Int16

zeroBits :: Int16

bit :: Int -> Int16

setBit :: Int16 -> Int -> Int16

clearBit :: Int16 -> Int -> Int16

complementBit :: Int16 -> Int -> Int16

testBit :: Int16 -> Int -> Bool

bitSizeMaybe :: Int16 -> Maybe Int

bitSize :: Int16 -> Int

isSigned :: Int16 -> Bool

shiftL :: Int16 -> Int -> Int16

unsafeShiftL :: Int16 -> Int -> Int16

shiftR :: Int16 -> Int -> Int16

unsafeShiftR :: Int16 -> Int -> Int16

rotateL :: Int16 -> Int -> Int16

rotateR :: Int16 -> Int -> Int16

popCount :: Int16 -> Int

Bits Int32

Methods

(.&.) :: Int32 -> Int32 -> Int32

(.|.) :: Int32 -> Int32 -> Int32

xor :: Int32 -> Int32 -> Int32

complement :: Int32 -> Int32

shift :: Int32 -> Int -> Int32

rotate :: Int32 -> Int -> Int32

zeroBits :: Int32

bit :: Int -> Int32

setBit :: Int32 -> Int -> Int32

clearBit :: Int32 -> Int -> Int32

complementBit :: Int32 -> Int -> Int32

testBit :: Int32 -> Int -> Bool

bitSizeMaybe :: Int32 -> Maybe Int

bitSize :: Int32 -> Int

isSigned :: Int32 -> Bool

shiftL :: Int32 -> Int -> Int32

unsafeShiftL :: Int32 -> Int -> Int32

shiftR :: Int32 -> Int -> Int32

unsafeShiftR :: Int32 -> Int -> Int32

rotateL :: Int32 -> Int -> Int32

rotateR :: Int32 -> Int -> Int32

popCount :: Int32 -> Int

Bits Int64

Methods

(.&.) :: Int64 -> Int64 -> Int64

(.|.) :: Int64 -> Int64 -> Int64

xor :: Int64 -> Int64 -> Int64

complement :: Int64 -> Int64

shift :: Int64 -> Int -> Int64

rotate :: Int64 -> Int -> Int64

zeroBits :: Int64

bit :: Int -> Int64

setBit :: Int64 -> Int -> Int64

clearBit :: Int64 -> Int -> Int64

complementBit :: Int64 -> Int -> Int64

testBit :: Int64 -> Int -> Bool

bitSizeMaybe :: Int64 -> Maybe Int

bitSize :: Int64 -> Int

isSigned :: Int64 -> Bool

shiftL :: Int64 -> Int -> Int64

unsafeShiftL :: Int64 -> Int -> Int64

shiftR :: Int64 -> Int -> Int64

unsafeShiftR :: Int64 -> Int -> Int64

rotateL :: Int64 -> Int -> Int64

rotateR :: Int64 -> Int -> Int64

popCount :: Int64 -> Int

Bits Integer

Methods

(.&.) :: Integer -> Integer -> Integer

(.|.) :: Integer -> Integer -> Integer

xor :: Integer -> Integer -> Integer

complement :: Integer -> Integer

shift :: Integer -> Int -> Integer

rotate :: Integer -> Int -> Integer

zeroBits :: Integer

bit :: Int -> Integer

setBit :: Integer -> Int -> Integer

clearBit :: Integer -> Int -> Integer

complementBit :: Integer -> Int -> Integer

testBit :: Integer -> Int -> Bool

bitSizeMaybe :: Integer -> Maybe Int

bitSize :: Integer -> Int

isSigned :: Integer -> Bool

shiftL :: Integer -> Int -> Integer

unsafeShiftL :: Integer -> Int -> Integer

shiftR :: Integer -> Int -> Integer

unsafeShiftR :: Integer -> Int -> Integer

rotateL :: Integer -> Int -> Integer

rotateR :: Integer -> Int -> Integer

popCount :: Integer -> Int

Bits Word

Methods

(.&.) :: Word -> Word -> Word

(.|.) :: Word -> Word -> Word

xor :: Word -> Word -> Word

complement :: Word -> Word

shift :: Word -> Int -> Word

rotate :: Word -> Int -> Word

zeroBits :: Word

bit :: Int -> Word

setBit :: Word -> Int -> Word

clearBit :: Word -> Int -> Word

complementBit :: Word -> Int -> Word

testBit :: Word -> Int -> Bool

bitSizeMaybe :: Word -> Maybe Int

bitSize :: Word -> Int

isSigned :: Word -> Bool

shiftL :: Word -> Int -> Word

unsafeShiftL :: Word -> Int -> Word

shiftR :: Word -> Int -> Word

unsafeShiftR :: Word -> Int -> Word

rotateL :: Word -> Int -> Word

rotateR :: Word -> Int -> Word

popCount :: Word -> Int

Bits Word8

Methods

(.&.) :: Word8 -> Word8 -> Word8

(.|.) :: Word8 -> Word8 -> Word8

xor :: Word8 -> Word8 -> Word8

complement :: Word8 -> Word8

shift :: Word8 -> Int -> Word8

rotate :: Word8 -> Int -> Word8

zeroBits :: Word8

bit :: Int -> Word8

setBit :: Word8 -> Int -> Word8

clearBit :: Word8 -> Int -> Word8

complementBit :: Word8 -> Int -> Word8

testBit :: Word8 -> Int -> Bool

bitSizeMaybe :: Word8 -> Maybe Int

bitSize :: Word8 -> Int

isSigned :: Word8 -> Bool

shiftL :: Word8 -> Int -> Word8

unsafeShiftL :: Word8 -> Int -> Word8

shiftR :: Word8 -> Int -> Word8

unsafeShiftR :: Word8 -> Int -> Word8

rotateL :: Word8 -> Int -> Word8

rotateR :: Word8 -> Int -> Word8

popCount :: Word8 -> Int

Bits Word16

Methods

(.&.) :: Word16 -> Word16 -> Word16

(.|.) :: Word16 -> Word16 -> Word16

xor :: Word16 -> Word16 -> Word16

complement :: Word16 -> Word16

shift :: Word16 -> Int -> Word16

rotate :: Word16 -> Int -> Word16

zeroBits :: Word16

bit :: Int -> Word16

setBit :: Word16 -> Int -> Word16

clearBit :: Word16 -> Int -> Word16

complementBit :: Word16 -> Int -> Word16

testBit :: Word16 -> Int -> Bool

bitSizeMaybe :: Word16 -> Maybe Int

bitSize :: Word16 -> Int

isSigned :: Word16 -> Bool

shiftL :: Word16 -> Int -> Word16

unsafeShiftL :: Word16 -> Int -> Word16

shiftR :: Word16 -> Int -> Word16

unsafeShiftR :: Word16 -> Int -> Word16

rotateL :: Word16 -> Int -> Word16

rotateR :: Word16 -> Int -> Word16

popCount :: Word16 -> Int

Bits Word32

Methods

(.&.) :: Word32 -> Word32 -> Word32

(.|.) :: Word32 -> Word32 -> Word32

xor :: Word32 -> Word32 -> Word32

complement :: Word32 -> Word32

shift :: Word32 -> Int -> Word32

rotate :: Word32 -> Int -> Word32

zeroBits :: Word32

bit :: Int -> Word32

setBit :: Word32 -> Int -> Word32

clearBit :: Word32 -> Int -> Word32

complementBit :: Word32 -> Int -> Word32

testBit :: Word32 -> Int -> Bool

bitSizeMaybe :: Word32 -> Maybe Int

bitSize :: Word32 -> Int

isSigned :: Word32 -> Bool

shiftL :: Word32 -> Int -> Word32

unsafeShiftL :: Word32 -> Int -> Word32

shiftR :: Word32 -> Int -> Word32

unsafeShiftR :: Word32 -> Int -> Word32

rotateL :: Word32 -> Int -> Word32

rotateR :: Word32 -> Int -> Word32

popCount :: Word32 -> Int

Bits Word64

Methods

(.&.) :: Word64 -> Word64 -> Word64

(.|.) :: Word64 -> Word64 -> Word64

xor :: Word64 -> Word64 -> Word64

complement :: Word64 -> Word64

shift :: Word64 -> Int -> Word64

rotate :: Word64 -> Int -> Word64

zeroBits :: Word64

bit :: Int -> Word64

setBit :: Word64 -> Int -> Word64

clearBit :: Word64 -> Int -> Word64

complementBit :: Word64 -> Int -> Word64

testBit :: Word64 -> Int -> Bool

bitSizeMaybe :: Word64 -> Maybe Int

bitSize :: Word64 -> Int

isSigned :: Word64 -> Bool

shiftL :: Word64 -> Int -> Word64

unsafeShiftL :: Word64 -> Int -> Word64

shiftR :: Word64 -> Int -> Word64

unsafeShiftR :: Word64 -> Int -> Word64

rotateL :: Word64 -> Int -> Word64

rotateR :: Word64 -> Int -> Word64

popCount :: Word64 -> Int

Bits a => Bits (Identity a)

Methods

(.&.) :: Identity a -> Identity a -> Identity a

(.|.) :: Identity a -> Identity a -> Identity a

xor :: Identity a -> Identity a -> Identity a

complement :: Identity a -> Identity a

shift :: Identity a -> Int -> Identity a

rotate :: Identity a -> Int -> Identity a

zeroBits :: Identity a

bit :: Int -> Identity a

setBit :: Identity a -> Int -> Identity a

clearBit :: Identity a -> Int -> Identity a

complementBit :: Identity a -> Int -> Identity a

testBit :: Identity a -> Int -> Bool

bitSizeMaybe :: Identity a -> Maybe Int

bitSize :: Identity a -> Int

isSigned :: Identity a -> Bool

shiftL :: Identity a -> Int -> Identity a

unsafeShiftL :: Identity a -> Int -> Identity a

shiftR :: Identity a -> Int -> Identity a

unsafeShiftR :: Identity a -> Int -> Identity a

rotateL :: Identity a -> Int -> Identity a

rotateR :: Identity a -> Int -> Identity a

popCount :: Identity a -> Int

Bits a => Bits (Const k a b)

Methods

(.&.) :: Const k a b -> Const k a b -> Const k a b

(.|.) :: Const k a b -> Const k a b -> Const k a b

xor :: Const k a b -> Const k a b -> Const k a b

complement :: Const k a b -> Const k a b

shift :: Const k a b -> Int -> Const k a b

rotate :: Const k a b -> Int -> Const k a b

zeroBits :: Const k a b

bit :: Int -> Const k a b

setBit :: Const k a b -> Int -> Const k a b

clearBit :: Const k a b -> Int -> Const k a b

complementBit :: Const k a b -> Int -> Const k a b

testBit :: Const k a b -> Int -> Bool

bitSizeMaybe :: Const k a b -> Maybe Int

bitSize :: Const k a b -> Int

isSigned :: Const k a b -> Bool

shiftL :: Const k a b -> Int -> Const k a b

unsafeShiftL :: Const k a b -> Int -> Const k a b

shiftR :: Const k a b -> Int -> Const k a b

unsafeShiftR :: Const k a b -> Int -> Const k a b

rotateL :: Const k a b -> Int -> Const k a b

rotateR :: Const k a b -> Int -> Const k a b

popCount :: Const k a b -> Int

class Bits b => FiniteBits b

The FiniteBits class denotes types with a finite, fixed number of bits.

Since: 4.7.0.0

Minimal complete definition

finiteBitSize

Instances

FiniteBits Bool

Methods

finiteBitSize :: Bool -> Int

countLeadingZeros :: Bool -> Int

countTrailingZeros :: Bool -> Int

FiniteBits Int

Methods

finiteBitSize :: Int -> Int

countLeadingZeros :: Int -> Int

countTrailingZeros :: Int -> Int

FiniteBits Int8

Methods

finiteBitSize :: Int8 -> Int

countLeadingZeros :: Int8 -> Int

countTrailingZeros :: Int8 -> Int

FiniteBits Int16

Methods

finiteBitSize :: Int16 -> Int

countLeadingZeros :: Int16 -> Int

countTrailingZeros :: Int16 -> Int

FiniteBits Int32

Methods

finiteBitSize :: Int32 -> Int

countLeadingZeros :: Int32 -> Int

countTrailingZeros :: Int32 -> Int

FiniteBits Int64

Methods

finiteBitSize :: Int64 -> Int

countLeadingZeros :: Int64 -> Int

countTrailingZeros :: Int64 -> Int

FiniteBits Word

Methods

finiteBitSize :: Word -> Int

countLeadingZeros :: Word -> Int

countTrailingZeros :: Word -> Int

FiniteBits Word8

Methods

finiteBitSize :: Word8 -> Int

countLeadingZeros :: Word8 -> Int

countTrailingZeros :: Word8 -> Int

FiniteBits Word16

Methods

finiteBitSize :: Word16 -> Int

countLeadingZeros :: Word16 -> Int

countTrailingZeros :: Word16 -> Int

FiniteBits Word32

Methods

finiteBitSize :: Word32 -> Int

countLeadingZeros :: Word32 -> Int

countTrailingZeros :: Word32 -> Int

FiniteBits Word64

Methods

finiteBitSize :: Word64 -> Int

countLeadingZeros :: Word64 -> Int

countTrailingZeros :: Word64 -> Int

FiniteBits a => FiniteBits (Identity a)

Methods

finiteBitSize :: Identity a -> Int

countLeadingZeros :: Identity a -> Int

countTrailingZeros :: Identity a -> Int

FiniteBits a => FiniteBits (Const k a b)

Methods

finiteBitSize :: Const k a b -> Int

countLeadingZeros :: Const k a b -> Int

countTrailingZeros :: Const k a b -> Int

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

Integral numbers, supporting integer division.

Minimal complete definition

quotRem, toInteger

Methods

toInteger :: a -> Integer

conversion to Integer

Instances

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

Integral Int8

Methods

quot :: Int8 -> Int8 -> Int8

rem :: Int8 -> Int8 -> Int8

div :: Int8 -> Int8 -> Int8

mod :: Int8 -> Int8 -> Int8

quotRem :: Int8 -> Int8 -> (Int8, Int8)

divMod :: Int8 -> Int8 -> (Int8, Int8)

toInteger :: Int8 -> Integer

Integral Int16

Methods

quot :: Int16 -> Int16 -> Int16

rem :: Int16 -> Int16 -> Int16

div :: Int16 -> Int16 -> Int16

mod :: Int16 -> Int16 -> Int16

quotRem :: Int16 -> Int16 -> (Int16, Int16)

divMod :: Int16 -> Int16 -> (Int16, Int16)

toInteger :: Int16 -> Integer

Integral Int32

Methods

quot :: Int32 -> Int32 -> Int32

rem :: Int32 -> Int32 -> Int32

div :: Int32 -> Int32 -> Int32

mod :: Int32 -> Int32 -> Int32

quotRem :: Int32 -> Int32 -> (Int32, Int32)

divMod :: Int32 -> Int32 -> (Int32, Int32)

toInteger :: Int32 -> Integer

Integral Int64

Methods

quot :: Int64 -> Int64 -> Int64

rem :: Int64 -> Int64 -> Int64

div :: Int64 -> Int64 -> Int64

mod :: Int64 -> Int64 -> Int64

quotRem :: Int64 -> Int64 -> (Int64, Int64)

divMod :: Int64 -> Int64 -> (Int64, Int64)

toInteger :: Int64 -> Integer

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

Integral Word

Methods

quot :: Word -> Word -> Word

rem :: Word -> Word -> Word

div :: Word -> Word -> Word

mod :: Word -> Word -> Word

quotRem :: Word -> Word -> (Word, Word)

divMod :: Word -> Word -> (Word, Word)

toInteger :: Word -> Integer

Integral Word8

Methods

quot :: Word8 -> Word8 -> Word8

rem :: Word8 -> Word8 -> Word8

div :: Word8 -> Word8 -> Word8

mod :: Word8 -> Word8 -> Word8

quotRem :: Word8 -> Word8 -> (Word8, Word8)

divMod :: Word8 -> Word8 -> (Word8, Word8)

toInteger :: Word8 -> Integer

Integral Word16

Methods

quot :: Word16 -> Word16 -> Word16

rem :: Word16 -> Word16 -> Word16

div :: Word16 -> Word16 -> Word16

mod :: Word16 -> Word16 -> Word16

quotRem :: Word16 -> Word16 -> (Word16, Word16)

divMod :: Word16 -> Word16 -> (Word16, Word16)

toInteger :: Word16 -> Integer

Integral Word32

Methods

quot :: Word32 -> Word32 -> Word32

rem :: Word32 -> Word32 -> Word32

div :: Word32 -> Word32 -> Word32

mod :: Word32 -> Word32 -> Word32

quotRem :: Word32 -> Word32 -> (Word32, Word32)

divMod :: Word32 -> Word32 -> (Word32, Word32)

toInteger :: Word32 -> Integer

Integral Word64

Methods

quot :: Word64 -> Word64 -> Word64

rem :: Word64 -> Word64 -> Word64

div :: Word64 -> Word64 -> Word64

mod :: Word64 -> Word64 -> Word64

quotRem :: Word64 -> Word64 -> (Word64, Word64)

divMod :: Word64 -> Word64 -> (Word64, Word64)

toInteger :: Word64 -> Integer

Integral Name

Methods

quot :: Name -> Name -> Name

rem :: Name -> Name -> Name

div :: Name -> Name -> Name

mod :: Name -> Name -> Name

quotRem :: Name -> Name -> (Name, Name)

divMod :: Name -> Name -> (Name, Name)

toInteger :: Name -> Integer

() :=> (Integral Int)

Methods

ins :: () :- Integral Int

() :=> (Integral Integer)

Methods

ins :: () :- Integral Integer

Integral a => Integral (Identity a)

Methods

quot :: Identity a -> Identity a -> Identity a

rem :: Identity a -> Identity a -> Identity a

div :: Identity a -> Identity a -> Identity a

mod :: Identity a -> Identity a -> Identity a

quotRem :: Identity a -> Identity a -> (Identity a, Identity a)

divMod :: Identity a -> Identity a -> (Identity a, Identity a)

toInteger :: Identity a -> Integer

(Integral a) :=> (RealFrac (Ratio a))

Methods

ins :: Integral a :- RealFrac (Ratio a)

(Integral a) :=> (Real (Ratio a))

Methods

ins :: Integral a :- Real (Ratio a)

(Integral a) :=> (Ord (Ratio a))

Methods

ins :: Integral a :- Ord (Ratio a)

(Integral a) :=> (Num (Ratio a))

Methods

ins :: Integral a :- Num (Ratio a)

(Integral a) :=> (Fractional (Ratio a))

Methods

ins :: Integral a :- Fractional (Ratio a)

(Integral a) :=> (Enum (Ratio a))

Methods

ins :: Integral a :- Enum (Ratio a)

Class (Real a, Enum a) (Integral a)

Methods

cls :: Integral a :- (Real a, Enum a)

(Integral a, Show a) :=> (Show (Ratio a))

Methods

ins :: (Integral a, Show a) :- Show (Ratio a)

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

Methods

ins :: (Integral a, Read a) :- Read (Ratio a)

Integral a => Integral (Const k a b)

Methods

quot :: Const k a b -> Const k a b -> Const k a b

rem :: Const k a b -> Const k a b -> Const k a b

div :: Const k a b -> Const k a b -> Const k a b

mod :: Const k a b -> Const k a b -> Const k a b

quotRem :: Const k a b -> Const k a b -> (Const k a b, Const k a b)

divMod :: Const k a b -> Const k a b -> (Const k a b, Const k a b)

toInteger :: Const k a b -> Integer

class Eq a => Ord a

The Ord class is used for totally ordered datatypes.

Instances of Ord can be derived for any user-defined datatype whose constituent types are in Ord. The declared order of the constructors in the data declaration determines the ordering in derived Ord instances. The Ordering datatype allows a single comparison to determine the precise ordering of two objects.

Minimal complete definition: either compare or <=. Using compare can be more efficient for complex types.

Minimal complete definition

compare | (<=)

Instances

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

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

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

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

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

Ord Int8

Methods

compare :: Int8 -> Int8 -> Ordering

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

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

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

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

max :: Int8 -> Int8 -> Int8

min :: Int8 -> Int8 -> Int8

Ord Int16

Methods

compare :: Int16 -> Int16 -> Ordering

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

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

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

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

max :: Int16 -> Int16 -> Int16

min :: Int16 -> Int16 -> Int16

Ord Int32

Methods

compare :: Int32 -> Int32 -> Ordering

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

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

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

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

max :: Int32 -> Int32 -> Int32

min :: Int32 -> Int32 -> Int32

Ord Int64

Methods

compare :: Int64 -> Int64 -> Ordering

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

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

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

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

max :: Int64 -> Int64 -> Int64

min :: Int64 -> Int64 -> Int64

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

Ord Ordering

Methods

compare :: Ordering -> Ordering -> Ordering

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

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

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

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

max :: Ordering -> Ordering -> Ordering

min :: Ordering -> Ordering -> Ordering

Ord Word

Methods

compare :: Word -> Word -> Ordering

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

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

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

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

max :: Word -> Word -> Word

min :: Word -> Word -> Word

Ord Word8

Methods

compare :: Word8 -> Word8 -> Ordering

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

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

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

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

max :: Word8 -> Word8 -> Word8

min :: Word8 -> Word8 -> Word8

Ord Word16

Methods

compare :: Word16 -> Word16 -> Ordering

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

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

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

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

max :: Word16 -> Word16 -> Word16

min :: Word16 -> Word16 -> Word16

Ord Word32

Methods

compare :: Word32 -> Word32 -> Ordering

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

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

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

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

max :: Word32 -> Word32 -> Word32

min :: Word32 -> Word32 -> Word32

Ord Word64

Methods

compare :: Word64 -> Word64 -> Ordering

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

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

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

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

max :: Word64 -> Word64 -> Word64

min :: Word64 -> Word64 -> Word64

Ord TypeRep

Methods

compare :: TypeRep -> TypeRep -> Ordering

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

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

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

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

max :: TypeRep -> TypeRep -> TypeRep

min :: TypeRep -> TypeRep -> TypeRep

Ord Exp

Methods

compare :: Exp -> Exp -> Ordering

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

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

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

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

max :: Exp -> Exp -> Exp

min :: Exp -> Exp -> Exp

Ord Match

Methods

compare :: Match -> Match -> Ordering

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

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

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

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

max :: Match -> Match -> Match

min :: Match -> Match -> Match

Ord Clause

Methods

compare :: Clause -> Clause -> Ordering

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

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

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

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

max :: Clause -> Clause -> Clause

min :: Clause -> Clause -> Clause

Ord Pat

Methods

compare :: Pat -> Pat -> Ordering

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

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

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

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

max :: Pat -> Pat -> Pat

min :: Pat -> Pat -> Pat

Ord Type

Methods

compare :: Type -> Type -> Ordering

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

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

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

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

max :: Type -> Type -> Type

min :: Type -> Type -> Type

Ord Dec

Methods

compare :: Dec -> Dec -> Ordering

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

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

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

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

max :: Dec -> Dec -> Dec

min :: Dec -> Dec -> Dec

Ord Name

Methods

compare :: Name -> Name -> Ordering

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

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

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

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

max :: Name -> Name -> Name

min :: Name -> Name -> Name

Ord FunDep

Methods

compare :: FunDep -> FunDep -> Ordering

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

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

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

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

max :: FunDep -> FunDep -> FunDep

min :: FunDep -> FunDep -> FunDep

Ord TyVarBndr

Methods

compare :: TyVarBndr -> TyVarBndr -> Ordering

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

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

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

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

max :: TyVarBndr -> TyVarBndr -> TyVarBndr

min :: TyVarBndr -> TyVarBndr -> TyVarBndr

Ord InjectivityAnn

Methods

compare :: InjectivityAnn -> InjectivityAnn -> Ordering

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

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

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

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

max :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn

min :: InjectivityAnn -> InjectivityAnn -> InjectivityAnn

Ord Overlap

Methods

compare :: Overlap -> Overlap -> Ordering

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

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

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

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

max :: Overlap -> Overlap -> Overlap

min :: Overlap -> Overlap -> Overlap

Ord ()

Methods

compare :: () -> () -> Ordering

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

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

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

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

max :: () -> () -> ()

min :: () -> () -> ()

Ord TyCon

Methods

compare :: TyCon -> TyCon -> Ordering

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

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

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

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

max :: TyCon -> TyCon -> TyCon

min :: TyCon -> TyCon -> TyCon

Ord BigNat

Methods

compare :: BigNat -> BigNat -> Ordering

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

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

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

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

max :: BigNat -> BigNat -> BigNat

min :: BigNat -> BigNat -> BigNat

Ord Void

Methods

compare :: Void -> Void -> Ordering

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

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

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

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

max :: Void -> Void -> Void

min :: Void -> Void -> Void

Ord Version

Methods

compare :: Version -> Version -> Ordering

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

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

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

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

max :: Version -> Version -> Version

min :: Version -> Version -> Version

Ord ThreadId

Methods

compare :: ThreadId -> ThreadId -> Ordering

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

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

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

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

max :: ThreadId -> ThreadId -> ThreadId

min :: ThreadId -> ThreadId -> ThreadId

Ord BlockReason

Methods

compare :: BlockReason -> BlockReason -> Ordering

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

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

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

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

max :: BlockReason -> BlockReason -> BlockReason

min :: BlockReason -> BlockReason -> BlockReason

Ord ThreadStatus

Methods

compare :: ThreadStatus -> ThreadStatus -> Ordering

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

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

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

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

max :: ThreadStatus -> ThreadStatus -> ThreadStatus

min :: ThreadStatus -> ThreadStatus -> ThreadStatus

Ord AsyncException

Methods

compare :: AsyncException -> AsyncException -> Ordering

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

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

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

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

max :: AsyncException -> AsyncException -> AsyncException

min :: AsyncException -> AsyncException -> AsyncException

Ord ArrayException

Methods

compare :: ArrayException -> ArrayException -> Ordering

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

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

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

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

max :: ArrayException -> ArrayException -> ArrayException

min :: ArrayException -> ArrayException -> ArrayException

Ord ExitCode

Methods

compare :: ExitCode -> ExitCode -> Ordering

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

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

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

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

max :: ExitCode -> ExitCode -> ExitCode

min :: ExitCode -> ExitCode -> ExitCode

Ord All

Methods

compare :: All -> All -> Ordering

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

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

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

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

max :: All -> All -> All

min :: All -> All -> All

Ord Any

Methods

compare :: Any -> Any -> Ordering

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

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

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

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

max :: Any -> Any -> Any

min :: Any -> Any -> Any

Ord Fixity

Methods

compare :: Fixity -> Fixity -> Ordering

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

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

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

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

max :: Fixity -> Fixity -> Fixity

min :: Fixity -> Fixity -> Fixity

Ord Associativity

Methods

compare :: Associativity -> Associativity -> Ordering

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

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

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

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

max :: Associativity -> Associativity -> Associativity

min :: Associativity -> Associativity -> Associativity

Ord SourceUnpackedness

Methods

compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering

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

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

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

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

max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

Ord SourceStrictness

Methods

compare :: SourceStrictness -> SourceStrictness -> Ordering

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

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

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

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

max :: SourceStrictness -> SourceStrictness -> SourceStrictness

min :: SourceStrictness -> SourceStrictness -> SourceStrictness

Ord DecidedStrictness

Methods

compare :: DecidedStrictness -> DecidedStrictness -> Ordering

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

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

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

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

max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

Ord SomeNat

Methods

compare :: SomeNat -> SomeNat -> Ordering

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

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

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

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

max :: SomeNat -> SomeNat -> SomeNat

min :: SomeNat -> SomeNat -> SomeNat

Ord SomeSymbol

Methods

compare :: SomeSymbol -> SomeSymbol -> Ordering

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

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

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

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

max :: SomeSymbol -> SomeSymbol -> SomeSymbol

min :: SomeSymbol -> SomeSymbol -> SomeSymbol

Ord IOMode

Methods

compare :: IOMode -> IOMode -> Ordering

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

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

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

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

max :: IOMode -> IOMode -> IOMode

min :: IOMode -> IOMode -> IOMode

Ord IntSet

Methods

compare :: IntSet -> IntSet -> Ordering

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

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

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

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

max :: IntSet -> IntSet -> IntSet

min :: IntSet -> IntSet -> IntSet

Ord Hash

Methods

compare :: Hash -> Hash -> Ordering

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

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

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

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

max :: Hash -> Hash -> Hash

min :: Hash -> Hash -> Hash

Ord SrcLoc

Methods

compare :: SrcLoc -> SrcLoc -> Ordering

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

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

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

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

max :: SrcLoc -> SrcLoc -> SrcLoc

min :: SrcLoc -> SrcLoc -> SrcLoc

Ord SrcSpan

Methods

compare :: SrcSpan -> SrcSpan -> Ordering

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

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

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

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

max :: SrcSpan -> SrcSpan -> SrcSpan

min :: SrcSpan -> SrcSpan -> SrcSpan

Ord SrcSpanInfo

Methods

compare :: SrcSpanInfo -> SrcSpanInfo -> Ordering

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

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

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

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

max :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo

min :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo

Ord Boxed

Methods

compare :: Boxed -> Boxed -> Ordering

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

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

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

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

max :: Boxed -> Boxed -> Boxed

min :: Boxed -> Boxed -> Boxed

Ord Tool

Methods

compare :: Tool -> Tool -> Ordering

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

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

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

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

max :: Tool -> Tool -> Tool

min :: Tool -> Tool -> Tool

Ord Definition

Methods

compare :: Definition -> Definition -> Ordering

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

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

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

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

max :: Definition -> Definition -> Definition

min :: Definition -> Definition -> Definition

Ord Fixity

Methods

compare :: Fixity -> Fixity -> Ordering

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

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

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

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

max :: Fixity -> Fixity -> Fixity

min :: Fixity -> Fixity -> Fixity

Ord Assoc

Methods

compare :: Assoc -> Assoc -> Ordering

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

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

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

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

max :: Assoc -> Assoc -> Assoc

min :: Assoc -> Assoc -> Assoc

Ord Extensions

Methods

compare :: Extensions -> Extensions -> Ordering

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

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

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

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

max :: Extensions -> Extensions -> Extensions

min :: Extensions -> Extensions -> Extensions

Ord Id

Methods

compare :: Id -> Id -> Ordering

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

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

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

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

max :: Id -> Id -> Id

min :: Id -> Id -> Id

Ord StringLit

Methods

compare :: StringLit -> StringLit -> Ordering

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

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

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

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

max :: StringLit -> StringLit -> StringLit

min :: StringLit -> StringLit -> StringLit

Ord Storage

Methods

compare :: Storage -> Storage -> Ordering

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

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

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

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

max :: Storage -> Storage -> Storage

min :: Storage -> Storage -> Storage

Ord TypeQual

Methods

compare :: TypeQual -> TypeQual -> Ordering

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

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

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

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

max :: TypeQual -> TypeQual -> TypeQual

min :: TypeQual -> TypeQual -> TypeQual

Ord Sign

Methods

compare :: Sign -> Sign -> Ordering

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

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

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

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

max :: Sign -> Sign -> Sign

min :: Sign -> Sign -> Sign

Ord TypeSpec

Methods

compare :: TypeSpec -> TypeSpec -> Ordering

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

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

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

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

max :: TypeSpec -> TypeSpec -> TypeSpec

min :: TypeSpec -> TypeSpec -> TypeSpec

Ord DeclSpec

Methods

compare :: DeclSpec -> DeclSpec -> Ordering

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

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

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

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

max :: DeclSpec -> DeclSpec -> DeclSpec

min :: DeclSpec -> DeclSpec -> DeclSpec

Ord ArraySize

Methods

compare :: ArraySize -> ArraySize -> Ordering

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

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

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

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

max :: ArraySize -> ArraySize -> ArraySize

min :: ArraySize -> ArraySize -> ArraySize

Ord Decl

Methods

compare :: Decl -> Decl -> Ordering

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

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

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

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

max :: Decl -> Decl -> Decl

min :: Decl -> Decl -> Decl

Ord Type

Methods

compare :: Type -> Type -> Ordering

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

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

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

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

max :: Type -> Type -> Type

min :: Type -> Type -> Type

Ord Designator

Methods

compare :: Designator -> Designator -> Ordering

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

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

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

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

max :: Designator -> Designator -> Designator

min :: Designator -> Designator -> Designator

Ord Designation

Methods

compare :: Designation -> Designation -> Ordering

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

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

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

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

max :: Designation -> Designation -> Designation

min :: Designation -> Designation -> Designation

Ord Initializer

Methods

compare :: Initializer -> Initializer -> Ordering

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

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

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

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

max :: Initializer -> Initializer -> Initializer

min :: Initializer -> Initializer -> Initializer

Ord Init

Methods

compare :: Init -> Init -> Ordering

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

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

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

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

max :: Init -> Init -> Init

min :: Init -> Init -> Init

Ord Typedef

Methods

compare :: Typedef -> Typedef -> Ordering

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

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

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

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

max :: Typedef -> Typedef -> Typedef

min :: Typedef -> Typedef -> Typedef

Ord InitGroup

Methods

compare :: InitGroup -> InitGroup -> Ordering

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

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

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

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

max :: InitGroup -> InitGroup -> InitGroup

min :: InitGroup -> InitGroup -> InitGroup

Ord Field

Methods

compare :: Field -> Field -> Ordering

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

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

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

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

max :: Field -> Field -> Field

min :: Field -> Field -> Field

Ord FieldGroup

Methods

compare :: FieldGroup -> FieldGroup -> Ordering

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

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

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

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

max :: FieldGroup -> FieldGroup -> FieldGroup

min :: FieldGroup -> FieldGroup -> FieldGroup

Ord CEnum

Methods

compare :: CEnum -> CEnum -> Ordering

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

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

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

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

max :: CEnum -> CEnum -> CEnum

min :: CEnum -> CEnum -> CEnum

Ord Attr

Methods

compare :: Attr -> Attr -> Ordering

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

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

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

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

max :: Attr -> Attr -> Attr

min :: Attr -> Attr -> Attr

Ord Param

Methods

compare :: Param -> Param -> Ordering

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

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

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

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

max :: Param -> Param -> Param

min :: Param -> Param -> Param

Ord Params

Methods

compare :: Params -> Params -> Ordering

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

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

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

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

max :: Params -> Params -> Params

min :: Params -> Params -> Params

Ord Func

Methods

compare :: Func -> Func -> Ordering

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

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

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

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

max :: Func -> Func -> Func

min :: Func -> Func -> Func

Ord Stm

Methods

compare :: Stm -> Stm -> Ordering

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

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

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

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

max :: Stm -> Stm -> Stm

min :: Stm -> Stm -> Stm

Ord BlockItem

Methods

compare :: BlockItem -> BlockItem -> Ordering

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

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

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

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

max :: BlockItem -> BlockItem -> BlockItem

min :: BlockItem -> BlockItem -> BlockItem

Ord Signed

Methods

compare :: Signed -> Signed -> Ordering

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

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

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

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

max :: Signed -> Signed -> Signed

min :: Signed -> Signed -> Signed

Ord Const

Methods

compare :: Const -> Const -> Ordering

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

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

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

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

max :: Const -> Const -> Const

min :: Const -> Const -> Const

Ord Exp

Methods

compare :: Exp -> Exp -> Ordering

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

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

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

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

max :: Exp -> Exp -> Exp

min :: Exp -> Exp -> Exp

Ord BinOp

Methods

compare :: BinOp -> BinOp -> Ordering

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

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

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

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

max :: BinOp -> BinOp -> BinOp

min :: BinOp -> BinOp -> BinOp

Ord AssignOp

Methods

compare :: AssignOp -> AssignOp -> Ordering

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

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

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

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

max :: AssignOp -> AssignOp -> AssignOp

min :: AssignOp -> AssignOp -> AssignOp

Ord UnOp

Methods

compare :: UnOp -> UnOp -> Ordering

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

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

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

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

max :: UnOp -> UnOp -> UnOp

min :: UnOp -> UnOp -> UnOp

Ord AsmOut

Methods

compare :: AsmOut -> AsmOut -> Ordering

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

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

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

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

max :: AsmOut -> AsmOut -> AsmOut

min :: AsmOut -> AsmOut -> AsmOut

Ord AsmIn

Methods

compare :: AsmIn -> AsmIn -> Ordering

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

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

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

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

max :: AsmIn -> AsmIn -> AsmIn

min :: AsmIn -> AsmIn -> AsmIn

Ord BlockType

Methods

compare :: BlockType -> BlockType -> Ordering

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

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

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

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

max :: BlockType -> BlockType -> BlockType

min :: BlockType -> BlockType -> BlockType

Ord ObjCIvarDecl

Methods

compare :: ObjCIvarDecl -> ObjCIvarDecl -> Ordering

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

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

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

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

max :: ObjCIvarDecl -> ObjCIvarDecl -> ObjCIvarDecl

min :: ObjCIvarDecl -> ObjCIvarDecl -> ObjCIvarDecl

Ord ObjCVisibilitySpec

Methods

compare :: ObjCVisibilitySpec -> ObjCVisibilitySpec -> Ordering

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

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

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

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

max :: ObjCVisibilitySpec -> ObjCVisibilitySpec -> ObjCVisibilitySpec

min :: ObjCVisibilitySpec -> ObjCVisibilitySpec -> ObjCVisibilitySpec

Ord ObjCIfaceDecl

Methods

compare :: ObjCIfaceDecl -> ObjCIfaceDecl -> Ordering

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

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

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

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

max :: ObjCIfaceDecl -> ObjCIfaceDecl -> ObjCIfaceDecl

min :: ObjCIfaceDecl -> ObjCIfaceDecl -> ObjCIfaceDecl

Ord ObjCPropAttr

Methods

compare :: ObjCPropAttr -> ObjCPropAttr -> Ordering

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

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

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

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

max :: ObjCPropAttr -> ObjCPropAttr -> ObjCPropAttr

min :: ObjCPropAttr -> ObjCPropAttr -> ObjCPropAttr

Ord ObjCMethodReq

Methods

compare :: ObjCMethodReq -> ObjCMethodReq -> Ordering

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

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

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

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

max :: ObjCMethodReq -> ObjCMethodReq -> ObjCMethodReq

min :: ObjCMethodReq -> ObjCMethodReq -> ObjCMethodReq

Ord ObjCParam

Methods

compare :: ObjCParam -> ObjCParam -> Ordering

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

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

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

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

max :: ObjCParam -> ObjCParam -> ObjCParam

min :: ObjCParam -> ObjCParam -> ObjCParam

Ord ObjCMethodProto

Methods

compare :: ObjCMethodProto -> ObjCMethodProto -> Ordering

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

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

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

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

max :: ObjCMethodProto -> ObjCMethodProto -> ObjCMethodProto

min :: ObjCMethodProto -> ObjCMethodProto -> ObjCMethodProto

Ord ObjCCatch

Methods

compare :: ObjCCatch -> ObjCCatch -> Ordering

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

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

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

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

max :: ObjCCatch -> ObjCCatch -> ObjCCatch

min :: ObjCCatch -> ObjCCatch -> ObjCCatch

Ord ObjCDictElem

Methods

compare :: ObjCDictElem -> ObjCDictElem -> Ordering

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

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

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

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

max :: ObjCDictElem -> ObjCDictElem -> ObjCDictElem

min :: ObjCDictElem -> ObjCDictElem -> ObjCDictElem

Ord ObjCRecv

Methods

compare :: ObjCRecv -> ObjCRecv -> Ordering

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

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

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

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

max :: ObjCRecv -> ObjCRecv -> ObjCRecv

min :: ObjCRecv -> ObjCRecv -> ObjCRecv

Ord ObjCArg

Methods

compare :: ObjCArg -> ObjCArg -> Ordering

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

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

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

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

max :: ObjCArg -> ObjCArg -> ObjCArg

min :: ObjCArg -> ObjCArg -> ObjCArg

Ord LambdaIntroducer

Methods

compare :: LambdaIntroducer -> LambdaIntroducer -> Ordering

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

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

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

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

max :: LambdaIntroducer -> LambdaIntroducer -> LambdaIntroducer

min :: LambdaIntroducer -> LambdaIntroducer -> LambdaIntroducer

Ord LambdaDeclarator

Methods

compare :: LambdaDeclarator -> LambdaDeclarator -> Ordering

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

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

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

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

max :: LambdaDeclarator -> LambdaDeclarator -> LambdaDeclarator

min :: LambdaDeclarator -> LambdaDeclarator -> LambdaDeclarator

Ord CaptureListEntry

Methods

compare :: CaptureListEntry -> CaptureListEntry -> Ordering

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

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

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

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

max :: CaptureListEntry -> CaptureListEntry -> CaptureListEntry

min :: CaptureListEntry -> CaptureListEntry -> CaptureListEntry

Ord ExeConfig

Methods

compare :: ExeConfig -> ExeConfig -> Ordering

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

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

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

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

max :: ExeConfig -> ExeConfig -> ExeConfig

min :: ExeConfig -> ExeConfig -> ExeConfig

Ord Addr

Methods

compare :: Addr -> Addr -> Ordering

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

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

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

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

max :: Addr -> Addr -> Addr

min :: Addr -> Addr -> Addr

Ord Pos

Methods

compare :: Pos -> Pos -> Ordering

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

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

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

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

max :: Pos -> Pos -> Pos

min :: Pos -> Pos -> Pos

Ord SrcLoc

Methods

compare :: SrcLoc -> SrcLoc -> Ordering

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

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

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

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

max :: SrcLoc -> SrcLoc -> SrcLoc

min :: SrcLoc -> SrcLoc -> SrcLoc

Ord Name

Methods

compare :: Name -> Name -> Ordering

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

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

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

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

max :: Name -> Name -> Name

min :: Name -> Name -> Name

Ord ModName

Methods

compare :: ModName -> ModName -> Ordering

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

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

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

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

max :: ModName -> ModName -> ModName

min :: ModName -> ModName -> ModName

Ord PkgName

Methods

compare :: PkgName -> PkgName -> Ordering

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

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

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

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

max :: PkgName -> PkgName -> PkgName

min :: PkgName -> PkgName -> PkgName

Ord Module

Methods

compare :: Module -> Module -> Ordering

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

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

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

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

max :: Module -> Module -> Module

min :: Module -> Module -> Module

Ord OccName

Methods

compare :: OccName -> OccName -> Ordering

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

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

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

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

max :: OccName -> OccName -> OccName

min :: OccName -> OccName -> OccName

Ord NameFlavour

Methods

compare :: NameFlavour -> NameFlavour -> Ordering

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

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

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

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

max :: NameFlavour -> NameFlavour -> NameFlavour

min :: NameFlavour -> NameFlavour -> NameFlavour

Ord NameSpace

Methods

compare :: NameSpace -> NameSpace -> Ordering

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

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

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

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

max :: NameSpace -> NameSpace -> NameSpace

min :: NameSpace -> NameSpace -> NameSpace

Ord Loc

Methods

compare :: Loc -> Loc -> Ordering

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

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

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

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

max :: Loc -> Loc -> Loc

min :: Loc -> Loc -> Loc

Ord Info

Methods

compare :: Info -> Info -> Ordering

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

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

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

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

max :: Info -> Info -> Info

min :: Info -> Info -> Info

Ord ModuleInfo

Methods

compare :: ModuleInfo -> ModuleInfo -> Ordering

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

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

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

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

max :: ModuleInfo -> ModuleInfo -> ModuleInfo

min :: ModuleInfo -> ModuleInfo -> ModuleInfo

Ord Fixity

Methods

compare :: Fixity -> Fixity -> Ordering

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

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

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

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

max :: Fixity -> Fixity -> Fixity

min :: Fixity -> Fixity -> Fixity

Ord FixityDirection

Methods

compare :: FixityDirection -> FixityDirection -> Ordering

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

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

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

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

max :: FixityDirection -> FixityDirection -> FixityDirection

min :: FixityDirection -> FixityDirection -> FixityDirection

Ord Lit

Methods

compare :: Lit -> Lit -> Ordering

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

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

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

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

max :: Lit -> Lit -> Lit

min :: Lit -> Lit -> Lit

Ord Body

Methods

compare :: Body -> Body -> Ordering

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

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

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

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

max :: Body -> Body -> Body

min :: Body -> Body -> Body

Ord Guard

Methods

compare :: Guard -> Guard -> Ordering

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

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

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

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

max :: Guard -> Guard -> Guard

min :: Guard -> Guard -> Guard

Ord Stmt

Methods

compare :: Stmt -> Stmt -> Ordering

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

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

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

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

max :: Stmt -> Stmt -> Stmt

min :: Stmt -> Stmt -> Stmt

Ord Range

Methods

compare :: Range -> Range -> Ordering

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

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

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

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

max :: Range -> Range -> Range

min :: Range -> Range -> Range

Ord TypeFamilyHead

Methods

compare :: TypeFamilyHead -> TypeFamilyHead -> Ordering

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

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

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

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

max :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead

min :: TypeFamilyHead -> TypeFamilyHead -> TypeFamilyHead

Ord TySynEqn

Methods

compare :: TySynEqn -> TySynEqn -> Ordering

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

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

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

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

max :: TySynEqn -> TySynEqn -> TySynEqn

min :: TySynEqn -> TySynEqn -> TySynEqn

Ord FamFlavour

Methods

compare :: FamFlavour -> FamFlavour -> Ordering

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

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

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

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

max :: FamFlavour -> FamFlavour -> FamFlavour

min :: FamFlavour -> FamFlavour -> FamFlavour

Ord Foreign

Methods

compare :: Foreign -> Foreign -> Ordering

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

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

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

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

max :: Foreign -> Foreign -> Foreign

min :: Foreign -> Foreign -> Foreign

Ord Callconv

Methods

compare :: Callconv -> Callconv -> Ordering

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

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

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

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

max :: Callconv -> Callconv -> Callconv

min :: Callconv -> Callconv -> Callconv

Ord Safety

Methods

compare :: Safety -> Safety -> Ordering

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

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

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

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

max :: Safety -> Safety -> Safety

min :: Safety -> Safety -> Safety

Ord Pragma

Methods

compare :: Pragma -> Pragma -> Ordering

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

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

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

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

max :: Pragma -> Pragma -> Pragma

min :: Pragma -> Pragma -> Pragma

Ord Inline

Methods

compare :: Inline -> Inline -> Ordering

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

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

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

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

max :: Inline -> Inline -> Inline

min :: Inline -> Inline -> Inline

Ord RuleMatch

Methods

compare :: RuleMatch -> RuleMatch -> Ordering

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

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

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

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

max :: RuleMatch -> RuleMatch -> RuleMatch

min :: RuleMatch -> RuleMatch -> RuleMatch

Ord Phases

Methods

compare :: Phases -> Phases -> Ordering

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

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

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

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

max :: Phases -> Phases -> Phases

min :: Phases -> Phases -> Phases

Ord RuleBndr

Methods

compare :: RuleBndr -> RuleBndr -> Ordering

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

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

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

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

max :: RuleBndr -> RuleBndr -> RuleBndr

min :: RuleBndr -> RuleBndr -> RuleBndr

Ord AnnTarget

Methods

compare :: AnnTarget -> AnnTarget -> Ordering

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

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

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

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

max :: AnnTarget -> AnnTarget -> AnnTarget

min :: AnnTarget -> AnnTarget -> AnnTarget

Ord SourceUnpackedness

Methods

compare :: SourceUnpackedness -> SourceUnpackedness -> Ordering

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

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

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

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

max :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

min :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness

Ord SourceStrictness

Methods

compare :: SourceStrictness -> SourceStrictness -> Ordering

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

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

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

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

max :: SourceStrictness -> SourceStrictness -> SourceStrictness

min :: SourceStrictness -> SourceStrictness -> SourceStrictness

Ord DecidedStrictness

Methods

compare :: DecidedStrictness -> DecidedStrictness -> Ordering

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

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

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

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

max :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

min :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness

Ord Con

Methods

compare :: Con -> Con -> Ordering

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

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

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

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

max :: Con -> Con -> Con

min :: Con -> Con -> Con

Ord Bang

Methods

compare :: Bang -> Bang -> Ordering

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

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

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

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

max :: Bang -> Bang -> Bang

min :: Bang -> Bang -> Bang

Ord FamilyResultSig

Methods

compare :: FamilyResultSig -> FamilyResultSig -> Ordering

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

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

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

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

max :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig

min :: FamilyResultSig -> FamilyResultSig -> FamilyResultSig

Ord TyLit

Methods

compare :: TyLit -> TyLit -> Ordering

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

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

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

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

max :: TyLit -> TyLit -> TyLit

min :: TyLit -> TyLit -> TyLit

Ord Role

Methods

compare :: Role -> Role -> Ordering

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

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

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

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

max :: Role -> Role -> Role

min :: Role -> Role -> Role

Ord AnnLookup

Methods

compare :: AnnLookup -> AnnLookup -> Ordering

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

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

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

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

max :: AnnLookup -> AnnLookup -> AnnLookup

min :: AnnLookup -> AnnLookup -> AnnLookup

Ord LocalTime

Methods

compare :: LocalTime -> LocalTime -> Ordering

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

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

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

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

max :: LocalTime -> LocalTime -> LocalTime

min :: LocalTime -> LocalTime -> LocalTime

Ord UTCTime

Methods

compare :: UTCTime -> UTCTime -> Ordering

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

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

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

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

max :: UTCTime -> UTCTime -> UTCTime

min :: UTCTime -> UTCTime -> UTCTime

Ord NominalDiffTime

Methods

compare :: NominalDiffTime -> NominalDiffTime -> Ordering

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

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

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

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

max :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

min :: NominalDiffTime -> NominalDiffTime -> NominalDiffTime

Ord Day

Methods

compare :: Day -> Day -> Ordering

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

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

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

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

max :: Day -> Day -> Day

min :: Day -> Day -> Day

Ord UniversalTime

Methods

compare :: UniversalTime -> UniversalTime -> Ordering

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

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

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

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

max :: UniversalTime -> UniversalTime -> UniversalTime

min :: UniversalTime -> UniversalTime -> UniversalTime

Ord DiffTime

Methods

compare :: DiffTime -> DiffTime -> Ordering

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

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

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

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

max :: DiffTime -> DiffTime -> DiffTime

min :: DiffTime -> DiffTime -> DiffTime

() :=> (Ord Bool)

Methods

ins :: () :- Ord Bool

() :=> (Ord Char)

Methods

ins :: () :- Ord Char

() :=> (Ord Double)

Methods

ins :: () :- Ord Double

() :=> (Ord Float)

Methods

ins :: () :- Ord Float

() :=> (Ord Int)

Methods

ins :: () :- Ord Int

() :=> (Ord Integer)

Methods

ins :: () :- Ord Integer

() :=> (Ord ())

Methods

ins :: () :- Ord ()

() :=> (Ord (Dict a))

Methods

ins :: () :- Ord (Dict a)

() :=> (Ord ((:-) a b))

Methods

ins :: () :- Ord (a :- b)

Ord a => Ord [a]

Methods

compare :: [a] -> [a] -> Ordering

(<) :: [a] -> [a] -> Bool

(<=) :: [a] -> [a] -> Bool

(>) :: [a] -> [a] -> Bool

(>=) :: [a] -> [a] -> Bool

max :: [a] -> [a] -> [a]

min :: [a] -> [a] -> [a]

Ord a => Ord (Maybe a)

Methods

compare :: Maybe a -> Maybe a -> Ordering

(<) :: Maybe a -> Maybe a -> Bool

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

(>) :: Maybe a -> Maybe a -> Bool

(>=) :: Maybe a -> Maybe a -> Bool

max :: Maybe a -> Maybe a -> Maybe a

min :: Maybe a -> Maybe a -> Maybe a

Integral a => Ord (Ratio a)

Methods

compare :: Ratio a -> Ratio a -> Ordering

(<) :: Ratio a -> Ratio a -> Bool

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

(>) :: Ratio a -> Ratio a -> Bool

(>=) :: Ratio a -> Ratio a -> Bool

max :: Ratio a -> Ratio a -> Ratio a

min :: Ratio a -> Ratio a -> Ratio a

Ord (Ptr a)

Methods

compare :: Ptr a -> Ptr a -> Ordering

(<) :: Ptr a -> Ptr a -> Bool

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

(>) :: Ptr a -> Ptr a -> Bool

(>=) :: Ptr a -> Ptr a -> Bool

max :: Ptr a -> Ptr a -> Ptr a

min :: Ptr a -> Ptr a -> Ptr a

Ord (FunPtr a)

Methods

compare :: FunPtr a -> FunPtr a -> Ordering

(<) :: FunPtr a -> FunPtr a -> Bool

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

(>) :: FunPtr a -> FunPtr a -> Bool

(>=) :: FunPtr a -> FunPtr a -> Bool

max :: FunPtr a -> FunPtr a -> FunPtr a

min :: FunPtr a -> FunPtr a -> FunPtr a

Ord (V1 p)

Methods

compare :: V1 p -> V1 p -> Ordering

(<) :: V1 p -> V1 p -> Bool

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

(>) :: V1 p -> V1 p -> Bool

(>=) :: V1 p -> V1 p -> Bool

max :: V1 p -> V1 p -> V1 p

min :: V1 p -> V1 p -> V1 p

Ord (U1 p)

Methods

compare :: U1 p -> U1 p -> Ordering

(<) :: U1 p -> U1 p -> Bool

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

(>) :: U1 p -> U1 p -> Bool

(>=) :: U1 p -> U1 p -> Bool

max :: U1 p -> U1 p -> U1 p

min :: U1 p -> U1 p -> U1 p

Ord p => Ord (Par1 p)

Methods

compare :: Par1 p -> Par1 p -> Ordering

(<) :: Par1 p -> Par1 p -> Bool

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

(>) :: Par1 p -> Par1 p -> Bool

(>=) :: Par1 p -> Par1 p -> Bool

max :: Par1 p -> Par1 p -> Par1 p

min :: Par1 p -> Par1 p -> Par1 p

Ord a => Ord (Identity a)

Methods

compare :: Identity a -> Identity a -> Ordering

(<) :: Identity a -> Identity a -> Bool

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

(>) :: Identity a -> Identity a -> Bool

(>=) :: Identity a -> Identity a -> Bool

max :: Identity a -> Identity a -> Identity a

min :: Identity a -> Identity a -> Identity a

Ord a => Ord (Min a)

Methods

compare :: Min a -> Min a -> Ordering

(<) :: Min a -> Min a -> Bool

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

(>) :: Min a -> Min a -> Bool

(>=) :: Min a -> Min a -> Bool

max :: Min a -> Min a -> Min a

min :: Min a -> Min a -> Min a

Ord a => Ord (Max a)

Methods

compare :: Max a -> Max a -> Ordering

(<) :: Max a -> Max a -> Bool

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

(>) :: Max a -> Max a -> Bool

(>=) :: Max a -> Max a -> Bool

max :: Max a -> Max a -> Max a

min :: Max a -> Max a -> Max a

Ord a => Ord (First a)

Methods

compare :: First a -> First a -> Ordering

(<) :: First a -> First a -> Bool

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

(>) :: First a -> First a -> Bool

(>=) :: First a -> First a -> Bool

max :: First a -> First a -> First a

min :: First a -> First a -> First a

Ord a => Ord (Last a)

Methods

compare :: Last a -> Last a -> Ordering

(<) :: Last a -> Last a -> Bool

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

(>) :: Last a -> Last a -> Bool

(>=) :: Last a -> Last a -> Bool

max :: Last a -> Last a -> Last a

min :: Last a -> Last a -> Last a

Ord m => Ord (WrappedMonoid m)

Methods

compare :: WrappedMonoid m -> WrappedMonoid m -> Ordering

(<) :: WrappedMonoid m -> WrappedMonoid m -> Bool

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

(>) :: WrappedMonoid m -> WrappedMonoid m -> Bool

(>=) :: WrappedMonoid m -> WrappedMonoid m -> Bool

max :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

min :: WrappedMonoid m -> WrappedMonoid m -> WrappedMonoid m

Ord a => Ord (Option a)

Methods

compare :: Option a -> Option a -> Ordering

(<) :: Option a -> Option a -> Bool

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

(>) :: Option a -> Option a -> Bool

(>=) :: Option a -> Option a -> Bool

max :: Option a -> Option a -> Option a

min :: Option a -> Option a -> Option a

Ord a => Ord (NonEmpty a)

Methods

compare :: NonEmpty a -> NonEmpty a -> Ordering

(<) :: NonEmpty a -> NonEmpty a -> Bool

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

(>) :: NonEmpty a -> NonEmpty a -> Bool

(>=) :: NonEmpty a -> NonEmpty a -> Bool

max :: NonEmpty a -> NonEmpty a -> NonEmpty a

min :: NonEmpty a -> NonEmpty a -> NonEmpty a

Ord a => Ord (ZipList a)

Methods

compare :: ZipList a -> ZipList a -> Ordering

(<) :: ZipList a -> ZipList a -> Bool

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

(>) :: ZipList a -> ZipList a -> Bool

(>=) :: ZipList a -> ZipList a -> Bool

max :: ZipList a -> ZipList a -> ZipList a

min :: ZipList a -> ZipList a -> ZipList a

Ord a => Ord (Dual a)

Methods

compare :: Dual a -> Dual a -> Ordering

(<) :: Dual a -> Dual a -> Bool

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

(>) :: Dual a -> Dual a -> Bool

(>=) :: Dual a -> Dual a -> Bool

max :: Dual a -> Dual a -> Dual a

min :: Dual a -> Dual a -> Dual a

Ord a => Ord (Sum a)

Methods

compare :: Sum a -> Sum a -> Ordering

(<) :: Sum a -> Sum a -> Bool

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

(>) :: Sum a -> Sum a -> Bool

(>=) :: Sum a -> Sum a -> Bool

max :: Sum a -> Sum a -> Sum a

min :: Sum a -> Sum a -> Sum a

Ord a => Ord (Product a)

Methods

compare :: Product a -> Product a -> Ordering

(<) :: Product a -> Product a -> Bool

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

(>) :: Product a -> Product a -> Bool

(>=) :: Product a -> Product a -> Bool

max :: Product a -> Product a -> Product a

min :: Product a -> Product a -> Product a

Ord a => Ord (First a)

Methods

compare :: First a -> First a -> Ordering

(<) :: First a -> First a -> Bool

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

(>) :: First a -> First a -> Bool

(>=) :: First a -> First a -> Bool

max :: First a -> First a -> First a

min :: First a -> First a -> First a

Ord a => Ord (Last a)

Methods

compare :: Last a -> Last a -> Ordering

(<) :: Last a -> Last a -> Bool

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

(>) :: Last a -> Last a -> Bool

(>=) :: Last a -> Last a -> Bool

max :: Last a -> Last a -> Last a

min :: Last a -> Last a -> Last a

Ord (Dict a)

Methods

compare :: Dict a -> Dict a -> Ordering

(<) :: Dict a -> Dict a -> Bool

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

(>) :: Dict a -> Dict a -> Bool

(>=) :: Dict a -> Dict a -> Bool

max :: Dict a -> Dict a -> Dict a

min :: Dict a -> Dict a -> Dict a

Ord a => Ord (IntMap a)

Methods

compare :: IntMap a -> IntMap a -> Ordering

(<) :: IntMap a -> IntMap a -> Bool

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

(>) :: IntMap a -> IntMap a -> Bool

(>=) :: IntMap a -> IntMap a -> Bool

max :: IntMap a -> IntMap a -> IntMap a

min :: IntMap a -> IntMap a -> IntMap a

Ord a => Ord (Seq a)

Methods

compare :: Seq a -> Seq a -> Ordering

(<) :: Seq a -> Seq a -> Bool

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

(>) :: Seq a -> Seq a -> Bool

(>=) :: Seq a -> Seq a -> Bool

max :: Seq a -> Seq a -> Seq a

min :: Seq a -> Seq a -> Seq a

Ord a => Ord (ViewL a)

Methods

compare :: ViewL a -> ViewL a -> Ordering

(<) :: ViewL a -> ViewL a -> Bool

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

(>) :: ViewL a -> ViewL a -> Bool

(>=) :: ViewL a -> ViewL a -> Bool

max :: ViewL a -> ViewL a -> ViewL a

min :: ViewL a -> ViewL a -> ViewL a

Ord a => Ord (ViewR a)

Methods

compare :: ViewR a -> ViewR a -> Ordering

(<) :: ViewR a -> ViewR a -> Bool

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

(>) :: ViewR a -> ViewR a -> Bool

(>=) :: ViewR a -> ViewR a -> Bool

max :: ViewR a -> ViewR a -> ViewR a

min :: ViewR a -> ViewR a -> ViewR a

Ord a => Ord (Set a)

Methods

compare :: Set a -> Set a -> Ordering

(<) :: Set a -> Set a -> Bool

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

(>) :: Set a -> Set a -> Bool

(>=) :: Set a -> Set a -> Bool

max :: Set a -> Set a -> Set a

min :: Set a -> Set a -> Set a

Ord l => Ord (PragmasAndModuleName l)

Methods

compare :: PragmasAndModuleName l -> PragmasAndModuleName l -> Ordering

(<) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool

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

(>) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool

(>=) :: PragmasAndModuleName l -> PragmasAndModuleName l -> Bool

max :: PragmasAndModuleName l -> PragmasAndModuleName l -> PragmasAndModuleName l

min :: PragmasAndModuleName l -> PragmasAndModuleName l -> PragmasAndModuleName l

Ord l => Ord (PragmasAndModuleHead l)

Methods

compare :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Ordering

(<) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool

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

(>) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool

(>=) :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> Bool

max :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> PragmasAndModuleHead l

min :: PragmasAndModuleHead l -> PragmasAndModuleHead l -> PragmasAndModuleHead l

Ord l => Ord (ModuleHeadAndImports l)

Methods

compare :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Ordering

(<) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool

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

(>) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool

(>=) :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> Bool

max :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> ModuleHeadAndImports l

min :: ModuleHeadAndImports l -> ModuleHeadAndImports l -> ModuleHeadAndImports l

Ord a => Ord (NonGreedy a)

Methods

compare :: NonGreedy a -> NonGreedy a -> Ordering

(<) :: NonGreedy a -> NonGreedy a -> Bool

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

(>) :: NonGreedy a -> NonGreedy a -> Bool

(>=) :: NonGreedy a -> NonGreedy a -> Bool

max :: NonGreedy a -> NonGreedy a -> NonGreedy a

min :: NonGreedy a -> NonGreedy a -> NonGreedy a

Ord a => Ord (ListOf a)

Methods

compare :: ListOf a -> ListOf a -> Ordering

(<) :: ListOf a -> ListOf a -> Bool

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

(>) :: ListOf a -> ListOf a -> Bool

(>=) :: ListOf a -> ListOf a -> Bool

max :: ListOf a -> ListOf a -> ListOf a

min :: ListOf a -> ListOf a -> ListOf a

Ord a => Ord (Loc a)

Methods

compare :: Loc a -> Loc a -> Ordering

(<) :: Loc a -> Loc a -> Bool

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

(>) :: Loc a -> Loc a -> Bool

(>=) :: Loc a -> Loc a -> Bool

max :: Loc a -> Loc a -> Loc a

min :: Loc a -> Loc a -> Loc a

Ord l => Ord (ModuleName l)

Methods

compare :: ModuleName l -> ModuleName l -> Ordering

(<) :: ModuleName l -> ModuleName l -> Bool

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

(>) :: ModuleName l -> ModuleName l -> Bool

(>=) :: ModuleName l -> ModuleName l -> Bool

max :: ModuleName l -> ModuleName l -> ModuleName l

min :: ModuleName l -> ModuleName l -> ModuleName l

Ord l => Ord (SpecialCon l)

Methods

compare :: SpecialCon l -> SpecialCon l -> Ordering

(<) :: SpecialCon l -> SpecialCon l -> Bool

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

(>) :: SpecialCon l -> SpecialCon l -> Bool

(>=) :: SpecialCon l -> SpecialCon l -> Bool

max :: SpecialCon l -> SpecialCon l -> SpecialCon l

min :: SpecialCon l -> SpecialCon l -> SpecialCon l

Ord l => Ord (QName l)

Methods

compare :: QName l -> QName l -> Ordering

(<) :: QName l -> QName l -> Bool

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

(>) :: QName l -> QName l -> Bool

(>=) :: QName l -> QName l -> Bool

max :: QName l -> QName l -> QName l

min :: QName l -> QName l -> QName l

Ord l => Ord (Name l)

Methods

compare :: Name l -> Name l -> Ordering

(<) :: Name l -> Name l -> Bool

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

(>) :: Name l -> Name l -> Bool

(>=) :: Name l -> Name l -> Bool

max :: Name l -> Name l -> Name l

min :: Name l -> Name l -> Name l

Ord l => Ord (IPName l)

Methods

compare :: IPName l -> IPName l -> Ordering

(<) :: IPName l -> IPName l -> Bool

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

(>) :: IPName l -> IPName l -> Bool

(>=) :: IPName l -> IPName l -> Bool

max :: IPName l -> IPName l -> IPName l

min :: IPName l -> IPName l -> IPName l

Ord l => Ord (QOp l)

Methods

compare :: QOp l -> QOp l -> Ordering

(<) :: QOp l -> QOp l -> Bool

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

(>) :: QOp l -> QOp l -> Bool

(>=) :: QOp l -> QOp l -> Bool

max :: QOp l -> QOp l -> QOp l

min :: QOp l -> QOp l -> QOp l

Ord l => Ord (Op l)

Methods

compare :: Op l -> Op l -> Ordering

(<) :: Op l -> Op l -> Bool

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

(>) :: Op l -> Op l -> Bool

(>=) :: Op l -> Op l -> Bool

max :: Op l -> Op l -> Op l

min :: Op l -> Op l -> Op l

Ord l => Ord (CName l)

Methods

compare :: CName l -> CName l -> Ordering

(<) :: CName l -> CName l -> Bool

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

(>) :: CName l -> CName l -> Bool

(>=) :: CName l -> CName l -> Bool

max :: CName l -> CName l -> CName l

min :: CName l -> CName l -> CName l

Ord l => Ord (Module l)

Methods

compare :: Module l -> Module l -> Ordering

(<) :: Module l -> Module l -> Bool

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

(>) :: Module l -> Module l -> Bool

(>=) :: Module l -> Module l -> Bool

max :: Module l -> Module l -> Module l

min :: Module l -> Module l -> Module l

Ord l => Ord (ModuleHead l)

Methods

compare :: ModuleHead l -> ModuleHead l -> Ordering

(<) :: ModuleHead l -> ModuleHead l -> Bool

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

(>) :: ModuleHead l -> ModuleHead l -> Bool

(>=) :: ModuleHead l -> ModuleHead l -> Bool

max :: ModuleHead l -> ModuleHead l -> ModuleHead l

min :: ModuleHead l -> ModuleHead l -> ModuleHead l

Ord l => Ord (ExportSpecList l)

Methods

compare :: ExportSpecList l -> ExportSpecList l -> Ordering

(<) :: ExportSpecList l -> ExportSpecList l -> Bool

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

(>) :: ExportSpecList l -> ExportSpecList l -> Bool

(>=) :: ExportSpecList l -> ExportSpecList l -> Bool

max :: ExportSpecList l -> ExportSpecList l -> ExportSpecList l

min :: ExportSpecList l -> ExportSpecList l -> ExportSpecList l

Ord l => Ord (ExportSpec l)

Methods

compare :: ExportSpec l -> ExportSpec l -> Ordering

(<) :: ExportSpec l -> ExportSpec l -> Bool

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

(>) :: ExportSpec l -> ExportSpec l -> Bool

(>=) :: ExportSpec l -> ExportSpec l -> Bool

max :: ExportSpec l -> ExportSpec l -> ExportSpec l

min :: ExportSpec l -> ExportSpec l -> ExportSpec l

Ord l => Ord (EWildcard l)

Methods

compare :: EWildcard l -> EWildcard l -> Ordering

(<) :: EWildcard l -> EWildcard l -> Bool

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

(>) :: EWildcard l -> EWildcard l -> Bool

(>=) :: EWildcard l -> EWildcard l -> Bool

max :: EWildcard l -> EWildcard l -> EWildcard l

min :: EWildcard l -> EWildcard l -> EWildcard l

Ord l => Ord (Namespace l)

Methods

compare :: Namespace l -> Namespace l -> Ordering

(<) :: Namespace l -> Namespace l -> Bool

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

(>) :: Namespace l -> Namespace l -> Bool

(>=) :: Namespace l -> Namespace l -> Bool

max :: Namespace l -> Namespace l -> Namespace l

min :: Namespace l -> Namespace l -> Namespace l

Ord l => Ord (ImportDecl l)

Methods

compare :: ImportDecl l -> ImportDecl l -> Ordering

(<) :: ImportDecl l -> ImportDecl l -> Bool

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

(>) :: ImportDecl l -> ImportDecl l -> Bool

(>=) :: ImportDecl l -> ImportDecl l -> Bool

max :: ImportDecl l -> ImportDecl l -> ImportDecl l

min :: ImportDecl l -> ImportDecl l -> ImportDecl l

Ord l => Ord (ImportSpecList l)

Methods

compare :: ImportSpecList l -> ImportSpecList l -> Ordering

(<) :: ImportSpecList l -> ImportSpecList l -> Bool

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

(>) :: ImportSpecList l -> ImportSpecList l -> Bool

(>=) :: ImportSpecList l -> ImportSpecList l -> Bool

max :: ImportSpecList l -> ImportSpecList l -> ImportSpecList l

min :: ImportSpecList l -> ImportSpecList l -> ImportSpecList l

Ord l => Ord (ImportSpec l)

Methods

compare :: ImportSpec l -> ImportSpec l -> Ordering

(<) :: ImportSpec l -> ImportSpec l -> Bool

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

(>) :: ImportSpec l -> ImportSpec l -> Bool

(>=) :: ImportSpec l -> ImportSpec l -> Bool

max :: ImportSpec l -> ImportSpec l -> ImportSpec l

min :: ImportSpec l -> ImportSpec l -> ImportSpec l

Ord l => Ord (Assoc l)

Methods

compare :: Assoc l -> Assoc l -> Ordering

(<) :: Assoc l -> Assoc l -> Bool

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

(>) :: Assoc l -> Assoc l -> Bool

(>=) :: Assoc l -> Assoc l -> Bool

max :: Assoc l -> Assoc l -> Assoc l

min :: Assoc l -> Assoc l -> Assoc l

Ord l => Ord (Decl l)

Methods

compare :: Decl l -> Decl l -> Ordering

(<) :: Decl l -> Decl l -> Bool

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

(>) :: Decl l -> Decl l -> Bool

(>=) :: Decl l -> Decl l -> Bool

max :: Decl l -> Decl l -> Decl l

min :: Decl l -> Decl l -> Decl l

Ord l => Ord (PatternSynDirection l)

Methods

compare :: PatternSynDirection l -> PatternSynDirection l -> Ordering

(<) :: PatternSynDirection l -> PatternSynDirection l -> Bool

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

(>) :: PatternSynDirection l -> PatternSynDirection l -> Bool

(>=) :: PatternSynDirection l -> PatternSynDirection l -> Bool

max :: PatternSynDirection l -> PatternSynDirection l -> PatternSynDirection l

min :: PatternSynDirection l -> PatternSynDirection l -> PatternSynDirection l

Ord l => Ord (TypeEqn l)

Methods

compare :: TypeEqn l -> TypeEqn l -> Ordering

(<) :: TypeEqn l -> TypeEqn l -> Bool

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

(>) :: TypeEqn l -> TypeEqn l -> Bool

(>=) :: TypeEqn l -> TypeEqn l -> Bool

max :: TypeEqn l -> TypeEqn l -> TypeEqn l

min :: TypeEqn l -> TypeEqn l -> TypeEqn l

Ord l => Ord (Annotation l)

Methods

compare :: Annotation l -> Annotation l -> Ordering

(<) :: Annotation l -> Annotation l -> Bool

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

(>) :: Annotation l -> Annotation l -> Bool

(>=) :: Annotation l -> Annotation l -> Bool

max :: Annotation l -> Annotation l -> Annotation l

min :: Annotation l -> Annotation l -> Annotation l

Ord l => Ord (BooleanFormula l)

Methods

compare :: BooleanFormula l -> BooleanFormula l -> Ordering

(<) :: BooleanFormula l -> BooleanFormula l -> Bool

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

(>) :: BooleanFormula l -> BooleanFormula l -> Bool

(>=) :: BooleanFormula l -> BooleanFormula l -> Bool

max :: BooleanFormula l -> BooleanFormula l -> BooleanFormula l

min :: BooleanFormula l -> BooleanFormula l -> BooleanFormula l

Ord l => Ord (Role l)

Methods

compare :: Role l -> Role l -> Ordering

(<) :: Role l -> Role l -> Bool

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

(>) :: Role l -> Role l -> Bool

(>=) :: Role l -> Role l -> Bool

max :: Role l -> Role l -> Role l

min :: Role l -> Role l -> Role l

Ord l => Ord (DataOrNew l)

Methods

compare :: DataOrNew l -> DataOrNew l -> Ordering

(<) :: DataOrNew l -> DataOrNew l -> Bool

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

(>) :: DataOrNew l -> DataOrNew l -> Bool

(>=) :: DataOrNew l -> DataOrNew l -> Bool

max :: DataOrNew l -> DataOrNew l -> DataOrNew l

min :: DataOrNew l -> DataOrNew l -> DataOrNew l

Ord l => Ord (InjectivityInfo l)

Methods

compare :: InjectivityInfo l -> InjectivityInfo l -> Ordering

(<) :: InjectivityInfo l -> InjectivityInfo l -> Bool

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

(>) :: InjectivityInfo l -> InjectivityInfo l -> Bool

(>=) :: InjectivityInfo l -> InjectivityInfo l -> Bool

max :: InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l

min :: InjectivityInfo l -> InjectivityInfo l -> InjectivityInfo l

Ord l => Ord (ResultSig l)

Methods

compare :: ResultSig l -> ResultSig l -> Ordering

(<) :: ResultSig l -> ResultSig l -> Bool

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

(>) :: ResultSig l -> ResultSig l -> Bool

(>=) :: ResultSig l -> ResultSig l -> Bool

max :: ResultSig l -> ResultSig l -> ResultSig l

min :: ResultSig l -> ResultSig l -> ResultSig l

Ord l => Ord (DeclHead l)

Methods

compare :: DeclHead l -> DeclHead l -> Ordering

(<) :: DeclHead l -> DeclHead l -> Bool

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

(>) :: DeclHead l -> DeclHead l -> Bool

(>=) :: DeclHead l -> DeclHead l -> Bool

max :: DeclHead l -> DeclHead l -> DeclHead l

min :: DeclHead l -> DeclHead l -> DeclHead l

Ord l => Ord (InstRule l)

Methods

compare :: InstRule l -> InstRule l -> Ordering

(<) :: InstRule l -> InstRule l -> Bool

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

(>) :: InstRule l -> InstRule l -> Bool

(>=) :: InstRule l -> InstRule l -> Bool

max :: InstRule l -> InstRule l -> InstRule l

min :: InstRule l -> InstRule l -> InstRule l

Ord l => Ord (InstHead l)

Methods

compare :: InstHead l -> InstHead l -> Ordering

(<) :: InstHead l -> InstHead l -> Bool

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

(>) :: InstHead l -> InstHead l -> Bool

(>=) :: InstHead l -> InstHead l -> Bool

max :: InstHead l -> InstHead l -> InstHead l

min :: InstHead l -> InstHead l -> InstHead l

Ord l => Ord (Deriving l)

Methods

compare :: Deriving l -> Deriving l -> Ordering

(<) :: Deriving l -> Deriving l -> Bool

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

(>) :: Deriving l -> Deriving l -> Bool

(>=) :: Deriving l -> Deriving l -> Bool

max :: Deriving l -> Deriving l -> Deriving l

min :: Deriving l -> Deriving l -> Deriving l

Ord l => Ord (Binds l)

Methods

compare :: Binds l -> Binds l -> Ordering

(<) :: Binds l -> Binds l -> Bool

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

(>) :: Binds l -> Binds l -> Bool

(>=) :: Binds l -> Binds l -> Bool

max :: Binds l -> Binds l -> Binds l

min :: Binds l -> Binds l -> Binds l

Ord l => Ord (IPBind l)

Methods

compare :: IPBind l -> IPBind l -> Ordering

(<) :: IPBind l -> IPBind l -> Bool

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

(>) :: IPBind l -> IPBind l -> Bool

(>=) :: IPBind l -> IPBind l -> Bool

max :: IPBind l -> IPBind l -> IPBind l

min :: IPBind l -> IPBind l -> IPBind l

Ord l => Ord (Match l)

Methods

compare :: Match l -> Match l -> Ordering

(<) :: Match l -> Match l -> Bool

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

(>) :: Match l -> Match l -> Bool

(>=) :: Match l -> Match l -> Bool

max :: Match l -> Match l -> Match l

min :: Match l -> Match l -> Match l

Ord l => Ord (QualConDecl l)

Methods

compare :: QualConDecl l -> QualConDecl l -> Ordering

(<) :: QualConDecl l -> QualConDecl l -> Bool

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

(>) :: QualConDecl l -> QualConDecl l -> Bool

(>=) :: QualConDecl l -> QualConDecl l -> Bool

max :: QualConDecl l -> QualConDecl l -> QualConDecl l

min :: QualConDecl l -> QualConDecl l -> QualConDecl l

Ord l => Ord (ConDecl l)

Methods

compare :: ConDecl l -> ConDecl l -> Ordering

(<) :: ConDecl l -> ConDecl l -> Bool

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

(>) :: ConDecl l -> ConDecl l -> Bool

(>=) :: ConDecl l -> ConDecl l -> Bool

max :: ConDecl l -> ConDecl l -> ConDecl l

min :: ConDecl l -> ConDecl l -> ConDecl l

Ord l => Ord (FieldDecl l)

Methods

compare :: FieldDecl l -> FieldDecl l -> Ordering

(<) :: FieldDecl l -> FieldDecl l -> Bool

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

(>) :: FieldDecl l -> FieldDecl l -> Bool

(>=) :: FieldDecl l -> FieldDecl l -> Bool

max :: FieldDecl l -> FieldDecl l -> FieldDecl l

min :: FieldDecl l -> FieldDecl l -> FieldDecl l

Ord l => Ord (GadtDecl l)

Methods

compare :: GadtDecl l -> GadtDecl l -> Ordering

(<) :: GadtDecl l -> GadtDecl l -> Bool

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

(>) :: GadtDecl l -> GadtDecl l -> Bool

(>=) :: GadtDecl l -> GadtDecl l -> Bool

max :: GadtDecl l -> GadtDecl l -> GadtDecl l

min :: GadtDecl l -> GadtDecl l -> GadtDecl l

Ord l => Ord (ClassDecl l)

Methods

compare :: ClassDecl l -> ClassDecl l -> Ordering

(<) :: ClassDecl l -> ClassDecl l -> Bool

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

(>) :: ClassDecl l -> ClassDecl l -> Bool

(>=) :: ClassDecl l -> ClassDecl l -> Bool

max :: ClassDecl l -> ClassDecl l -> ClassDecl l

min :: ClassDecl l -> ClassDecl l -> ClassDecl l

Ord l => Ord (InstDecl l)

Methods

compare :: InstDecl l -> InstDecl l -> Ordering

(<) :: InstDecl l -> InstDecl l -> Bool

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

(>) :: InstDecl l -> InstDecl l -> Bool

(>=) :: InstDecl l -> InstDecl l -> Bool

max :: InstDecl l -> InstDecl l -> InstDecl l

min :: InstDecl l -> InstDecl l -> InstDecl l

Ord l => Ord (BangType l)

Methods

compare :: BangType l -> BangType l -> Ordering

(<) :: BangType l -> BangType l -> Bool

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

(>) :: BangType l -> BangType l -> Bool

(>=) :: BangType l -> BangType l -> Bool

max :: BangType l -> BangType l -> BangType l

min :: BangType l -> BangType l -> BangType l

Ord l => Ord (Unpackedness l)

Methods

compare :: Unpackedness l -> Unpackedness l -> Ordering

(<) :: Unpackedness l -> Unpackedness l -> Bool

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

(>) :: Unpackedness l -> Unpackedness l -> Bool

(>=) :: Unpackedness l -> Unpackedness l -> Bool

max :: Unpackedness l -> Unpackedness l -> Unpackedness l

min :: Unpackedness l -> Unpackedness l -> Unpackedness l

Ord l => Ord (Rhs l)

Methods

compare :: Rhs l -> Rhs l -> Ordering

(<) :: Rhs l -> Rhs l -> Bool

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

(>) :: Rhs l -> Rhs l -> Bool

(>=) :: Rhs l -> Rhs l -> Bool

max :: Rhs l -> Rhs l -> Rhs l

min :: Rhs l -> Rhs l -> Rhs l

Ord l => Ord (GuardedRhs l)

Methods

compare :: GuardedRhs l -> GuardedRhs l -> Ordering

(<) :: GuardedRhs l -> GuardedRhs l -> Bool

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

(>) :: GuardedRhs l -> GuardedRhs l -> Bool

(>=) :: GuardedRhs l -> GuardedRhs l -> Bool

max :: GuardedRhs l -> GuardedRhs l -> GuardedRhs l

min :: GuardedRhs l -> GuardedRhs l -> GuardedRhs l

Ord l => Ord (Type l)

Methods

compare :: Type l -> Type l -> Ordering

(<) :: Type l -> Type l -> Bool

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

(>) :: Type l -> Type l -> Bool

(>=) :: Type l -> Type l -> Bool

max :: Type l -> Type l -> Type l

min :: Type l -> Type l -> Type l

Ord l => Ord (Promoted l)

Methods

compare :: Promoted l -> Promoted l -> Ordering

(<) :: Promoted l -> Promoted l -> Bool

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

(>) :: Promoted l -> Promoted l -> Bool

(>=) :: Promoted l -> Promoted l -> Bool

max :: Promoted l -> Promoted l -> Promoted l

min :: Promoted l -> Promoted l -> Promoted l

Ord l => Ord (TyVarBind l)

Methods

compare :: TyVarBind l -> TyVarBind l -> Ordering

(<) :: TyVarBind l -> TyVarBind l -> Bool

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

(>) :: TyVarBind l -> TyVarBind l -> Bool

(>=) :: TyVarBind l -> TyVarBind l -> Bool

max :: TyVarBind l -> TyVarBind l -> TyVarBind l

min :: TyVarBind l -> TyVarBind l -> TyVarBind l

Ord l => Ord (Kind l)

Methods

compare :: Kind l -> Kind l -> Ordering

(<) :: Kind l -> Kind l -> Bool

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

(>) :: Kind l -> Kind l -> Bool

(>=) :: Kind l -> Kind l -> Bool

max :: Kind l -> Kind l -> Kind l

min :: Kind l -> Kind l -> Kind l

Ord l => Ord (FunDep l)

Methods

compare :: FunDep l -> FunDep l -> Ordering

(<) :: FunDep l -> FunDep l -> Bool

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

(>) :: FunDep l -> FunDep l -> Bool

(>=) :: FunDep l -> FunDep l -> Bool

max :: FunDep l -> FunDep l -> FunDep l

min :: FunDep l -> FunDep l -> FunDep l

Ord l => Ord (Context l)

Methods

compare :: Context l -> Context l -> Ordering

(<) :: Context l -> Context l -> Bool

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

(>) :: Context l -> Context l -> Bool

(>=) :: Context l -> Context l -> Bool

max :: Context l -> Context l -> Context l

min :: Context l -> Context l -> Context l

Ord l => Ord (Asst l)

Methods

compare :: Asst l -> Asst l -> Ordering

(<) :: Asst l -> Asst l -> Bool

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

(>) :: Asst l -> Asst l -> Bool

(>=) :: Asst l -> Asst l -> Bool

max :: Asst l -> Asst l -> Asst l

min :: Asst l -> Asst l -> Asst l

Ord l => Ord (Literal l)

Methods

compare :: Literal l -> Literal l -> Ordering

(<) :: Literal l -> Literal l -> Bool

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

(>) :: Literal l -> Literal l -> Bool

(>=) :: Literal l -> Literal l -> Bool

max :: Literal l -> Literal l -> Literal l

min :: Literal l -> Literal l -> Literal l

Ord l => Ord (Sign l)

Methods

compare :: Sign l -> Sign l -> Ordering

(<) :: Sign l -> Sign l -> Bool

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

(>) :: Sign l -> Sign l -> Bool

(>=) :: Sign l -> Sign l -> Bool

max :: Sign l -> Sign l -> Sign l

min :: Sign l -> Sign l -> Sign l

Ord l => Ord (Exp l)

Methods

compare :: Exp l -> Exp l -> Ordering

(<) :: Exp l -> Exp l -> Bool

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

(>) :: Exp l -> Exp l -> Bool

(>=) :: Exp l -> Exp l -> Bool

max :: Exp l -> Exp l -> Exp l

min :: Exp l -> Exp l -> Exp l

Ord l => Ord (XName l)

Methods

compare :: XName l -> XName l -> Ordering

(<) :: XName l -> XName l -> Bool

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

(>) :: XName l -> XName l -> Bool

(>=) :: XName l -> XName l -> Bool

max :: XName l -> XName l -> XName l

min :: XName l -> XName l -> XName l

Ord l => Ord (XAttr l)

Methods

compare :: XAttr l -> XAttr l -> Ordering

(<) :: XAttr l -> XAttr l -> Bool

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

(>) :: XAttr l -> XAttr l -> Bool

(>=) :: XAttr l -> XAttr l -> Bool

max :: XAttr l -> XAttr l -> XAttr l

min :: XAttr l -> XAttr l -> XAttr l

Ord l => Ord (Bracket l)

Methods

compare :: Bracket l -> Bracket l -> Ordering

(<) :: Bracket l -> Bracket l -> Bool

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

(>) :: Bracket l -> Bracket l -> Bool

(>=) :: Bracket l -> Bracket l -> Bool

max :: Bracket l -> Bracket l -> Bracket l

min :: Bracket l -> Bracket l -> Bracket l

Ord l => Ord (Splice l)

Methods

compare :: Splice l -> Splice l -> Ordering

(<) :: Splice l -> Splice l -> Bool

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

(>) :: Splice l -> Splice l -> Bool

(>=) :: Splice l -> Splice l -> Bool

max :: Splice l -> Splice l -> Splice l

min :: Splice l -> Splice l -> Splice l

Ord l => Ord (Safety l)

Methods

compare :: Safety l -> Safety l -> Ordering

(<) :: Safety l -> Safety l -> Bool

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

(>) :: Safety l -> Safety l -> Bool

(>=) :: Safety l -> Safety l -> Bool

max :: Safety l -> Safety l -> Safety l

min :: Safety l -> Safety l -> Safety l

Ord l => Ord (CallConv l)

Methods

compare :: CallConv l -> CallConv l -> Ordering

(<) :: CallConv l -> CallConv l -> Bool

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

(>) :: CallConv l -> CallConv l -> Bool

(>=) :: CallConv l -> CallConv l -> Bool

max :: CallConv l -> CallConv l -> CallConv l

min :: CallConv l -> CallConv l -> CallConv l

Ord l => Ord (ModulePragma l)

Methods

compare :: ModulePragma l -> ModulePragma l -> Ordering

(<) :: ModulePragma l -> ModulePragma l -> Bool

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

(>) :: ModulePragma l -> ModulePragma l -> Bool

(>=) :: ModulePragma l -> ModulePragma l -> Bool

max :: ModulePragma l -> ModulePragma l -> ModulePragma l

min :: ModulePragma l -> ModulePragma l -> ModulePragma l

Ord l => Ord (Overlap l)

Methods

compare :: Overlap l -> Overlap l -> Ordering

(<) :: Overlap l -> Overlap l -> Bool

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

(>) :: Overlap l -> Overlap l -> Bool

(>=) :: Overlap l -> Overlap l -> Bool

max :: Overlap l -> Overlap l -> Overlap l

min :: Overlap l -> Overlap l -> Overlap l

Ord l => Ord (Activation l)

Methods

compare :: Activation l -> Activation l -> Ordering

(<) :: Activation l -> Activation l -> Bool

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

(>) :: Activation l -> Activation l -> Bool

(>=) :: Activation l -> Activation l -> Bool

max :: Activation l -> Activation l -> Activation l

min :: Activation l -> Activation l -> Activation l

Ord l => Ord (Rule l)

Methods

compare :: Rule l -> Rule l -> Ordering

(<) :: Rule l -> Rule l -> Bool

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

(>) :: Rule l -> Rule l -> Bool

(>=) :: Rule l -> Rule l -> Bool

max :: Rule l -> Rule l -> Rule l

min :: Rule l -> Rule l -> Rule l

Ord l => Ord (RuleVar l)

Methods

compare :: RuleVar l -> RuleVar l -> Ordering

(<) :: RuleVar l -> RuleVar l -> Bool

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

(>) :: RuleVar l -> RuleVar l -> Bool

(>=) :: RuleVar l -> RuleVar l -> Bool

max :: RuleVar l -> RuleVar l -> RuleVar l

min :: RuleVar l -> RuleVar l -> RuleVar l

Ord l => Ord (WarningText l)

Methods

compare :: WarningText l -> WarningText l -> Ordering

(<) :: WarningText l -> WarningText l -> Bool

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

(>) :: WarningText l -> WarningText l -> Bool

(>=) :: WarningText l -> WarningText l -> Bool

max :: WarningText l -> WarningText l -> WarningText l

min :: WarningText l -> WarningText l -> WarningText l

Ord l => Ord (Pat l)

Methods

compare :: Pat l -> Pat l -> Ordering

(<) :: Pat l -> Pat l -> Bool

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

(>) :: Pat l -> Pat l -> Bool

(>=) :: Pat l -> Pat l -> Bool

max :: Pat l -> Pat l -> Pat l

min :: Pat l -> Pat l -> Pat l

Ord l => Ord (PXAttr l)

Methods

compare :: PXAttr l -> PXAttr l -> Ordering

(<) :: PXAttr l -> PXAttr l -> Bool

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

(>) :: PXAttr l -> PXAttr l -> Bool

(>=) :: PXAttr l -> PXAttr l -> Bool

max :: PXAttr l -> PXAttr l -> PXAttr l

min :: PXAttr l -> PXAttr l -> PXAttr l

Ord l => Ord (RPatOp l)

Methods

compare :: RPatOp l -> RPatOp l -> Ordering

(<) :: RPatOp l -> RPatOp l -> Bool

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

(>) :: RPatOp l -> RPatOp l -> Bool

(>=) :: RPatOp l -> RPatOp l -> Bool

max :: RPatOp l -> RPatOp l -> RPatOp l

min :: RPatOp l -> RPatOp l -> RPatOp l

Ord l => Ord (RPat l)

Methods

compare :: RPat l -> RPat l -> Ordering

(<) :: RPat l -> RPat l -> Bool

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

(>) :: RPat l -> RPat l -> Bool

(>=) :: RPat l -> RPat l -> Bool

max :: RPat l -> RPat l -> RPat l

min :: RPat l -> RPat l -> RPat l

Ord l => Ord (PatField l)

Methods

compare :: PatField l -> PatField l -> Ordering

(<) :: PatField l -> PatField l -> Bool

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

(>) :: PatField l -> PatField l -> Bool

(>=) :: PatField l -> PatField l -> Bool

max :: PatField l -> PatField l -> PatField l

min :: PatField l -> PatField l -> PatField l

Ord l => Ord (Stmt l)

Methods

compare :: Stmt l -> Stmt l -> Ordering

(<) :: Stmt l -> Stmt l -> Bool

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

(>) :: Stmt l -> Stmt l -> Bool

(>=) :: Stmt l -> Stmt l -> Bool

max :: Stmt l -> Stmt l -> Stmt l

min :: Stmt l -> Stmt l -> Stmt l

Ord l => Ord (QualStmt l)

Methods

compare :: QualStmt l -> QualStmt l -> Ordering

(<) :: QualStmt l -> QualStmt l -> Bool

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

(>) :: QualStmt l -> QualStmt l -> Bool

(>=) :: QualStmt l -> QualStmt l -> Bool

max :: QualStmt l -> QualStmt l -> QualStmt l

min :: QualStmt l -> QualStmt l -> QualStmt l

Ord l => Ord (FieldUpdate l)

Methods

compare :: FieldUpdate l -> FieldUpdate l -> Ordering

(<) :: FieldUpdate l -> FieldUpdate l -> Bool

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

(>) :: FieldUpdate l -> FieldUpdate l -> Bool

(>=) :: FieldUpdate l -> FieldUpdate l -> Bool

max :: FieldUpdate l -> FieldUpdate l -> FieldUpdate l

min :: FieldUpdate l -> FieldUpdate l -> FieldUpdate l

Ord l => Ord (Alt l)

Methods

compare :: Alt l -> Alt l -> Ordering

(<) :: Alt l -> Alt l -> Bool

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

(>) :: Alt l -> Alt l -> Bool

(>=) :: Alt l -> Alt l -> Bool

max :: Alt l -> Alt l -> Alt l

min :: Alt l -> Alt l -> Alt l

Ord x => Ord (L x)

Methods

compare :: L x -> L x -> Ordering

(<) :: L x -> L x -> Bool

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

(>) :: L x -> L x -> Bool

(>=) :: L x -> L x -> Bool

max :: L x -> L x -> L x

min :: L x -> L x -> L x

Ord a => Ord (Vector a)

Methods

compare :: Vector a -> Vector a -> Ordering

(<) :: Vector a -> Vector a -> Bool

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

(>) :: Vector a -> Vector a -> Bool

(>=) :: Vector a -> Vector a -> Bool

max :: Vector a -> Vector a -> Vector a

min :: Vector a -> Vector a -> Vector a

(Storable a, Ord a) => Ord (Vector a)

Methods

compare :: Vector a -> Vector a -> Ordering

(<) :: Vector a -> Vector a -> Bool

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

(>) :: Vector a -> Vector a -> Bool

(>=) :: Vector a -> Vector a -> Bool

max :: Vector a -> Vector a -> Vector a

min :: Vector a -> Vector a -> Vector a

(Prim a, Ord a) => Ord (Vector a)

Methods

compare :: Vector a -> Vector a -> Ordering

(<) :: Vector a -> Vector a -> Bool

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

(>) :: Vector a -> Vector a -> Bool

(>=) :: Vector a -> Vector a -> Bool

max :: Vector a -> Vector a -> Vector a

min :: Vector a -> Vector a -> Vector a

Class (Eq a) (Ord a)

Methods

cls :: Ord a :- Eq a

(Integral a) :=> (Ord (Ratio a))

Methods

ins :: Integral a :- Ord (Ratio a)

(Ord a) :=> (Ord (Maybe a))

Methods

ins :: Ord a :- Ord (Maybe a)

(Ord a) :=> (Ord [a])

Methods

ins :: Ord a :- Ord [a]

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

Methods

compare :: Either a b -> Either a b -> Ordering

(<) :: Either a b -> Either a b -> Bool

(<=) :: Either a b -> Either a b -> Bool

(>) :: Either a b -> Either a b -> Bool

(>=) :: Either a b -> Either a b -> Bool

max :: Either a b -> Either a b -> Either a b

min :: Either a b -> Either a b -> Either a b

Ord (f p) => Ord (Rec1 f p)

Methods

compare :: Rec1 f p -> Rec1 f p -> Ordering

(<) :: Rec1 f p -> Rec1 f p -> Bool

(<=) :: Rec1 f p -> Rec1 f p -> Bool

(>) :: Rec1 f p -> Rec1 f p -> Bool

(>=) :: Rec1 f p -> Rec1 f p -> Bool

max :: Rec1 f p -> Rec1 f p -> Rec1 f p

min :: Rec1 f p -> Rec1 f p -> Rec1 f p

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

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

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

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

Ord (URec Word p)

Methods

compare :: URec Word p -> URec Word p -> Ordering

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

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

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

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

max :: URec Word p -> URec Word p -> URec Word p

min :: URec Word p -> URec Word p -> URec Word p

Ord (URec (Ptr ()) p)

Methods

compare :: URec (Ptr ()) p -> URec (Ptr ()) p -> Ordering

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

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

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

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

max :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

min :: URec (Ptr ()) p -> URec (Ptr ()) p -> URec (Ptr ()) p

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

Methods

compare :: (a, b) -> (a, b) -> Ordering

(<) :: (a, b) -> (a, b) -> Bool

(<=) :: (a, b) -> (a, b) -> Bool

(>) :: (a, b) -> (a, b) -> Bool

(>=) :: (a, b) -> (a, b) -> Bool

max :: (a, b) -> (a, b) -> (a, b)

min :: (a, b) -> (a, b) -> (a, b)

(Ix i, Ord e) => Ord (Array i e)

Methods

compare :: Array i e -> Array i e -> Ordering

(<) :: Array i e -> Array i e -> Bool

(<=) :: Array i e -> Array i e -> Bool

(>) :: Array i e -> Array i e -> Bool

(>=) :: Array i e -> Array i e -> Bool

max :: Array i e -> Array i e -> Array i e

min :: Array i e -> Array i e -> Array i e

Ord a => Ord (Arg a b)

Methods

compare :: Arg a b -> Arg a b -> Ordering

(<) :: Arg a b -> Arg a b -> Bool

(<=) :: Arg a b -> Arg a b -> Bool

(>) :: Arg a b -> Arg a b -> Bool

(>=) :: Arg a b -> Arg a b -> Bool

max :: Arg a b -> Arg a b -> Arg a b

min :: Arg a b -> Arg a b -> Arg a b

Ord (Proxy k s)

Methods

compare :: Proxy k s -> Proxy k s -> Ordering

(<) :: Proxy k s -> Proxy k s -> Bool

(<=) :: Proxy k s -> Proxy k s -> Bool

(>) :: Proxy k s -> Proxy k s -> Bool

(>=) :: Proxy k s -> Proxy k s -> Bool

max :: Proxy k s -> Proxy k s -> Proxy k s

min :: Proxy k s -> Proxy k s -> Proxy k s

Ord ((:-) a b)

Assumes IncoherentInstances doesn't exist.

Methods

compare :: (a :- b) -> (a :- b) -> Ordering

(<) :: (a :- b) -> (a :- b) -> Bool

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

(>) :: (a :- b) -> (a :- b) -> Bool

(>=) :: (a :- b) -> (a :- b) -> Bool

max :: (a :- b) -> (a :- b) -> a :- b

min :: (a :- b) -> (a :- b) -> a :- b

(Ord k, Ord v) => Ord (Map k v)

Methods

compare :: Map k v -> Map k v -> Ordering

(<) :: Map k v -> Map k v -> Bool

(<=) :: Map k v -> Map k v -> Bool

(>) :: Map k v -> Map k v -> Bool

(>=) :: Map k v -> Map k v -> Bool

max :: Map k v -> Map k v -> Map k v

min :: Map k v -> Map k v -> Map k v

(Ord1 m, Ord a) => Ord (ListT m a)

Methods

compare :: ListT m a -> ListT m a -> Ordering

(<) :: ListT m a -> ListT m a -> Bool

(<=) :: ListT m a -> ListT m a -> Bool

(>) :: ListT m a -> ListT m a -> Bool

(>=) :: ListT m a -> ListT m a -> Bool

max :: ListT m a -> ListT m a -> ListT m a

min :: ListT m a -> ListT m a -> ListT m a

(Ord1 m, Ord a) => Ord (MaybeT m a)

Methods

compare :: MaybeT m a -> MaybeT m a -> Ordering

(<) :: MaybeT m a -> MaybeT m a -> Bool

(<=) :: MaybeT m a -> MaybeT m a -> Bool

(>) :: MaybeT m a -> MaybeT m a -> Bool

(>=) :: MaybeT m a -> MaybeT m a -> Bool

max :: MaybeT m a -> MaybeT m a -> MaybeT m a

min :: MaybeT m a -> MaybeT m a -> MaybeT m a

Class (Num a, Ord a) (Real a)

Methods

cls :: Real a :- (Num a, Ord a)

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

Methods

ins :: (Ord a, Ord b) :- Ord (a, b)

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

Methods

ins :: (Ord a, Ord b) :- Ord (Either a b)

Ord c => Ord (K1 i c p)

Methods

compare :: K1 i c p -> K1 i c p -> Ordering

(<) :: K1 i c p -> K1 i c p -> Bool

(<=) :: K1 i c p -> K1 i c p -> Bool

(>) :: K1 i c p -> K1 i c p -> Bool

(>=) :: K1 i c p -> K1 i c p -> Bool

max :: K1 i c p -> K1 i c p -> K1 i c p

min :: K1 i c p -> K1 i c p -> K1 i c p

(Ord (g p), Ord (f p)) => Ord ((:+:) f g p)

Methods

compare :: (f :+: g) p -> (f :+: g) p -> Ordering

(<) :: (f :+: g) p -> (f :+: g) p -> Bool

(<=) :: (f :+: g) p -> (f :+: g) p -> Bool

(>) :: (f :+: g) p -> (f :+: g) p -> Bool

(>=) :: (f :+: g) p -> (f :+: g) p -> Bool

max :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p

min :: (f :+: g) p -> (f :+: g) p -> (f :+: g) p

(Ord (g p), Ord (f p)) => Ord ((:*:) f g p)

Methods

compare :: (f :*: g) p -> (f :*: g) p -> Ordering

(<) :: (f :*: g) p -> (f :*: g) p -> Bool

(<=) :: (f :*: g) p -> (f :*: g) p -> Bool

(>) :: (f :*: g) p -> (f :*: g) p -> Bool

(>=) :: (f :*: g) p -> (f :*: g) p -> Bool

max :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

min :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

Ord (f (g p)) => Ord ((:.:) f g p)

Methods

compare :: (f :.: g) p -> (f :.: g) p -> Ordering

(<) :: (f :.: g) p -> (f :.: g) p -> Bool

(<=) :: (f :.: g) p -> (f :.: g) p -> Bool

(>) :: (f :.: g) p -> (f :.: g) p -> Bool

(>=) :: (f :.: g) p -> (f :.: g) p -> Bool

max :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p

min :: (f :.: g) p -> (f :.: g) p -> (f :.: g) p

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

Methods

compare :: (a, b, c) -> (a, b, c) -> Ordering

(<) :: (a, b, c) -> (a, b, c) -> Bool

(<=) :: (a, b, c) -> (a, b, c) -> Bool

(>) :: (a, b, c) -> (a, b, c) -> Bool

(>=) :: (a, b, c) -> (a, b, c) -> Bool

max :: (a, b, c) -> (a, b, c) -> (a, b, c)

min :: (a, b, c) -> (a, b, c) -> (a, b, c)

Ord a => Ord (Const k a b)

Methods

compare :: Const k a b -> Const k a b -> Ordering

(<) :: Const k a b -> Const k a b -> Bool

(<=) :: Const k a b -> Const k a b -> Bool

(>) :: Const k a b -> Const k a b -> Bool

(>=) :: Const k a b -> Const k a b -> Bool

max :: Const k a b -> Const k a b -> Const k a b

min :: Const k a b -> Const k a b -> Const k a b

Ord (f a) => Ord (Alt k f a)

Methods

compare :: Alt k f a -> Alt k f a -> Ordering

(<) :: Alt k f a -> Alt k f a -> Bool

(<=) :: Alt k f a -> Alt k f a -> Bool

(>) :: Alt k f a -> Alt k f a -> Bool

(>=) :: Alt k f a -> Alt k f a -> Bool

max :: Alt k f a -> Alt k f a -> Alt k f a

min :: Alt k f a -> Alt k f a -> Alt k f a

Ord ((:~:) k a b)

Methods

compare :: (k :~: a) b -> (k :~: a) b -> Ordering

(<) :: (k :~: a) b -> (k :~: a) b -> Bool

(<=) :: (k :~: a) b -> (k :~: a) b -> Bool

(>) :: (k :~: a) b -> (k :~: a) b -> Bool

(>=) :: (k :~: a) b -> (k :~: a) b -> Bool

max :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b

min :: (k :~: a) b -> (k :~: a) b -> (k :~: a) b

(Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a)

Methods

compare :: ErrorT e m a -> ErrorT e m a -> Ordering

(<) :: ErrorT e m a -> ErrorT e m a -> Bool

(<=) :: ErrorT e m a -> ErrorT e m a -> Bool

(>) :: ErrorT e m a -> ErrorT e m a -> Bool

(>=) :: ErrorT e m a -> ErrorT e m a -> Bool

max :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a

min :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a

(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a)

Methods

compare :: ExceptT e m a -> ExceptT e m a -> Ordering

(<) :: ExceptT e m a -> ExceptT e m a -> Bool

(<=) :: ExceptT e m a -> ExceptT e m a -> Bool

(>) :: ExceptT e m a -> ExceptT e m a -> Bool

(>=) :: ExceptT e m a -> ExceptT e m a -> Bool

max :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a

min :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a

(Ord w, Ord1 m, Ord a) => Ord (WriterT w m a)

Methods

compare :: WriterT w m a -> WriterT w m a -> Ordering

(<) :: WriterT w m a -> WriterT w m a -> Bool

(<=) :: WriterT w m a -> WriterT w m a -> Bool

(>) :: WriterT w m a -> WriterT w m a -> Bool

(>=) :: WriterT w m a -> WriterT w m a -> Bool

max :: WriterT w m a -> WriterT w m a -> WriterT w m a

min :: WriterT w m a -> WriterT w m a -> WriterT w m a

(Ord w, Ord1 m, Ord a) => Ord (WriterT w m a)

Methods

compare :: WriterT w m a -> WriterT w m a -> Ordering

(<) :: WriterT w m a -> WriterT w m a -> Bool

(<=) :: WriterT w m a -> WriterT w m a -> Bool

(>) :: WriterT w m a -> WriterT w m a -> Bool

(>=) :: WriterT w m a -> WriterT w m a -> Bool

max :: WriterT w m a -> WriterT w m a -> WriterT w m a

min :: WriterT w m a -> WriterT w m a -> WriterT w m a

(Ord1 f, Ord a) => Ord (IdentityT * f a)

Methods

compare :: IdentityT * f a -> IdentityT * f a -> Ordering

(<) :: IdentityT * f a -> IdentityT * f a -> Bool

(<=) :: IdentityT * f a -> IdentityT * f a -> Bool

(>) :: IdentityT * f a -> IdentityT * f a -> Bool

(>=) :: IdentityT * f a -> IdentityT * f a -> Bool

max :: IdentityT * f a -> IdentityT * f a -> IdentityT * f a

min :: IdentityT * f a -> IdentityT * f a -> IdentityT * f a

Ord (f p) => Ord (M1 i c f p)

Methods

compare :: M1 i c f p -> M1 i c f p -> Ordering

(<) :: M1 i c f p -> M1 i c f p -> Bool

(<=) :: M1 i c f p -> M1 i c f p -> Bool

(>) :: M1 i c f p -> M1 i c f p -> Bool

(>=) :: M1 i c f p -> M1 i c f p -> Bool

max :: M1 i c f p -> M1 i c f p -> M1 i c f p

min :: M1 i c f p -> M1 i c f p -> M1 i c f p

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

Methods

compare :: (a, b, c, d) -> (a, b, c, d) -> Ordering

(<) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(<=) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(>) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(>=) :: (a, b, c, d) -> (a, b, c, d) -> Bool

max :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

min :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

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

Methods

compare :: (a, b, c, d, e) -> (a, b, c, d, e) -> Ordering

(<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(<=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(>=) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

max :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

min :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

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

Methods

compare :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Ordering

(<) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(<=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(>) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

(>=) :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> Bool

max :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

min :: (a, b, c, d, e, f) -> (a, b, c, d, e, f) -> (a, b, c, d, e, f)

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

Methods

compare :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Ordering

(<) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(<=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(>) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

(>=) :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> Bool

max :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

min :: (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g) -> (a, b, c, d, e, f, g)

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

Methods

compare :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Ordering

(<) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(<=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(>) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

(>=) :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> Bool

max :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h)

min :: (a, b, c, d, e, f, g, h) -> (a, b, c, d, e, f, g, h) -> (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 (a, b, c, d, e, f, g, h, i)

Methods

compare :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> Bool

max :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i)

min :: (a, b, c, d, e, f, g, h, i) -> (a, b, c, d, e, f, g, h, i) -> (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 (a, b, c, d, e, f, g, h, i, j)

Methods

compare :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j)

min :: (a, b, c, d, e, f, g, h, i, j) -> (a, b, c, d, e, f, g, h, i, j) -> (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 (a, b, c, d, e, f, g, h, i, j, k)

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k)

min :: (a, b, c, d, e, f, g, h, i, j, k) -> (a, b, c, d, e, f, g, h, i, j, k) -> (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 (a, b, c, d, e, f, g, h, i, j, k, l)

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l)

min :: (a, b, c, d, e, f, g, h, i, j, k, l) -> (a, b, c, d, e, f, g, h, i, j, k, l) -> (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 (a, b, c, d, e, f, g, h, i, j, k, l, m)

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m)

min :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> (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 (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

(>=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Bool

max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> (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 (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Methods

compare :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Ordering

(<) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

(<=) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

(>) :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Bool

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

max :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

min :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

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

Efficient, machine-independent access to the components of a floating-point number.

Minimal complete definition

floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE

Instances

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

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

() :=> (RealFloat Double)

Methods

ins :: () :- RealFloat Double

() :=> (RealFloat Float)

Methods

ins :: () :- RealFloat Float

RealFloat a => RealFloat (Identity a)

Methods

floatRadix :: Identity a -> Integer

floatDigits :: Identity a -> Int

floatRange :: Identity a -> (Int, Int)

decodeFloat :: Identity a -> (Integer, Int)

encodeFloat :: Integer -> Int -> Identity a

exponent :: Identity a -> Int

significand :: Identity a -> Identity a

scaleFloat :: Int -> Identity a -> Identity a

isNaN :: Identity a -> Bool

isInfinite :: Identity a -> Bool

isDenormalized :: Identity a -> Bool

isNegativeZero :: Identity a -> Bool

isIEEE :: Identity a -> Bool

atan2 :: Identity a -> Identity a -> Identity a

(RealFloat a) :=> (Num (Complex a))

Methods

ins :: RealFloat a :- Num (Complex a)

(RealFloat a) :=> (Fractional (Complex a))

Methods

ins :: RealFloat a :- Fractional (Complex a)

(RealFloat a) :=> (Floating (Complex a))

Methods

ins :: RealFloat a :- Floating (Complex a)

Class (RealFrac a, Floating a) (RealFloat a)

Methods

cls :: RealFloat a :- (RealFrac a, Floating a)

RealFloat a => RealFloat (Const k a b)

Methods

floatRadix :: Const k a b -> Integer

floatDigits :: Const k a b -> Int

floatRange :: Const k a b -> (Int, Int)

decodeFloat :: Const k a b -> (Integer, Int)

encodeFloat :: Integer -> Int -> Const k a b

exponent :: Const k a b -> Int

significand :: Const k a b -> Const k a b

scaleFloat :: Int -> Const k a b -> Const k a b

isNaN :: Const k a b -> Bool

isInfinite :: Const k a b -> Bool

isDenormalized :: Const k a b -> Bool

isNegativeZero :: Const k a b -> Bool

isIEEE :: Const k a b -> Bool

atan2 :: Const k a b -> Const k a b -> Const k a b

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

Extracting components of fractions.

Minimal complete definition

properFraction

Instances

RealFrac NominalDiffTime

Methods

properFraction :: Integral b => NominalDiffTime -> (b, NominalDiffTime)

truncate :: Integral b => NominalDiffTime -> b

round :: Integral b => NominalDiffTime -> b

ceiling :: Integral b => NominalDiffTime -> b

floor :: Integral b => NominalDiffTime -> b

RealFrac DiffTime

Methods

properFraction :: Integral b => DiffTime -> (b, DiffTime)

truncate :: Integral b => DiffTime -> b

round :: Integral b => DiffTime -> b

ceiling :: Integral b => DiffTime -> b

floor :: Integral b => DiffTime -> b

() :=> (RealFrac Double)

Methods

ins :: () :- RealFrac Double

() :=> (RealFrac Float)

Methods

ins :: () :- RealFrac Float

Integral a => RealFrac (Ratio a)

Methods

properFraction :: Integral b => Ratio a -> (b, Ratio a)

truncate :: Integral b => Ratio a -> b

round :: Integral b => Ratio a -> b

ceiling :: Integral b => Ratio a -> b

floor :: Integral b => Ratio a -> b

RealFrac a => RealFrac (Identity a)

Methods

properFraction :: Integral b => Identity a -> (b, Identity a)

truncate :: Integral b => Identity a -> b

round :: Integral b => Identity a -> b

ceiling :: Integral b => Identity a -> b

floor :: Integral b => Identity a -> b

(Integral a) :=> (RealFrac (Ratio a))

Methods

ins :: Integral a :- RealFrac (Ratio a)

Class (Real a, Fractional a) (RealFrac a)

Methods

cls :: RealFrac a :- (Real a, Fractional a)

Class (RealFrac a, Floating a) (RealFloat a)

Methods

cls :: RealFloat a :- (RealFrac a, Floating a)

RealFrac a => RealFrac (Const k a b)

Methods

properFraction :: Integral b => Const k a b -> (b, Const k a b)

truncate :: Integral b => Const k a b -> b

round :: Integral b => Const k a b -> b

ceiling :: Integral b => Const k a b -> b

floor :: Integral b => Const k a b -> b

data Border i :: * -> *

Constructors

Incl i

Excl i

Instances

Functor Border

Methods

fmap :: (a -> b) -> Border a -> Border b

(<$) :: a -> Border b -> Border a

Foldable Border

Methods

fold :: Monoid m => Border m -> m

foldMap :: Monoid m => (a -> m) -> Border a -> m

foldr :: (a -> b -> b) -> b -> Border a -> b

foldr' :: (a -> b -> b) -> b -> Border a -> b

foldl :: (b -> a -> b) -> b -> Border a -> b

foldl' :: (b -> a -> b) -> b -> Border a -> b

foldr1 :: (a -> a -> a) -> Border a -> a

foldl1 :: (a -> a -> a) -> Border a -> a

toList :: Border a -> [a]

null :: Border a -> Bool

length :: Border a -> Int

elem :: Eq a => a -> Border a -> Bool

maximum :: Ord a => Border a -> a

minimum :: Ord a => Border a -> a

sum :: Num a => Border a -> a

product :: Num a => Border a -> a

Traversable Border

Methods

traverse :: Applicative f => (a -> f b) -> Border a -> f (Border b)

sequenceA :: Applicative f => Border (f a) -> f (Border a)

mapM :: Monad m => (a -> m b) -> Border a -> m (Border b)

sequence :: Monad m => Border (m a) -> m (Border a)

Eq i => Eq (Border i)

Methods

(==) :: Border i -> Border i -> Bool

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

Num i => Num (Border i)

fromInteger gives an inclusive border. No other methods defined.

Methods

(+) :: Border i -> Border i -> Border i

(-) :: Border i -> Border i -> Border i

(*) :: Border i -> Border i -> Border i

negate :: Border i -> Border i

abs :: Border i -> Border i

signum :: Border i -> Border i

fromInteger :: Integer -> Border i

Show i => Show (Border i)

Methods

showsPrec :: Int -> Border i -> ShowS

show :: Border i -> String

showList :: [Border i] -> ShowS

type IxRange i = (i, Int, Border i)

Index range

(lo,step,hi)

lo gives the start index; step gives the step length; hi gives the stop index which may be inclusive or exclusive.

data AssertionLabel

Assertion labels

Constructors

InternalAssertion

Internal assertion to guarantee meaningful results

LibraryAssertion String

Assertion related to a specific library

UserAssertion String

Assertion in user code. The default label for user assertions is UserAssertion ""

Instances

Eq AssertionLabel

Methods

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

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

Show AssertionLabel

Methods

showsPrec :: Int -> AssertionLabel -> ShowS

show :: AssertionLabel -> String

showList :: [AssertionLabel] -> ShowS