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' ((IO -> *, (IO -> *, AssertCMD (* -> *) (* -> Constraint))) m ((IO -> *, AssertCMD (* -> *) (* -> Constraint)) 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 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) => 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 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 CChar

Methods

(.&.) :: CChar -> CChar -> CChar

(.|.) :: CChar -> CChar -> CChar

xor :: CChar -> CChar -> CChar

complement :: CChar -> CChar

shift :: CChar -> Int -> CChar

rotate :: CChar -> Int -> CChar

zeroBits :: CChar

bit :: Int -> CChar

setBit :: CChar -> Int -> CChar

clearBit :: CChar -> Int -> CChar

complementBit :: CChar -> Int -> CChar

testBit :: CChar -> Int -> Bool

bitSizeMaybe :: CChar -> Maybe Int

bitSize :: CChar -> Int

isSigned :: CChar -> Bool

shiftL :: CChar -> Int -> CChar

unsafeShiftL :: CChar -> Int -> CChar

shiftR :: CChar -> Int -> CChar

unsafeShiftR :: CChar -> Int -> CChar

rotateL :: CChar -> Int -> CChar

rotateR :: CChar -> Int -> CChar

popCount :: CChar -> Int

Bits CSChar

Methods

(.&.) :: CSChar -> CSChar -> CSChar

(.|.) :: CSChar -> CSChar -> CSChar

xor :: CSChar -> CSChar -> CSChar

complement :: CSChar -> CSChar

shift :: CSChar -> Int -> CSChar

rotate :: CSChar -> Int -> CSChar

zeroBits :: CSChar

bit :: Int -> CSChar

setBit :: CSChar -> Int -> CSChar

clearBit :: CSChar -> Int -> CSChar

complementBit :: CSChar -> Int -> CSChar

testBit :: CSChar -> Int -> Bool

bitSizeMaybe :: CSChar -> Maybe Int

bitSize :: CSChar -> Int

isSigned :: CSChar -> Bool

shiftL :: CSChar -> Int -> CSChar

unsafeShiftL :: CSChar -> Int -> CSChar

shiftR :: CSChar -> Int -> CSChar

unsafeShiftR :: CSChar -> Int -> CSChar

rotateL :: CSChar -> Int -> CSChar

rotateR :: CSChar -> Int -> CSChar

popCount :: CSChar -> Int

Bits CUChar

Methods

(.&.) :: CUChar -> CUChar -> CUChar

(.|.) :: CUChar -> CUChar -> CUChar

xor :: CUChar -> CUChar -> CUChar

complement :: CUChar -> CUChar

shift :: CUChar -> Int -> CUChar

rotate :: CUChar -> Int -> CUChar

zeroBits :: CUChar

bit :: Int -> CUChar

setBit :: CUChar -> Int -> CUChar

clearBit :: CUChar -> Int -> CUChar

complementBit :: CUChar -> Int -> CUChar

testBit :: CUChar -> Int -> Bool

bitSizeMaybe :: CUChar -> Maybe Int

bitSize :: CUChar -> Int

isSigned :: CUChar -> Bool

shiftL :: CUChar -> Int -> CUChar

unsafeShiftL :: CUChar -> Int -> CUChar

shiftR :: CUChar -> Int -> CUChar

unsafeShiftR :: CUChar -> Int -> CUChar

rotateL :: CUChar -> Int -> CUChar

rotateR :: CUChar -> Int -> CUChar

popCount :: CUChar -> Int

Bits CShort

Methods

(.&.) :: CShort -> CShort -> CShort

(.|.) :: CShort -> CShort -> CShort

xor :: CShort -> CShort -> CShort

complement :: CShort -> CShort

shift :: CShort -> Int -> CShort

rotate :: CShort -> Int -> CShort

zeroBits :: CShort

bit :: Int -> CShort

setBit :: CShort -> Int -> CShort

clearBit :: CShort -> Int -> CShort

complementBit :: CShort -> Int -> CShort

testBit :: CShort -> Int -> Bool

bitSizeMaybe :: CShort -> Maybe Int

bitSize :: CShort -> Int

isSigned :: CShort -> Bool

shiftL :: CShort -> Int -> CShort

unsafeShiftL :: CShort -> Int -> CShort

shiftR :: CShort -> Int -> CShort

unsafeShiftR :: CShort -> Int -> CShort

rotateL :: CShort -> Int -> CShort

rotateR :: CShort -> Int -> CShort

popCount :: CShort -> Int

Bits CUShort

Methods

(.&.) :: CUShort -> CUShort -> CUShort

(.|.) :: CUShort -> CUShort -> CUShort

xor :: CUShort -> CUShort -> CUShort

complement :: CUShort -> CUShort

shift :: CUShort -> Int -> CUShort

rotate :: CUShort -> Int -> CUShort

zeroBits :: CUShort

bit :: Int -> CUShort

setBit :: CUShort -> Int -> CUShort

clearBit :: CUShort -> Int -> CUShort

complementBit :: CUShort -> Int -> CUShort

testBit :: CUShort -> Int -> Bool

bitSizeMaybe :: CUShort -> Maybe Int

bitSize :: CUShort -> Int

isSigned :: CUShort -> Bool

shiftL :: CUShort -> Int -> CUShort

unsafeShiftL :: CUShort -> Int -> CUShort

shiftR :: CUShort -> Int -> CUShort

unsafeShiftR :: CUShort -> Int -> CUShort

rotateL :: CUShort -> Int -> CUShort

rotateR :: CUShort -> Int -> CUShort

popCount :: CUShort -> Int

Bits CInt

Methods

(.&.) :: CInt -> CInt -> CInt

(.|.) :: CInt -> CInt -> CInt

xor :: CInt -> CInt -> CInt

complement :: CInt -> CInt

shift :: CInt -> Int -> CInt

rotate :: CInt -> Int -> CInt

zeroBits :: CInt

bit :: Int -> CInt

setBit :: CInt -> Int -> CInt

clearBit :: CInt -> Int -> CInt

complementBit :: CInt -> Int -> CInt

testBit :: CInt -> Int -> Bool

bitSizeMaybe :: CInt -> Maybe Int

bitSize :: CInt -> Int

isSigned :: CInt -> Bool

shiftL :: CInt -> Int -> CInt

unsafeShiftL :: CInt -> Int -> CInt

shiftR :: CInt -> Int -> CInt

unsafeShiftR :: CInt -> Int -> CInt

rotateL :: CInt -> Int -> CInt

rotateR :: CInt -> Int -> CInt

popCount :: CInt -> Int

Bits CUInt

Methods

(.&.) :: CUInt -> CUInt -> CUInt

(.|.) :: CUInt -> CUInt -> CUInt

xor :: CUInt -> CUInt -> CUInt

complement :: CUInt -> CUInt

shift :: CUInt -> Int -> CUInt

rotate :: CUInt -> Int -> CUInt

zeroBits :: CUInt

bit :: Int -> CUInt

setBit :: CUInt -> Int -> CUInt

clearBit :: CUInt -> Int -> CUInt

complementBit :: CUInt -> Int -> CUInt

testBit :: CUInt -> Int -> Bool

bitSizeMaybe :: CUInt -> Maybe Int

bitSize :: CUInt -> Int

isSigned :: CUInt -> Bool

shiftL :: CUInt -> Int -> CUInt

unsafeShiftL :: CUInt -> Int -> CUInt

shiftR :: CUInt -> Int -> CUInt

unsafeShiftR :: CUInt -> Int -> CUInt

rotateL :: CUInt -> Int -> CUInt

rotateR :: CUInt -> Int -> CUInt

popCount :: CUInt -> Int

Bits CLong

Methods

(.&.) :: CLong -> CLong -> CLong

(.|.) :: CLong -> CLong -> CLong

xor :: CLong -> CLong -> CLong

complement :: CLong -> CLong

shift :: CLong -> Int -> CLong

rotate :: CLong -> Int -> CLong

zeroBits :: CLong

bit :: Int -> CLong

setBit :: CLong -> Int -> CLong

clearBit :: CLong -> Int -> CLong

complementBit :: CLong -> Int -> CLong

testBit :: CLong -> Int -> Bool

bitSizeMaybe :: CLong -> Maybe Int

bitSize :: CLong -> Int

isSigned :: CLong -> Bool

shiftL :: CLong -> Int -> CLong

unsafeShiftL :: CLong -> Int -> CLong

shiftR :: CLong -> Int -> CLong

unsafeShiftR :: CLong -> Int -> CLong

rotateL :: CLong -> Int -> CLong

rotateR :: CLong -> Int -> CLong

popCount :: CLong -> Int

Bits CULong

Methods

(.&.) :: CULong -> CULong -> CULong

(.|.) :: CULong -> CULong -> CULong

xor :: CULong -> CULong -> CULong

complement :: CULong -> CULong

shift :: CULong -> Int -> CULong

rotate :: CULong -> Int -> CULong

zeroBits :: CULong

bit :: Int -> CULong

setBit :: CULong -> Int -> CULong

clearBit :: CULong -> Int -> CULong

complementBit :: CULong -> Int -> CULong

testBit :: CULong -> Int -> Bool

bitSizeMaybe :: CULong -> Maybe Int

bitSize :: CULong -> Int

isSigned :: CULong -> Bool

shiftL :: CULong -> Int -> CULong

unsafeShiftL :: CULong -> Int -> CULong

shiftR :: CULong -> Int -> CULong

unsafeShiftR :: CULong -> Int -> CULong

rotateL :: CULong -> Int -> CULong

rotateR :: CULong -> Int -> CULong

popCount :: CULong -> Int

Bits CLLong

Methods

(.&.) :: CLLong -> CLLong -> CLLong

(.|.) :: CLLong -> CLLong -> CLLong

xor :: CLLong -> CLLong -> CLLong

complement :: CLLong -> CLLong

shift :: CLLong -> Int -> CLLong

rotate :: CLLong -> Int -> CLLong

zeroBits :: CLLong

bit :: Int -> CLLong

setBit :: CLLong -> Int -> CLLong

clearBit :: CLLong -> Int -> CLLong

complementBit :: CLLong -> Int -> CLLong

testBit :: CLLong -> Int -> Bool

bitSizeMaybe :: CLLong -> Maybe Int

bitSize :: CLLong -> Int

isSigned :: CLLong -> Bool

shiftL :: CLLong -> Int -> CLLong

unsafeShiftL :: CLLong -> Int -> CLLong

shiftR :: CLLong -> Int -> CLLong

unsafeShiftR :: CLLong -> Int -> CLLong

rotateL :: CLLong -> Int -> CLLong

rotateR :: CLLong -> Int -> CLLong

popCount :: CLLong -> Int

Bits CULLong

Methods

(.&.) :: CULLong -> CULLong -> CULLong

(.|.) :: CULLong -> CULLong -> CULLong

xor :: CULLong -> CULLong -> CULLong

complement :: CULLong -> CULLong

shift :: CULLong -> Int -> CULLong

rotate :: CULLong -> Int -> CULLong

zeroBits :: CULLong

bit :: Int -> CULLong

setBit :: CULLong -> Int -> CULLong

clearBit :: CULLong -> Int -> CULLong

complementBit :: CULLong -> Int -> CULLong

testBit :: CULLong -> Int -> Bool

bitSizeMaybe :: CULLong -> Maybe Int

bitSize :: CULLong -> Int

isSigned :: CULLong -> Bool

shiftL :: CULLong -> Int -> CULLong

unsafeShiftL :: CULLong -> Int -> CULLong

shiftR :: CULLong -> Int -> CULLong

unsafeShiftR :: CULLong -> Int -> CULLong

rotateL :: CULLong -> Int -> CULLong

rotateR :: CULLong -> Int -> CULLong

popCount :: CULLong -> Int

Bits CPtrdiff

Methods

(.&.) :: CPtrdiff -> CPtrdiff -> CPtrdiff

(.|.) :: CPtrdiff -> CPtrdiff -> CPtrdiff

xor :: CPtrdiff -> CPtrdiff -> CPtrdiff

complement :: CPtrdiff -> CPtrdiff

shift :: CPtrdiff -> Int -> CPtrdiff

rotate :: CPtrdiff -> Int -> CPtrdiff

zeroBits :: CPtrdiff

bit :: Int -> CPtrdiff

setBit :: CPtrdiff -> Int -> CPtrdiff

clearBit :: CPtrdiff -> Int -> CPtrdiff

complementBit :: CPtrdiff -> Int -> CPtrdiff

testBit :: CPtrdiff -> Int -> Bool

bitSizeMaybe :: CPtrdiff -> Maybe Int

bitSize :: CPtrdiff -> Int

isSigned :: CPtrdiff -> Bool

shiftL :: CPtrdiff -> Int -> CPtrdiff

unsafeShiftL :: CPtrdiff -> Int -> CPtrdiff

shiftR :: CPtrdiff -> Int -> CPtrdiff

unsafeShiftR :: CPtrdiff -> Int -> CPtrdiff

rotateL :: CPtrdiff -> Int -> CPtrdiff

rotateR :: CPtrdiff -> Int -> CPtrdiff

popCount :: CPtrdiff -> Int

Bits CSize

Methods

(.&.) :: CSize -> CSize -> CSize

(.|.) :: CSize -> CSize -> CSize

xor :: CSize -> CSize -> CSize

complement :: CSize -> CSize

shift :: CSize -> Int -> CSize

rotate :: CSize -> Int -> CSize

zeroBits :: CSize

bit :: Int -> CSize

setBit :: CSize -> Int -> CSize

clearBit :: CSize -> Int -> CSize

complementBit :: CSize -> Int -> CSize

testBit :: CSize -> Int -> Bool

bitSizeMaybe :: CSize -> Maybe Int

bitSize :: CSize -> Int

isSigned :: CSize -> Bool

shiftL :: CSize -> Int -> CSize

unsafeShiftL :: CSize -> Int -> CSize

shiftR :: CSize -> Int -> CSize

unsafeShiftR :: CSize -> Int -> CSize

rotateL :: CSize -> Int -> CSize

rotateR :: CSize -> Int -> CSize

popCount :: CSize -> Int

Bits CWchar

Methods

(.&.) :: CWchar -> CWchar -> CWchar

(.|.) :: CWchar -> CWchar -> CWchar

xor :: CWchar -> CWchar -> CWchar

complement :: CWchar -> CWchar

shift :: CWchar -> Int -> CWchar

rotate :: CWchar -> Int -> CWchar

zeroBits :: CWchar

bit :: Int -> CWchar

setBit :: CWchar -> Int -> CWchar

clearBit :: CWchar -> Int -> CWchar

complementBit :: CWchar -> Int -> CWchar

testBit :: CWchar -> Int -> Bool

bitSizeMaybe :: CWchar -> Maybe Int

bitSize :: CWchar -> Int

isSigned :: CWchar -> Bool

shiftL :: CWchar -> Int -> CWchar

unsafeShiftL :: CWchar -> Int -> CWchar

shiftR :: CWchar -> Int -> CWchar

unsafeShiftR :: CWchar -> Int -> CWchar

rotateL :: CWchar -> Int -> CWchar

rotateR :: CWchar -> Int -> CWchar

popCount :: CWchar -> Int

Bits CSigAtomic

Methods

(.&.) :: CSigAtomic -> CSigAtomic -> CSigAtomic

(.|.) :: CSigAtomic -> CSigAtomic -> CSigAtomic

xor :: CSigAtomic -> CSigAtomic -> CSigAtomic

complement :: CSigAtomic -> CSigAtomic

shift :: CSigAtomic -> Int -> CSigAtomic

rotate :: CSigAtomic -> Int -> CSigAtomic

zeroBits :: CSigAtomic

bit :: Int -> CSigAtomic

setBit :: CSigAtomic -> Int -> CSigAtomic

clearBit :: CSigAtomic -> Int -> CSigAtomic

complementBit :: CSigAtomic -> Int -> CSigAtomic

testBit :: CSigAtomic -> Int -> Bool

bitSizeMaybe :: CSigAtomic -> Maybe Int

bitSize :: CSigAtomic -> Int

isSigned :: CSigAtomic -> Bool

shiftL :: CSigAtomic -> Int -> CSigAtomic

unsafeShiftL :: CSigAtomic -> Int -> CSigAtomic

shiftR :: CSigAtomic -> Int -> CSigAtomic

unsafeShiftR :: CSigAtomic -> Int -> CSigAtomic

rotateL :: CSigAtomic -> Int -> CSigAtomic

rotateR :: CSigAtomic -> Int -> CSigAtomic

popCount :: CSigAtomic -> Int

Bits CIntPtr

Methods

(.&.) :: CIntPtr -> CIntPtr -> CIntPtr

(.|.) :: CIntPtr -> CIntPtr -> CIntPtr

xor :: CIntPtr -> CIntPtr -> CIntPtr

complement :: CIntPtr -> CIntPtr

shift :: CIntPtr -> Int -> CIntPtr

rotate :: CIntPtr -> Int -> CIntPtr

zeroBits :: CIntPtr

bit :: Int -> CIntPtr

setBit :: CIntPtr -> Int -> CIntPtr

clearBit :: CIntPtr -> Int -> CIntPtr

complementBit :: CIntPtr -> Int -> CIntPtr

testBit :: CIntPtr -> Int -> Bool

bitSizeMaybe :: CIntPtr -> Maybe Int

bitSize :: CIntPtr -> Int

isSigned :: CIntPtr -> Bool

shiftL :: CIntPtr -> Int -> CIntPtr

unsafeShiftL :: CIntPtr -> Int -> CIntPtr

shiftR :: CIntPtr -> Int -> CIntPtr

unsafeShiftR :: CIntPtr -> Int -> CIntPtr

rotateL :: CIntPtr -> Int -> CIntPtr

rotateR :: CIntPtr -> Int -> CIntPtr

popCount :: CIntPtr -> Int

Bits CUIntPtr

Methods

(.&.) :: CUIntPtr -> CUIntPtr -> CUIntPtr

(.|.) :: CUIntPtr -> CUIntPtr -> CUIntPtr

xor :: CUIntPtr -> CUIntPtr -> CUIntPtr

complement :: CUIntPtr -> CUIntPtr

shift :: CUIntPtr -> Int -> CUIntPtr

rotate :: CUIntPtr -> Int -> CUIntPtr

zeroBits :: CUIntPtr

bit :: Int -> CUIntPtr

setBit :: CUIntPtr -> Int -> CUIntPtr

clearBit :: CUIntPtr -> Int -> CUIntPtr

complementBit :: CUIntPtr -> Int -> CUIntPtr

testBit :: CUIntPtr -> Int -> Bool

bitSizeMaybe :: CUIntPtr -> Maybe Int

bitSize :: CUIntPtr -> Int

isSigned :: CUIntPtr -> Bool

shiftL :: CUIntPtr -> Int -> CUIntPtr

unsafeShiftL :: CUIntPtr -> Int -> CUIntPtr

shiftR :: CUIntPtr -> Int -> CUIntPtr

unsafeShiftR :: CUIntPtr -> Int -> CUIntPtr

rotateL :: CUIntPtr -> Int -> CUIntPtr

rotateR :: CUIntPtr -> Int -> CUIntPtr

popCount :: CUIntPtr -> Int

Bits CIntMax

Methods

(.&.) :: CIntMax -> CIntMax -> CIntMax

(.|.) :: CIntMax -> CIntMax -> CIntMax

xor :: CIntMax -> CIntMax -> CIntMax

complement :: CIntMax -> CIntMax

shift :: CIntMax -> Int -> CIntMax

rotate :: CIntMax -> Int -> CIntMax

zeroBits :: CIntMax

bit :: Int -> CIntMax

setBit :: CIntMax -> Int -> CIntMax

clearBit :: CIntMax -> Int -> CIntMax

complementBit :: CIntMax -> Int -> CIntMax

testBit :: CIntMax -> Int -> Bool

bitSizeMaybe :: CIntMax -> Maybe Int

bitSize :: CIntMax -> Int

isSigned :: CIntMax -> Bool

shiftL :: CIntMax -> Int -> CIntMax

unsafeShiftL :: CIntMax -> Int -> CIntMax

shiftR :: CIntMax -> Int -> CIntMax

unsafeShiftR :: CIntMax -> Int -> CIntMax

rotateL :: CIntMax -> Int -> CIntMax

rotateR :: CIntMax -> Int -> CIntMax

popCount :: CIntMax -> Int

Bits CUIntMax

Methods

(.&.) :: CUIntMax -> CUIntMax -> CUIntMax

(.|.) :: CUIntMax -> CUIntMax -> CUIntMax

xor :: CUIntMax -> CUIntMax -> CUIntMax

complement :: CUIntMax -> CUIntMax

shift :: CUIntMax -> Int -> CUIntMax

rotate :: CUIntMax -> Int -> CUIntMax

zeroBits :: CUIntMax

bit :: Int -> CUIntMax

setBit :: CUIntMax -> Int -> CUIntMax

clearBit :: CUIntMax -> Int -> CUIntMax

complementBit :: CUIntMax -> Int -> CUIntMax

testBit :: CUIntMax -> Int -> Bool

bitSizeMaybe :: CUIntMax -> Maybe Int

bitSize :: CUIntMax -> Int

isSigned :: CUIntMax -> Bool

shiftL :: CUIntMax -> Int -> CUIntMax

unsafeShiftL :: CUIntMax -> Int -> CUIntMax

shiftR :: CUIntMax -> Int -> CUIntMax

unsafeShiftR :: CUIntMax -> Int -> CUIntMax

rotateL :: CUIntMax -> Int -> CUIntMax

rotateR :: CUIntMax -> Int -> CUIntMax

popCount :: CUIntMax -> 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 CChar

Methods

finiteBitSize :: CChar -> Int

countLeadingZeros :: CChar -> Int

countTrailingZeros :: CChar -> Int

FiniteBits CSChar

Methods

finiteBitSize :: CSChar -> Int

countLeadingZeros :: CSChar -> Int

countTrailingZeros :: CSChar -> Int

FiniteBits CUChar

Methods

finiteBitSize :: CUChar -> Int

countLeadingZeros :: CUChar -> Int

countTrailingZeros :: CUChar -> Int

FiniteBits CShort

Methods

finiteBitSize :: CShort -> Int

countLeadingZeros :: CShort -> Int

countTrailingZeros :: CShort -> Int

FiniteBits CUShort

Methods

finiteBitSize :: CUShort -> Int

countLeadingZeros :: CUShort -> Int

countTrailingZeros :: CUShort -> Int

FiniteBits CInt

Methods

finiteBitSize :: CInt -> Int

countLeadingZeros :: CInt -> Int

countTrailingZeros :: CInt -> Int

FiniteBits CUInt

Methods

finiteBitSize :: CUInt -> Int

countLeadingZeros :: CUInt -> Int

countTrailingZeros :: CUInt -> Int

FiniteBits CLong

Methods

finiteBitSize :: CLong -> Int

countLeadingZeros :: CLong -> Int

countTrailingZeros :: CLong -> Int

FiniteBits CULong

Methods

finiteBitSize :: CULong -> Int

countLeadingZeros :: CULong -> Int

countTrailingZeros :: CULong -> Int

FiniteBits CLLong

Methods

finiteBitSize :: CLLong -> Int

countLeadingZeros :: CLLong -> Int

countTrailingZeros :: CLLong -> Int

FiniteBits CULLong

Methods

finiteBitSize :: CULLong -> Int

countLeadingZeros :: CULLong -> Int

countTrailingZeros :: CULLong -> Int

FiniteBits CPtrdiff

Methods

finiteBitSize :: CPtrdiff -> Int

countLeadingZeros :: CPtrdiff -> Int

countTrailingZeros :: CPtrdiff -> Int

FiniteBits CSize

Methods

finiteBitSize :: CSize -> Int

countLeadingZeros :: CSize -> Int

countTrailingZeros :: CSize -> Int

FiniteBits CWchar

Methods

finiteBitSize :: CWchar -> Int

countLeadingZeros :: CWchar -> Int

countTrailingZeros :: CWchar -> Int

FiniteBits CSigAtomic

Methods

finiteBitSize :: CSigAtomic -> Int

countLeadingZeros :: CSigAtomic -> Int

countTrailingZeros :: CSigAtomic -> Int

FiniteBits CIntPtr

Methods

finiteBitSize :: CIntPtr -> Int

countLeadingZeros :: CIntPtr -> Int

countTrailingZeros :: CIntPtr -> Int

FiniteBits CUIntPtr

Methods

finiteBitSize :: CUIntPtr -> Int

countLeadingZeros :: CUIntPtr -> Int

countTrailingZeros :: CUIntPtr -> Int

FiniteBits CIntMax

Methods

finiteBitSize :: CIntMax -> Int

countLeadingZeros :: CIntMax -> Int

countTrailingZeros :: CIntMax -> Int

FiniteBits CUIntMax

Methods

finiteBitSize :: CUIntMax -> Int

countLeadingZeros :: CUIntMax -> Int

countTrailingZeros :: CUIntMax -> 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

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 CChar

Methods

quot :: CChar -> CChar -> CChar

rem :: CChar -> CChar -> CChar

div :: CChar -> CChar -> CChar

mod :: CChar -> CChar -> CChar

quotRem :: CChar -> CChar -> (CChar, CChar)

divMod :: CChar -> CChar -> (CChar, CChar)

toInteger :: CChar -> Integer

Integral CSChar

Methods

quot :: CSChar -> CSChar -> CSChar

rem :: CSChar -> CSChar -> CSChar

div :: CSChar -> CSChar -> CSChar

mod :: CSChar -> CSChar -> CSChar

quotRem :: CSChar -> CSChar -> (CSChar, CSChar)

divMod :: CSChar -> CSChar -> (CSChar, CSChar)

toInteger :: CSChar -> Integer

Integral CUChar

Methods

quot :: CUChar -> CUChar -> CUChar

rem :: CUChar -> CUChar -> CUChar

div :: CUChar -> CUChar -> CUChar

mod :: CUChar -> CUChar -> CUChar

quotRem :: CUChar -> CUChar -> (CUChar, CUChar)

divMod :: CUChar -> CUChar -> (CUChar, CUChar)

toInteger :: CUChar -> Integer

Integral CShort

Methods

quot :: CShort -> CShort -> CShort

rem :: CShort -> CShort -> CShort

div :: CShort -> CShort -> CShort

mod :: CShort -> CShort -> CShort

quotRem :: CShort -> CShort -> (CShort, CShort)

divMod :: CShort -> CShort -> (CShort, CShort)

toInteger :: CShort -> Integer

Integral CUShort

Methods

quot :: CUShort -> CUShort -> CUShort

rem :: CUShort -> CUShort -> CUShort

div :: CUShort -> CUShort -> CUShort

mod :: CUShort -> CUShort -> CUShort

quotRem :: CUShort -> CUShort -> (CUShort, CUShort)

divMod :: CUShort -> CUShort -> (CUShort, CUShort)

toInteger :: CUShort -> Integer

Integral CInt

Methods

quot :: CInt -> CInt -> CInt

rem :: CInt -> CInt -> CInt

div :: CInt -> CInt -> CInt

mod :: CInt -> CInt -> CInt

quotRem :: CInt -> CInt -> (CInt, CInt)

divMod :: CInt -> CInt -> (CInt, CInt)

toInteger :: CInt -> Integer

Integral CUInt

Methods

quot :: CUInt -> CUInt -> CUInt

rem :: CUInt -> CUInt -> CUInt

div :: CUInt -> CUInt -> CUInt

mod :: CUInt -> CUInt -> CUInt

quotRem :: CUInt -> CUInt -> (CUInt, CUInt)

divMod :: CUInt -> CUInt -> (CUInt, CUInt)

toInteger :: CUInt -> Integer

Integral CLong

Methods

quot :: CLong -> CLong -> CLong

rem :: CLong -> CLong -> CLong

div :: CLong -> CLong -> CLong

mod :: CLong -> CLong -> CLong

quotRem :: CLong -> CLong -> (CLong, CLong)

divMod :: CLong -> CLong -> (CLong, CLong)

toInteger :: CLong -> Integer

Integral CULong

Methods

quot :: CULong -> CULong -> CULong

rem :: CULong -> CULong -> CULong

div :: CULong -> CULong -> CULong

mod :: CULong -> CULong -> CULong

quotRem :: CULong -> CULong -> (CULong, CULong)

divMod :: CULong -> CULong -> (CULong, CULong)

toInteger :: CULong -> Integer

Integral CLLong

Methods

quot :: CLLong -> CLLong -> CLLong

rem :: CLLong -> CLLong -> CLLong

div :: CLLong -> CLLong -> CLLong

mod :: CLLong -> CLLong -> CLLong

quotRem :: CLLong -> CLLong -> (CLLong, CLLong)

divMod :: CLLong -> CLLong -> (CLLong, CLLong)

toInteger :: CLLong -> Integer

Integral CULLong

Methods

quot :: CULLong -> CULLong -> CULLong

rem :: CULLong -> CULLong -> CULLong

div :: CULLong -> CULLong -> CULLong

mod :: CULLong -> CULLong -> CULLong

quotRem :: CULLong -> CULLong -> (CULLong, CULLong)

divMod :: CULLong -> CULLong -> (CULLong, CULLong)

toInteger :: CULLong -> Integer

Integral CPtrdiff

Methods

quot :: CPtrdiff -> CPtrdiff -> CPtrdiff

rem :: CPtrdiff -> CPtrdiff -> CPtrdiff

div :: CPtrdiff -> CPtrdiff -> CPtrdiff

mod :: CPtrdiff -> CPtrdiff -> CPtrdiff

quotRem :: CPtrdiff -> CPtrdiff -> (CPtrdiff, CPtrdiff)

divMod :: CPtrdiff -> CPtrdiff -> (CPtrdiff, CPtrdiff)

toInteger :: CPtrdiff -> Integer

Integral CSize

Methods

quot :: CSize -> CSize -> CSize

rem :: CSize -> CSize -> CSize

div :: CSize -> CSize -> CSize

mod :: CSize -> CSize -> CSize

quotRem :: CSize -> CSize -> (CSize, CSize)

divMod :: CSize -> CSize -> (CSize, CSize)

toInteger :: CSize -> Integer

Integral CWchar

Methods

quot :: CWchar -> CWchar -> CWchar

rem :: CWchar -> CWchar -> CWchar

div :: CWchar -> CWchar -> CWchar

mod :: CWchar -> CWchar -> CWchar

quotRem :: CWchar -> CWchar -> (CWchar, CWchar)

divMod :: CWchar -> CWchar -> (CWchar, CWchar)

toInteger :: CWchar -> Integer

Integral CSigAtomic

Methods

quot :: CSigAtomic -> CSigAtomic -> CSigAtomic

rem :: CSigAtomic -> CSigAtomic -> CSigAtomic

div :: CSigAtomic -> CSigAtomic -> CSigAtomic

mod :: CSigAtomic -> CSigAtomic -> CSigAtomic

quotRem :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic)

divMod :: CSigAtomic -> CSigAtomic -> (CSigAtomic, CSigAtomic)

toInteger :: CSigAtomic -> Integer

Integral CIntPtr

Methods

quot :: CIntPtr -> CIntPtr -> CIntPtr

rem :: CIntPtr -> CIntPtr -> CIntPtr

div :: CIntPtr -> CIntPtr -> CIntPtr

mod :: CIntPtr -> CIntPtr -> CIntPtr

quotRem :: CIntPtr -> CIntPtr -> (CIntPtr, CIntPtr)

divMod :: CIntPtr -> CIntPtr -> (CIntPtr, CIntPtr)

toInteger :: CIntPtr -> Integer

Integral CUIntPtr

Methods

quot :: CUIntPtr -> CUIntPtr -> CUIntPtr

rem :: CUIntPtr -> CUIntPtr -> CUIntPtr

div :: CUIntPtr -> CUIntPtr -> CUIntPtr

mod :: CUIntPtr -> CUIntPtr -> CUIntPtr

quotRem :: CUIntPtr -> CUIntPtr -> (CUIntPtr, CUIntPtr)

divMod :: CUIntPtr -> CUIntPtr -> (CUIntPtr, CUIntPtr)

toInteger :: CUIntPtr -> Integer

Integral CIntMax

Methods

quot :: CIntMax -> CIntMax -> CIntMax

rem :: CIntMax -> CIntMax -> CIntMax

div :: CIntMax -> CIntMax -> CIntMax

mod :: CIntMax -> CIntMax -> CIntMax

quotRem :: CIntMax -> CIntMax -> (CIntMax, CIntMax)

divMod :: CIntMax -> CIntMax -> (CIntMax, CIntMax)

toInteger :: CIntMax -> Integer

Integral CUIntMax

Methods

quot :: CUIntMax -> CUIntMax -> CUIntMax

rem :: CUIntMax -> CUIntMax -> CUIntMax

div :: CUIntMax -> CUIntMax -> CUIntMax

mod :: CUIntMax -> CUIntMax -> CUIntMax

quotRem :: CUIntMax -> CUIntMax -> (CUIntMax, CUIntMax)

divMod :: CUIntMax -> CUIntMax -> (CUIntMax, CUIntMax)

toInteger :: CUIntMax -> 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 CChar

Methods

compare :: CChar -> CChar -> Ordering

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

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

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

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

max :: CChar -> CChar -> CChar

min :: CChar -> CChar -> CChar

Ord CSChar

Methods

compare :: CSChar -> CSChar -> Ordering

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

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

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

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

max :: CSChar -> CSChar -> CSChar

min :: CSChar -> CSChar -> CSChar

Ord CUChar

Methods

compare :: CUChar -> CUChar -> Ordering

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

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

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

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

max :: CUChar -> CUChar -> CUChar

min :: CUChar -> CUChar -> CUChar

Ord CShort

Methods

compare :: CShort -> CShort -> Ordering

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

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

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

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

max :: CShort -> CShort -> CShort

min :: CShort -> CShort -> CShort

Ord CUShort

Methods

compare :: CUShort -> CUShort -> Ordering

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

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

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

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

max :: CUShort -> CUShort -> CUShort

min :: CUShort -> CUShort -> CUShort

Ord CInt

Methods

compare :: CInt -> CInt -> Ordering

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

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

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

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

max :: CInt -> CInt -> CInt

min :: CInt -> CInt -> CInt

Ord CUInt

Methods

compare :: CUInt -> CUInt -> Ordering

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

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

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

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

max :: CUInt -> CUInt -> CUInt

min :: CUInt -> CUInt -> CUInt

Ord CLong

Methods

compare :: CLong -> CLong -> Ordering

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

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

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

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

max :: CLong -> CLong -> CLong

min :: CLong -> CLong -> CLong

Ord CULong

Methods

compare :: CULong -> CULong -> Ordering

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

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

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

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

max :: CULong -> CULong -> CULong

min :: CULong -> CULong -> CULong

Ord CLLong

Methods

compare :: CLLong -> CLLong -> Ordering

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

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

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

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

max :: CLLong -> CLLong -> CLLong

min :: CLLong -> CLLong -> CLLong

Ord CULLong

Methods

compare :: CULLong -> CULLong -> Ordering

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

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

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

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

max :: CULLong -> CULLong -> CULLong

min :: CULLong -> CULLong -> CULLong

Ord CFloat

Methods

compare :: CFloat -> CFloat -> Ordering

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

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

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

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

max :: CFloat -> CFloat -> CFloat

min :: CFloat -> CFloat -> CFloat

Ord CDouble

Methods

compare :: CDouble -> CDouble -> Ordering

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

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

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

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

max :: CDouble -> CDouble -> CDouble

min :: CDouble -> CDouble -> CDouble

Ord CPtrdiff

Methods

compare :: CPtrdiff -> CPtrdiff -> Ordering

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

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

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

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

max :: CPtrdiff -> CPtrdiff -> CPtrdiff

min :: CPtrdiff -> CPtrdiff -> CPtrdiff

Ord CSize

Methods

compare :: CSize -> CSize -> Ordering

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

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

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

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

max :: CSize -> CSize -> CSize

min :: CSize -> CSize -> CSize

Ord CWchar

Methods

compare :: CWchar -> CWchar -> Ordering

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

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

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

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

max :: CWchar -> CWchar -> CWchar

min :: CWchar -> CWchar -> CWchar

Ord CSigAtomic

Methods

compare :: CSigAtomic -> CSigAtomic -> Ordering

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

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

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

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

max :: CSigAtomic -> CSigAtomic -> CSigAtomic

min :: CSigAtomic -> CSigAtomic -> CSigAtomic

Ord CClock

Methods

compare :: CClock -> CClock -> Ordering

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

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

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

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

max :: CClock -> CClock -> CClock

min :: CClock -> CClock -> CClock

Ord CTime

Methods

compare :: CTime -> CTime -> Ordering

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

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

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

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

max :: CTime -> CTime -> CTime

min :: CTime -> CTime -> CTime

Ord CUSeconds

Methods

compare :: CUSeconds -> CUSeconds -> Ordering

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

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

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

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

max :: CUSeconds -> CUSeconds -> CUSeconds

min :: CUSeconds -> CUSeconds -> CUSeconds

Ord CSUSeconds

Methods

compare :: CSUSeconds -> CSUSeconds -> Ordering

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

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

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

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

max :: CSUSeconds -> CSUSeconds -> CSUSeconds

min :: CSUSeconds -> CSUSeconds -> CSUSeconds

Ord CIntPtr

Methods

compare :: CIntPtr -> CIntPtr -> Ordering

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

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

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

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

max :: CIntPtr -> CIntPtr -> CIntPtr

min :: CIntPtr -> CIntPtr -> CIntPtr

Ord CUIntPtr

Methods

compare :: CUIntPtr -> CUIntPtr -> Ordering

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

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

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

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

max :: CUIntPtr -> CUIntPtr -> CUIntPtr

min :: CUIntPtr -> CUIntPtr -> CUIntPtr

Ord CIntMax

Methods

compare :: CIntMax -> CIntMax -> Ordering

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

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

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

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

max :: CIntMax -> CIntMax -> CIntMax

min :: CIntMax -> CIntMax -> CIntMax

Ord CUIntMax

Methods

compare :: CUIntMax -> CUIntMax -> Ordering

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

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

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

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

max :: CUIntMax -> CUIntMax -> CUIntMax

min :: CUIntMax -> CUIntMax -> CUIntMax

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 ErrorCall

Methods

compare :: ErrorCall -> ErrorCall -> Ordering

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

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

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

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

max :: ErrorCall -> ErrorCall -> ErrorCall

min :: ErrorCall -> ErrorCall -> ErrorCall

Ord ArithException

Methods

compare :: ArithException -> ArithException -> Ordering

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

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

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

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

max :: ArithException -> ArithException -> ArithException

min :: ArithException -> ArithException -> ArithException

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 GeneralCategory

Methods

compare :: GeneralCategory -> GeneralCategory -> Ordering

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

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

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

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

max :: GeneralCategory -> GeneralCategory -> GeneralCategory

min :: GeneralCategory -> GeneralCategory -> GeneralCategory

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 PragmasAndModuleName

Methods

compare :: PragmasAndModuleName -> PragmasAndModuleName -> Ordering

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

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

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

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

max :: PragmasAndModuleName -> PragmasAndModuleName -> PragmasAndModuleName

min :: PragmasAndModuleName -> PragmasAndModuleName -> PragmasAndModuleName

Ord PragmasAndModuleHead

Methods

compare :: PragmasAndModuleHead -> PragmasAndModuleHead -> Ordering

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

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

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

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

max :: PragmasAndModuleHead -> PragmasAndModuleHead -> PragmasAndModuleHead

min :: PragmasAndModuleHead -> PragmasAndModuleHead -> PragmasAndModuleHead

Ord ModuleHeadAndImports

Methods

compare :: ModuleHeadAndImports -> ModuleHeadAndImports -> Ordering

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

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

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

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

max :: ModuleHeadAndImports -> ModuleHeadAndImports -> ModuleHeadAndImports

min :: ModuleHeadAndImports -> ModuleHeadAndImports -> ModuleHeadAndImports

Ord ModuleName

Methods

compare :: ModuleName -> ModuleName -> Ordering

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

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

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

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

max :: ModuleName -> ModuleName -> ModuleName

min :: ModuleName -> ModuleName -> ModuleName

Ord SpecialCon

Methods

compare :: SpecialCon -> SpecialCon -> Ordering

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

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

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

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

max :: SpecialCon -> SpecialCon -> SpecialCon

min :: SpecialCon -> SpecialCon -> SpecialCon

Ord QName

Methods

compare :: QName -> QName -> Ordering

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

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

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

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

max :: QName -> QName -> QName

min :: QName -> QName -> QName

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 IPName

Methods

compare :: IPName -> IPName -> Ordering

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

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

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

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

max :: IPName -> IPName -> IPName

min :: IPName -> IPName -> IPName

Ord QOp

Methods

compare :: QOp -> QOp -> Ordering

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

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

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

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

max :: QOp -> QOp -> QOp

min :: QOp -> QOp -> QOp

Ord Op

Methods

compare :: Op -> Op -> Ordering

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

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

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

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

max :: Op -> Op -> Op

min :: Op -> Op -> Op

Ord CName

Methods

compare :: CName -> CName -> Ordering

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

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

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

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

max :: CName -> CName -> CName

min :: CName -> CName -> CName

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 ExportSpec

Methods

compare :: ExportSpec -> ExportSpec -> Ordering

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

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

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

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

max :: ExportSpec -> ExportSpec -> ExportSpec

min :: ExportSpec -> ExportSpec -> ExportSpec

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 ImportDecl

Methods

compare :: ImportDecl -> ImportDecl -> Ordering

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

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

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

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

max :: ImportDecl -> ImportDecl -> ImportDecl

min :: ImportDecl -> ImportDecl -> ImportDecl

Ord ImportSpec

Methods

compare :: ImportSpec -> ImportSpec -> Ordering

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

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

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

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

max :: ImportSpec -> ImportSpec -> ImportSpec

min :: ImportSpec -> ImportSpec -> ImportSpec

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

Methods

compare :: PatternSynDirection -> PatternSynDirection -> Ordering

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

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

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

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

max :: PatternSynDirection -> PatternSynDirection -> PatternSynDirection

min :: PatternSynDirection -> PatternSynDirection -> PatternSynDirection

Ord TypeEqn

Methods

compare :: TypeEqn -> TypeEqn -> Ordering

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

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

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

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

max :: TypeEqn -> TypeEqn -> TypeEqn

min :: TypeEqn -> TypeEqn -> TypeEqn

Ord Annotation

Methods

compare :: Annotation -> Annotation -> Ordering

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

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

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

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

max :: Annotation -> Annotation -> Annotation

min :: Annotation -> Annotation -> Annotation

Ord BooleanFormula

Methods

compare :: BooleanFormula -> BooleanFormula -> Ordering

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

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

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

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

max :: BooleanFormula -> BooleanFormula -> BooleanFormula

min :: BooleanFormula -> BooleanFormula -> BooleanFormula

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 DataOrNew

Methods

compare :: DataOrNew -> DataOrNew -> Ordering

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

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

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

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

max :: DataOrNew -> DataOrNew -> DataOrNew

min :: DataOrNew -> DataOrNew -> DataOrNew

Ord Binds

Methods

compare :: Binds -> Binds -> Ordering

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

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

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

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

max :: Binds -> Binds -> Binds

min :: Binds -> Binds -> Binds

Ord IPBind

Methods

compare :: IPBind -> IPBind -> Ordering

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

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

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

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

max :: IPBind -> IPBind -> IPBind

min :: IPBind -> IPBind -> IPBind

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 QualConDecl

Methods

compare :: QualConDecl -> QualConDecl -> Ordering

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

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

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

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

max :: QualConDecl -> QualConDecl -> QualConDecl

min :: QualConDecl -> QualConDecl -> QualConDecl

Ord ConDecl

Methods

compare :: ConDecl -> ConDecl -> Ordering

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

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

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

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

max :: ConDecl -> ConDecl -> ConDecl

min :: ConDecl -> ConDecl -> ConDecl

Ord GadtDecl

Methods

compare :: GadtDecl -> GadtDecl -> Ordering

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

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

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

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

max :: GadtDecl -> GadtDecl -> GadtDecl

min :: GadtDecl -> GadtDecl -> GadtDecl

Ord ClassDecl

Methods

compare :: ClassDecl -> ClassDecl -> Ordering

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

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

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

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

max :: ClassDecl -> ClassDecl -> ClassDecl

min :: ClassDecl -> ClassDecl -> ClassDecl

Ord InstDecl

Methods

compare :: InstDecl -> InstDecl -> Ordering

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

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

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

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

max :: InstDecl -> InstDecl -> InstDecl

min :: InstDecl -> InstDecl -> InstDecl

Ord BangType

Methods

compare :: BangType -> BangType -> Ordering

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

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

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

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

max :: BangType -> BangType -> BangType

min :: BangType -> BangType -> BangType

Ord Rhs

Methods

compare :: Rhs -> Rhs -> Ordering

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

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

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

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

max :: Rhs -> Rhs -> Rhs

min :: Rhs -> Rhs -> Rhs

Ord GuardedRhs

Methods

compare :: GuardedRhs -> GuardedRhs -> Ordering

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

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

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

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

max :: GuardedRhs -> GuardedRhs -> GuardedRhs

min :: GuardedRhs -> GuardedRhs -> GuardedRhs

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 Promoted

Methods

compare :: Promoted -> Promoted -> Ordering

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

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

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

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

max :: Promoted -> Promoted -> Promoted

min :: Promoted -> Promoted -> Promoted

Ord TyVarBind

Methods

compare :: TyVarBind -> TyVarBind -> Ordering

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

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

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

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

max :: TyVarBind -> TyVarBind -> TyVarBind

min :: TyVarBind -> TyVarBind -> TyVarBind

Ord Kind

Methods

compare :: Kind -> Kind -> Ordering

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

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

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

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

max :: Kind -> Kind -> Kind

min :: Kind -> Kind -> Kind

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 Asst

Methods

compare :: Asst -> Asst -> Ordering

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

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

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

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

max :: Asst -> Asst -> Asst

min :: Asst -> Asst -> Asst

Ord Literal

Methods

compare :: Literal -> Literal -> Ordering

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

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

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

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

max :: Literal -> Literal -> Literal

min :: Literal -> Literal -> Literal

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

Methods

compare :: XName -> XName -> Ordering

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

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

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

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

max :: XName -> XName -> XName

min :: XName -> XName -> XName

Ord XAttr

Methods

compare :: XAttr -> XAttr -> Ordering

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

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

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

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

max :: XAttr -> XAttr -> XAttr

min :: XAttr -> XAttr -> XAttr

Ord Bracket

Methods

compare :: Bracket -> Bracket -> Ordering

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

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

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

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

max :: Bracket -> Bracket -> Bracket

min :: Bracket -> Bracket -> Bracket

Ord Splice

Methods

compare :: Splice -> Splice -> Ordering

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

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

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

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

max :: Splice -> Splice -> Splice

min :: Splice -> Splice -> Splice

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

Methods

compare :: ModulePragma -> ModulePragma -> Ordering

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

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

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

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

max :: ModulePragma -> ModulePragma -> ModulePragma

min :: ModulePragma -> ModulePragma -> ModulePragma

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 Activation

Methods

compare :: Activation -> Activation -> Ordering

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

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

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

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

max :: Activation -> Activation -> Activation

min :: Activation -> Activation -> Activation

Ord Rule

Methods

compare :: Rule -> Rule -> Ordering

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

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

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

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

max :: Rule -> Rule -> Rule

min :: Rule -> Rule -> Rule

Ord RuleVar

Methods

compare :: RuleVar -> RuleVar -> Ordering

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

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

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

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

max :: RuleVar -> RuleVar -> RuleVar

min :: RuleVar -> RuleVar -> RuleVar

Ord WarningText

Methods

compare :: WarningText -> WarningText -> Ordering

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

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

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

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

max :: WarningText -> WarningText -> WarningText

min :: WarningText -> WarningText -> WarningText

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 PXAttr

Methods

compare :: PXAttr -> PXAttr -> Ordering

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

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

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

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

max :: PXAttr -> PXAttr -> PXAttr

min :: PXAttr -> PXAttr -> PXAttr

Ord RPatOp

Methods

compare :: RPatOp -> RPatOp -> Ordering

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

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

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

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

max :: RPatOp -> RPatOp -> RPatOp

min :: RPatOp -> RPatOp -> RPatOp

Ord RPat

Methods

compare :: RPat -> RPat -> Ordering

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

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

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

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

max :: RPat -> RPat -> RPat

min :: RPat -> RPat -> RPat

Ord PatField

Methods

compare :: PatField -> PatField -> Ordering

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

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

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

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

max :: PatField -> PatField -> PatField

min :: PatField -> PatField -> PatField

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 QualStmt

Methods

compare :: QualStmt -> QualStmt -> Ordering

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

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

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

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

max :: QualStmt -> QualStmt -> QualStmt

min :: QualStmt -> QualStmt -> QualStmt

Ord FieldUpdate

Methods

compare :: FieldUpdate -> FieldUpdate -> Ordering

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

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

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

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

max :: FieldUpdate -> FieldUpdate -> FieldUpdate

min :: FieldUpdate -> FieldUpdate -> FieldUpdate

Ord Alt

Methods

compare :: Alt -> Alt -> Ordering

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

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

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

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

max :: Alt -> Alt -> Alt

min :: Alt -> Alt -> Alt

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 TimeOfDay

Methods

compare :: TimeOfDay -> TimeOfDay -> Ordering

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

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

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

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

max :: TimeOfDay -> TimeOfDay -> TimeOfDay

min :: TimeOfDay -> TimeOfDay -> TimeOfDay

Ord TimeZone

Methods

compare :: TimeZone -> TimeZone -> Ordering

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

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

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

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

max :: TimeZone -> TimeZone -> TimeZone

min :: TimeZone -> TimeZone -> TimeZone

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 (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 (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 (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 (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 (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 (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 a, Ord b) => 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 (f p), Ord (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 (f p), Ord (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 (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 (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 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 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 CFloat

Methods

floatRadix :: CFloat -> Integer

floatDigits :: CFloat -> Int

floatRange :: CFloat -> (Int, Int)

decodeFloat :: CFloat -> (Integer, Int)

encodeFloat :: Integer -> Int -> CFloat

exponent :: CFloat -> Int

significand :: CFloat -> CFloat

scaleFloat :: Int -> CFloat -> CFloat

isNaN :: CFloat -> Bool

isInfinite :: CFloat -> Bool

isDenormalized :: CFloat -> Bool

isNegativeZero :: CFloat -> Bool

isIEEE :: CFloat -> Bool

atan2 :: CFloat -> CFloat -> CFloat

RealFloat CDouble

Methods

floatRadix :: CDouble -> Integer

floatDigits :: CDouble -> Int

floatRange :: CDouble -> (Int, Int)

decodeFloat :: CDouble -> (Integer, Int)

encodeFloat :: Integer -> Int -> CDouble

exponent :: CDouble -> Int

significand :: CDouble -> CDouble

scaleFloat :: Int -> CDouble -> CDouble

isNaN :: CDouble -> Bool

isInfinite :: CDouble -> Bool

isDenormalized :: CDouble -> Bool

isNegativeZero :: CDouble -> Bool

isIEEE :: CDouble -> Bool

atan2 :: CDouble -> CDouble -> CDouble

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

Methods

properFraction :: Integral b => CFloat -> (b, CFloat)

truncate :: Integral b => CFloat -> b

round :: Integral b => CFloat -> b

ceiling :: Integral b => CFloat -> b

floor :: Integral b => CFloat -> b

RealFrac CDouble

Methods

properFraction :: Integral b => CDouble -> (b, CDouble)

truncate :: Integral b => CDouble -> b

round :: Integral b => CDouble -> b

ceiling :: Integral b => CDouble -> b

floor :: Integral b => CDouble -> b

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