| Safe Haskell | Safe |
|---|---|
| Language | Haskell2010 |
Copilot.Language.Prelude
Description
Reexports Prelude from package "base" hiding identifiers redefined by
Copilot.
Documentation
Instances
| Data Int | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Int -> c Int gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Int dataTypeOf :: Int -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Int) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Int) gmapT :: (forall b. Data b => b -> b) -> Int -> Int gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Int -> r gmapQ :: (forall d. Data d => d -> u) -> Int -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Int -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Int -> m Int gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Int -> m Int | |||||
| Storable Int | |||||
| Bits Int | |||||
Defined in GHC.Bits Methods complement :: Int -> Int # complementBit :: Int -> Int -> Int bitSizeMaybe :: Int -> Maybe Int unsafeShiftL :: Int -> Int -> Int unsafeShiftR :: Int -> Int -> Int | |||||
| FiniteBits Int | |||||
Defined in GHC.Bits | |||||
| Bounded Int | |||||
| Enum Int | |||||
| Ix Int | |||||
| Num Int | |||||
| Read Int | |||||
| Integral Int | |||||
| Real Int | |||||
Defined in GHC.Real Methods toRational :: Int -> Rational # | |||||
| Show Int | |||||
| PrintfArg Int | |||||
Defined in Text.Printf | |||||
| NFData Int | |||||
Defined in Control.DeepSeq | |||||
| Eq Int | |||||
| Ord Int | |||||
| IArray UArray Int | |||||
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Int -> (i, i) numElements :: Ix i => UArray i Int -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Int)] -> UArray i Int unsafeAt :: Ix i => UArray i Int -> Int -> Int unsafeReplace :: Ix i => UArray i Int -> [(Int, Int)] -> UArray i Int unsafeAccum :: Ix i => (Int -> e' -> Int) -> UArray i Int -> [(Int, e')] -> UArray i Int unsafeAccumArray :: Ix i => (Int -> e' -> Int) -> Int -> (i, i) -> [(Int, e')] -> UArray i Int | |||||
| Lift Int | |||||
| MArray IOUArray Int IO | |||||
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Int -> IO (i, i) getNumElements :: Ix i => IOUArray i Int -> IO Int newArray :: Ix i => (i, i) -> Int -> IO (IOUArray i Int) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Int) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Int) unsafeRead :: Ix i => IOUArray i Int -> Int -> IO Int unsafeWrite :: Ix i => IOUArray i Int -> Int -> Int -> IO () | |||||
| Generic1 (URec Int :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Foldable (UInt :: Type -> Type) | |||||
Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |||||
| Traversable (UInt :: Type -> Type) | |||||
Defined in Data.Traversable | |||||
| MArray (STUArray s) Int (ST s) | |||||
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Int -> ST s (i, i) getNumElements :: Ix i => STUArray s i Int -> ST s Int newArray :: Ix i => (i, i) -> Int -> ST s (STUArray s i Int) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Int) unsafeRead :: Ix i => STUArray s i Int -> Int -> ST s Int unsafeWrite :: Ix i => STUArray s i Int -> Int -> Int -> ST s () | |||||
| Functor (URec Int :: Type -> Type) | |||||
| Generic (URec Int p) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Show (URec Int p) | |||||
| Eq (URec Int p) | |||||
| Ord (URec Int p) | |||||
| data URec Int (p :: k) | |||||
Defined in GHC.Generics | |||||
| type Rep1 (URec Int :: k -> Type) | |||||
Defined in GHC.Generics | |||||
| type Rep (URec Int p) | |||||
Defined in GHC.Generics | |||||
Instances
| Data Word | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Word -> c Word gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Word dataTypeOf :: Word -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Word) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Word) gmapT :: (forall b. Data b => b -> b) -> Word -> Word gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Word -> r gmapQ :: (forall d. Data d => d -> u) -> Word -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Word -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Word -> m Word gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Word -> m Word | |||||
| Storable Word | |||||
Defined in Foreign.Storable | |||||
| Bits Word | |||||
Defined in GHC.Bits Methods (.&.) :: Word -> Word -> Word # (.|.) :: Word -> Word -> Word # complement :: Word -> Word # clearBit :: Word -> Int -> Word complementBit :: Word -> Int -> Word testBit :: Word -> Int -> Bool bitSizeMaybe :: Word -> Maybe Int unsafeShiftL :: Word -> Int -> Word unsafeShiftR :: Word -> Int -> Word rotateL :: Word -> Int -> Word | |||||
| FiniteBits Word | |||||
Defined in GHC.Bits Methods finiteBitSize :: Word -> Int countLeadingZeros :: Word -> Int countTrailingZeros :: Word -> Int | |||||
| Bounded Word | |||||
| Enum Word | |||||
| Ix Word | |||||
| Num Word | |||||
| Read Word | |||||
| Integral Word | |||||
| Real Word | |||||
Defined in GHC.Real Methods toRational :: Word -> Rational # | |||||
| Show Word | |||||
| PrintfArg Word | |||||
Defined in Text.Printf | |||||
| NFData Word | |||||
Defined in Control.DeepSeq | |||||
| Eq Word | |||||
| Ord Word | |||||
| IArray UArray Word | |||||
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Word -> (i, i) numElements :: Ix i => UArray i Word -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Word)] -> UArray i Word unsafeAt :: Ix i => UArray i Word -> Int -> Word unsafeReplace :: Ix i => UArray i Word -> [(Int, Word)] -> UArray i Word unsafeAccum :: Ix i => (Word -> e' -> Word) -> UArray i Word -> [(Int, e')] -> UArray i Word unsafeAccumArray :: Ix i => (Word -> e' -> Word) -> Word -> (i, i) -> [(Int, e')] -> UArray i Word | |||||
| Lift Word | |||||
| MArray IOUArray Word IO | |||||
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word -> IO (i, i) getNumElements :: Ix i => IOUArray i Word -> IO Int newArray :: Ix i => (i, i) -> Word -> IO (IOUArray i Word) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word) unsafeRead :: Ix i => IOUArray i Word -> Int -> IO Word unsafeWrite :: Ix i => IOUArray i Word -> Int -> Word -> IO () | |||||
| Generic1 (URec Word :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Foldable (UWord :: Type -> Type) | |||||
Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # | |||||
| Traversable (UWord :: Type -> Type) | |||||
Defined in Data.Traversable | |||||
| MArray (STUArray s) Word (ST s) | |||||
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Word -> ST s (i, i) getNumElements :: Ix i => STUArray s i Word -> ST s Int newArray :: Ix i => (i, i) -> Word -> ST s (STUArray s i Word) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Word) unsafeRead :: Ix i => STUArray s i Word -> Int -> ST s Word unsafeWrite :: Ix i => STUArray s i Word -> Int -> Word -> ST s () | |||||
| Functor (URec Word :: Type -> Type) | |||||
| Generic (URec Word p) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Show (URec Word p) | |||||
| Eq (URec Word p) | |||||
| Ord (URec Word p) | |||||
| data URec Word (p :: k) | |||||
Defined in GHC.Generics | |||||
| type Rep1 (URec Word :: k -> Type) | |||||
Defined in GHC.Generics | |||||
| type Rep (URec Word p) | |||||
Defined in GHC.Generics | |||||
Minimal complete definition
(==) | (/=)
Instances
| Eq ByteArray | |
Defined in Data.Array.Byte | |
| Eq Constr | |
| Eq ConstrRep | |
| Eq DataRep | |
| Eq Fixity | |
| Eq SomeTypeRep | |
Defined in Data.Typeable.Internal | |
| Eq Unique | |
Defined in Data.Unique | |
| Eq Version | |
Defined in Data.Version | |
| Eq Errno | |
Defined in Foreign.C.Error | |
| Eq CBool | |
Defined in Foreign.C.Types | |
| Eq CChar | |
Defined in Foreign.C.Types | |
| Eq CClock | |
Defined in Foreign.C.Types | |
| Eq CDouble | |
Defined in Foreign.C.Types | |
| Eq CFloat | |
Defined in Foreign.C.Types | |
| Eq CInt | |
Defined in Foreign.C.Types | |
| Eq CIntMax | |
Defined in Foreign.C.Types | |
| Eq CIntPtr | |
Defined in Foreign.C.Types | |
| Eq CLLong | |
Defined in Foreign.C.Types | |
| Eq CLong | |
Defined in Foreign.C.Types | |
| Eq CPtrdiff | |
Defined in Foreign.C.Types | |
| Eq CSChar | |
Defined in Foreign.C.Types | |
| Eq CSUSeconds | |
Defined in Foreign.C.Types | |
| Eq CShort | |
Defined in Foreign.C.Types | |
| Eq CSigAtomic | |
Defined in Foreign.C.Types | |
| Eq CSize | |
Defined in Foreign.C.Types | |
| Eq CTime | |
Defined in Foreign.C.Types | |
| Eq CUChar | |
Defined in Foreign.C.Types | |
| Eq CUInt | |
Defined in Foreign.C.Types | |
| Eq CUIntMax | |
Defined in Foreign.C.Types | |
| Eq CUIntPtr | |
Defined in Foreign.C.Types | |
| Eq CULLong | |
Defined in Foreign.C.Types | |
| Eq CULong | |
Defined in Foreign.C.Types | |
| Eq CUSeconds | |
Defined in Foreign.C.Types | |
| Eq CUShort | |
Defined in Foreign.C.Types | |
| Eq CWchar | |
Defined in Foreign.C.Types | |
| Eq IntPtr | |
Defined in Foreign.Ptr | |
| Eq WordPtr | |
Defined in Foreign.Ptr | |
| Eq Void | |
| Eq ByteOrder | |
Defined in GHC.ByteOrder | |
| Eq BlockReason | |
Defined in GHC.Conc.Sync | |
| Eq ThreadId | |
Defined in GHC.Conc.Sync | |
| Eq ThreadStatus | |
Defined in GHC.Conc.Sync | |
| Eq TimeoutKey | |
Defined in GHC.Event.TimeOut | |
| Eq ErrorCall | |
Defined in GHC.Exception | |
| Eq ArithException | |
Defined in GHC.Exception.Type | |
| Eq SpecConstrAnnotation | |
| Eq Fingerprint | |
Defined in GHC.Fingerprint.Type | |
| Eq Associativity | |
Defined in GHC.Generics | |
| Eq DecidedStrictness | |
Defined in GHC.Generics | |
| Eq Fixity | |
Defined in GHC.Generics | |
| Eq SourceStrictness | |
Defined in GHC.Generics | |
| Eq SourceUnpackedness | |
Defined in GHC.Generics | |
| Eq MaskingState | |
| Eq BufferState | |
Defined in GHC.IO.Buffer | |
| Eq IODeviceType | |
Defined in GHC.IO.Device | |
| Eq SeekMode | |
Defined in GHC.IO.Device | |
| Eq CodingProgress | |
Defined in GHC.IO.Encoding.Types | |
| Eq ArrayException | |
Defined in GHC.IO.Exception | |
| Eq AsyncException | |
Defined in GHC.IO.Exception | |
| Eq ExitCode | |
Defined in GHC.IO.Exception | |
| Eq IOErrorType | |
Defined in GHC.IO.Exception | |
| Eq IOException | |
Defined in GHC.IO.Exception | |
| Eq HandlePosn | |
Defined in GHC.IO.Handle | |
| Eq BufferMode | |
Defined in GHC.IO.Handle.Types | |
| Eq Handle | |
Defined in GHC.IO.Handle.Types | |
| Eq Newline | |
Defined in GHC.IO.Handle.Types | |
| Eq NewlineMode | |
Defined in GHC.IO.Handle.Types | |
| Eq IOMode | |
Defined in GHC.IO.IOMode | |
| Eq InfoProv | |
Defined in GHC.InfoProv | |
| Eq Int16 | |
| Eq Int32 | |
| Eq Int64 | |
| Eq Int8 | |
| Eq IoSubSystem | |
Defined in GHC.RTS.Flags | |
| Eq StackEntry | |
Defined in GHC.Stack.CloneStack | |
| Eq SrcLoc | |
Defined in GHC.Stack.Types | |
| Eq SomeChar | |
Defined in GHC.TypeLits | |
| Eq SomeSymbol | |
Defined in GHC.TypeLits | |
| Eq SomeNat | |
Defined in GHC.TypeNats | |
| Eq GeneralCategory | |
Defined in GHC.Unicode | |
| Eq Word16 | |
| Eq Word32 | |
| Eq Word64 | |
| Eq Word8 | |
| Eq CBlkCnt | |
Defined in System.Posix.Types | |
| Eq CBlkSize | |
Defined in System.Posix.Types | |
| Eq CCc | |
Defined in System.Posix.Types | |
| Eq CClockId | |
Defined in System.Posix.Types | |
| Eq CDev | |
Defined in System.Posix.Types | |
| Eq CFsBlkCnt | |
Defined in System.Posix.Types | |
| Eq CFsFilCnt | |
Defined in System.Posix.Types | |
| Eq CGid | |
Defined in System.Posix.Types | |
| Eq CId | |
Defined in System.Posix.Types | |
| Eq CIno | |
Defined in System.Posix.Types | |
| Eq CKey | |
Defined in System.Posix.Types | |
| Eq CMode | |
Defined in System.Posix.Types | |
| Eq CNfds | |
Defined in System.Posix.Types | |
| Eq CNlink | |
Defined in System.Posix.Types | |
| Eq COff | |
Defined in System.Posix.Types | |
| Eq CPid | |
Defined in System.Posix.Types | |
| Eq CRLim | |
Defined in System.Posix.Types | |
| Eq CSocklen | |
Defined in System.Posix.Types | |
| Eq CSpeed | |
Defined in System.Posix.Types | |
| Eq CSsize | |
Defined in System.Posix.Types | |
| Eq CTcflag | |
Defined in System.Posix.Types | |
| Eq CTimer | |
Defined in System.Posix.Types | |
| Eq CUid | |
Defined in System.Posix.Types | |
| Eq Fd | |
Defined in System.Posix.Types | |
| Eq Timeout | |
Defined in System.Timeout | |
| Eq Lexeme | |
Defined in Text.Read.Lex | |
| Eq Number | |
Defined in Text.Read.Lex | |
| Eq IntSet | |
Defined in Data.IntSet.Internal | |
| Eq SimpleType | |
Defined in Copilot.Core.Type | |
| Eq UType | |
| Eq SolverId | |
Defined in Copilot.Theorem.Prover.SMT | |
| Eq DynStableName | |
Defined in Data.Reify | |
| Eq BigNat | |
Defined in GHC.Num.BigNat | |
| Eq ForeignSrcLang | |
Defined in GHC.ForeignSrcLang.Type | |
| Eq Extension | |
Defined in GHC.LanguageExtensions.Type | |
| Eq Module | |
Defined in GHC.Classes | |
| Eq Ordering | |
| Eq TrName | |
Defined in GHC.Classes | |
| Eq TyCon | |
Defined in GHC.Classes | |
| Eq Mode | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Eq Style | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Eq TextDetails | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Eq Doc | |
Defined in Text.PrettyPrint.HughesPJ | |
| Eq AnnLookup | |
Defined in Language.Haskell.TH.Syntax | |
| Eq AnnTarget | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Bang | |
Defined in Language.Haskell.TH.Syntax | |
| Eq BndrVis | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Body | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Bytes | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Callconv | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Clause | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Con | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Dec | |
Defined in Language.Haskell.TH.Syntax | |
| Eq DecidedStrictness | |
Defined in Language.Haskell.TH.Syntax | |
| Eq DerivClause | |
Defined in Language.Haskell.TH.Syntax | |
| Eq DerivStrategy | |
Defined in Language.Haskell.TH.Syntax | |
| Eq DocLoc | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Exp | |
Defined in Language.Haskell.TH.Syntax | |
| Eq FamilyResultSig | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Fixity | |
Defined in Language.Haskell.TH.Syntax | |
| Eq FixityDirection | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Foreign | |
Defined in Language.Haskell.TH.Syntax | |
| Eq FunDep | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Guard | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Info | |
Defined in Language.Haskell.TH.Syntax | |
| Eq InjectivityAnn | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Inline | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Lit | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Loc | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Match | |
Defined in Language.Haskell.TH.Syntax | |
| Eq ModName | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Module | |
Defined in Language.Haskell.TH.Syntax | |
| Eq ModuleInfo | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Name | |
Defined in Language.Haskell.TH.Syntax | |
| Eq NameFlavour | |
Defined in Language.Haskell.TH.Syntax | |
| Eq NameSpace | |
Defined in Language.Haskell.TH.Syntax | |
| Eq OccName | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Overlap | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Pat | |
Defined in Language.Haskell.TH.Syntax | |
| Eq PatSynArgs | |
Defined in Language.Haskell.TH.Syntax | |
| Eq PatSynDir | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Phases | |
Defined in Language.Haskell.TH.Syntax | |
| Eq PkgName | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Pragma | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Range | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Role | |
Defined in Language.Haskell.TH.Syntax | |
| Eq RuleBndr | |
Defined in Language.Haskell.TH.Syntax | |
| Eq RuleMatch | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Safety | |
Defined in Language.Haskell.TH.Syntax | |
| Eq SourceStrictness | |
Defined in Language.Haskell.TH.Syntax | |
| Eq SourceUnpackedness | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Specificity | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Stmt | |
Defined in Language.Haskell.TH.Syntax | |
| Eq TyLit | |
Defined in Language.Haskell.TH.Syntax | |
| Eq TySynEqn | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Type | |
Defined in Language.Haskell.TH.Syntax | |
| Eq TypeFamilyHead | |
Defined in Language.Haskell.TH.Syntax | |
| Eq Integer | |
| Eq Natural | |
Defined in GHC.Num.Natural | |
| Eq () | |
Defined in GHC.Classes | |
| Eq Bool | |
| Eq Char | |
| Eq Double | |
| Eq Float | |
| Eq Int | |
| Eq Word | |
| Eq a => Eq (ZipList a) | |
Defined in Control.Applicative | |
| Eq (Chan a) | |
Defined in Control.Concurrent.Chan | |
| Eq (MutableByteArray s) | |
Defined in Data.Array.Byte | |
| Eq a => Eq (And a) | |
| Eq a => Eq (Iff a) | |
| Eq a => Eq (Ior a) | |
| Eq a => Eq (Xor a) | |
| Eq a => Eq (Complex a) | |
Defined in Data.Complex | |
| Eq a => Eq (Identity a) | |
Defined in Data.Functor.Identity | |
| Eq a => Eq (First a) | |
Defined in Data.Monoid | |
| Eq a => Eq (Last a) | |
Defined in Data.Monoid | |
| Eq a => Eq (Down a) | |
| Eq a => Eq (First a) | |
Defined in Data.Semigroup | |
| Eq a => Eq (Last a) | |
Defined in Data.Semigroup | |
| Eq a => Eq (Max a) | |
Defined in Data.Semigroup | |
| Eq a => Eq (Min a) | |
Defined in Data.Semigroup | |
| Eq m => Eq (WrappedMonoid m) | |
Defined in Data.Semigroup | |
| Eq (ConstPtr a) | |
Defined in Foreign.C.ConstPtr | |
| Eq a => Eq (NonEmpty a) | |
| Eq (TVar a) | |
Defined in GHC.Conc.Sync | |
| Eq (ForeignPtr a) | |
Defined in GHC.ForeignPtr | |
| Eq p => Eq (Par1 p) | |
Defined in GHC.Generics | |
| Eq (IOPort a) | |
Defined in GHC.IOPort | |
| Eq (IORef a) | |
| Eq (MVar a) | |
| Eq (FunPtr a) | |
| Eq (Ptr a) | |
| Eq a => Eq (Ratio a) | |
| Eq (StablePtr a) | |
Defined in GHC.Stable | |
| Eq (StableName a) | |
Defined in GHC.StableName | |
| Eq (SChar c) | |
Defined in GHC.TypeLits | |
| Eq (SSymbol s) | |
Defined in GHC.TypeLits | |
| Eq (SNat n) | |
Defined in GHC.TypeNats | |
| Eq vertex => Eq (SCC vertex) | |
Defined in Data.Graph | |
| Eq a => Eq (IntMap a) | |
Defined in Data.IntMap.Internal | |
| Eq a => Eq (Seq a) | |
Defined in Data.Sequence.Internal | |
| Eq a => Eq (ViewL a) | |
Defined in Data.Sequence.Internal | |
| Eq a => Eq (ViewR a) | |
Defined in Data.Sequence.Internal | |
| Eq a => Eq (Intersection a) | |
Defined in Data.Set.Internal | |
| Eq a => Eq (Set a) | |
Defined in Data.Set.Internal | |
| Eq a => Eq (Tree a) | |
| Eq (Stream a) Source # | |
| Eq a => Eq (AnnotDetails a) | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Eq (Doc a) | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Eq a => Eq (Span a) | |
Defined in Text.PrettyPrint.Annotated.HughesPJ | |
| Eq flag => Eq (TyVarBndr flag) | |
Defined in Language.Haskell.TH.Syntax | |
| Eq a => Eq (Maybe a) | |
| Eq a => Eq (Solo a) | |
Defined in GHC.Classes | |
| Eq a => Eq [a] | |
Defined in GHC.Classes | |
| (Ix ix, Eq e, IArray UArray e) => Eq (UArray ix e) | |
Defined in Data.Array.Base | |
| Eq (IOUArray i e) | |
Defined in Data.Array.IO.Internals | |
| (Eq a, Eq b) => Eq (Either a b) | |
| Eq (Fixed a) | |
Defined in Data.Fixed | |
| Eq (Proxy s) | |
Defined in Data.Proxy | |
| Eq a => Eq (Arg a b) | |
Defined in Data.Semigroup | |
| Eq (TypeRep a) | |
Defined in Data.Typeable.Internal | |
| (Ix i, Eq e) => Eq (Array i e) | |
| Eq (U1 p) | |
Defined in GHC.Generics | |
| Eq (V1 p) | |
Defined in GHC.Generics | |
| Eq (IOArray i e) | |
Defined in GHC.IOArray | |
| Eq (STRef s a) | |
| (Eq k, Eq a) => Eq (Map k a) | |
Defined in Data.Map.Internal | |
| (Eq1 m, Eq a) => Eq (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
| (Eq a, Eq b) => Eq (a, b) | |
Defined in GHC.Classes | |
| Eq (STUArray s i e) | |
Defined in Data.Array.Base | |
| Eq a => Eq (Const a b) | |
Defined in Data.Functor.Const | |
| Eq (f a) => Eq (Ap f a) | |
Defined in Data.Monoid | |
| Eq (Coercion a b) | |
Defined in Data.Type.Coercion | |
| Eq (a :~: b) | |
Defined in Data.Type.Equality | |
| Eq (OrderingI a b) | |
Defined in Data.Type.Ord | |
| Eq (STArray s i e) | |
| (Generic1 f, Eq (Rep1 f a)) => Eq (Generically1 f a) | |
Defined in GHC.Generics | |
| Eq (f p) => Eq (Rec1 f p) | |
Defined in GHC.Generics | |
| Eq (URec (Ptr ()) p) | |
Defined in GHC.Generics | |
| Eq (URec Char p) | |
| Eq (URec Double p) | |
| Eq (URec Float p) | |
| Eq (URec Int p) | |
| Eq (URec Word p) | |
| (Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except | |
| (Eq1 f, Eq a) => Eq (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity | |
| (Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| (Eq w, Eq1 m, Eq a) => Eq (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| (Eq a, Eq b, Eq c) => Eq (a, b, c) | |
Defined in GHC.Classes | |
| (Eq (f a), Eq (g a)) => Eq (Product f g a) | |
Defined in Data.Functor.Product | |
| (Eq (f a), Eq (g a)) => Eq (Sum f g a) | |
Defined in Data.Functor.Sum | |
| Eq (a :~~: b) | |
Defined in Data.Type.Equality | |
| (Eq (f p), Eq (g p)) => Eq ((f :*: g) p) | |
Defined in GHC.Generics | |
| (Eq (f p), Eq (g p)) => Eq ((f :+: g) p) | |
Defined in GHC.Generics | |
| Eq c => Eq (K1 i c p) | |
Defined in GHC.Generics | |
| (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
Defined in GHC.Classes | |
| Eq (f (g a)) => Eq (Compose f g a) | |
Defined in Data.Functor.Compose | |
| Eq (f (g p)) => Eq ((f :.: g) p) | |
Defined in GHC.Generics | |
| Eq (f p) => Eq (M1 i c f p) | |
Defined in GHC.Generics | |
| (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
Defined in GHC.Classes | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
Defined in GHC.Classes | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
Defined in GHC.Classes | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) | |
Defined in GHC.Classes | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) | |
Defined in GHC.Classes | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) | |
Defined in GHC.Classes | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) | |
Defined in GHC.Classes | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) | |
Defined in GHC.Classes | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
Defined in GHC.Classes | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
Defined in GHC.Classes | |
| (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Classes | |
class (Real a, Enum a) => Integral a where #
Methods
Instances
| Integral CBool | |
| Integral CChar | |
| Integral CInt | |
| Integral CIntMax | |
Defined in Foreign.C.Types | |
| Integral CIntPtr | |
Defined in Foreign.C.Types | |
| Integral CLLong | |
Defined in Foreign.C.Types | |
| Integral CLong | |
| Integral CPtrdiff | |
Defined in Foreign.C.Types | |
| Integral CSChar | |
Defined in Foreign.C.Types | |
| Integral CShort | |
Defined in Foreign.C.Types | |
| Integral CSigAtomic | |
Defined in Foreign.C.Types 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) # | |
| Integral CSize | |
| Integral CUChar | |
Defined in Foreign.C.Types | |
| Integral CUInt | |
| Integral CUIntMax | |
Defined in Foreign.C.Types | |
| Integral CUIntPtr | |
Defined in Foreign.C.Types | |
| Integral CULLong | |
Defined in Foreign.C.Types | |
| Integral CULong | |
Defined in Foreign.C.Types | |
| Integral CUShort | |
Defined in Foreign.C.Types | |
| Integral CWchar | |
Defined in Foreign.C.Types | |
| Integral IntPtr | |
| Integral WordPtr | |
Defined in Foreign.Ptr | |
| Integral Int16 | |
| Integral Int32 | |
| Integral Int64 | |
| Integral Int8 | |
| Integral Word16 | |
| Integral Word32 | |
| Integral Word64 | |
| Integral Word8 | |
| Integral CBlkCnt | |
Defined in System.Posix.Types | |
| Integral CBlkSize | |
Defined in System.Posix.Types | |
| Integral CClockId | |
Defined in System.Posix.Types | |
| Integral CDev | |
| Integral CFsBlkCnt | |
Defined in System.Posix.Types Methods quot :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # rem :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt # div :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt mod :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt quotRem :: CFsBlkCnt -> CFsBlkCnt -> (CFsBlkCnt, CFsBlkCnt) # divMod :: CFsBlkCnt -> CFsBlkCnt -> (CFsBlkCnt, CFsBlkCnt) # | |
| Integral CFsFilCnt | |
Defined in System.Posix.Types Methods quot :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # rem :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt # div :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt mod :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt quotRem :: CFsFilCnt -> CFsFilCnt -> (CFsFilCnt, CFsFilCnt) # divMod :: CFsFilCnt -> CFsFilCnt -> (CFsFilCnt, CFsFilCnt) # | |
| Integral CGid | |
| Integral CId | |
| Integral CIno | |
| Integral CKey | |
| Integral CMode | |
| Integral CNfds | |
| Integral CNlink | |
Defined in System.Posix.Types | |
| Integral COff | |
| Integral CPid | |
| Integral CRLim | |
| Integral CSocklen | |
Defined in System.Posix.Types | |
| Integral CSsize | |
Defined in System.Posix.Types | |
| Integral CTcflag | |
Defined in System.Posix.Types | |
| Integral CUid | |
| Integral Fd | |
| Integral Integer | |
Defined in GHC.Real | |
| Integral Natural | |
Defined in GHC.Real | |
| Integral Int | |
| Integral Word | |
| Integral a => Integral (Identity a) | |
Defined in Data.Functor.Identity 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) # | |
| Integral a => Integral (Const a b) | |
Defined in Data.Functor.Const Methods quot :: Const a b -> Const a b -> Const a b # rem :: Const a b -> Const a b -> Const a b # div :: Const a b -> Const a b -> Const a b mod :: Const a b -> Const a b -> Const a b quotRem :: Const a b -> Const a b -> (Const a b, Const a b) # divMod :: Const a b -> Const a b -> (Const a b, Const a b) # | |
| Integral (f (g a)) => Integral (Compose f g a) | |
Defined in Data.Functor.Compose Methods quot :: Compose f g a -> Compose f g a -> Compose f g a # rem :: Compose f g a -> Compose f g a -> Compose f g a # div :: Compose f g a -> Compose f g a -> Compose f g a mod :: Compose f g a -> Compose f g a -> Compose f g a quotRem :: Compose f g a -> Compose f g a -> (Compose f g a, Compose f g a) # divMod :: Compose f g a -> Compose f g a -> (Compose f g a, Compose f g a) # | |
Minimal complete definition
compare | (<=)
Instances
| Ord ByteArray | |
Defined in Data.Array.Byte | |
| Ord SomeTypeRep | |
Defined in Data.Typeable.Internal Methods compare :: SomeTypeRep -> SomeTypeRep -> Ordering # (<) :: SomeTypeRep -> SomeTypeRep -> Bool (<=) :: SomeTypeRep -> SomeTypeRep -> Bool (>) :: SomeTypeRep -> SomeTypeRep -> Bool (>=) :: SomeTypeRep -> SomeTypeRep -> Bool max :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep min :: SomeTypeRep -> SomeTypeRep -> SomeTypeRep | |
| Ord Unique | |
| Ord Version | |
| Ord CBool | |
| Ord CChar | |
| Ord CClock | |
| Ord CDouble | |
| Ord CFloat | |
| Ord CInt | |
| Ord CIntMax | |
| Ord CIntPtr | |
| Ord CLLong | |
| Ord CLong | |
| Ord CPtrdiff | |
| Ord CSChar | |
| Ord CSUSeconds | |
Defined in Foreign.C.Types 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 CShort | |
| Ord CSigAtomic | |
Defined in Foreign.C.Types 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 CSize | |
| Ord CTime | |
| Ord CUChar | |
| Ord CUInt | |
| Ord CUIntMax | |
| Ord CUIntPtr | |
| Ord CULLong | |
| Ord CULong | |
| Ord CUSeconds | |
Defined in Foreign.C.Types | |
| Ord CUShort | |
| Ord CWchar | |
| Ord IntPtr | |
| Ord WordPtr | |
| Ord Void | |
| Ord ByteOrder | |
Defined in GHC.ByteOrder | |
| Ord BlockReason | |
Defined in GHC.Conc.Sync 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 ThreadId | |
| Ord ThreadStatus | |
Defined in GHC.Conc.Sync 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 TimeoutKey | |
Defined in GHC.Event.TimeOut Methods compare :: TimeoutKey -> TimeoutKey -> Ordering # (<) :: TimeoutKey -> TimeoutKey -> Bool (<=) :: TimeoutKey -> TimeoutKey -> Bool (>) :: TimeoutKey -> TimeoutKey -> Bool (>=) :: TimeoutKey -> TimeoutKey -> Bool max :: TimeoutKey -> TimeoutKey -> TimeoutKey min :: TimeoutKey -> TimeoutKey -> TimeoutKey | |
| Ord ErrorCall | |
Defined in GHC.Exception | |
| Ord ArithException | |
Defined in GHC.Exception.Type 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 Fingerprint | |
Defined in GHC.Fingerprint.Type Methods compare :: Fingerprint -> Fingerprint -> Ordering # (<) :: Fingerprint -> Fingerprint -> Bool (<=) :: Fingerprint -> Fingerprint -> Bool (>) :: Fingerprint -> Fingerprint -> Bool (>=) :: Fingerprint -> Fingerprint -> Bool max :: Fingerprint -> Fingerprint -> Fingerprint min :: Fingerprint -> Fingerprint -> Fingerprint | |
| Ord Associativity | |
Defined in GHC.Generics 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 DecidedStrictness | |
Defined in GHC.Generics 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 Fixity | |
| Ord SourceStrictness | |
Defined in GHC.Generics 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 SourceUnpackedness | |
Defined in GHC.Generics 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 SeekMode | |
| Ord ArrayException | |
Defined in GHC.IO.Exception 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 AsyncException | |
Defined in GHC.IO.Exception 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 ExitCode | |
Defined in GHC.IO.Exception | |
| Ord BufferMode | |
Defined in GHC.IO.Handle.Types Methods compare :: BufferMode -> BufferMode -> Ordering # (<) :: BufferMode -> BufferMode -> Bool (<=) :: BufferMode -> BufferMode -> Bool (>) :: BufferMode -> BufferMode -> Bool (>=) :: BufferMode -> BufferMode -> Bool max :: BufferMode -> BufferMode -> BufferMode min :: BufferMode -> BufferMode -> BufferMode | |
| Ord Newline | |
| Ord NewlineMode | |
Defined in GHC.IO.Handle.Types Methods compare :: NewlineMode -> NewlineMode -> Ordering # (<) :: NewlineMode -> NewlineMode -> Bool (<=) :: NewlineMode -> NewlineMode -> Bool (>) :: NewlineMode -> NewlineMode -> Bool (>=) :: NewlineMode -> NewlineMode -> Bool max :: NewlineMode -> NewlineMode -> NewlineMode min :: NewlineMode -> NewlineMode -> NewlineMode | |
| Ord IOMode | |
| Ord Int16 | |
| Ord Int32 | |
| Ord Int64 | |
| Ord Int8 | |
| Ord SomeChar | |
| Ord SomeSymbol | |
Defined in GHC.TypeLits 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 SomeNat | |
| Ord GeneralCategory | |
Defined in GHC.Unicode 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 Word16 | |
| Ord Word32 | |
| Ord Word64 | |
| Ord Word8 | |
| Ord CBlkCnt | |
| Ord CBlkSize | |
Defined in System.Posix.Types | |
| Ord CCc | |
| Ord CClockId | |
Defined in System.Posix.Types | |
| Ord CDev | |
| Ord CFsBlkCnt | |
Defined in System.Posix.Types | |
| Ord CFsFilCnt | |
Defined in System.Posix.Types | |
| Ord CGid | |
| Ord CId | |
| Ord CIno | |
| Ord CKey | |
| Ord CMode | |
| Ord CNfds | |
| Ord CNlink | |
| Ord COff | |
| Ord CPid | |
| Ord CRLim | |
| Ord CSocklen | |
Defined in System.Posix.Types | |
| Ord CSpeed | |
| Ord CSsize | |
| Ord CTcflag | |
| Ord CTimer | |
| Ord CUid | |
| Ord Fd | |
| Ord IntSet | |
| Ord SolverId | |
Defined in Copilot.Theorem.Prover.SMT | |
| Ord BigNat | |
| Ord Extension | |
Defined in GHC.LanguageExtensions.Type | |
| Ord Ordering | |
| Ord TyCon | |
| Ord AnnLookup | |
Defined in Language.Haskell.TH.Syntax | |
| Ord AnnTarget | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Bang | |
| Ord BndrVis | |
| Ord Body | |
| Ord Bytes | |
| Ord Callconv | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Clause | |
| Ord Con | |
| Ord Dec | |
| Ord DecidedStrictness | |
Defined in Language.Haskell.TH.Syntax 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 DerivClause | |
Defined in Language.Haskell.TH.Syntax Methods compare :: DerivClause -> DerivClause -> Ordering # (<) :: DerivClause -> DerivClause -> Bool (<=) :: DerivClause -> DerivClause -> Bool (>) :: DerivClause -> DerivClause -> Bool (>=) :: DerivClause -> DerivClause -> Bool max :: DerivClause -> DerivClause -> DerivClause min :: DerivClause -> DerivClause -> DerivClause | |
| Ord DerivStrategy | |
Defined in Language.Haskell.TH.Syntax Methods compare :: DerivStrategy -> DerivStrategy -> Ordering # (<) :: DerivStrategy -> DerivStrategy -> Bool (<=) :: DerivStrategy -> DerivStrategy -> Bool (>) :: DerivStrategy -> DerivStrategy -> Bool (>=) :: DerivStrategy -> DerivStrategy -> Bool max :: DerivStrategy -> DerivStrategy -> DerivStrategy min :: DerivStrategy -> DerivStrategy -> DerivStrategy | |
| Ord DocLoc | |
| Ord Exp | |
| Ord FamilyResultSig | |
Defined in Language.Haskell.TH.Syntax 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 Fixity | |
| Ord FixityDirection | |
Defined in Language.Haskell.TH.Syntax 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 Foreign | |
| Ord FunDep | |
| Ord Guard | |
| Ord Info | |
| Ord InjectivityAnn | |
Defined in Language.Haskell.TH.Syntax 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 Inline | |
| Ord Lit | |
| Ord Loc | |
| Ord Match | |
| Ord ModName | |
| Ord Module | |
| Ord ModuleInfo | |
Defined in Language.Haskell.TH.Syntax 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 Name | |
| Ord NameFlavour | |
Defined in Language.Haskell.TH.Syntax 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 | |
Defined in Language.Haskell.TH.Syntax | |
| Ord OccName | |
| Ord Overlap | |
| Ord Pat | |
| Ord PatSynArgs | |
Defined in Language.Haskell.TH.Syntax Methods compare :: PatSynArgs -> PatSynArgs -> Ordering # (<) :: PatSynArgs -> PatSynArgs -> Bool (<=) :: PatSynArgs -> PatSynArgs -> Bool (>) :: PatSynArgs -> PatSynArgs -> Bool (>=) :: PatSynArgs -> PatSynArgs -> Bool max :: PatSynArgs -> PatSynArgs -> PatSynArgs min :: PatSynArgs -> PatSynArgs -> PatSynArgs | |
| Ord PatSynDir | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Phases | |
| Ord PkgName | |
| Ord Pragma | |
| Ord Range | |
| Ord Role | |
| Ord RuleBndr | |
Defined in Language.Haskell.TH.Syntax | |
| Ord RuleMatch | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Safety | |
| Ord SourceStrictness | |
Defined in Language.Haskell.TH.Syntax 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 SourceUnpackedness | |
Defined in Language.Haskell.TH.Syntax 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 Specificity | |
Defined in Language.Haskell.TH.Syntax Methods compare :: Specificity -> Specificity -> Ordering # (<) :: Specificity -> Specificity -> Bool (<=) :: Specificity -> Specificity -> Bool (>) :: Specificity -> Specificity -> Bool (>=) :: Specificity -> Specificity -> Bool max :: Specificity -> Specificity -> Specificity min :: Specificity -> Specificity -> Specificity | |
| Ord Stmt | |
| Ord TyLit | |
| Ord TySynEqn | |
Defined in Language.Haskell.TH.Syntax | |
| Ord Type | |
| Ord TypeFamilyHead | |
Defined in Language.Haskell.TH.Syntax 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 Integer | |
| Ord Natural | |
| Ord () | |
| Ord Bool | |
| Ord Char | |
| Ord Double | |
| Ord Float | |
| Ord Int | |
| Ord Word | |
| Ord a => Ord (ZipList a) | |
Defined in Control.Applicative | |
| Ord a => Ord (Identity a) | |
Defined in Data.Functor.Identity 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 (First a) | |
| Ord a => Ord (Last a) | |
| Ord a => Ord (Down a) | |
| Ord a => Ord (First a) | |
| Ord a => Ord (Last a) | |
| Ord a => Ord (Max a) | |
| Ord a => Ord (Min a) | |
| Ord m => Ord (WrappedMonoid m) | |
Defined in Data.Semigroup 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 (ConstPtr a) | |
Defined in Foreign.C.ConstPtr Methods compare :: ConstPtr a -> ConstPtr a -> Ordering # (<) :: ConstPtr a -> ConstPtr a -> Bool (<=) :: ConstPtr a -> ConstPtr a -> Bool (>) :: ConstPtr a -> ConstPtr a -> Bool (>=) :: ConstPtr a -> ConstPtr a -> Bool max :: ConstPtr a -> ConstPtr a -> ConstPtr a min :: ConstPtr a -> ConstPtr a -> ConstPtr a | |
| Ord a => Ord (NonEmpty a) | |
Defined in GHC.Base 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 (ForeignPtr a) | |
Defined in GHC.ForeignPtr Methods compare :: ForeignPtr a -> ForeignPtr a -> Ordering # (<) :: ForeignPtr a -> ForeignPtr a -> Bool (<=) :: ForeignPtr a -> ForeignPtr a -> Bool (>) :: ForeignPtr a -> ForeignPtr a -> Bool (>=) :: ForeignPtr a -> ForeignPtr a -> Bool max :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a min :: ForeignPtr a -> ForeignPtr a -> ForeignPtr a | |
| Ord p => Ord (Par1 p) | |
| Ord (FunPtr a) | |
| Ord (Ptr a) | |
| Integral a => Ord (Ratio a) | |
| Ord (SChar c) | |
| Ord (SSymbol s) | |
Defined in GHC.TypeLits | |
| Ord (SNat n) | |
| Ord a => Ord (IntMap a) | |
Defined in Data.IntMap.Internal | |
| Ord a => Ord (Seq a) | |
| Ord a => Ord (ViewL a) | |
| Ord a => Ord (ViewR a) | |
| Ord a => Ord (Intersection a) | |
Defined in Data.Set.Internal Methods compare :: Intersection a -> Intersection a -> Ordering # (<) :: Intersection a -> Intersection a -> Bool (<=) :: Intersection a -> Intersection a -> Bool (>) :: Intersection a -> Intersection a -> Bool (>=) :: Intersection a -> Intersection a -> Bool max :: Intersection a -> Intersection a -> Intersection a min :: Intersection a -> Intersection a -> Intersection a | |
| Ord a => Ord (Set a) | |
| Ord a => Ord (Tree a) | |
| Ord flag => Ord (TyVarBndr flag) | |
Defined in Language.Haskell.TH.Syntax Methods compare :: TyVarBndr flag -> TyVarBndr flag -> Ordering # (<) :: TyVarBndr flag -> TyVarBndr flag -> Bool (<=) :: TyVarBndr flag -> TyVarBndr flag -> Bool (>) :: TyVarBndr flag -> TyVarBndr flag -> Bool (>=) :: TyVarBndr flag -> TyVarBndr flag -> Bool max :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag min :: TyVarBndr flag -> TyVarBndr flag -> TyVarBndr flag | |
| Ord a => Ord (Maybe a) | |
| Ord a => Ord (Solo a) | |
| Ord a => Ord [a] | |
| (Ix ix, Ord e, IArray UArray e) => Ord (UArray ix e) | |
Defined in Data.Array.Base Methods compare :: UArray ix e -> UArray ix e -> Ordering # (<) :: UArray ix e -> UArray ix e -> Bool (<=) :: UArray ix e -> UArray ix e -> Bool (>) :: UArray ix e -> UArray ix e -> Bool (>=) :: UArray ix e -> UArray ix e -> Bool max :: UArray ix e -> UArray ix e -> UArray ix e min :: UArray ix e -> UArray ix e -> UArray ix e | |
| (Ord a, Ord b) => Ord (Either a b) | |
| Ord (Fixed a) | |
| Ord (Proxy s) | |
| Ord a => Ord (Arg a b) | |
| Ord (TypeRep a) | |
Defined in Data.Typeable.Internal | |
| (Ix i, Ord e) => Ord (Array i e) | |
Defined in GHC.Arr | |
| Ord (U1 p) | |
| Ord (V1 p) | |
| (Ord k, Ord v) => Ord (Map k v) | |
| (Ord1 m, Ord a) => Ord (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe 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 | |
| (Ord a, Ord b) => Ord (a, b) | |
| Ord a => Ord (Const a b) | |
Defined in Data.Functor.Const | |
| Ord (f a) => Ord (Ap f a) | |
| Ord (Coercion a b) | |
Defined in Data.Type.Coercion Methods compare :: Coercion a b -> Coercion a b -> Ordering # (<) :: Coercion a b -> Coercion a b -> Bool (<=) :: Coercion a b -> Coercion a b -> Bool (>) :: Coercion a b -> Coercion a b -> Bool (>=) :: Coercion a b -> Coercion a b -> Bool max :: Coercion a b -> Coercion a b -> Coercion a b min :: Coercion a b -> Coercion a b -> Coercion a b | |
| Ord (a :~: b) | |
Defined in Data.Type.Equality | |
| (Generic1 f, Ord (Rep1 f a)) => Ord (Generically1 f a) | |
Defined in GHC.Generics Methods compare :: Generically1 f a -> Generically1 f a -> Ordering # (<) :: Generically1 f a -> Generically1 f a -> Bool (<=) :: Generically1 f a -> Generically1 f a -> Bool (>) :: Generically1 f a -> Generically1 f a -> Bool (>=) :: Generically1 f a -> Generically1 f a -> Bool max :: Generically1 f a -> Generically1 f a -> Generically1 f a min :: Generically1 f a -> Generically1 f a -> Generically1 f a | |
| Ord (f p) => Ord (Rec1 f p) | |
| Ord (URec (Ptr ()) p) | |
Defined in GHC.Generics 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 (URec Char p) | |
| Ord (URec Double p) | |
Defined in GHC.Generics | |
| Ord (URec Float p) | |
Defined in GHC.Generics | |
| Ord (URec Int p) | |
| Ord (URec Word p) | |
| (Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except 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 | |
| (Ord1 f, Ord a) => Ord (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity 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 w, Ord1 m, Ord a) => Ord (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy 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) | |
Defined in Control.Monad.Trans.Writer.Strict 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 a, Ord b, Ord c) => Ord (a, b, c) | |
Defined in GHC.Classes | |
| (Ord (f a), Ord (g a)) => Ord (Product f g a) | |
Defined in Data.Functor.Product Methods compare :: Product f g a -> Product f g a -> Ordering # (<) :: Product f g a -> Product f g a -> Bool (<=) :: Product f g a -> Product f g a -> Bool (>) :: Product f g a -> Product f g a -> Bool (>=) :: Product f g a -> Product f g a -> Bool max :: Product f g a -> Product f g a -> Product f g a min :: Product f g a -> Product f g a -> Product f g a | |
| (Ord (f a), Ord (g a)) => Ord (Sum f g a) | |
Defined in Data.Functor.Sum | |
| Ord (a :~~: b) | |
Defined in Data.Type.Equality 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 (f p), Ord (g p)) => Ord ((f :*: g) p) | |
Defined in GHC.Generics 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) | |
Defined in GHC.Generics 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 c => Ord (K1 i c p) | |
| (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | |
Defined in GHC.Classes 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 (f (g a)) => Ord (Compose f g a) | |
Defined in Data.Functor.Compose Methods compare :: Compose f g a -> Compose f g a -> Ordering # (<) :: Compose f g a -> Compose f g a -> Bool (<=) :: Compose f g a -> Compose f g a -> Bool (>) :: Compose f g a -> Compose f g a -> Bool (>=) :: Compose f g a -> Compose f g a -> Bool max :: Compose f g a -> Compose f g a -> Compose f g a min :: Compose f g a -> Compose f g a -> Compose f g a | |
| Ord (f (g p)) => Ord ((f :.: g) p) | |
Defined in GHC.Generics 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 (M1 i c f p) | |
Defined in GHC.Generics 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 e) => Ord (a, b, c, d, e) | |
Defined in GHC.Classes 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) | |
Defined in GHC.Classes 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) | |
Defined in GHC.Classes 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) | |
Defined in GHC.Classes 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) | |
Defined in GHC.Classes 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) | |
Defined in GHC.Classes 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) | |
Defined in GHC.Classes 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) | |
Defined in GHC.Classes 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) | |
Defined in GHC.Classes 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) | |
Defined in GHC.Classes 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) | |
Defined in GHC.Classes 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) | |
Methods
fromInteger :: Integer -> a #
Instances
| Num CBool | |
| Num CChar | |
| Num CClock | |
| Num CDouble | |
| Num CFloat | |
| Num CInt | |
| Num CIntMax | |
| Num CIntPtr | |
| Num CLLong | |
| Num CLong | |
| Num CPtrdiff | |
| Num CSChar | |
| Num CSUSeconds | |
Defined in Foreign.C.Types | |
| Num CShort | |
| Num CSigAtomic | |
Defined in Foreign.C.Types | |
| Num CSize | |
| Num CTime | |
| Num CUChar | |
| Num CUInt | |
| Num CUIntMax | |
| Num CUIntPtr | |
| Num CULLong | |
| Num CULong | |
| Num CUSeconds | |
Defined in Foreign.C.Types | |
| Num CUShort | |
| Num CWchar | |
| Num IntPtr | |
| Num WordPtr | |
| Num Int16 | |
| Num Int32 | |
| Num Int64 | |
| Num Int8 | |
| Num Word16 | |
| Num Word32 | |
| Num Word64 | |
| Num Word8 | |
| Num CBlkCnt | |
| Num CBlkSize | |
| Num CCc | |
| Num CClockId | |
| Num CDev | |
| Num CFsBlkCnt | |
Defined in System.Posix.Types | |
| Num CFsFilCnt | |
Defined in System.Posix.Types | |
| Num CGid | |
| Num CId | |
| Num CIno | |
| Num CKey | |
| Num CMode | |
| Num CNfds | |
| Num CNlink | |
| Num COff | |
| Num CPid | |
| Num CRLim | |
| Num CSocklen | |
| Num CSpeed | |
| Num CSsize | |
| Num CTcflag | |
| Num CUid | |
| Num Fd | |
| Num Integer | |
| Num Natural | |
| Num Int | |
| Num Word | |
| RealFloat a => Num (Complex a) | |
| Num a => Num (Identity a) | |
Defined in Data.Functor.Identity | |
| Num a => Num (Down a) | |
| Num a => Num (Max a) | |
| Num a => Num (Min a) | |
| Integral a => Num (Ratio a) | |
| (Typed a, Eq a, Num a) => Num (Stream a) Source # | Streams carrying numbers are instances of |
| HasResolution a => Num (Fixed a) | |
| Num a => Num (Op a b) | |
| Num a => Num (Const a b) | |
Defined in Data.Functor.Const | |
| (Applicative f, Num a) => Num (Ap f a) | |
| Num (f (g a)) => Num (Compose f g a) | |
Defined in Data.Functor.Compose Methods (+) :: Compose f g a -> Compose f g a -> Compose f g a # (-) :: Compose f g a -> Compose f g a -> Compose f g a # (*) :: Compose f g a -> Compose f g a -> Compose f g a # negate :: Compose f g a -> Compose f g a # abs :: Compose f g a -> Compose f g a # signum :: Compose f g a -> Compose f g a # fromInteger :: Integer -> Compose f g a # | |
class Applicative m => Monad (m :: Type -> Type) where #
Minimal complete definition
Instances
| Monad Complex | |
| Monad Identity | |
| Monad First | |
| Monad Last | |
| Monad Down | |
| Monad First | |
| Monad Last | |
| Monad Max | |
| Monad Min | |
| Monad NonEmpty | |
| Monad STM | |
| Monad NoIO | |
| Monad Par1 | |
| Monad P | |
| Monad ReadP | |
| Monad ReadPrec | |
| Monad Seq | |
| Monad Tree | |
| Monad IO | |
| Monad Q | |
| Monad Maybe | |
| Monad Solo | |
| Monad [] | |
| Monad m => Monad (WrappedMonad m) | |
| ArrowApply a => Monad (ArrowMonad a) | |
| Monad (Either e) | |
| Monad (Proxy :: Type -> Type) | |
| Monad (U1 :: Type -> Type) | |
| Monad (ST s) | |
| Monad (SetM s) | |
| Monad (ProofScheme a) | |
| Monad m => Monad (MaybeT m) | |
| Monoid a => Monad ((,) a) | |
| Monad m => Monad (Kleisli m a) | |
| Monad f => Monad (Ap f) | |
| Monad f => Monad (Rec1 f) | |
| (Applicative f, Monad f) => Monad (WhenMissing f x) | |
| Monad (t m) => Monad (LiftingAccum t m) | |
| Monad (t m) => Monad (LiftingSelect t m) | |
| (Monoid w, Functor m, Monad m) => Monad (AccumT w m) | |
| Monad m => Monad (ExceptT e m) | |
| Monad m => Monad (IdentityT m) | |
| Monad m => Monad (ReaderT r m) | |
| Monad m => Monad (StateT s m) | |
| Monad m => Monad (StateT s m) | |
| Monad m => Monad (WriterT w m) | |
| (Monoid w, Monad m) => Monad (WriterT w m) | |
| (Monoid w, Monad m) => Monad (WriterT w m) | |
| (Monoid a, Monoid b) => Monad ((,,) a b) | |
| (Monad f, Monad g) => Monad (Product f g) | |
| (Monad f, Monad g) => Monad (f :*: g) | |
| (Monad f, Applicative f) => Monad (WhenMatched f x y) | |
| (Applicative f, Monad f) => Monad (WhenMissing f k x) | |
| (Monoid a, Monoid b, Monoid c) => Monad ((,,,) a b c) | |
| Monad ((->) r) | |
| Monad f => Monad (M1 i c f) | |
| (Monad f, Applicative f) => Monad (WhenMatched f k x y) | |
| Monad m => Monad (RWST r w s m) | |
| (Monoid w, Monad m) => Monad (RWST r w s m) | |
| (Monoid w, Monad m) => Monad (RWST r w s m) | |
class (Real a, Fractional a) => RealFrac a where #
Minimal complete definition
Methods
properFraction :: Integral b => a -> (b, a) #
truncate :: Integral b => a -> b #
round :: Integral b => a -> b #
class (RealFrac a, Floating a) => RealFloat a where #
Minimal complete definition
floatRadix, floatDigits, floatRange, decodeFloat, encodeFloat, isNaN, isInfinite, isDenormalized, isNegativeZero, isIEEE
Methods
floatRadix :: a -> Integer #
floatDigits :: a -> Int #
floatRange :: a -> (Int, Int) #
decodeFloat :: a -> (Integer, Int) #
encodeFloat :: Integer -> Int -> a #
significand :: a -> a #
scaleFloat :: Int -> a -> a #
isInfinite :: a -> Bool #
isDenormalized :: a -> Bool #
isNegativeZero :: a -> Bool #
Instances
class Foldable (t :: Type -> Type) where #
Methods
foldMap :: Monoid m => (a -> m) -> t a -> m #
foldr :: (a -> b -> b) -> b -> t a -> b #
foldl :: (b -> a -> b) -> b -> t a -> b #
foldr1 :: (a -> a -> a) -> t a -> a #
foldl1 :: (a -> a -> a) -> t a -> a #
elem :: Eq a => a -> t a -> Bool #
maximum :: Ord a => t a -> a #
Instances
| Foldable ZipList | |
Defined in Control.Applicative Methods fold :: Monoid m => ZipList m -> m foldMap :: Monoid m => (a -> m) -> ZipList a -> m # foldMap' :: Monoid m => (a -> m) -> ZipList a -> m foldr :: (a -> b -> b) -> b -> ZipList a -> b # foldr' :: (a -> b -> b) -> b -> ZipList a -> b foldl :: (b -> a -> b) -> b -> ZipList a -> b # foldl' :: (b -> a -> b) -> b -> ZipList a -> b foldr1 :: (a -> a -> a) -> ZipList a -> a # foldl1 :: (a -> a -> a) -> ZipList a -> a # toList :: ZipList a -> [a] elem :: Eq a => a -> ZipList a -> Bool # maximum :: Ord a => ZipList a -> a # minimum :: Ord a => ZipList a -> a # | |
| Foldable Complex | |
Defined in Data.Complex Methods fold :: Monoid m => Complex m -> m foldMap :: Monoid m => (a -> m) -> Complex a -> 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] elem :: Eq a => a -> Complex a -> Bool # maximum :: Ord a => Complex a -> a # minimum :: Ord a => Complex a -> a # | |
| Foldable Identity | |
Defined in Data.Functor.Identity Methods fold :: Monoid m => Identity m -> m foldMap :: Monoid m => (a -> m) -> Identity a -> m # foldMap' :: Monoid m => (a -> m) -> Identity a -> m foldr :: (a -> b -> b) -> b -> Identity a -> b # foldr' :: (a -> b -> b) -> b -> Identity a -> b foldl :: (b -> a -> b) -> b -> Identity a -> b # foldl' :: (b -> a -> b) -> b -> Identity a -> b foldr1 :: (a -> a -> a) -> Identity a -> a # foldl1 :: (a -> a -> a) -> Identity a -> a # toList :: Identity a -> [a] elem :: Eq a => a -> Identity a -> Bool # maximum :: Ord a => Identity a -> a # minimum :: Ord a => Identity a -> a # | |
| Foldable First | |
Defined in Data.Foldable Methods fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # | |
| Foldable Last | |
Defined in Data.Foldable Methods fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
| Foldable Down | |
Defined in Data.Foldable Methods fold :: Monoid m => Down m -> m foldMap :: Monoid m => (a -> m) -> Down a -> m # foldMap' :: Monoid m => (a -> m) -> Down a -> m foldr :: (a -> b -> b) -> b -> Down a -> b # foldr' :: (a -> b -> b) -> b -> Down a -> b foldl :: (b -> a -> b) -> b -> Down a -> b # foldl' :: (b -> a -> b) -> b -> Down a -> b foldr1 :: (a -> a -> a) -> Down a -> a # foldl1 :: (a -> a -> a) -> Down a -> a # toList :: Down a -> [a] elem :: Eq a => a -> Down a -> Bool # maximum :: Ord a => Down a -> a # | |
| Foldable First | |
Defined in Data.Semigroup Methods fold :: Monoid m => First m -> m foldMap :: Monoid m => (a -> m) -> First a -> m # foldMap' :: Monoid m => (a -> m) -> First a -> m foldr :: (a -> b -> b) -> b -> First a -> b # foldr' :: (a -> b -> b) -> b -> First a -> b foldl :: (b -> a -> b) -> b -> First a -> b # foldl' :: (b -> a -> b) -> b -> First a -> b foldr1 :: (a -> a -> a) -> First a -> a # foldl1 :: (a -> a -> a) -> First a -> a # toList :: First a -> [a] elem :: Eq a => a -> First a -> Bool # maximum :: Ord a => First a -> a # | |
| Foldable Last | |
Defined in Data.Semigroup Methods fold :: Monoid m => Last m -> m foldMap :: Monoid m => (a -> m) -> Last a -> m # foldMap' :: Monoid m => (a -> m) -> Last a -> m foldr :: (a -> b -> b) -> b -> Last a -> b # foldr' :: (a -> b -> b) -> b -> Last a -> b foldl :: (b -> a -> b) -> b -> Last a -> b # foldl' :: (b -> a -> b) -> b -> Last a -> b foldr1 :: (a -> a -> a) -> Last a -> a # foldl1 :: (a -> a -> a) -> Last a -> a # toList :: Last a -> [a] elem :: Eq a => a -> Last a -> Bool # maximum :: Ord a => Last a -> a # | |
| Foldable Max | |
Defined in Data.Semigroup Methods fold :: Monoid m => Max m -> m foldMap :: Monoid m => (a -> m) -> Max a -> m # foldMap' :: Monoid m => (a -> m) -> Max a -> m foldr :: (a -> b -> b) -> b -> Max a -> b # foldr' :: (a -> b -> b) -> b -> Max a -> b foldl :: (b -> a -> b) -> b -> Max a -> b # foldl' :: (b -> a -> b) -> b -> Max a -> b foldr1 :: (a -> a -> a) -> Max a -> a # foldl1 :: (a -> a -> a) -> Max a -> a # toList :: Max a -> [a] elem :: Eq a => a -> Max a -> Bool # maximum :: Ord a => Max a -> a # | |
| Foldable Min | |
Defined in Data.Semigroup Methods fold :: Monoid m => Min m -> m foldMap :: Monoid m => (a -> m) -> Min a -> m # foldMap' :: Monoid m => (a -> m) -> Min a -> m foldr :: (a -> b -> b) -> b -> Min a -> b # foldr' :: (a -> b -> b) -> b -> Min a -> b foldl :: (b -> a -> b) -> b -> Min a -> b # foldl' :: (b -> a -> b) -> b -> Min a -> b foldr1 :: (a -> a -> a) -> Min a -> a # foldl1 :: (a -> a -> a) -> Min a -> a # toList :: Min a -> [a] elem :: Eq a => a -> Min a -> Bool # maximum :: Ord a => Min a -> a # | |
| Foldable Dual | |
Defined in Data.Foldable Methods fold :: Monoid m => Dual m -> m foldMap :: Monoid m => (a -> m) -> Dual a -> m # foldMap' :: Monoid m => (a -> m) -> Dual a -> m foldr :: (a -> b -> b) -> b -> Dual a -> b # foldr' :: (a -> b -> b) -> b -> Dual a -> b foldl :: (b -> a -> b) -> b -> Dual a -> b # foldl' :: (b -> a -> b) -> b -> Dual a -> b foldr1 :: (a -> a -> a) -> Dual a -> a # foldl1 :: (a -> a -> a) -> Dual a -> a # toList :: Dual a -> [a] elem :: Eq a => a -> Dual a -> Bool # maximum :: Ord a => Dual a -> a # | |
| Foldable Product | |
Defined in Data.Foldable Methods fold :: Monoid m => Product m -> m foldMap :: Monoid m => (a -> m) -> Product a -> m # foldMap' :: Monoid m => (a -> m) -> Product a -> m foldr :: (a -> b -> b) -> b -> Product a -> b # foldr' :: (a -> b -> b) -> b -> Product a -> b foldl :: (b -> a -> b) -> b -> Product a -> b # foldl' :: (b -> a -> b) -> b -> Product a -> b foldr1 :: (a -> a -> a) -> Product a -> a # foldl1 :: (a -> a -> a) -> Product a -> a # toList :: Product a -> [a] elem :: Eq a => a -> Product a -> Bool # maximum :: Ord a => Product a -> a # minimum :: Ord a => Product a -> a # | |
| Foldable Sum | |
Defined in Data.Foldable Methods fold :: Monoid m => Sum m -> m foldMap :: Monoid m => (a -> m) -> Sum a -> m # foldMap' :: Monoid m => (a -> m) -> Sum a -> m foldr :: (a -> b -> b) -> b -> Sum a -> b # foldr' :: (a -> b -> b) -> b -> Sum a -> b foldl :: (b -> a -> b) -> b -> Sum a -> b # foldl' :: (b -> a -> b) -> b -> Sum a -> b foldr1 :: (a -> a -> a) -> Sum a -> a # foldl1 :: (a -> a -> a) -> Sum a -> a # toList :: Sum a -> [a] elem :: Eq a => a -> Sum a -> Bool # maximum :: Ord a => Sum a -> a # | |
| Foldable NonEmpty | |
Defined in Data.Foldable Methods fold :: Monoid m => NonEmpty m -> m foldMap :: Monoid m => (a -> m) -> NonEmpty a -> m # foldMap' :: Monoid m => (a -> m) -> NonEmpty a -> m foldr :: (a -> b -> b) -> b -> NonEmpty a -> b # foldr' :: (a -> b -> b) -> b -> NonEmpty a -> b foldl :: (b -> a -> b) -> b -> NonEmpty a -> b # foldl' :: (b -> a -> b) -> b -> NonEmpty a -> b foldr1 :: (a -> a -> a) -> NonEmpty a -> a # foldl1 :: (a -> a -> a) -> NonEmpty a -> a # toList :: NonEmpty a -> [a] elem :: Eq a => a -> NonEmpty a -> Bool # maximum :: Ord a => NonEmpty a -> a # minimum :: Ord a => NonEmpty a -> a # | |
| Foldable Par1 | |
Defined in Data.Foldable Methods fold :: Monoid m => Par1 m -> m foldMap :: Monoid m => (a -> m) -> Par1 a -> m # foldMap' :: Monoid m => (a -> m) -> Par1 a -> m foldr :: (a -> b -> b) -> b -> Par1 a -> b # foldr' :: (a -> b -> b) -> b -> Par1 a -> b foldl :: (b -> a -> b) -> b -> Par1 a -> b # foldl' :: (b -> a -> b) -> b -> Par1 a -> b foldr1 :: (a -> a -> a) -> Par1 a -> a # foldl1 :: (a -> a -> a) -> Par1 a -> a # toList :: Par1 a -> [a] elem :: Eq a => a -> Par1 a -> Bool # maximum :: Ord a => Par1 a -> a # | |
| Foldable SCC | |
Defined in Data.Graph Methods fold :: Monoid m => SCC m -> m foldMap :: Monoid m => (a -> m) -> SCC a -> m # foldMap' :: Monoid m => (a -> m) -> SCC a -> m foldr :: (a -> b -> b) -> b -> SCC a -> b # foldr' :: (a -> b -> b) -> b -> SCC a -> b foldl :: (b -> a -> b) -> b -> SCC a -> b # foldl' :: (b -> a -> b) -> b -> SCC a -> b foldr1 :: (a -> a -> a) -> SCC a -> a # foldl1 :: (a -> a -> a) -> SCC a -> a # toList :: SCC a -> [a] elem :: Eq a => a -> SCC a -> Bool # maximum :: Ord a => SCC a -> a # | |
| Foldable IntMap | |
Defined in Data.IntMap.Internal Methods fold :: Monoid m => IntMap m -> m foldMap :: Monoid m => (a -> m) -> IntMap a -> m # foldMap' :: Monoid m => (a -> m) -> IntMap a -> m foldr :: (a -> b -> b) -> b -> IntMap a -> b # foldr' :: (a -> b -> b) -> b -> IntMap a -> b foldl :: (b -> a -> b) -> b -> IntMap a -> b # foldl' :: (b -> a -> b) -> b -> IntMap a -> b foldr1 :: (a -> a -> a) -> IntMap a -> a # foldl1 :: (a -> a -> a) -> IntMap a -> a # toList :: IntMap a -> [a] elem :: Eq a => a -> IntMap a -> Bool # maximum :: Ord a => IntMap a -> a # | |
| Foldable Digit | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Digit m -> m foldMap :: Monoid m => (a -> m) -> Digit a -> m # foldMap' :: Monoid m => (a -> m) -> Digit a -> m foldr :: (a -> b -> b) -> b -> Digit a -> b # foldr' :: (a -> b -> b) -> b -> Digit a -> b foldl :: (b -> a -> b) -> b -> Digit a -> b # foldl' :: (b -> a -> b) -> b -> Digit a -> b foldr1 :: (a -> a -> a) -> Digit a -> a # foldl1 :: (a -> a -> a) -> Digit a -> a # toList :: Digit a -> [a] elem :: Eq a => a -> Digit a -> Bool # maximum :: Ord a => Digit a -> a # | |
| Foldable Elem | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Elem m -> m foldMap :: Monoid m => (a -> m) -> Elem a -> m # foldMap' :: Monoid m => (a -> m) -> Elem a -> m foldr :: (a -> b -> b) -> b -> Elem a -> b # foldr' :: (a -> b -> b) -> b -> Elem a -> b foldl :: (b -> a -> b) -> b -> Elem a -> b # foldl' :: (b -> a -> b) -> b -> Elem a -> b foldr1 :: (a -> a -> a) -> Elem a -> a # foldl1 :: (a -> a -> a) -> Elem a -> a # toList :: Elem a -> [a] elem :: Eq a => a -> Elem a -> Bool # maximum :: Ord a => Elem a -> a # | |
| Foldable FingerTree | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => FingerTree m -> m foldMap :: Monoid m => (a -> m) -> FingerTree a -> m # foldMap' :: Monoid m => (a -> m) -> FingerTree a -> m foldr :: (a -> b -> b) -> b -> FingerTree a -> b # foldr' :: (a -> b -> b) -> b -> FingerTree a -> b foldl :: (b -> a -> b) -> b -> FingerTree a -> b # foldl' :: (b -> a -> b) -> b -> FingerTree a -> b foldr1 :: (a -> a -> a) -> FingerTree a -> a # foldl1 :: (a -> a -> a) -> FingerTree a -> a # toList :: FingerTree a -> [a] null :: FingerTree a -> Bool # length :: FingerTree a -> Int # elem :: Eq a => a -> FingerTree a -> Bool # maximum :: Ord a => FingerTree a -> a # minimum :: Ord a => FingerTree a -> a # | |
| Foldable Node | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Node m -> m foldMap :: Monoid m => (a -> m) -> Node a -> m # foldMap' :: Monoid m => (a -> m) -> Node a -> m foldr :: (a -> b -> b) -> b -> Node a -> b # foldr' :: (a -> b -> b) -> b -> Node a -> b foldl :: (b -> a -> b) -> b -> Node a -> b # foldl' :: (b -> a -> b) -> b -> Node a -> b foldr1 :: (a -> a -> a) -> Node a -> a # foldl1 :: (a -> a -> a) -> Node a -> a # toList :: Node a -> [a] elem :: Eq a => a -> Node a -> Bool # maximum :: Ord a => Node a -> a # | |
| Foldable Seq | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => Seq m -> m foldMap :: Monoid m => (a -> m) -> Seq a -> m # foldMap' :: Monoid m => (a -> m) -> Seq a -> m foldr :: (a -> b -> b) -> b -> Seq a -> b # foldr' :: (a -> b -> b) -> b -> Seq a -> b foldl :: (b -> a -> b) -> b -> Seq a -> b # foldl' :: (b -> a -> b) -> b -> Seq a -> b foldr1 :: (a -> a -> a) -> Seq a -> a # foldl1 :: (a -> a -> a) -> Seq a -> a # toList :: Seq a -> [a] elem :: Eq a => a -> Seq a -> Bool # maximum :: Ord a => Seq a -> a # | |
| Foldable ViewL | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewL m -> m foldMap :: Monoid m => (a -> m) -> ViewL a -> m # foldMap' :: Monoid m => (a -> m) -> ViewL a -> m foldr :: (a -> b -> b) -> b -> ViewL a -> b # foldr' :: (a -> b -> b) -> b -> ViewL a -> b foldl :: (b -> a -> b) -> b -> ViewL a -> b # foldl' :: (b -> a -> b) -> b -> ViewL a -> b foldr1 :: (a -> a -> a) -> ViewL a -> a # foldl1 :: (a -> a -> a) -> ViewL a -> a # toList :: ViewL a -> [a] elem :: Eq a => a -> ViewL a -> Bool # maximum :: Ord a => ViewL a -> a # | |
| Foldable ViewR | |
Defined in Data.Sequence.Internal Methods fold :: Monoid m => ViewR m -> m foldMap :: Monoid m => (a -> m) -> ViewR a -> m # foldMap' :: Monoid m => (a -> m) -> ViewR a -> m foldr :: (a -> b -> b) -> b -> ViewR a -> b # foldr' :: (a -> b -> b) -> b -> ViewR a -> b foldl :: (b -> a -> b) -> b -> ViewR a -> b # foldl' :: (b -> a -> b) -> b -> ViewR a -> b foldr1 :: (a -> a -> a) -> ViewR a -> a # foldl1 :: (a -> a -> a) -> ViewR a -> a # toList :: ViewR a -> [a] elem :: Eq a => a -> ViewR a -> Bool # maximum :: Ord a => ViewR a -> a # | |
| Foldable Set | |
Defined in Data.Set.Internal Methods fold :: Monoid m => Set m -> m foldMap :: Monoid m => (a -> m) -> Set a -> m # foldMap' :: Monoid m => (a -> m) -> Set a -> m foldr :: (a -> b -> b) -> b -> Set a -> b # foldr' :: (a -> b -> b) -> b -> Set a -> b foldl :: (b -> a -> b) -> b -> Set a -> b # foldl' :: (b -> a -> b) -> b -> Set a -> b foldr1 :: (a -> a -> a) -> Set a -> a # foldl1 :: (a -> a -> a) -> Set a -> a # toList :: Set a -> [a] elem :: Eq a => a -> Set a -> Bool # maximum :: Ord a => Set a -> a # | |
| Foldable Tree | |
Defined in Data.Tree Methods fold :: Monoid m => Tree m -> m foldMap :: Monoid m => (a -> m) -> Tree a -> m # foldMap' :: Monoid m => (a -> m) -> Tree a -> m foldr :: (a -> b -> b) -> b -> Tree a -> b # foldr' :: (a -> b -> b) -> b -> Tree a -> b foldl :: (b -> a -> b) -> b -> Tree a -> b # foldl' :: (b -> a -> b) -> b -> Tree a -> b foldr1 :: (a -> a -> a) -> Tree a -> a # foldl1 :: (a -> a -> a) -> Tree a -> a # toList :: Tree a -> [a] elem :: Eq a => a -> Tree a -> Bool # maximum :: Ord a => Tree a -> a # | |
| Foldable TyVarBndr | |
Defined in Language.Haskell.TH.Syntax Methods fold :: Monoid m => TyVarBndr m -> m foldMap :: Monoid m => (a -> m) -> TyVarBndr a -> m # foldMap' :: Monoid m => (a -> m) -> TyVarBndr a -> m foldr :: (a -> b -> b) -> b -> TyVarBndr a -> b # foldr' :: (a -> b -> b) -> b -> TyVarBndr a -> b foldl :: (b -> a -> b) -> b -> TyVarBndr a -> b # foldl' :: (b -> a -> b) -> b -> TyVarBndr a -> b foldr1 :: (a -> a -> a) -> TyVarBndr a -> a # foldl1 :: (a -> a -> a) -> TyVarBndr a -> a # toList :: TyVarBndr a -> [a] length :: TyVarBndr a -> Int # elem :: Eq a => a -> TyVarBndr a -> Bool # maximum :: Ord a => TyVarBndr a -> a # minimum :: Ord a => TyVarBndr a -> a # | |
| Foldable Maybe | |
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # | |
| Foldable Solo | |
Defined in Data.Foldable Methods fold :: Monoid m => Solo m -> m foldMap :: Monoid m => (a -> m) -> Solo a -> m # foldMap' :: Monoid m => (a -> m) -> Solo a -> m foldr :: (a -> b -> b) -> b -> Solo a -> b # foldr' :: (a -> b -> b) -> b -> Solo a -> b foldl :: (b -> a -> b) -> b -> Solo a -> b # foldl' :: (b -> a -> b) -> b -> Solo a -> b foldr1 :: (a -> a -> a) -> Solo a -> a # foldl1 :: (a -> a -> a) -> Solo a -> a # toList :: Solo a -> [a] elem :: Eq a => a -> Solo a -> Bool # maximum :: Ord a => Solo a -> a # | |
| Foldable [] | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> [a] -> m # foldMap' :: Monoid m => (a -> m) -> [a] -> m foldr :: (a -> b -> b) -> b -> [a] -> b # foldr' :: (a -> b -> b) -> b -> [a] -> b foldl :: (b -> a -> b) -> b -> [a] -> b # foldl' :: (b -> a -> b) -> b -> [a] -> b foldr1 :: (a -> a -> a) -> [a] -> a # foldl1 :: (a -> a -> a) -> [a] -> a # toList :: [a] -> [a] elem :: Eq a => a -> [a] -> Bool # maximum :: Ord a => [a] -> a # | |
| Foldable (Either a) | |
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |
| Foldable (Proxy :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => Proxy m -> m foldMap :: Monoid m => (a -> m) -> Proxy a -> m # foldMap' :: Monoid m => (a -> m) -> Proxy a -> m foldr :: (a -> b -> b) -> b -> Proxy a -> b # foldr' :: (a -> b -> b) -> b -> Proxy a -> b foldl :: (b -> a -> b) -> b -> Proxy a -> b # foldl' :: (b -> a -> b) -> b -> Proxy a -> b foldr1 :: (a -> a -> a) -> Proxy a -> a # foldl1 :: (a -> a -> a) -> Proxy a -> a # toList :: Proxy a -> [a] elem :: Eq a => a -> Proxy a -> Bool # maximum :: Ord a => Proxy a -> a # | |
| Foldable (Arg a) | |
Defined in Data.Semigroup Methods fold :: Monoid m => Arg a m -> m foldMap :: Monoid m => (a0 -> m) -> Arg a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Arg a a0 -> m foldr :: (a0 -> b -> b) -> b -> Arg a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Arg a a0 -> b foldl :: (b -> a0 -> b) -> b -> Arg a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Arg a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Arg a a0 -> a0 # toList :: Arg a a0 -> [a0] elem :: Eq a0 => a0 -> Arg a a0 -> Bool # maximum :: Ord a0 => Arg a a0 -> a0 # minimum :: Ord a0 => Arg a a0 -> a0 # | |
| Foldable (Array i) | |
Defined in Data.Foldable Methods fold :: Monoid m => Array i m -> m foldMap :: Monoid m => (a -> m) -> Array i a -> m # foldMap' :: Monoid m => (a -> m) -> Array i a -> m foldr :: (a -> b -> b) -> b -> Array i a -> b # foldr' :: (a -> b -> b) -> b -> Array i a -> b foldl :: (b -> a -> b) -> b -> Array i a -> b # foldl' :: (b -> a -> b) -> b -> Array i a -> b foldr1 :: (a -> a -> a) -> Array i a -> a # foldl1 :: (a -> a -> a) -> Array i a -> a # toList :: Array i a -> [a] elem :: Eq a => a -> Array i a -> Bool # maximum :: Ord a => Array i a -> a # minimum :: Ord a => Array i a -> a # | |
| Foldable (U1 :: Type -> Type) | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> U1 a -> m # foldMap' :: Monoid m => (a -> m) -> U1 a -> m foldr :: (a -> b -> b) -> b -> U1 a -> b # foldr' :: (a -> b -> b) -> b -> U1 a -> b foldl :: (b -> a -> b) -> b -> U1 a -> b # foldl' :: (b -> a -> b) -> b -> U1 a -> b foldr1 :: (a -> a -> a) -> U1 a -> a # foldl1 :: (a -> a -> a) -> U1 a -> a # toList :: U1 a -> [a] elem :: Eq a => a -> U1 a -> Bool # maximum :: Ord a => U1 a -> a # | |
| Foldable (UAddr :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UAddr m -> m foldMap :: Monoid m => (a -> m) -> UAddr a -> m # foldMap' :: Monoid m => (a -> m) -> UAddr a -> m foldr :: (a -> b -> b) -> b -> UAddr a -> b # foldr' :: (a -> b -> b) -> b -> UAddr a -> b foldl :: (b -> a -> b) -> b -> UAddr a -> b # foldl' :: (b -> a -> b) -> b -> UAddr a -> b foldr1 :: (a -> a -> a) -> UAddr a -> a # foldl1 :: (a -> a -> a) -> UAddr a -> a # toList :: UAddr a -> [a] elem :: Eq a => a -> UAddr a -> Bool # maximum :: Ord a => UAddr a -> a # | |
| Foldable (UChar :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # | |
| Foldable (UDouble :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |
| Foldable (UFloat :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # | |
| Foldable (UInt :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UInt m -> m foldMap :: Monoid m => (a -> m) -> UInt a -> m # foldMap' :: Monoid m => (a -> m) -> UInt a -> m foldr :: (a -> b -> b) -> b -> UInt a -> b # foldr' :: (a -> b -> b) -> b -> UInt a -> b foldl :: (b -> a -> b) -> b -> UInt a -> b # foldl' :: (b -> a -> b) -> b -> UInt a -> b foldr1 :: (a -> a -> a) -> UInt a -> a # foldl1 :: (a -> a -> a) -> UInt a -> a # toList :: UInt a -> [a] elem :: Eq a => a -> UInt a -> Bool # maximum :: Ord a => UInt a -> a # | |
| Foldable (UWord :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => UWord m -> m foldMap :: Monoid m => (a -> m) -> UWord a -> m # foldMap' :: Monoid m => (a -> m) -> UWord a -> m foldr :: (a -> b -> b) -> b -> UWord a -> b # foldr' :: (a -> b -> b) -> b -> UWord a -> b foldl :: (b -> a -> b) -> b -> UWord a -> b # foldl' :: (b -> a -> b) -> b -> UWord a -> b foldr1 :: (a -> a -> a) -> UWord a -> a # foldl1 :: (a -> a -> a) -> UWord a -> a # toList :: UWord a -> [a] elem :: Eq a => a -> UWord a -> Bool # maximum :: Ord a => UWord a -> a # | |
| Foldable (V1 :: Type -> Type) | |
Defined in Data.Foldable Methods foldMap :: Monoid m => (a -> m) -> V1 a -> m # foldMap' :: Monoid m => (a -> m) -> V1 a -> m foldr :: (a -> b -> b) -> b -> V1 a -> b # foldr' :: (a -> b -> b) -> b -> V1 a -> b foldl :: (b -> a -> b) -> b -> V1 a -> b # foldl' :: (b -> a -> b) -> b -> V1 a -> b foldr1 :: (a -> a -> a) -> V1 a -> a # foldl1 :: (a -> a -> a) -> V1 a -> a # toList :: V1 a -> [a] elem :: Eq a => a -> V1 a -> Bool # maximum :: Ord a => V1 a -> a # | |
| Foldable (Map k) | |
Defined in Data.Map.Internal Methods fold :: Monoid m => Map k m -> m foldMap :: Monoid m => (a -> m) -> Map k a -> m # foldMap' :: Monoid m => (a -> m) -> Map k a -> m foldr :: (a -> b -> b) -> b -> Map k a -> b # foldr' :: (a -> b -> b) -> b -> Map k a -> b foldl :: (b -> a -> b) -> b -> Map k a -> b # foldl' :: (b -> a -> b) -> b -> Map k a -> b foldr1 :: (a -> a -> a) -> Map k a -> a # foldl1 :: (a -> a -> a) -> Map k a -> a # toList :: Map k a -> [a] elem :: Eq a => a -> Map k a -> Bool # maximum :: Ord a => Map k a -> a # | |
| Foldable f => Foldable (MaybeT f) | |
Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m # foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m foldr :: (a -> b -> b) -> b -> MaybeT f a -> b # foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b foldl :: (b -> a -> b) -> b -> MaybeT f a -> b # foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b foldr1 :: (a -> a -> a) -> MaybeT f a -> a # foldl1 :: (a -> a -> a) -> MaybeT f a -> a # toList :: MaybeT f a -> [a] elem :: Eq a => a -> MaybeT f a -> Bool # maximum :: Ord a => MaybeT f a -> a # minimum :: Ord a => MaybeT f a -> a # | |
| Foldable ((,) a) | |
Defined in Data.Foldable Methods fold :: Monoid m => (a, m) -> m foldMap :: Monoid m => (a0 -> m) -> (a, a0) -> m # foldMap' :: Monoid m => (a0 -> m) -> (a, a0) -> m foldr :: (a0 -> b -> b) -> b -> (a, a0) -> b # foldr' :: (a0 -> b -> b) -> b -> (a, a0) -> b foldl :: (b -> a0 -> b) -> b -> (a, a0) -> b # foldl' :: (b -> a0 -> b) -> b -> (a, a0) -> b foldr1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # foldl1 :: (a0 -> a0 -> a0) -> (a, a0) -> a0 # toList :: (a, a0) -> [a0] elem :: Eq a0 => a0 -> (a, a0) -> Bool # maximum :: Ord a0 => (a, a0) -> a0 # minimum :: Ord a0 => (a, a0) -> a0 # | |
| Foldable (Const m :: Type -> Type) | |
Defined in Data.Functor.Const Methods fold :: Monoid m0 => Const m m0 -> m0 foldMap :: Monoid m0 => (a -> m0) -> Const m a -> m0 # foldMap' :: Monoid m0 => (a -> m0) -> Const m a -> m0 foldr :: (a -> b -> b) -> b -> Const m a -> b # foldr' :: (a -> b -> b) -> b -> Const m a -> b foldl :: (b -> a -> b) -> b -> Const m a -> b # foldl' :: (b -> a -> b) -> b -> Const m a -> b foldr1 :: (a -> a -> a) -> Const m a -> a # foldl1 :: (a -> a -> a) -> Const m a -> a # toList :: Const m a -> [a] elem :: Eq a => a -> Const m a -> Bool # maximum :: Ord a => Const m a -> a # minimum :: Ord a => Const m a -> a # | |
| Foldable f => Foldable (Ap f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Ap f m -> m foldMap :: Monoid m => (a -> m) -> Ap f a -> m # foldMap' :: Monoid m => (a -> m) -> Ap f a -> m foldr :: (a -> b -> b) -> b -> Ap f a -> b # foldr' :: (a -> b -> b) -> b -> Ap f a -> b foldl :: (b -> a -> b) -> b -> Ap f a -> b # foldl' :: (b -> a -> b) -> b -> Ap f a -> b foldr1 :: (a -> a -> a) -> Ap f a -> a # foldl1 :: (a -> a -> a) -> Ap f a -> a # toList :: Ap f a -> [a] elem :: Eq a => a -> Ap f a -> Bool # maximum :: Ord a => Ap f a -> a # | |
| Foldable f => Foldable (Alt f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Alt f m -> m foldMap :: Monoid m => (a -> m) -> Alt f a -> m # foldMap' :: Monoid m => (a -> m) -> Alt f a -> m foldr :: (a -> b -> b) -> b -> Alt f a -> b # foldr' :: (a -> b -> b) -> b -> Alt f a -> b foldl :: (b -> a -> b) -> b -> Alt f a -> b # foldl' :: (b -> a -> b) -> b -> Alt f a -> b foldr1 :: (a -> a -> a) -> Alt f a -> a # foldl1 :: (a -> a -> a) -> Alt f a -> a # toList :: Alt f a -> [a] elem :: Eq a => a -> Alt f a -> Bool # maximum :: Ord a => Alt f a -> a # | |
| Foldable f => Foldable (Rec1 f) | |
Defined in Data.Foldable Methods fold :: Monoid m => Rec1 f m -> m foldMap :: Monoid m => (a -> m) -> Rec1 f a -> m # foldMap' :: Monoid m => (a -> m) -> Rec1 f a -> m foldr :: (a -> b -> b) -> b -> Rec1 f a -> b # foldr' :: (a -> b -> b) -> b -> Rec1 f a -> b foldl :: (b -> a -> b) -> b -> Rec1 f a -> b # foldl' :: (b -> a -> b) -> b -> Rec1 f a -> b foldr1 :: (a -> a -> a) -> Rec1 f a -> a # foldl1 :: (a -> a -> a) -> Rec1 f a -> a # toList :: Rec1 f a -> [a] elem :: Eq a => a -> Rec1 f a -> Bool # maximum :: Ord a => Rec1 f a -> a # | |
| Foldable f => Foldable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # | |
| Foldable f => Foldable (IdentityT f) | |
Defined in Control.Monad.Trans.Identity Methods fold :: Monoid m => IdentityT f m -> m foldMap :: Monoid m => (a -> m) -> IdentityT f a -> m # foldMap' :: Monoid m => (a -> m) -> IdentityT f a -> m foldr :: (a -> b -> b) -> b -> IdentityT f a -> b # foldr' :: (a -> b -> b) -> b -> IdentityT f a -> b foldl :: (b -> a -> b) -> b -> IdentityT f a -> b # foldl' :: (b -> a -> b) -> b -> IdentityT f a -> b foldr1 :: (a -> a -> a) -> IdentityT f a -> a # foldl1 :: (a -> a -> a) -> IdentityT f a -> a # toList :: IdentityT f a -> [a] null :: IdentityT f a -> Bool # length :: IdentityT f a -> Int # elem :: Eq a => a -> IdentityT f a -> Bool # maximum :: Ord a => IdentityT f a -> a # minimum :: Ord a => IdentityT f a -> a # | |
| Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Lazy Methods fold :: Monoid m => WriterT w f m -> m foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
| Foldable f => Foldable (WriterT w f) | |
Defined in Control.Monad.Trans.Writer.Strict Methods fold :: Monoid m => WriterT w f m -> m foldMap :: Monoid m => (a -> m) -> WriterT w f a -> m # foldMap' :: Monoid m => (a -> m) -> WriterT w f a -> m foldr :: (a -> b -> b) -> b -> WriterT w f a -> b # foldr' :: (a -> b -> b) -> b -> WriterT w f a -> b foldl :: (b -> a -> b) -> b -> WriterT w f a -> b # foldl' :: (b -> a -> b) -> b -> WriterT w f a -> b foldr1 :: (a -> a -> a) -> WriterT w f a -> a # foldl1 :: (a -> a -> a) -> WriterT w f a -> a # toList :: WriterT w f a -> [a] null :: WriterT w f a -> Bool # length :: WriterT w f a -> Int # elem :: Eq a => a -> WriterT w f a -> Bool # maximum :: Ord a => WriterT w f a -> a # minimum :: Ord a => WriterT w f a -> a # | |
| (Foldable f, Foldable g) => Foldable (Product f g) | |
Defined in Data.Functor.Product Methods fold :: Monoid m => Product f g m -> m foldMap :: Monoid m => (a -> m) -> Product f g a -> m # foldMap' :: Monoid m => (a -> m) -> Product f g a -> m foldr :: (a -> b -> b) -> b -> Product f g a -> b # foldr' :: (a -> b -> b) -> b -> Product f g a -> b foldl :: (b -> a -> b) -> b -> Product f g a -> b # foldl' :: (b -> a -> b) -> b -> Product f g a -> b foldr1 :: (a -> a -> a) -> Product f g a -> a # foldl1 :: (a -> a -> a) -> Product f g a -> a # toList :: Product f g a -> [a] null :: Product f g a -> Bool # length :: Product f g a -> Int # elem :: Eq a => a -> Product f g a -> Bool # maximum :: Ord a => Product f g a -> a # minimum :: Ord a => Product f g a -> a # | |
| (Foldable f, Foldable g) => Foldable (Sum f g) | |
Defined in Data.Functor.Sum Methods fold :: Monoid m => Sum f g m -> m foldMap :: Monoid m => (a -> m) -> Sum f g a -> m # foldMap' :: Monoid m => (a -> m) -> Sum f g a -> m foldr :: (a -> b -> b) -> b -> Sum f g a -> b # foldr' :: (a -> b -> b) -> b -> Sum f g a -> b foldl :: (b -> a -> b) -> b -> Sum f g a -> b # foldl' :: (b -> a -> b) -> b -> Sum f g a -> b foldr1 :: (a -> a -> a) -> Sum f g a -> a # foldl1 :: (a -> a -> a) -> Sum f g a -> a # toList :: Sum f g a -> [a] elem :: Eq a => a -> Sum f g a -> Bool # maximum :: Ord a => Sum f g a -> a # minimum :: Ord a => Sum f g a -> a # | |
| (Foldable f, Foldable g) => Foldable (f :*: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :*: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :*: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :*: g) a -> m foldr :: (a -> b -> b) -> b -> (f :*: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :*: g) a -> b foldl :: (b -> a -> b) -> b -> (f :*: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :*: g) a -> b foldr1 :: (a -> a -> a) -> (f :*: g) a -> a # foldl1 :: (a -> a -> a) -> (f :*: g) a -> a # toList :: (f :*: g) a -> [a] length :: (f :*: g) a -> Int # elem :: Eq a => a -> (f :*: g) a -> Bool # maximum :: Ord a => (f :*: g) a -> a # minimum :: Ord a => (f :*: g) a -> a # | |
| (Foldable f, Foldable g) => Foldable (f :+: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :+: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :+: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :+: g) a -> m foldr :: (a -> b -> b) -> b -> (f :+: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :+: g) a -> b foldl :: (b -> a -> b) -> b -> (f :+: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :+: g) a -> b foldr1 :: (a -> a -> a) -> (f :+: g) a -> a # foldl1 :: (a -> a -> a) -> (f :+: g) a -> a # toList :: (f :+: g) a -> [a] length :: (f :+: g) a -> Int # elem :: Eq a => a -> (f :+: g) a -> Bool # maximum :: Ord a => (f :+: g) a -> a # minimum :: Ord a => (f :+: g) a -> a # | |
| Foldable (K1 i c :: Type -> Type) | |
Defined in Data.Foldable Methods fold :: Monoid m => K1 i c m -> m foldMap :: Monoid m => (a -> m) -> K1 i c a -> m # foldMap' :: Monoid m => (a -> m) -> K1 i c a -> m foldr :: (a -> b -> b) -> b -> K1 i c a -> b # foldr' :: (a -> b -> b) -> b -> K1 i c a -> b foldl :: (b -> a -> b) -> b -> K1 i c a -> b # foldl' :: (b -> a -> b) -> b -> K1 i c a -> b foldr1 :: (a -> a -> a) -> K1 i c a -> a # foldl1 :: (a -> a -> a) -> K1 i c a -> a # toList :: K1 i c a -> [a] elem :: Eq a => a -> K1 i c a -> Bool # maximum :: Ord a => K1 i c a -> a # | |
| (Foldable f, Foldable g) => Foldable (Compose f g) | |
Defined in Data.Functor.Compose Methods fold :: Monoid m => Compose f g m -> m foldMap :: Monoid m => (a -> m) -> Compose f g a -> m # foldMap' :: Monoid m => (a -> m) -> Compose f g a -> m foldr :: (a -> b -> b) -> b -> Compose f g a -> b # foldr' :: (a -> b -> b) -> b -> Compose f g a -> b foldl :: (b -> a -> b) -> b -> Compose f g a -> b # foldl' :: (b -> a -> b) -> b -> Compose f g a -> b foldr1 :: (a -> a -> a) -> Compose f g a -> a # foldl1 :: (a -> a -> a) -> Compose f g a -> a # toList :: Compose f g a -> [a] null :: Compose f g a -> Bool # length :: Compose f g a -> Int # elem :: Eq a => a -> Compose f g a -> Bool # maximum :: Ord a => Compose f g a -> a # minimum :: Ord a => Compose f g a -> a # | |
| (Foldable f, Foldable g) => Foldable (f :.: g) | |
Defined in Data.Foldable Methods fold :: Monoid m => (f :.: g) m -> m foldMap :: Monoid m => (a -> m) -> (f :.: g) a -> m # foldMap' :: Monoid m => (a -> m) -> (f :.: g) a -> m foldr :: (a -> b -> b) -> b -> (f :.: g) a -> b # foldr' :: (a -> b -> b) -> b -> (f :.: g) a -> b foldl :: (b -> a -> b) -> b -> (f :.: g) a -> b # foldl' :: (b -> a -> b) -> b -> (f :.: g) a -> b foldr1 :: (a -> a -> a) -> (f :.: g) a -> a # foldl1 :: (a -> a -> a) -> (f :.: g) a -> a # toList :: (f :.: g) a -> [a] length :: (f :.: g) a -> Int # elem :: Eq a => a -> (f :.: g) a -> Bool # maximum :: Ord a => (f :.: g) a -> a # minimum :: Ord a => (f :.: g) a -> a # | |
| Foldable f => Foldable (M1 i c f) | |
Defined in Data.Foldable Methods fold :: Monoid m => M1 i c f m -> m foldMap :: Monoid m => (a -> m) -> M1 i c f a -> m # foldMap' :: Monoid m => (a -> m) -> M1 i c f a -> m foldr :: (a -> b -> b) -> b -> M1 i c f a -> b # foldr' :: (a -> b -> b) -> b -> M1 i c f a -> b foldl :: (b -> a -> b) -> b -> M1 i c f a -> b # foldl' :: (b -> a -> b) -> b -> M1 i c f a -> b foldr1 :: (a -> a -> a) -> M1 i c f a -> a # foldl1 :: (a -> a -> a) -> M1 i c f a -> a # toList :: M1 i c f a -> [a] elem :: Eq a => a -> M1 i c f a -> Bool # maximum :: Ord a => M1 i c f a -> a # minimum :: Ord a => M1 i c f a -> a # | |
class Monad m => MonadFail (m :: Type -> Type) where #
Instances
Instances
| Bifoldable Either | |||||
| Bifoldable1 Either | |||||
Defined in Data.Bifoldable1 | |||||
| Bifunctor Either | |||||
| Bitraversable Either | |||||
Defined in Data.Bitraversable Methods bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) | |||||
| Eq2 Either | |||||
| Ord2 Either | |||||
Defined in Data.Functor.Classes | |||||
| Read2 Either | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (Either a b) liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [Either a b] liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (Either a b) liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [Either a b] | |||||
| Show2 Either | |||||
| NFData2 Either | |||||
Defined in Control.DeepSeq | |||||
| Generic1 (Either a :: Type -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| MonadError e (Either e) | |||||
Defined in Control.Monad.Error.Class | |||||
| (Lift a, Lift b) => Lift (Either a b :: Type) | |||||
| MonadFix (Either e) | |||||
Defined in Control.Monad.Fix | |||||
| Foldable (Either a) | |||||
Defined in Data.Foldable Methods fold :: Monoid m => Either a m -> m foldMap :: Monoid m => (a0 -> m) -> Either a a0 -> m # foldMap' :: Monoid m => (a0 -> m) -> Either a a0 -> m foldr :: (a0 -> b -> b) -> b -> Either a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> Either a a0 -> b foldl :: (b -> a0 -> b) -> b -> Either a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> Either a a0 -> b foldr1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> Either a a0 -> a0 # length :: Either a a0 -> Int # elem :: Eq a0 => a0 -> Either a a0 -> Bool # maximum :: Ord a0 => Either a a0 -> a0 # minimum :: Ord a0 => Either a a0 -> a0 # | |||||
| Eq a => Eq1 (Either a) | |||||
| Ord a => Ord1 (Either a) | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a0 -> b -> Ordering) -> Either a a0 -> Either a b -> Ordering | |||||
| Read a => Read1 (Either a) | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (Either a a0) liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [Either a a0] liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (Either a a0) liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [Either a a0] | |||||
| Show a => Show1 (Either a) | |||||
Defined in Data.Functor.Classes | |||||
| Traversable (Either a) | |||||
Defined in Data.Traversable | |||||
| Applicative (Either e) | |||||
| Functor (Either a) | |||||
| Monad (Either e) | |||||
| NFData a => NFData1 (Either a) | |||||
Defined in Control.DeepSeq | |||||
| (Data a, Data b) => Data (Either a b) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b0. Data d => c (d -> b0) -> d -> c b0) -> (forall g. g -> c g) -> Either a b -> c (Either a b) gunfold :: (forall b0 r. Data b0 => c (b0 -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Either a b) toConstr :: Either a b -> Constr dataTypeOf :: Either a b -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Either a b)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Either a b)) gmapT :: (forall b0. Data b0 => b0 -> b0) -> Either a b -> Either a b gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Either a b -> r gmapQ :: (forall d. Data d => d -> u) -> Either a b -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Either a b -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Either a b -> m (Either a b) | |||||
| Semigroup (Either a b) | |||||
| Generic (Either a b) | |||||
Defined in GHC.Generics Associated Types
| |||||
| (Read a, Read b) => Read (Either a b) | |||||
| (Show a, Show b) => Show (Either a b) | |||||
| (NFData a, NFData b) => NFData (Either a b) | |||||
Defined in Control.DeepSeq | |||||
| (Eq a, Eq b) => Eq (Either a b) | |||||
| (Ord a, Ord b) => Ord (Either a b) | |||||
| type Rep1 (Either a :: Type -> Type) | |||||
Defined in GHC.Generics type Rep1 (Either a :: Type -> Type) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1)) | |||||
| type Rep (Either a b) | |||||
Defined in GHC.Generics type Rep (Either a b) = D1 ('MetaData "Either" "Data.Either" "base" 'False) (C1 ('MetaCons "Left" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "Right" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 b))) | |||||
class (Functor t, Foldable t) => Traversable (t :: Type -> Type) where #
Methods
traverse :: Applicative f => (a -> f b) -> t a -> f (t b) #
sequenceA :: Applicative f => t (f a) -> f (t a) #
Instances
class Functor f => Applicative (f :: Type -> Type) where #
Instances
| Applicative ZipList | |
| Applicative Complex | |
| Applicative Identity | |
| Applicative First | |
| Applicative Last | |
| Applicative Down | |
| Applicative First | |
| Applicative Last | |
| Applicative Max | |
| Applicative Min | |
| Applicative NonEmpty | |
| Applicative STM | |
| Applicative NoIO | |
| Applicative Par1 | |
| Applicative P | |
| Applicative ReadP | |
| Applicative ReadPrec | |
| Applicative Seq | |
| Applicative Tree | |
| Applicative IO | |
| Applicative Q | |
| Applicative Maybe | |
| Applicative Solo | |
| Applicative [] | |
| Monad m => Applicative (WrappedMonad m) | |
Defined in Control.Applicative Methods pure :: a -> WrappedMonad m a # (<*>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # liftA2 :: (a -> b -> c) -> WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m c # (*>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a # | |
| Arrow a => Applicative (ArrowMonad a) | |
Defined in Control.Arrow Methods pure :: a0 -> ArrowMonad a a0 # (<*>) :: ArrowMonad a (a0 -> b) -> ArrowMonad a a0 -> ArrowMonad a b # liftA2 :: (a0 -> b -> c) -> ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a c # (*>) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a b # (<*) :: ArrowMonad a a0 -> ArrowMonad a b -> ArrowMonad a a0 # | |
| Applicative (Either e) | |
| Applicative (Proxy :: Type -> Type) | |
| Applicative (U1 :: Type -> Type) | |
| Applicative (ST s) | |
| Applicative (SetM s) | |
| Applicative (ProofScheme a) | |
Defined in Copilot.Theorem.Prove Methods pure :: a0 -> ProofScheme a a0 # (<*>) :: ProofScheme a (a0 -> b) -> ProofScheme a a0 -> ProofScheme a b # liftA2 :: (a0 -> b -> c) -> ProofScheme a a0 -> ProofScheme a b -> ProofScheme a c # (*>) :: ProofScheme a a0 -> ProofScheme a b -> ProofScheme a b # (<*) :: ProofScheme a a0 -> ProofScheme a b -> ProofScheme a a0 # | |
| (Functor m, Monad m) => Applicative (MaybeT m) | |
| Monoid a => Applicative ((,) a) | |
| Arrow a => Applicative (WrappedArrow a b) | |
Defined in Control.Applicative Methods pure :: a0 -> WrappedArrow a b a0 # (<*>) :: WrappedArrow a b (a0 -> b0) -> WrappedArrow a b a0 -> WrappedArrow a b b0 # liftA2 :: (a0 -> b0 -> c) -> WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b c # (*>) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b b0 # (<*) :: WrappedArrow a b a0 -> WrappedArrow a b b0 -> WrappedArrow a b a0 # | |
| Applicative m => Applicative (Kleisli m a) | |
Defined in Control.Arrow | |
| Monoid m => Applicative (Const m :: Type -> Type) | |
| Applicative f => Applicative (Ap f) | |
| (Generic1 f, Applicative (Rep1 f)) => Applicative (Generically1 f) | |
Defined in GHC.Generics Methods pure :: a -> Generically1 f a # (<*>) :: Generically1 f (a -> b) -> Generically1 f a -> Generically1 f b # liftA2 :: (a -> b -> c) -> Generically1 f a -> Generically1 f b -> Generically1 f c # (*>) :: Generically1 f a -> Generically1 f b -> Generically1 f b # (<*) :: Generically1 f a -> Generically1 f b -> Generically1 f a # | |
| Applicative f => Applicative (Rec1 f) | |
| (Applicative f, Monad f) => Applicative (WhenMissing f x) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMissing f x a # (<*>) :: WhenMissing f x (a -> b) -> WhenMissing f x a -> WhenMissing f x b # liftA2 :: (a -> b -> c) -> WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x c # (*>) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x b # (<*) :: WhenMissing f x a -> WhenMissing f x b -> WhenMissing f x a # | |
| Applicative (t m) => Applicative (LiftingAccum t m) | |
Defined in Control.Monad.Accum Methods pure :: a -> LiftingAccum t m a # (<*>) :: LiftingAccum t m (a -> b) -> LiftingAccum t m a -> LiftingAccum t m b # liftA2 :: (a -> b -> c) -> LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m c # (*>) :: LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m b # (<*) :: LiftingAccum t m a -> LiftingAccum t m b -> LiftingAccum t m a # | |
| Applicative (t m) => Applicative (LiftingSelect t m) | |
Defined in Control.Monad.Select Methods pure :: a -> LiftingSelect t m a # (<*>) :: LiftingSelect t m (a -> b) -> LiftingSelect t m a -> LiftingSelect t m b # liftA2 :: (a -> b -> c) -> LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m c # (*>) :: LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m b # (<*) :: LiftingSelect t m a -> LiftingSelect t m b -> LiftingSelect t m a # | |
| (Monoid w, Functor m, Monad m) => Applicative (AccumT w m) | |
Defined in Control.Monad.Trans.Accum | |
| (Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
| Applicative m => Applicative (IdentityT m) | |
Defined in Control.Monad.Trans.Identity | |
| Applicative m => Applicative (ReaderT r m) | |
Defined in Control.Monad.Trans.Reader | |
| (Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Lazy | |
| (Functor m, Monad m) => Applicative (StateT s m) | |
Defined in Control.Monad.Trans.State.Strict | |
| (Functor m, Monad m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.CPS | |
| (Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| (Monoid w, Applicative m) => Applicative (WriterT w m) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| (Monoid a, Monoid b) => Applicative ((,,) a b) | |
| (Applicative f, Applicative g) => Applicative (Product f g) | |
Defined in Data.Functor.Product | |
| (Applicative f, Applicative g) => Applicative (f :*: g) | |
| Monoid c => Applicative (K1 i c :: Type -> Type) | |
| (Monad f, Applicative f) => Applicative (WhenMatched f x y) | |
Defined in Data.IntMap.Internal Methods pure :: a -> WhenMatched f x y a # (<*>) :: WhenMatched f x y (a -> b) -> WhenMatched f x y a -> WhenMatched f x y b # liftA2 :: (a -> b -> c) -> WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y c # (*>) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y b # (<*) :: WhenMatched f x y a -> WhenMatched f x y b -> WhenMatched f x y a # | |
| (Applicative f, Monad f) => Applicative (WhenMissing f k x) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMissing f k x a # (<*>) :: WhenMissing f k x (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b # liftA2 :: (a -> b -> c) -> WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x c # (*>) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x b # (<*) :: WhenMissing f k x a -> WhenMissing f k x b -> WhenMissing f k x a # | |
| (Monoid a, Monoid b, Monoid c) => Applicative ((,,,) a b c) | |
Defined in GHC.Base | |
| Applicative ((->) r) | |
| (Applicative f, Applicative g) => Applicative (Compose f g) | |
Defined in Data.Functor.Compose | |
| (Applicative f, Applicative g) => Applicative (f :.: g) | |
| Applicative f => Applicative (M1 i c f) | |
| (Monad f, Applicative f) => Applicative (WhenMatched f k x y) | |
Defined in Data.Map.Internal Methods pure :: a -> WhenMatched f k x y a # (<*>) :: WhenMatched f k x y (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b # liftA2 :: (a -> b -> c) -> WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y c # (*>) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y b # (<*) :: WhenMatched f k x y a -> WhenMatched f k x y b -> WhenMatched f k x y a # | |
| (Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.CPS | |
| (Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Lazy | |
| (Monoid w, Functor m, Monad m) => Applicative (RWST r w s m) | |
Defined in Control.Monad.Trans.RWS.Strict | |
class Functor (f :: Type -> Type) where #
Minimal complete definition
Instances
Minimal complete definition
(<>) | sconcat
Instances
| Semigroup ByteArray | |
| Semigroup Void | |
| Semigroup IntSet | |
| Semigroup Unit | |
| Semigroup Ordering | |
| Semigroup Doc | |
| Semigroup () | |
| Bits a => Semigroup (And a) | |
| FiniteBits a => Semigroup (Iff a) | |
| Bits a => Semigroup (Ior a) | |
| Bits a => Semigroup (Xor a) | |
| Semigroup (FromMaybe b) | |
| Semigroup a => Semigroup (JoinWith a) | |
| Semigroup (NonEmptyDList a) | |
| Semigroup (Comparison a) | |
| Semigroup (Equivalence a) | |
| Semigroup (Predicate a) | |
| Semigroup a => Semigroup (Identity a) | |
| Semigroup (First a) | |
| Semigroup (Last a) | |
| Semigroup a => Semigroup (Down a) | |
| Semigroup (First a) | |
| Semigroup (Last a) | |
| Ord a => Semigroup (Max a) | |
| Ord a => Semigroup (Min a) | |
| Monoid m => Semigroup (WrappedMonoid m) | |
| Semigroup (NonEmpty a) | |
| Semigroup a => Semigroup (STM a) | |
| (Generic a, Semigroup (Rep a ())) => Semigroup (Generically a) | |
| Semigroup p => Semigroup (Par1 p) | |
| Semigroup (IntMap a) | |
| Semigroup (Seq a) | |
| Ord a => Semigroup (Intersection a) | |
| Semigroup (MergeSet a) | |
| Ord a => Semigroup (Set a) | |
| Semigroup a => Semigroup (IO a) | |
| Semigroup (Doc a) | |
| Semigroup a => Semigroup (Q a) | |
| Semigroup a => Semigroup (Maybe a) | |
| Semigroup a => Semigroup (Solo a) | |
| Semigroup [a] | |
| Semigroup (Either a b) | |
| Semigroup a => Semigroup (Op a b) | |
| Semigroup (Proxy s) | |
| Semigroup (U1 p) | |
| Semigroup (V1 p) | |
| Semigroup a => Semigroup (ST s a) | |
| Ord k => Semigroup (Map k v) | |
| (Semigroup a, Semigroup b) => Semigroup (a, b) | |
| Semigroup b => Semigroup (a -> b) | |
| Semigroup a => Semigroup (Const a b) | |
| (Applicative f, Semigroup a) => Semigroup (Ap f a) | |
| Semigroup (f p) => Semigroup (Rec1 f p) | |
| (Semigroup a, Semigroup b, Semigroup c) => Semigroup (a, b, c) | |
| (Semigroup (f a), Semigroup (g a)) => Semigroup (Product f g a) | |
| (Semigroup (f p), Semigroup (g p)) => Semigroup ((f :*: g) p) | |
| Semigroup c => Semigroup (K1 i c p) | |
| (Semigroup a, Semigroup b, Semigroup c, Semigroup d) => Semigroup (a, b, c, d) | |
| Semigroup (f (g a)) => Semigroup (Compose f g a) | |
| Semigroup (f (g p)) => Semigroup ((f :.: g) p) | |
| Semigroup (f p) => Semigroup (M1 i c f p) | |
| (Semigroup a, Semigroup b, Semigroup c, Semigroup d, Semigroup e) => Semigroup (a, b, c, d, e) | |
class Semigroup a => Monoid a where #
Instances
| Monoid ByteArray | |
| Monoid IntSet | |
| Monoid Unit | |
| Monoid Ordering | |
| Monoid Doc | |
| Monoid () | |
| FiniteBits a => Monoid (And a) | |
| FiniteBits a => Monoid (Iff a) | |
| Bits a => Monoid (Ior a) | |
| Bits a => Monoid (Xor a) | |
| Monoid (Comparison a) | |
| Monoid (Equivalence a) | |
| Monoid (Predicate a) | |
| Monoid a => Monoid (Identity a) | |
| Monoid (First a) | |
| Monoid (Last a) | |
| Monoid a => Monoid (Down a) | |
| (Ord a, Bounded a) => Monoid (Max a) | |
| (Ord a, Bounded a) => Monoid (Min a) | |
| Monoid m => Monoid (WrappedMonoid m) | |
| Monoid a => Monoid (STM a) | |
| (Generic a, Monoid (Rep a ())) => Monoid (Generically a) | |
| Monoid p => Monoid (Par1 p) | |
| Monoid (IntMap a) | |
| Monoid (Seq a) | |
| Monoid (MergeSet a) | |
| Ord a => Monoid (Set a) | |
| Monoid a => Monoid (IO a) | |
| Monoid (Doc a) | |
| Monoid a => Monoid (Q a) | |
| Semigroup a => Monoid (Maybe a) | |
| Monoid a => Monoid (Solo a) | |
| Monoid [a] | |
| Monoid a => Monoid (Op a b) | |
| Monoid (Proxy s) | |
| Monoid (U1 p) | |
| Monoid a => Monoid (ST s a) | |
| Ord k => Monoid (Map k v) | |
| (Monoid a, Monoid b) => Monoid (a, b) | |
| Monoid b => Monoid (a -> b) | |
| Monoid a => Monoid (Const a b) | |
| (Applicative f, Monoid a) => Monoid (Ap f a) | |
| Monoid (f p) => Monoid (Rec1 f p) | |
| (Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) | |
| (Monoid (f a), Monoid (g a)) => Monoid (Product f g a) | |
| (Monoid (f p), Monoid (g p)) => Monoid ((f :*: g) p) | |
| Monoid c => Monoid (K1 i c p) | |
| (Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) | |
| Monoid (f (g a)) => Monoid (Compose f g a) | |
| Monoid (f (g p)) => Monoid ((f :.: g) p) | |
| Monoid (f p) => Monoid (M1 i c f p) | |
| (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) | |
Instances
Methods
enumFromThen :: a -> a -> [a] #
enumFromTo :: a -> a -> [a] #
enumFromThenTo :: a -> a -> a -> [a] #
Instances
| Enum CBool | |
Defined in Foreign.C.Types | |
| Enum CChar | |
Defined in Foreign.C.Types | |
| Enum CClock | |
Defined in Foreign.C.Types | |
| Enum CDouble | |
Defined in Foreign.C.Types Methods enumFrom :: CDouble -> [CDouble] # enumFromThen :: CDouble -> CDouble -> [CDouble] # enumFromTo :: CDouble -> CDouble -> [CDouble] # enumFromThenTo :: CDouble -> CDouble -> CDouble -> [CDouble] # | |
| Enum CFloat | |
Defined in Foreign.C.Types | |
| Enum CInt | |
Defined in Foreign.C.Types | |
| Enum CIntMax | |
Defined in Foreign.C.Types Methods enumFrom :: CIntMax -> [CIntMax] # enumFromThen :: CIntMax -> CIntMax -> [CIntMax] # enumFromTo :: CIntMax -> CIntMax -> [CIntMax] # enumFromThenTo :: CIntMax -> CIntMax -> CIntMax -> [CIntMax] # | |
| Enum CIntPtr | |
Defined in Foreign.C.Types Methods enumFrom :: CIntPtr -> [CIntPtr] # enumFromThen :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromTo :: CIntPtr -> CIntPtr -> [CIntPtr] # enumFromThenTo :: CIntPtr -> CIntPtr -> CIntPtr -> [CIntPtr] # | |
| Enum CLLong | |
Defined in Foreign.C.Types | |
| Enum CLong | |
Defined in Foreign.C.Types | |
| Enum CPtrdiff | |
Defined in Foreign.C.Types Methods succ :: CPtrdiff -> CPtrdiff # pred :: CPtrdiff -> CPtrdiff # enumFrom :: CPtrdiff -> [CPtrdiff] # enumFromThen :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromTo :: CPtrdiff -> CPtrdiff -> [CPtrdiff] # enumFromThenTo :: CPtrdiff -> CPtrdiff -> CPtrdiff -> [CPtrdiff] # | |
| Enum CSChar | |
Defined in Foreign.C.Types | |
| Enum CSUSeconds | |
Defined in Foreign.C.Types Methods succ :: CSUSeconds -> CSUSeconds # pred :: CSUSeconds -> CSUSeconds # fromEnum :: CSUSeconds -> Int # enumFrom :: CSUSeconds -> [CSUSeconds] # enumFromThen :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromTo :: CSUSeconds -> CSUSeconds -> [CSUSeconds] # enumFromThenTo :: CSUSeconds -> CSUSeconds -> CSUSeconds -> [CSUSeconds] # | |
| Enum CShort | |
Defined in Foreign.C.Types | |
| Enum CSigAtomic | |
Defined in Foreign.C.Types Methods succ :: CSigAtomic -> CSigAtomic # pred :: CSigAtomic -> CSigAtomic # fromEnum :: CSigAtomic -> Int # enumFrom :: CSigAtomic -> [CSigAtomic] # enumFromThen :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromTo :: CSigAtomic -> CSigAtomic -> [CSigAtomic] # enumFromThenTo :: CSigAtomic -> CSigAtomic -> CSigAtomic -> [CSigAtomic] # | |
| Enum CSize | |
Defined in Foreign.C.Types | |
| Enum CTime | |
Defined in Foreign.C.Types | |
| Enum CUChar | |
Defined in Foreign.C.Types | |
| Enum CUInt | |
Defined in Foreign.C.Types | |
| Enum CUIntMax | |
Defined in Foreign.C.Types Methods succ :: CUIntMax -> CUIntMax # pred :: CUIntMax -> CUIntMax # enumFrom :: CUIntMax -> [CUIntMax] # enumFromThen :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromTo :: CUIntMax -> CUIntMax -> [CUIntMax] # enumFromThenTo :: CUIntMax -> CUIntMax -> CUIntMax -> [CUIntMax] # | |
| Enum CUIntPtr | |
Defined in Foreign.C.Types Methods succ :: CUIntPtr -> CUIntPtr # pred :: CUIntPtr -> CUIntPtr # enumFrom :: CUIntPtr -> [CUIntPtr] # enumFromThen :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromTo :: CUIntPtr -> CUIntPtr -> [CUIntPtr] # enumFromThenTo :: CUIntPtr -> CUIntPtr -> CUIntPtr -> [CUIntPtr] # | |
| Enum CULLong | |
Defined in Foreign.C.Types Methods enumFrom :: CULLong -> [CULLong] # enumFromThen :: CULLong -> CULLong -> [CULLong] # enumFromTo :: CULLong -> CULLong -> [CULLong] # enumFromThenTo :: CULLong -> CULLong -> CULLong -> [CULLong] # | |
| Enum CULong | |
Defined in Foreign.C.Types | |
| Enum CUSeconds | |
Defined in Foreign.C.Types Methods succ :: CUSeconds -> CUSeconds # pred :: CUSeconds -> CUSeconds # fromEnum :: CUSeconds -> Int # enumFrom :: CUSeconds -> [CUSeconds] # enumFromThen :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromTo :: CUSeconds -> CUSeconds -> [CUSeconds] # enumFromThenTo :: CUSeconds -> CUSeconds -> CUSeconds -> [CUSeconds] # | |
| Enum CUShort | |
Defined in Foreign.C.Types Methods enumFrom :: CUShort -> [CUShort] # enumFromThen :: CUShort -> CUShort -> [CUShort] # enumFromTo :: CUShort -> CUShort -> [CUShort] # enumFromThenTo :: CUShort -> CUShort -> CUShort -> [CUShort] # | |
| Enum CWchar | |
Defined in Foreign.C.Types | |
| Enum IntPtr | |
Defined in Foreign.Ptr | |
| Enum WordPtr | |
Defined in Foreign.Ptr Methods enumFrom :: WordPtr -> [WordPtr] # enumFromThen :: WordPtr -> WordPtr -> [WordPtr] # enumFromTo :: WordPtr -> WordPtr -> [WordPtr] # enumFromThenTo :: WordPtr -> WordPtr -> WordPtr -> [WordPtr] # | |
| Enum ByteOrder | |
Defined in GHC.ByteOrder Methods succ :: ByteOrder -> ByteOrder # pred :: ByteOrder -> ByteOrder # fromEnum :: ByteOrder -> Int # enumFrom :: ByteOrder -> [ByteOrder] # enumFromThen :: ByteOrder -> ByteOrder -> [ByteOrder] # enumFromTo :: ByteOrder -> ByteOrder -> [ByteOrder] # enumFromThenTo :: ByteOrder -> ByteOrder -> ByteOrder -> [ByteOrder] # | |
| Enum Associativity | |
Defined in GHC.Generics Methods succ :: Associativity -> Associativity # pred :: Associativity -> Associativity # toEnum :: Int -> Associativity # fromEnum :: Associativity -> Int # enumFrom :: Associativity -> [Associativity] # enumFromThen :: Associativity -> Associativity -> [Associativity] # enumFromTo :: Associativity -> Associativity -> [Associativity] # enumFromThenTo :: Associativity -> Associativity -> Associativity -> [Associativity] # | |
| Enum DecidedStrictness | |
Defined in GHC.Generics Methods succ :: DecidedStrictness -> DecidedStrictness # pred :: DecidedStrictness -> DecidedStrictness # toEnum :: Int -> DecidedStrictness # fromEnum :: DecidedStrictness -> Int # enumFrom :: DecidedStrictness -> [DecidedStrictness] # enumFromThen :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromTo :: DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # enumFromThenTo :: DecidedStrictness -> DecidedStrictness -> DecidedStrictness -> [DecidedStrictness] # | |
| Enum SourceStrictness | |
Defined in GHC.Generics Methods succ :: SourceStrictness -> SourceStrictness # pred :: SourceStrictness -> SourceStrictness # toEnum :: Int -> SourceStrictness # fromEnum :: SourceStrictness -> Int # enumFrom :: SourceStrictness -> [SourceStrictness] # enumFromThen :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromTo :: SourceStrictness -> SourceStrictness -> [SourceStrictness] # enumFromThenTo :: SourceStrictness -> SourceStrictness -> SourceStrictness -> [SourceStrictness] # | |
| Enum SourceUnpackedness | |
Defined in GHC.Generics Methods succ :: SourceUnpackedness -> SourceUnpackedness # pred :: SourceUnpackedness -> SourceUnpackedness # toEnum :: Int -> SourceUnpackedness # fromEnum :: SourceUnpackedness -> Int # enumFrom :: SourceUnpackedness -> [SourceUnpackedness] # enumFromThen :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromTo :: SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # enumFromThenTo :: SourceUnpackedness -> SourceUnpackedness -> SourceUnpackedness -> [SourceUnpackedness] # | |
| Enum SeekMode | |
Defined in GHC.IO.Device Methods succ :: SeekMode -> SeekMode # pred :: SeekMode -> SeekMode # enumFrom :: SeekMode -> [SeekMode] # enumFromThen :: SeekMode -> SeekMode -> [SeekMode] # enumFromTo :: SeekMode -> SeekMode -> [SeekMode] # enumFromThenTo :: SeekMode -> SeekMode -> SeekMode -> [SeekMode] # | |
| Enum IOMode | |
Defined in GHC.IO.IOMode | |
| Enum Int16 | |
| Enum Int32 | |
| Enum Int64 | |
| Enum Int8 | |
| Enum DoCostCentres | |
Defined in GHC.RTS.Flags Methods succ :: DoCostCentres -> DoCostCentres # pred :: DoCostCentres -> DoCostCentres # toEnum :: Int -> DoCostCentres # fromEnum :: DoCostCentres -> Int # enumFrom :: DoCostCentres -> [DoCostCentres] # enumFromThen :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromTo :: DoCostCentres -> DoCostCentres -> [DoCostCentres] # enumFromThenTo :: DoCostCentres -> DoCostCentres -> DoCostCentres -> [DoCostCentres] # | |
| Enum DoHeapProfile | |
Defined in GHC.RTS.Flags Methods succ :: DoHeapProfile -> DoHeapProfile # pred :: DoHeapProfile -> DoHeapProfile # toEnum :: Int -> DoHeapProfile # fromEnum :: DoHeapProfile -> Int # enumFrom :: DoHeapProfile -> [DoHeapProfile] # enumFromThen :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromTo :: DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # enumFromThenTo :: DoHeapProfile -> DoHeapProfile -> DoHeapProfile -> [DoHeapProfile] # | |
| Enum DoTrace | |
Defined in GHC.RTS.Flags Methods enumFrom :: DoTrace -> [DoTrace] # enumFromThen :: DoTrace -> DoTrace -> [DoTrace] # enumFromTo :: DoTrace -> DoTrace -> [DoTrace] # enumFromThenTo :: DoTrace -> DoTrace -> DoTrace -> [DoTrace] # | |
| Enum GiveGCStats | |
Defined in GHC.RTS.Flags Methods succ :: GiveGCStats -> GiveGCStats # pred :: GiveGCStats -> GiveGCStats # toEnum :: Int -> GiveGCStats # fromEnum :: GiveGCStats -> Int # enumFrom :: GiveGCStats -> [GiveGCStats] # enumFromThen :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromTo :: GiveGCStats -> GiveGCStats -> [GiveGCStats] # enumFromThenTo :: GiveGCStats -> GiveGCStats -> GiveGCStats -> [GiveGCStats] # | |
| Enum IoSubSystem | |
Defined in GHC.RTS.Flags Methods succ :: IoSubSystem -> IoSubSystem # pred :: IoSubSystem -> IoSubSystem # toEnum :: Int -> IoSubSystem # fromEnum :: IoSubSystem -> Int # enumFrom :: IoSubSystem -> [IoSubSystem] # enumFromThen :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromTo :: IoSubSystem -> IoSubSystem -> [IoSubSystem] # enumFromThenTo :: IoSubSystem -> IoSubSystem -> IoSubSystem -> [IoSubSystem] # | |
| Enum GeneralCategory | |
Defined in GHC.Unicode Methods succ :: GeneralCategory -> GeneralCategory # pred :: GeneralCategory -> GeneralCategory # toEnum :: Int -> GeneralCategory # fromEnum :: GeneralCategory -> Int # enumFrom :: GeneralCategory -> [GeneralCategory] # enumFromThen :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromTo :: GeneralCategory -> GeneralCategory -> [GeneralCategory] # enumFromThenTo :: GeneralCategory -> GeneralCategory -> GeneralCategory -> [GeneralCategory] # | |
| Enum Word16 | |
Defined in GHC.Word | |
| Enum Word32 | |
Defined in GHC.Word | |
| Enum Word64 | |
Defined in GHC.Word | |
| Enum Word8 | |
| Enum CBlkCnt | |
Defined in System.Posix.Types Methods enumFrom :: CBlkCnt -> [CBlkCnt] # enumFromThen :: CBlkCnt -> CBlkCnt -> [CBlkCnt] # enumFromTo :: CBlkCnt -> CBlkCnt -> [CBlkCnt] # enumFromThenTo :: CBlkCnt -> CBlkCnt -> CBlkCnt -> [CBlkCnt] # | |
| Enum CBlkSize | |
Defined in System.Posix.Types Methods succ :: CBlkSize -> CBlkSize # pred :: CBlkSize -> CBlkSize # enumFrom :: CBlkSize -> [CBlkSize] # enumFromThen :: CBlkSize -> CBlkSize -> [CBlkSize] # enumFromTo :: CBlkSize -> CBlkSize -> [CBlkSize] # enumFromThenTo :: CBlkSize -> CBlkSize -> CBlkSize -> [CBlkSize] # | |
| Enum CCc | |
Defined in System.Posix.Types | |
| Enum CClockId | |
Defined in System.Posix.Types Methods succ :: CClockId -> CClockId # pred :: CClockId -> CClockId # enumFrom :: CClockId -> [CClockId] # enumFromThen :: CClockId -> CClockId -> [CClockId] # enumFromTo :: CClockId -> CClockId -> [CClockId] # enumFromThenTo :: CClockId -> CClockId -> CClockId -> [CClockId] # | |
| Enum CDev | |
Defined in System.Posix.Types | |
| Enum CFsBlkCnt | |
Defined in System.Posix.Types Methods succ :: CFsBlkCnt -> CFsBlkCnt # pred :: CFsBlkCnt -> CFsBlkCnt # fromEnum :: CFsBlkCnt -> Int # enumFrom :: CFsBlkCnt -> [CFsBlkCnt] # enumFromThen :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # enumFromTo :: CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # enumFromThenTo :: CFsBlkCnt -> CFsBlkCnt -> CFsBlkCnt -> [CFsBlkCnt] # | |
| Enum CFsFilCnt | |
Defined in System.Posix.Types Methods succ :: CFsFilCnt -> CFsFilCnt # pred :: CFsFilCnt -> CFsFilCnt # fromEnum :: CFsFilCnt -> Int # enumFrom :: CFsFilCnt -> [CFsFilCnt] # enumFromThen :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # enumFromTo :: CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # enumFromThenTo :: CFsFilCnt -> CFsFilCnt -> CFsFilCnt -> [CFsFilCnt] # | |
| Enum CGid | |
Defined in System.Posix.Types | |
| Enum CId | |
Defined in System.Posix.Types | |
| Enum CIno | |
Defined in System.Posix.Types | |
| Enum CKey | |
Defined in System.Posix.Types | |
| Enum CMode | |
Defined in System.Posix.Types | |
| Enum CNfds | |
Defined in System.Posix.Types | |
| Enum CNlink | |
Defined in System.Posix.Types | |
| Enum COff | |
Defined in System.Posix.Types | |
| Enum CPid | |
Defined in System.Posix.Types | |
| Enum CRLim | |
Defined in System.Posix.Types | |
| Enum CSocklen | |
Defined in System.Posix.Types Methods succ :: CSocklen -> CSocklen # pred :: CSocklen -> CSocklen # enumFrom :: CSocklen -> [CSocklen] # enumFromThen :: CSocklen -> CSocklen -> [CSocklen] # enumFromTo :: CSocklen -> CSocklen -> [CSocklen] # enumFromThenTo :: CSocklen -> CSocklen -> CSocklen -> [CSocklen] # | |
| Enum CSpeed | |
Defined in System.Posix.Types | |
| Enum CSsize | |
Defined in System.Posix.Types | |
| Enum CTcflag | |
Defined in System.Posix.Types Methods enumFrom :: CTcflag -> [CTcflag] # enumFromThen :: CTcflag -> CTcflag -> [CTcflag] # enumFromTo :: CTcflag -> CTcflag -> [CTcflag] # enumFromThenTo :: CTcflag -> CTcflag -> CTcflag -> [CTcflag] # | |
| Enum CUid | |
Defined in System.Posix.Types | |
| Enum Fd | |
Defined in System.Posix.Types | |
| Enum Extension | |
Defined in GHC.LanguageExtensions.Type Methods succ :: Extension -> Extension # pred :: Extension -> Extension # fromEnum :: Extension -> Int # enumFrom :: Extension -> [Extension] # enumFromThen :: Extension -> Extension -> [Extension] # enumFromTo :: Extension -> Extension -> [Extension] # enumFromThenTo :: Extension -> Extension -> Extension -> [Extension] # | |
| Enum Ordering | |
| Enum Integer | |
| Enum Natural | |
Defined in GHC.Enum Methods enumFrom :: Natural -> [Natural] # enumFromThen :: Natural -> Natural -> [Natural] # enumFromTo :: Natural -> Natural -> [Natural] # enumFromThenTo :: Natural -> Natural -> Natural -> [Natural] # | |
| Enum () | |
| Enum Bool | |
| Enum Char | |
| Enum Int | |
| Enum Levity | |
Defined in GHC.Enum | |
| Enum VecCount | |
Defined in GHC.Enum Methods succ :: VecCount -> VecCount # pred :: VecCount -> VecCount # enumFrom :: VecCount -> [VecCount] # enumFromThen :: VecCount -> VecCount -> [VecCount] # enumFromTo :: VecCount -> VecCount -> [VecCount] # enumFromThenTo :: VecCount -> VecCount -> VecCount -> [VecCount] # | |
| Enum VecElem | |
Defined in GHC.Enum Methods enumFrom :: VecElem -> [VecElem] # enumFromThen :: VecElem -> VecElem -> [VecElem] # enumFromTo :: VecElem -> VecElem -> [VecElem] # enumFromThenTo :: VecElem -> VecElem -> VecElem -> [VecElem] # | |
| Enum Word | |
| Enum a => Enum (And a) | |
| Enum a => Enum (Iff a) | |
| Enum a => Enum (Ior a) | |
| Enum a => Enum (Xor a) | |
| Enum a => Enum (Identity a) | |
Defined in Data.Functor.Identity Methods succ :: Identity a -> Identity a # pred :: Identity a -> Identity a # fromEnum :: Identity a -> Int # enumFrom :: Identity a -> [Identity a] # enumFromThen :: Identity a -> Identity a -> [Identity a] # enumFromTo :: Identity a -> Identity a -> [Identity a] # enumFromThenTo :: Identity a -> Identity a -> Identity a -> [Identity a] # | |
| (Enum a, Bounded a, Eq a) => Enum (Down a) | |
Defined in Data.Ord | |
| Enum a => Enum (First a) | |
Defined in Data.Semigroup Methods enumFrom :: First a -> [First a] # enumFromThen :: First a -> First a -> [First a] # enumFromTo :: First a -> First a -> [First a] # enumFromThenTo :: First a -> First a -> First a -> [First a] # | |
| Enum a => Enum (Last a) | |
Defined in Data.Semigroup | |
| Enum a => Enum (Max a) | |
Defined in Data.Semigroup | |
| Enum a => Enum (Min a) | |
Defined in Data.Semigroup | |
| Enum a => Enum (WrappedMonoid a) | |
Defined in Data.Semigroup Methods succ :: WrappedMonoid a -> WrappedMonoid a # pred :: WrappedMonoid a -> WrappedMonoid a # toEnum :: Int -> WrappedMonoid a # fromEnum :: WrappedMonoid a -> Int # enumFrom :: WrappedMonoid a -> [WrappedMonoid a] # enumFromThen :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromTo :: WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # enumFromThenTo :: WrappedMonoid a -> WrappedMonoid a -> WrappedMonoid a -> [WrappedMonoid a] # | |
| Integral a => Enum (Ratio a) | |
Defined in GHC.Real Methods enumFrom :: Ratio a -> [Ratio a] # enumFromThen :: Ratio a -> Ratio a -> [Ratio a] # enumFromTo :: Ratio a -> Ratio a -> [Ratio a] # enumFromThenTo :: Ratio a -> Ratio a -> Ratio a -> [Ratio a] # | |
| Enum a => Enum (Solo a) | |
Defined in GHC.Enum | |
| Enum (Fixed a) | |
Defined in Data.Fixed Methods enumFrom :: Fixed a -> [Fixed a] # enumFromThen :: Fixed a -> Fixed a -> [Fixed a] # enumFromTo :: Fixed a -> Fixed a -> [Fixed a] # enumFromThenTo :: Fixed a -> Fixed a -> Fixed a -> [Fixed a] # | |
| Enum (Proxy s) | |
Defined in Data.Proxy Methods enumFrom :: Proxy s -> [Proxy s] # enumFromThen :: Proxy s -> Proxy s -> [Proxy s] # enumFromTo :: Proxy s -> Proxy s -> [Proxy s] # enumFromThenTo :: Proxy s -> Proxy s -> Proxy s -> [Proxy s] # | |
| Enum a => Enum (Const a b) | |
Defined in Data.Functor.Const Methods succ :: Const a b -> Const a b # pred :: Const a b -> Const a b # fromEnum :: Const a b -> Int # enumFrom :: Const a b -> [Const a b] # enumFromThen :: Const a b -> Const a b -> [Const a b] # enumFromTo :: Const a b -> Const a b -> [Const a b] # enumFromThenTo :: Const a b -> Const a b -> Const a b -> [Const a b] # | |
| Enum (f a) => Enum (Ap f a) | |
Defined in Data.Monoid | |
| Coercible a b => Enum (Coercion a b) | |
Defined in Data.Type.Coercion Methods succ :: Coercion a b -> Coercion a b # pred :: Coercion a b -> Coercion a b # toEnum :: Int -> Coercion a b # fromEnum :: Coercion a b -> Int # enumFrom :: Coercion a b -> [Coercion a b] # enumFromThen :: Coercion a b -> Coercion a b -> [Coercion a b] # enumFromTo :: Coercion a b -> Coercion a b -> [Coercion a b] # enumFromThenTo :: Coercion a b -> Coercion a b -> Coercion a b -> [Coercion a b] # | |
| a ~ b => Enum (a :~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~: b) -> a :~: b # pred :: (a :~: b) -> a :~: b # fromEnum :: (a :~: b) -> Int # enumFrom :: (a :~: b) -> [a :~: b] # enumFromThen :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromTo :: (a :~: b) -> (a :~: b) -> [a :~: b] # enumFromThenTo :: (a :~: b) -> (a :~: b) -> (a :~: b) -> [a :~: b] # | |
| a ~~ b => Enum (a :~~: b) | |
Defined in Data.Type.Equality Methods succ :: (a :~~: b) -> a :~~: b # pred :: (a :~~: b) -> a :~~: b # fromEnum :: (a :~~: b) -> Int # enumFrom :: (a :~~: b) -> [a :~~: b] # enumFromThen :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromTo :: (a :~~: b) -> (a :~~: b) -> [a :~~: b] # enumFromThenTo :: (a :~~: b) -> (a :~~: b) -> (a :~~: b) -> [a :~~: b] # | |
| Enum (f (g a)) => Enum (Compose f g a) | |
Defined in Data.Functor.Compose Methods succ :: Compose f g a -> Compose f g a # pred :: Compose f g a -> Compose f g a # toEnum :: Int -> Compose f g a # fromEnum :: Compose f g a -> Int # enumFrom :: Compose f g a -> [Compose f g a] # enumFromThen :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromTo :: Compose f g a -> Compose f g a -> [Compose f g a] # enumFromThenTo :: Compose f g a -> Compose f g a -> Compose f g a -> [Compose f g a] # | |
errorWithoutStackTrace :: [Char] -> a #
class Fractional a => Floating a where #
Minimal complete definition
pi, exp, log, sin, cos, asin, acos, atan, sinh, cosh, asinh, acosh, atanh
Methods
Instances
| Floating CDouble | |
| Floating CFloat | |
| Floating Double | |
| Floating Float | |
| RealFloat a => Floating (Complex a) | |
Defined in Data.Complex Methods 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 | |
| Floating a => Floating (Identity a) | |
Defined in Data.Functor.Identity Methods exp :: Identity a -> Identity a # log :: Identity a -> Identity a # sqrt :: Identity a -> Identity a # (**) :: Identity a -> Identity a -> Identity a # logBase :: Identity a -> Identity a -> Identity a # sin :: Identity a -> Identity a # cos :: Identity a -> Identity a # tan :: Identity a -> Identity a # asin :: Identity a -> Identity a # acos :: Identity a -> Identity a # atan :: Identity a -> Identity a # sinh :: Identity a -> Identity a # cosh :: Identity a -> Identity a # tanh :: Identity a -> Identity a # asinh :: Identity a -> Identity a # acosh :: Identity a -> Identity a # atanh :: Identity a -> Identity a # log1p :: Identity a -> Identity a expm1 :: Identity a -> Identity a log1pexp :: Identity a -> Identity a log1mexp :: Identity a -> Identity a | |
| Floating a => Floating (Down a) | |
| (Typed a, Eq a, Floating a) => Floating (Stream a) Source # | Streams carrying floating point numbers are instances of |
Defined in Copilot.Language.Stream Methods sqrt :: Stream a -> Stream a # (**) :: Stream a -> Stream a -> Stream a # logBase :: Stream a -> Stream a -> Stream a # asin :: Stream a -> Stream a # acos :: Stream a -> Stream a # atan :: Stream a -> Stream a # sinh :: Stream a -> Stream a # cosh :: Stream a -> Stream a # tanh :: Stream a -> Stream a # asinh :: Stream a -> Stream a # acosh :: Stream a -> Stream a # atanh :: Stream a -> Stream a # | |
| Floating a => Floating (Op a b) | |
| Floating a => Floating (Const a b) | |
Defined in Data.Functor.Const Methods exp :: Const a b -> Const a b # log :: Const a b -> Const a b # sqrt :: Const a b -> Const a b # (**) :: Const a b -> Const a b -> Const a b # logBase :: Const a b -> Const a b -> Const a b # sin :: Const a b -> Const a b # cos :: Const a b -> Const a b # tan :: Const a b -> Const a b # asin :: Const a b -> Const a b # acos :: Const a b -> Const a b # atan :: Const a b -> Const a b # sinh :: Const a b -> Const a b # cosh :: Const a b -> Const a b # tanh :: Const a b -> Const a b # asinh :: Const a b -> Const a b # acosh :: Const a b -> Const a b # atanh :: Const a b -> Const a b # log1p :: Const a b -> Const a b expm1 :: Const a b -> Const a b log1pexp :: Const a b -> Const a b log1mexp :: Const a b -> Const a b | |
Minimal complete definition
readsPrec | readPrec
Instances
| Read Version | |
Defined in Data.Version | |
| Read CBool | |
Defined in Foreign.C.Types | |
| Read CChar | |
Defined in Foreign.C.Types | |
| Read CClock | |
Defined in Foreign.C.Types | |
| Read CDouble | |
Defined in Foreign.C.Types | |
| Read CFloat | |
Defined in Foreign.C.Types | |
| Read CInt | |
Defined in Foreign.C.Types | |
| Read CIntMax | |
Defined in Foreign.C.Types | |
| Read CIntPtr | |
Defined in Foreign.C.Types | |
| Read CLLong | |
Defined in Foreign.C.Types | |
| Read CLong | |
Defined in Foreign.C.Types | |
| Read CPtrdiff | |
Defined in Foreign.C.Types | |
| Read CSChar | |
Defined in Foreign.C.Types | |
| Read CSUSeconds | |
Defined in Foreign.C.Types | |
| Read CShort | |
Defined in Foreign.C.Types | |
| Read CSigAtomic | |
Defined in Foreign.C.Types | |
| Read CSize | |
Defined in Foreign.C.Types | |
| Read CTime | |
Defined in Foreign.C.Types | |
| Read CUChar | |
Defined in Foreign.C.Types | |
| Read CUInt | |
Defined in Foreign.C.Types | |
| Read CUIntMax | |
Defined in Foreign.C.Types | |
| Read CUIntPtr | |
Defined in Foreign.C.Types | |
| Read CULLong | |
Defined in Foreign.C.Types | |
| Read CULong | |
Defined in Foreign.C.Types | |
| Read CUSeconds | |
Defined in Foreign.C.Types | |
| Read CUShort | |
Defined in Foreign.C.Types | |
| Read CWchar | |
Defined in Foreign.C.Types | |
| Read IntPtr | |
Defined in Foreign.Ptr | |
| Read WordPtr | |
Defined in Foreign.Ptr | |
| Read Void | |
| Read ByteOrder | |
Defined in GHC.ByteOrder | |
| Read Associativity | |
Defined in GHC.Generics | |
| Read DecidedStrictness | |
Defined in GHC.Generics | |
| Read Fixity | |
Defined in GHC.Generics | |
| Read SourceStrictness | |
Defined in GHC.Generics | |
| Read SourceUnpackedness | |
Defined in GHC.Generics | |
| Read SeekMode | |
Defined in GHC.IO.Device | |
| Read ExitCode | |
Defined in GHC.IO.Exception | |
| Read BufferMode | |
Defined in GHC.IO.Handle.Types | |
| Read Newline | |
Defined in GHC.IO.Handle.Types | |
| Read NewlineMode | |
Defined in GHC.IO.Handle.Types | |
| Read IOMode | |
Defined in GHC.IO.IOMode | |
| Read Int16 | |
| Read Int32 | |
| Read Int64 | |
| Read Int8 | |
| Read GCDetails | |
| Read RTSStats | |
| Read SomeChar | |
Defined in GHC.TypeLits | |
| Read SomeSymbol | |
Defined in GHC.TypeLits | |
| Read SomeNat | |
Defined in GHC.TypeNats | |
| Read GeneralCategory | |
| Read Word16 | |
| Read Word32 | |
| Read Word64 | |
| Read Word8 | |
| Read CBlkCnt | |
Defined in System.Posix.Types | |
| Read CBlkSize | |
Defined in System.Posix.Types | |
| Read CCc | |
Defined in System.Posix.Types | |
| Read CClockId | |
Defined in System.Posix.Types | |
| Read CDev | |
Defined in System.Posix.Types | |
| Read CFsBlkCnt | |
Defined in System.Posix.Types | |
| Read CFsFilCnt | |
Defined in System.Posix.Types | |
| Read CGid | |
Defined in System.Posix.Types | |
| Read CId | |
Defined in System.Posix.Types | |
| Read CIno | |
Defined in System.Posix.Types | |
| Read CKey | |
Defined in System.Posix.Types | |
| Read CMode | |
Defined in System.Posix.Types | |
| Read CNfds | |
Defined in System.Posix.Types | |
| Read CNlink | |
Defined in System.Posix.Types | |
| Read COff | |
Defined in System.Posix.Types | |
| Read CPid | |
Defined in System.Posix.Types | |
| Read CRLim | |
Defined in System.Posix.Types | |
| Read CSocklen | |
Defined in System.Posix.Types | |
| Read CSpeed | |
Defined in System.Posix.Types | |
| Read CSsize | |
Defined in System.Posix.Types | |
| Read CTcflag | |
Defined in System.Posix.Types | |
| Read CUid | |
Defined in System.Posix.Types | |
| Read Fd | |
Defined in System.Posix.Types | |
| Read Lexeme | |
| Read IntSet | |
Defined in Data.IntSet.Internal | |
| Read Ordering | |
| Read Integer | |
| Read Natural | |
| Read () | |
| Read Bool | |
| Read Char | |
| Read Double | |
| Read Float | |
| Read Int | |
| Read Word | |
| Read a => Read (ZipList a) | |
Defined in Control.Applicative | |
| Read a => Read (And a) | |
| Read a => Read (Iff a) | |
| Read a => Read (Ior a) | |
| Read a => Read (Xor a) | |
| Read a => Read (Complex a) | |
Defined in Data.Complex | |
| Read a => Read (Identity a) | |
Defined in Data.Functor.Identity | |
| Read a => Read (First a) | |
Defined in Data.Monoid | |
| Read a => Read (Last a) | |
Defined in Data.Monoid | |
| Read a => Read (Down a) | |
| Read a => Read (First a) | |
Defined in Data.Semigroup | |
| Read a => Read (Last a) | |
Defined in Data.Semigroup | |
| Read a => Read (Max a) | |
Defined in Data.Semigroup | |
| Read a => Read (Min a) | |
Defined in Data.Semigroup | |
| Read m => Read (WrappedMonoid m) | |
Defined in Data.Semigroup | |
| Read a => Read (NonEmpty a) | |
| Read p => Read (Par1 p) | |
Defined in GHC.Generics | |
| (Integral a, Read a) => Read (Ratio a) | |
| Read vertex => Read (SCC vertex) | |
Defined in Data.Graph | |
| Read e => Read (IntMap e) | |
Defined in Data.IntMap.Internal | |
| Read a => Read (Seq a) | |
Defined in Data.Sequence.Internal | |
| Read a => Read (ViewL a) | |
Defined in Data.Sequence.Internal | |
| Read a => Read (ViewR a) | |
Defined in Data.Sequence.Internal | |
| (Read a, Ord a) => Read (Set a) | |
Defined in Data.Set.Internal | |
| Read a => Read (Tree a) | |
| Read a => Read (Maybe a) | |
| Read a => Read (Solo a) | |
| Read a => Read [a] | |
| (Ix ix, Read ix, Read e, IArray UArray e) => Read (UArray ix e) | |
Defined in Data.Array.Base | |
| (Read a, Read b) => Read (Either a b) | |
| HasResolution a => Read (Fixed a) | |
Defined in Data.Fixed | |
| Read (Proxy t) | |
Defined in Data.Proxy | |
| (Read a, Read b) => Read (Arg a b) | |
Defined in Data.Semigroup | |
| (Ix a, Read a, Read b) => Read (Array a b) | |
| Read (U1 p) | |
Defined in GHC.Generics | |
| Read (V1 p) | |
Defined in GHC.Generics | |
| (Ord k, Read k, Read e) => Read (Map k e) | |
Defined in Data.Map.Internal | |
| (Read1 m, Read a) => Read (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
| (Read a, Read b) => Read (a, b) | |
| Read a => Read (Const a b) | |
Defined in Data.Functor.Const | |
| Read (f a) => Read (Ap f a) | |
Defined in Data.Monoid | |
| Coercible a b => Read (Coercion a b) | |
Defined in Data.Type.Coercion | |
| a ~ b => Read (a :~: b) | |
Defined in Data.Type.Equality | |
| Read (f p) => Read (Rec1 f p) | |
Defined in GHC.Generics | |
| (Read e, Read1 m, Read a) => Read (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except | |
| (Read1 f, Read a) => Read (IdentityT f a) | |
Defined in Control.Monad.Trans.Identity | |
| (Read w, Read1 m, Read a) => Read (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Lazy | |
| (Read w, Read1 m, Read a) => Read (WriterT w m a) | |
Defined in Control.Monad.Trans.Writer.Strict | |
| (Read a, Read b, Read c) => Read (a, b, c) | |
| (Read (f a), Read (g a)) => Read (Product f g a) | |
Defined in Data.Functor.Product | |
| (Read (f a), Read (g a)) => Read (Sum f g a) | |
Defined in Data.Functor.Sum | |
| a ~~ b => Read (a :~~: b) | |
Defined in Data.Type.Equality | |
| (Read (f p), Read (g p)) => Read ((f :*: g) p) | |
Defined in GHC.Generics | |
| (Read (f p), Read (g p)) => Read ((f :+: g) p) | |
Defined in GHC.Generics | |
| Read c => Read (K1 i c p) | |
Defined in GHC.Generics | |
| (Read a, Read b, Read c, Read d) => Read (a, b, c, d) | |
| Read (f (g a)) => Read (Compose f g a) | |
Defined in Data.Functor.Compose | |
| Read (f (g p)) => Read ((f :.: g) p) | |
Defined in GHC.Generics | |
| Read (f p) => Read (M1 i c f p) | |
Defined in GHC.Generics | |
| (Read a, Read b, Read c, Read d, Read e) => Read (a, b, c, d, e) | |
| (Read a, Read b, Read c, Read d, Read e, Read f) => Read (a, b, c, d, e, f) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g) => Read (a, b, c, d, e, f, g) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) => Read (a, b, c, d, e, f, g, h) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i) => Read (a, b, c, d, e, f, g, h, i) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j) => Read (a, b, c, d, e, f, g, h, i, j) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k) => Read (a, b, c, d, e, f, g, h, i, j, k) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l) => Read (a, b, c, d, e, f, g, h, i, j, k, l) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
| (Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h, Read i, Read j, Read k, Read l, Read m, Read n, Read o) => Read (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
Defined in GHC.Read | |
class Num a => Fractional a where #
Minimal complete definition
fromRational, (recip | (/))
Instances
| Fractional CDouble | |
Defined in Foreign.C.Types | |
| Fractional CFloat | |
Defined in Foreign.C.Types | |
| RealFloat a => Fractional (Complex a) | |
Defined in Data.Complex | |
| Fractional a => Fractional (Identity a) | |
Defined in Data.Functor.Identity | |
| Fractional a => Fractional (Down a) | |
| Integral a => Fractional (Ratio a) | |
| (Typed a, Eq a, Fractional a) => Fractional (Stream a) Source # | Streams carrying fractional numbers are instances of |
| HasResolution a => Fractional (Fixed a) | |
Defined in Data.Fixed | |
| Fractional a => Fractional (Op a b) | |
Defined in Data.Functor.Contravariant | |
| Fractional a => Fractional (Const a b) | |
Defined in Data.Functor.Const | |
class (Num a, Ord a) => Real a where #
Methods
toRational :: a -> Rational #
Instances
| Real CBool | |
Defined in Foreign.C.Types Methods toRational :: CBool -> Rational # | |
| Real CChar | |
Defined in Foreign.C.Types Methods toRational :: CChar -> Rational # | |
| Real CClock | |
Defined in Foreign.C.Types Methods toRational :: CClock -> Rational # | |
| Real CDouble | |
Defined in Foreign.C.Types Methods toRational :: CDouble -> Rational # | |
| Real CFloat | |
Defined in Foreign.C.Types Methods toRational :: CFloat -> Rational # | |
| Real CInt | |
Defined in Foreign.C.Types Methods toRational :: CInt -> Rational # | |
| Real CIntMax | |
Defined in Foreign.C.Types Methods toRational :: CIntMax -> Rational # | |
| Real CIntPtr | |
Defined in Foreign.C.Types Methods toRational :: CIntPtr -> Rational # | |
| Real CLLong | |
Defined in Foreign.C.Types Methods toRational :: CLLong -> Rational # | |
| Real CLong | |
Defined in Foreign.C.Types Methods toRational :: CLong -> Rational # | |
| Real CPtrdiff | |
Defined in Foreign.C.Types Methods toRational :: CPtrdiff -> Rational # | |
| Real CSChar | |
Defined in Foreign.C.Types Methods toRational :: CSChar -> Rational # | |
| Real CSUSeconds | |
Defined in Foreign.C.Types Methods toRational :: CSUSeconds -> Rational # | |
| Real CShort | |
Defined in Foreign.C.Types Methods toRational :: CShort -> Rational # | |
| Real CSigAtomic | |
Defined in Foreign.C.Types Methods toRational :: CSigAtomic -> Rational # | |
| Real CSize | |
Defined in Foreign.C.Types Methods toRational :: CSize -> Rational # | |
| Real CTime | |
Defined in Foreign.C.Types Methods toRational :: CTime -> Rational # | |
| Real CUChar | |
Defined in Foreign.C.Types Methods toRational :: CUChar -> Rational # | |
| Real CUInt | |
Defined in Foreign.C.Types Methods toRational :: CUInt -> Rational # | |
| Real CUIntMax | |
Defined in Foreign.C.Types Methods toRational :: CUIntMax -> Rational # | |
| Real CUIntPtr | |
Defined in Foreign.C.Types Methods toRational :: CUIntPtr -> Rational # | |
| Real CULLong | |
Defined in Foreign.C.Types Methods toRational :: CULLong -> Rational # | |
| Real CULong | |
Defined in Foreign.C.Types Methods toRational :: CULong -> Rational # | |
| Real CUSeconds | |
Defined in Foreign.C.Types Methods toRational :: CUSeconds -> Rational # | |
| Real CUShort | |
Defined in Foreign.C.Types Methods toRational :: CUShort -> Rational # | |
| Real CWchar | |
Defined in Foreign.C.Types Methods toRational :: CWchar -> Rational # | |
| Real IntPtr | |
Defined in Foreign.Ptr Methods toRational :: IntPtr -> Rational # | |
| Real WordPtr | |
Defined in Foreign.Ptr Methods toRational :: WordPtr -> Rational # | |
| Real Int16 | |
Defined in GHC.Int Methods toRational :: Int16 -> Rational # | |
| Real Int32 | |
Defined in GHC.Int Methods toRational :: Int32 -> Rational # | |
| Real Int64 | |
Defined in GHC.Int Methods toRational :: Int64 -> Rational # | |
| Real Int8 | |
Defined in GHC.Int Methods toRational :: Int8 -> Rational # | |
| Real Word16 | |
Defined in GHC.Word Methods toRational :: Word16 -> Rational # | |
| Real Word32 | |
Defined in GHC.Word Methods toRational :: Word32 -> Rational # | |
| Real Word64 | |
Defined in GHC.Word Methods toRational :: Word64 -> Rational # | |
| Real Word8 | |
Defined in GHC.Word Methods toRational :: Word8 -> Rational # | |
| Real CBlkCnt | |
Defined in System.Posix.Types Methods toRational :: CBlkCnt -> Rational # | |
| Real CBlkSize | |
Defined in System.Posix.Types Methods toRational :: CBlkSize -> Rational # | |
| Real CCc | |
Defined in System.Posix.Types Methods toRational :: CCc -> Rational # | |
| Real CClockId | |
Defined in System.Posix.Types Methods toRational :: CClockId -> Rational # | |
| Real CDev | |
Defined in System.Posix.Types Methods toRational :: CDev -> Rational # | |
| Real CFsBlkCnt | |
Defined in System.Posix.Types Methods toRational :: CFsBlkCnt -> Rational # | |
| Real CFsFilCnt | |
Defined in System.Posix.Types Methods toRational :: CFsFilCnt -> Rational # | |
| Real CGid | |
Defined in System.Posix.Types Methods toRational :: CGid -> Rational # | |
| Real CId | |
Defined in System.Posix.Types Methods toRational :: CId -> Rational # | |
| Real CIno | |
Defined in System.Posix.Types Methods toRational :: CIno -> Rational # | |
| Real CKey | |
Defined in System.Posix.Types Methods toRational :: CKey -> Rational # | |
| Real CMode | |
Defined in System.Posix.Types Methods toRational :: CMode -> Rational # | |
| Real CNfds | |
Defined in System.Posix.Types Methods toRational :: CNfds -> Rational # | |
| Real CNlink | |
Defined in System.Posix.Types Methods toRational :: CNlink -> Rational # | |
| Real COff | |
Defined in System.Posix.Types Methods toRational :: COff -> Rational # | |
| Real CPid | |
Defined in System.Posix.Types Methods toRational :: CPid -> Rational # | |
| Real CRLim | |
Defined in System.Posix.Types Methods toRational :: CRLim -> Rational # | |
| Real CSocklen | |
Defined in System.Posix.Types Methods toRational :: CSocklen -> Rational # | |
| Real CSpeed | |
Defined in System.Posix.Types Methods toRational :: CSpeed -> Rational # | |
| Real CSsize | |
Defined in System.Posix.Types Methods toRational :: CSsize -> Rational # | |
| Real CTcflag | |
Defined in System.Posix.Types Methods toRational :: CTcflag -> Rational # | |
| Real CUid | |
Defined in System.Posix.Types Methods toRational :: CUid -> Rational # | |
| Real Fd | |
Defined in System.Posix.Types Methods toRational :: Fd -> Rational # | |
| Real Integer | |
Defined in GHC.Real Methods toRational :: Integer -> Rational # | |
| Real Natural | |
Defined in GHC.Real Methods toRational :: Natural -> Rational # | |
| Real Int | |
Defined in GHC.Real Methods toRational :: Int -> Rational # | |
| Real Word | |
Defined in GHC.Real Methods toRational :: Word -> Rational # | |
| Real a => Real (Identity a) | |
Defined in Data.Functor.Identity Methods toRational :: Identity a -> Rational # | |
| Real a => Real (Down a) | |
Defined in Data.Ord Methods toRational :: Down a -> Rational # | |
| Integral a => Real (Ratio a) | |
Defined in GHC.Real Methods toRational :: Ratio a -> Rational # | |
| HasResolution a => Real (Fixed a) | |
Defined in Data.Fixed Methods toRational :: Fixed a -> Rational # | |
| Real a => Real (Const a b) | |
Defined in Data.Functor.Const Methods toRational :: Const a b -> Rational # | |
| Real (f (g a)) => Real (Compose f g a) | |
Defined in Data.Functor.Compose Methods toRational :: Compose f g a -> Rational # | |
(^^) :: (Fractional a, Integral b) => a -> b -> a #
fromIntegral :: (Integral a, Num b) => a -> b #
realToFrac :: (Real a, Fractional b) => a -> b #
Instances
| Show NestedAtomically | |
| Show NoMatchingContinuationPrompt | |
| Show NoMethodError | |
| Show NonTermination | |
| Show PatternMatchFail | |
| Show RecConError | |
| Show RecSelError | |
| Show RecUpdError | |
| Show TypeError | |
| Show ByteArray | |
| Show Constr | |
| Show ConstrRep | |
| Show DataRep | |
| Show DataType | |
| Show Fixity | |
| Show Dynamic | |
| Show SomeTypeRep | |
| Show Version | |
| Show CBool | |
| Show CChar | |
| Show CClock | |
| Show CDouble | |
| Show CFloat | |
| Show CInt | |
| Show CIntMax | |
| Show CIntPtr | |
| Show CLLong | |
| Show CLong | |
| Show CPtrdiff | |
| Show CSChar | |
| Show CSUSeconds | |
| Show CShort | |
| Show CSigAtomic | |
| Show CSize | |
| Show CTime | |
| Show CUChar | |
| Show CUInt | |
| Show CUIntMax | |
| Show CUIntPtr | |
| Show CULLong | |
| Show CULong | |
| Show CUSeconds | |
| Show CUShort | |
| Show CWchar | |
| Show IntPtr | |
| Show WordPtr | |
| Show Void | |
| Show ByteOrder | |
| Show BlockReason | |
| Show ThreadId | |
| Show ThreadStatus | |
| Show ErrorCall | |
| Show ArithException | |
| Show SomeException | |
| Show Fingerprint | |
| Show Associativity | |
| Show DecidedStrictness | |
| Show Fixity | |
| Show SourceStrictness | |
| Show SourceUnpackedness | |
| Show MaskingState | |
| Show SeekMode | |
| Show CodingFailureMode | |
| Show CodingProgress | |
| Show TextEncoding | |
| Show AllocationLimitExceeded | |
| Show ArrayException | |
| Show AssertionFailed | |
| Show AsyncException | |
| Show BlockedIndefinitelyOnMVar | |
| Show BlockedIndefinitelyOnSTM | |
| Show CompactionFailed | |
| Show Deadlock | |
| Show ExitCode | |
| Show FixIOException | |
| Show IOErrorType | |
| Show IOException | |
| Show SomeAsyncException | |
| Show FD | |
| Show HandlePosn | |
| Show BufferMode | |
| Show Handle | |
| Show HandleType | |
| Show Newline | |
| Show NewlineMode | |
| Show IOMode | |
| Show IOPortException | |
| Show InfoProv | |
| Show Int16 | |
| Show Int32 | |
| Show Int64 | |
| Show Int8 | |
| Show CCFlags | |
| Show ConcFlags | |
| Show DebugFlags | |
| Show DoCostCentres | |
| Show DoHeapProfile | |
| Show DoTrace | |
| Show GCFlags | |
| Show GiveGCStats | |
| Show IoSubSystem | |
| Show MiscFlags | |
| Show ParFlags | |
| Show ProfFlags | |
| Show RTSFlags | |
| Show TickyFlags | |
| Show TraceFlags | |
| Show FractionalExponentBase | |
| Show StackEntry | |
| Show CallStack | |
| Show SrcLoc | |
| Show StaticPtrInfo | |
| Show GCDetails | |
| Show RTSStats | |
| Show SomeChar | |
| Show SomeSymbol | |
| Show SomeNat | |
| Show GeneralCategory | |
| Show Word16 | |
| Show Word32 | |
| Show Word64 | |
| Show Word8 | |
| Show CBlkCnt | |
| Show CBlkSize | |
| Show CCc | |
| Show CClockId | |
| Show CDev | |
| Show CFsBlkCnt | |
| Show CFsFilCnt | |
| Show CGid | |
| Show CId | |
| Show CIno | |
| Show CKey | |
| Show CMode | |
| Show CNfds | |
| Show CNlink | |
| Show COff | |
| Show CPid | |
| Show CRLim | |
| Show CSocklen | |
| Show CSpeed | |
| Show CSsize | |
| Show CTcflag | |
| Show CTimer | |
| Show CUid | |
| Show Fd | |
| Show Timeout | |
| Show Lexeme | |
| Show Number | |
| Show IntSet | |
| Show BitQueue | |
| Show BitQueueB | |
| Show ExecTrace | |
| Show InterpException | |
| Show SolverId | |
| Show SatResult | |
| Show ForeignSrcLang | |
| Show Extension | |
| Show KindRep | |
| Show Module | |
| Show Ordering | |
| Show TrName | |
| Show TyCon | |
| Show TypeLitSort | |
| Show Mode | |
| Show Style | |
| Show TextDetails | |
| Show Doc | |
| Show AnnLookup | |
| Show AnnTarget | |
| Show Bang | |
| Show BndrVis | |
| Show Body | |
| Show Bytes | |
| Show Callconv | |
| Show Clause | |
| Show Con | |
| Show Dec | |
| Show DecidedStrictness | |
| Show DerivClause | |
| Show DerivStrategy | |
| Show DocLoc | |
| Show Exp | |
| Show FamilyResultSig | |
| Show Fixity | |
| Show FixityDirection | |
| Show Foreign | |
| Show FunDep | |
| Show Guard | |
| Show Info | |
| Show InjectivityAnn | |
| Show Inline | |
| Show Lit | |
| Show Loc | |
| Show Match | |
| Show ModName | |
| Show Module | |
| Show ModuleInfo | |
| Show Name | |
| Show NameFlavour | |
| Show NameSpace | |
| Show OccName | |
| Show Overlap | |
| Show Pat | |
| Show PatSynArgs | |
| Show PatSynDir | |
| Show Phases | |
| Show PkgName | |
| Show Pragma | |
| Show Range | |
| Show Role | |
| Show RuleBndr | |
| Show RuleMatch | |
| Show Safety | |
| Show SourceStrictness | |
| Show SourceUnpackedness | |
| Show Specificity | |
| Show Stmt | |
| Show TyLit | |
| Show TySynEqn | |
| Show Type | |
| Show TypeFamilyHead | |
| Show Integer | |
| Show Natural | |
| Show () | |
| Show Bool | |
| Show Char | |
| Show Int | |
| Show Levity | |
| Show RuntimeRep | |
| Show VecCount | |
| Show VecElem | |
| Show Word | |
| Show a => Show (ZipList a) | |
| Show a => Show (And a) | |
| Show a => Show (Iff a) | |
| Show a => Show (Ior a) | |
| Show a => Show (Xor a) | |
| Show a => Show (Complex a) | |
| Show a => Show (Identity a) | |
| Show a => Show (First a) | |
| Show a => Show (Last a) | |
| Show a => Show (Down a) | |
| Show a => Show (First a) | |
| Show a => Show (Last a) | |
| Show a => Show (Max a) | |
| Show a => Show (Min a) | |
| Show m => Show (WrappedMonoid m) | |
| Show (ConstPtr a) | |
| Show a => Show (NonEmpty a) | |
| Show (ForeignPtr a) | |
| Show p => Show (Par1 p) | |
| Show (FunPtr a) | |
| Show (Ptr a) | |
| Show a => Show (Ratio a) | |
| Show (SChar c) | |
| Show (SSymbol s) | |
| Show (SNat n) | |
| Show vertex => Show (SCC vertex) | |
| Show a => Show (IntMap a) | |
| Show a => Show (Seq a) | |
| Show a => Show (ViewL a) | |
| Show a => Show (ViewR a) | |
| Show a => Show (Intersection a) | |
| Show a => Show (Set a) | |
| Show a => Show (Tree a) | |
| Show (Stream a) Source # | |
| Show (e Unique) => Show (Graph e) | |
| Show a => Show (AnnotDetails a) | |
| Show (Doc a) | |
| Show a => Show (Span a) | |
| Show flag => Show (TyVarBndr flag) | |
| Show a => Show (Maybe a) | |
| Show a => Show (Solo a) | |
| Show a => Show [a] | |
| (Ix ix, Show ix, Show e, IArray UArray e) => Show (UArray ix e) | |
| (Show a, Show b) => Show (Either a b) | |
| HasResolution a => Show (Fixed a) | |
| Show (Proxy s) | |
| (Show a, Show b) => Show (Arg a b) | |
| Show (TypeRep a) | |
| (Ix a, Show a, Show b) => Show (Array a b) | |
| Show (U1 p) | |
| Show (V1 p) | |
| Show (ST s a) | |
| (Show k, Show a) => Show (Map k a) | |
| (KnownSymbol s, Show t) => Show (Field s t) | |
| Show t => Show (Array n t) | |
| (Show1 m, Show a) => Show (MaybeT m a) | |
| (Show a, Show b) => Show (a, b) | |
| Show a => Show (Const a b) | |
| Show (f a) => Show (Ap f a) | |
| Show (Coercion a b) | |
| Show (a :~: b) | |
| Show (OrderingI a b) | |
| Show (f p) => Show (Rec1 f p) | |
| Show (URec Char p) | |
| Show (URec Double p) | |
| Show (URec Float p) | |
| Show (URec Int p) | |
| Show (URec Word p) | |
| (Show e, Show1 m, Show a) => Show (ExceptT e m a) | |
| (Show1 f, Show a) => Show (IdentityT f a) | |
| (Show w, Show1 m, Show a) => Show (WriterT w m a) | |
| (Show w, Show1 m, Show a) => Show (WriterT w m a) | |
| (Show a, Show b, Show c) => Show (a, b, c) | |
| (Show (f a), Show (g a)) => Show (Product f g a) | |
| (Show (f a), Show (g a)) => Show (Sum f g a) | |
| Show (a :~~: b) | |
| (Show (f p), Show (g p)) => Show ((f :*: g) p) | |
| (Show (f p), Show (g p)) => Show ((f :+: g) p) | |
| Show c => Show (K1 i c p) | |
| (Show a, Show b, Show c, Show d) => Show (a, b, c, d) | |
| Show (f (g a)) => Show (Compose f g a) | |
| Show (f (g p)) => Show ((f :.: g) p) | |
| Show (f p) => Show (M1 i c f p) | |
| (Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) | |
| (Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) | |
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) | |
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) | |
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) | |
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) | |
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) | |
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) | |
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) | |
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) | |
| (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) | |
showString :: String -> ShowS #
appendFile :: FilePath -> String -> IO () #
getContents :: IO String #
Instances
| Data Bool | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Bool -> c Bool gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Bool dataTypeOf :: Bool -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Bool) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Bool) gmapT :: (forall b. Data b => b -> b) -> Bool -> Bool gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Bool -> r gmapQ :: (forall d. Data d => d -> u) -> Bool -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Bool -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Bool -> m Bool | |||||
| Storable Bool | |||||
Defined in Foreign.Storable | |||||
| Bits Bool | |||||
Defined in GHC.Bits Methods (.&.) :: Bool -> Bool -> Bool # (.|.) :: Bool -> Bool -> Bool # complement :: Bool -> Bool # clearBit :: Bool -> Int -> Bool complementBit :: Bool -> Int -> Bool testBit :: Bool -> Int -> Bool bitSizeMaybe :: Bool -> Maybe Int unsafeShiftL :: Bool -> Int -> Bool unsafeShiftR :: Bool -> Int -> Bool rotateL :: Bool -> Int -> Bool | |||||
| FiniteBits Bool | |||||
Defined in GHC.Bits Methods finiteBitSize :: Bool -> Int countLeadingZeros :: Bool -> Int countTrailingZeros :: Bool -> Int | |||||
| Bounded Bool | |||||
| Enum Bool | |||||
| Generic Bool | |||||
Defined in GHC.Generics Associated Types
| |||||
| SingKind Bool | |||||
Defined in GHC.Generics Associated Types
| |||||
| Ix Bool | |||||
| Read Bool | |||||
| Show Bool | |||||
| Typed Bool | |||||
Defined in Copilot.Core.Type | |||||
| NFData Bool | |||||
Defined in Control.DeepSeq | |||||
| Eq Bool | |||||
| Ord Bool | |||||
| IArray UArray Bool | |||||
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Bool -> (i, i) numElements :: Ix i => UArray i Bool -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Bool)] -> UArray i Bool unsafeAt :: Ix i => UArray i Bool -> Int -> Bool unsafeReplace :: Ix i => UArray i Bool -> [(Int, Bool)] -> UArray i Bool unsafeAccum :: Ix i => (Bool -> e' -> Bool) -> UArray i Bool -> [(Int, e')] -> UArray i Bool unsafeAccumArray :: Ix i => (Bool -> e' -> Bool) -> Bool -> (i, i) -> [(Int, e')] -> UArray i Bool | |||||
| SingI 'False | |||||
Defined in GHC.Generics | |||||
| SingI 'True | |||||
Defined in GHC.Generics | |||||
| Cast Bool Int16 Source # | Cast a boolean stream to a stream of numbers, producing 1 if the
value at a point in time is | ||||
| Cast Bool Int32 Source # | Cast a boolean stream to a stream of numbers, producing 1 if the
value at a point in time is | ||||
| Cast Bool Int64 Source # | Cast a boolean stream to a stream of numbers, producing 1 if the
value at a point in time is | ||||
| Cast Bool Int8 Source # | Cast a boolean stream to a stream of numbers, producing 1 if the
value at a point in time is | ||||
| Cast Bool Word16 Source # | Cast a boolean stream to a stream of numbers, producing 1 if the
value at a point in time is | ||||
| Cast Bool Word32 Source # | Cast a boolean stream to a stream of numbers, producing 1 if the
value at a point in time is | ||||
| Cast Bool Word64 Source # | Cast a boolean stream to a stream of numbers, producing 1 if the
value at a point in time is | ||||
| Cast Bool Word8 Source # | Cast a boolean stream to a stream of numbers, producing 1 if the
value at a point in time is | ||||
| Cast Bool Bool Source # | Identity casting. | ||||
| Lift Bool | |||||
| MArray IOUArray Bool IO | |||||
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Bool -> IO (i, i) getNumElements :: Ix i => IOUArray i Bool -> IO Int newArray :: Ix i => (i, i) -> Bool -> IO (IOUArray i Bool) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Bool) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Bool) unsafeRead :: Ix i => IOUArray i Bool -> Int -> IO Bool unsafeWrite :: Ix i => IOUArray i Bool -> Int -> Bool -> IO () | |||||
| MArray (STUArray s) Bool (ST s) | |||||
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Bool -> ST s (i, i) getNumElements :: Ix i => STUArray s i Bool -> ST s Int newArray :: Ix i => (i, i) -> Bool -> ST s (STUArray s i Bool) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Bool) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Bool) unsafeRead :: Ix i => STUArray s i Bool -> Int -> ST s Bool unsafeWrite :: Ix i => STUArray s i Bool -> Int -> Bool -> ST s () | |||||
| type DemoteRep Bool | |||||
Defined in GHC.Generics | |||||
| type Rep Bool | |||||
Defined in GHC.Generics | |||||
| data Sing (a :: Bool) | |||||
Instances
| Data Char | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char dataTypeOf :: Char -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Char) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char) gmapT :: (forall b. Data b => b -> b) -> Char -> Char gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r gmapQ :: (forall d. Data d => d -> u) -> Char -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char | |||||
| Storable Char | |||||
Defined in Foreign.Storable | |||||
| Bounded Char | |||||
| Enum Char | |||||
| Ix Char | |||||
| Read Char | |||||
| Show Char | |||||
| IsChar Char | |||||
| PrintfArg Char | |||||
Defined in Text.Printf | |||||
| NFData Char | |||||
Defined in Control.DeepSeq | |||||
| Eq Char | |||||
| Ord Char | |||||
| IArray UArray Char | |||||
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Char -> (i, i) numElements :: Ix i => UArray i Char -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Char)] -> UArray i Char unsafeAt :: Ix i => UArray i Char -> Int -> Char unsafeReplace :: Ix i => UArray i Char -> [(Int, Char)] -> UArray i Char unsafeAccum :: Ix i => (Char -> e' -> Char) -> UArray i Char -> [(Int, e')] -> UArray i Char unsafeAccumArray :: Ix i => (Char -> e' -> Char) -> Char -> (i, i) -> [(Int, e')] -> UArray i Char | |||||
| TestCoercion SChar | |||||
Defined in GHC.TypeLits Methods testCoercion :: forall (a :: Char) (b :: Char). SChar a -> SChar b -> Maybe (Coercion a b) | |||||
| TestEquality SChar | |||||
Defined in GHC.TypeLits Methods testEquality :: forall (a :: Char) (b :: Char). SChar a -> SChar b -> Maybe (a :~: b) | |||||
| Lift Char | |||||
| MArray IOUArray Char IO | |||||
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Char -> IO (i, i) getNumElements :: Ix i => IOUArray i Char -> IO Int newArray :: Ix i => (i, i) -> Char -> IO (IOUArray i Char) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Char) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Char) unsafeRead :: Ix i => IOUArray i Char -> Int -> IO Char unsafeWrite :: Ix i => IOUArray i Char -> Int -> Char -> IO () | |||||
| Generic1 (URec Char :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Foldable (UChar :: Type -> Type) | |||||
Defined in Data.Foldable Methods fold :: Monoid m => UChar m -> m foldMap :: Monoid m => (a -> m) -> UChar a -> m # foldMap' :: Monoid m => (a -> m) -> UChar a -> m foldr :: (a -> b -> b) -> b -> UChar a -> b # foldr' :: (a -> b -> b) -> b -> UChar a -> b foldl :: (b -> a -> b) -> b -> UChar a -> b # foldl' :: (b -> a -> b) -> b -> UChar a -> b foldr1 :: (a -> a -> a) -> UChar a -> a # foldl1 :: (a -> a -> a) -> UChar a -> a # toList :: UChar a -> [a] elem :: Eq a => a -> UChar a -> Bool # maximum :: Ord a => UChar a -> a # | |||||
| Traversable (UChar :: Type -> Type) | |||||
Defined in Data.Traversable | |||||
| MArray (STUArray s) Char (ST s) | |||||
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Char -> ST s (i, i) getNumElements :: Ix i => STUArray s i Char -> ST s Int newArray :: Ix i => (i, i) -> Char -> ST s (STUArray s i Char) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Char) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Char) unsafeRead :: Ix i => STUArray s i Char -> Int -> ST s Char unsafeWrite :: Ix i => STUArray s i Char -> Int -> Char -> ST s () | |||||
| Functor (URec Char :: Type -> Type) | |||||
| Generic (URec Char p) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Show (URec Char p) | |||||
| Eq (URec Char p) | |||||
| Ord (URec Char p) | |||||
| data URec Char (p :: k) | |||||
Defined in GHC.Generics | |||||
| type Compare (a :: Char) (b :: Char) | |||||
Defined in Data.Type.Ord | |||||
| type Rep1 (URec Char :: k -> Type) | |||||
Defined in GHC.Generics | |||||
| type Rep (URec Char p) | |||||
Defined in GHC.Generics | |||||
Instances
| Data Double | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Double -> c Double gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Double dataTypeOf :: Double -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Double) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Double) gmapT :: (forall b. Data b => b -> b) -> Double -> Double gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Double -> r gmapQ :: (forall d. Data d => d -> u) -> Double -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Double -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Double -> m Double gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Double -> m Double | |||||
| Storable Double | |||||
Defined in Foreign.Storable | |||||
| Floating Double | |||||
| RealFloat Double | |||||
Defined in GHC.Float Methods floatRadix :: Double -> Integer # floatDigits :: Double -> Int # floatRange :: Double -> (Int, Int) # decodeFloat :: Double -> (Integer, Int) # encodeFloat :: Integer -> Int -> Double # significand :: Double -> Double # scaleFloat :: Int -> Double -> Double # isInfinite :: Double -> Bool # isDenormalized :: Double -> Bool # isNegativeZero :: Double -> Bool # | |||||
| Read Double | |||||
| PrintfArg Double | |||||
Defined in Text.Printf | |||||
| Typed Double | |||||
Defined in Copilot.Core.Type | |||||
| NFData Double | |||||
Defined in Control.DeepSeq | |||||
| Eq Double | |||||
| Ord Double | |||||
| IArray UArray Double | |||||
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Double -> (i, i) numElements :: Ix i => UArray i Double -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Double)] -> UArray i Double unsafeAt :: Ix i => UArray i Double -> Int -> Double unsafeReplace :: Ix i => UArray i Double -> [(Int, Double)] -> UArray i Double unsafeAccum :: Ix i => (Double -> e' -> Double) -> UArray i Double -> [(Int, e')] -> UArray i Double unsafeAccumArray :: Ix i => (Double -> e' -> Double) -> Double -> (i, i) -> [(Int, e')] -> UArray i Double | |||||
| UnsafeCast Int16 Double Source # | Unsafe signed integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Int32 Double Source # | Unsafe signed integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Int64 Double Source # | Unsafe signed integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Int8 Double Source # | Unsafe signed integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Word16 Double Source # | Unsafe unsigned integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Word32 Double Source # | Unsafe unsigned integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Word64 Double Source # | Unsafe unsigned integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Word8 Double Source # | Unsafe unsigned integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| Lift Double | |||||
| MArray IOUArray Double IO | |||||
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Double -> IO (i, i) getNumElements :: Ix i => IOUArray i Double -> IO Int newArray :: Ix i => (i, i) -> Double -> IO (IOUArray i Double) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Double) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Double) unsafeRead :: Ix i => IOUArray i Double -> Int -> IO Double unsafeWrite :: Ix i => IOUArray i Double -> Int -> Double -> IO () | |||||
| Generic1 (URec Double :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Foldable (UDouble :: Type -> Type) | |||||
Defined in Data.Foldable Methods fold :: Monoid m => UDouble m -> m foldMap :: Monoid m => (a -> m) -> UDouble a -> m # foldMap' :: Monoid m => (a -> m) -> UDouble a -> m foldr :: (a -> b -> b) -> b -> UDouble a -> b # foldr' :: (a -> b -> b) -> b -> UDouble a -> b foldl :: (b -> a -> b) -> b -> UDouble a -> b # foldl' :: (b -> a -> b) -> b -> UDouble a -> b foldr1 :: (a -> a -> a) -> UDouble a -> a # foldl1 :: (a -> a -> a) -> UDouble a -> a # toList :: UDouble a -> [a] elem :: Eq a => a -> UDouble a -> Bool # maximum :: Ord a => UDouble a -> a # minimum :: Ord a => UDouble a -> a # | |||||
| Traversable (UDouble :: Type -> Type) | |||||
Defined in Data.Traversable | |||||
| MArray (STUArray s) Double (ST s) | |||||
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Double -> ST s (i, i) getNumElements :: Ix i => STUArray s i Double -> ST s Int newArray :: Ix i => (i, i) -> Double -> ST s (STUArray s i Double) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Double) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Double) unsafeRead :: Ix i => STUArray s i Double -> Int -> ST s Double unsafeWrite :: Ix i => STUArray s i Double -> Int -> Double -> ST s () | |||||
| Functor (URec Double :: Type -> Type) | |||||
| Generic (URec Double p) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Show (URec Double p) | |||||
| Eq (URec Double p) | |||||
| Ord (URec Double p) | |||||
Defined in GHC.Generics | |||||
| data URec Double (p :: k) | |||||
Defined in GHC.Generics | |||||
| type Rep1 (URec Double :: k -> Type) | |||||
Defined in GHC.Generics | |||||
| type Rep (URec Double p) | |||||
Defined in GHC.Generics | |||||
Instances
| Data Float | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Float -> c Float gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Float dataTypeOf :: Float -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Float) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Float) gmapT :: (forall b. Data b => b -> b) -> Float -> Float gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Float -> r gmapQ :: (forall d. Data d => d -> u) -> Float -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Float -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Float -> m Float gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Float -> m Float | |||||
| Storable Float | |||||
Defined in Foreign.Storable | |||||
| Floating Float | |||||
| RealFloat Float | |||||
Defined in GHC.Float Methods floatRadix :: Float -> Integer # floatDigits :: Float -> Int # floatRange :: Float -> (Int, Int) # decodeFloat :: Float -> (Integer, Int) # encodeFloat :: Integer -> Int -> Float # significand :: Float -> Float # scaleFloat :: Int -> Float -> Float # isInfinite :: Float -> Bool # isDenormalized :: Float -> Bool # isNegativeZero :: Float -> Bool # | |||||
| Read Float | |||||
| PrintfArg Float | |||||
Defined in Text.Printf | |||||
| Typed Float | |||||
Defined in Copilot.Core.Type | |||||
| NFData Float | |||||
Defined in Control.DeepSeq | |||||
| Eq Float | |||||
| Ord Float | |||||
| IArray UArray Float | |||||
Defined in Data.Array.Base Methods bounds :: Ix i => UArray i Float -> (i, i) numElements :: Ix i => UArray i Float -> Int unsafeArray :: Ix i => (i, i) -> [(Int, Float)] -> UArray i Float unsafeAt :: Ix i => UArray i Float -> Int -> Float unsafeReplace :: Ix i => UArray i Float -> [(Int, Float)] -> UArray i Float unsafeAccum :: Ix i => (Float -> e' -> Float) -> UArray i Float -> [(Int, e')] -> UArray i Float unsafeAccumArray :: Ix i => (Float -> e' -> Float) -> Float -> (i, i) -> [(Int, e')] -> UArray i Float | |||||
| UnsafeCast Int16 Float Source # | Unsafe signed integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Int32 Float Source # | Unsafe signed integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Int64 Float Source # | Unsafe signed integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Int8 Float Source # | Unsafe signed integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Word16 Float Source # | Unsafe unsigned integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Word32 Float Source # | Unsafe unsigned integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Word64 Float Source # | Unsafe unsigned integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| UnsafeCast Word8 Float Source # | Unsafe unsigned integer promotion to floating point values. | ||||
Defined in Copilot.Language.Operators.Cast | |||||
| Lift Float | |||||
| MArray IOUArray Float IO | |||||
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Float -> IO (i, i) getNumElements :: Ix i => IOUArray i Float -> IO Int newArray :: Ix i => (i, i) -> Float -> IO (IOUArray i Float) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Float) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Float) unsafeRead :: Ix i => IOUArray i Float -> Int -> IO Float unsafeWrite :: Ix i => IOUArray i Float -> Int -> Float -> IO () | |||||
| Generic1 (URec Float :: k -> Type) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Foldable (UFloat :: Type -> Type) | |||||
Defined in Data.Foldable Methods fold :: Monoid m => UFloat m -> m foldMap :: Monoid m => (a -> m) -> UFloat a -> m # foldMap' :: Monoid m => (a -> m) -> UFloat a -> m foldr :: (a -> b -> b) -> b -> UFloat a -> b # foldr' :: (a -> b -> b) -> b -> UFloat a -> b foldl :: (b -> a -> b) -> b -> UFloat a -> b # foldl' :: (b -> a -> b) -> b -> UFloat a -> b foldr1 :: (a -> a -> a) -> UFloat a -> a # foldl1 :: (a -> a -> a) -> UFloat a -> a # toList :: UFloat a -> [a] elem :: Eq a => a -> UFloat a -> Bool # maximum :: Ord a => UFloat a -> a # | |||||
| Traversable (UFloat :: Type -> Type) | |||||
Defined in Data.Traversable | |||||
| MArray (STUArray s) Float (ST s) | |||||
Defined in Data.Array.Base Methods getBounds :: Ix i => STUArray s i Float -> ST s (i, i) getNumElements :: Ix i => STUArray s i Float -> ST s Int newArray :: Ix i => (i, i) -> Float -> ST s (STUArray s i Float) newArray_ :: Ix i => (i, i) -> ST s (STUArray s i Float) unsafeNewArray_ :: Ix i => (i, i) -> ST s (STUArray s i Float) unsafeRead :: Ix i => STUArray s i Float -> Int -> ST s Float unsafeWrite :: Ix i => STUArray s i Float -> Int -> Float -> ST s () | |||||
| Functor (URec Float :: Type -> Type) | |||||
| Generic (URec Float p) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Show (URec Float p) | |||||
| Eq (URec Float p) | |||||
| Ord (URec Float p) | |||||
Defined in GHC.Generics | |||||
| data URec Float (p :: k) | |||||
Defined in GHC.Generics | |||||
| type Rep1 (URec Float :: k -> Type) | |||||
Defined in GHC.Generics | |||||
| type Rep (URec Float p) | |||||
Defined in GHC.Generics | |||||
Instances
| Data Ordering | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ordering -> c Ordering gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Ordering toConstr :: Ordering -> Constr dataTypeOf :: Ordering -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Ordering) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ordering) gmapT :: (forall b. Data b => b -> b) -> Ordering -> Ordering gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ordering -> r gmapQ :: (forall d. Data d => d -> u) -> Ordering -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Ordering -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ordering -> m Ordering | |||||
| Monoid Ordering | |||||
| Semigroup Ordering | |||||
| Bounded Ordering | |||||
| Enum Ordering | |||||
| Generic Ordering | |||||
Defined in GHC.Generics Associated Types
| |||||
| Ix Ordering | |||||
Defined in GHC.Ix | |||||
| Read Ordering | |||||
| Show Ordering | |||||
| NFData Ordering | |||||
Defined in Control.DeepSeq | |||||
| Eq Ordering | |||||
| Ord Ordering | |||||
| type Rep Ordering | |||||
Instances
| MonadFail Maybe | |||||
Defined in Control.Monad.Fail | |||||
| MonadFix Maybe | |||||
Defined in Control.Monad.Fix | |||||
| MonadZip Maybe | |||||
| Foldable Maybe | |||||
Defined in Data.Foldable Methods fold :: Monoid m => Maybe m -> m foldMap :: Monoid m => (a -> m) -> Maybe a -> m # foldMap' :: Monoid m => (a -> m) -> Maybe a -> m foldr :: (a -> b -> b) -> b -> Maybe a -> b # foldr' :: (a -> b -> b) -> b -> Maybe a -> b foldl :: (b -> a -> b) -> b -> Maybe a -> b # foldl' :: (b -> a -> b) -> b -> Maybe a -> b foldr1 :: (a -> a -> a) -> Maybe a -> a # foldl1 :: (a -> a -> a) -> Maybe a -> a # elem :: Eq a => a -> Maybe a -> Bool # maximum :: Ord a => Maybe a -> a # | |||||
| Eq1 Maybe | |||||
| Ord1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftCompare :: (a -> b -> Ordering) -> Maybe a -> Maybe b -> Ordering | |||||
| Read1 Maybe | |||||
Defined in Data.Functor.Classes Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (Maybe a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [Maybe a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (Maybe a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [Maybe a] | |||||
| Show1 Maybe | |||||
Defined in Data.Functor.Classes | |||||
| Traversable Maybe | |||||
| Alternative Maybe | |||||
| Applicative Maybe | |||||
| Functor Maybe | |||||
| Monad Maybe | |||||
| MonadPlus Maybe | |||||
| NFData1 Maybe | |||||
Defined in Control.DeepSeq | |||||
| Generic1 Maybe | |||||
Defined in GHC.Generics Associated Types
| |||||
| MonadError () Maybe | |||||
Defined in Control.Monad.Error.Class | |||||
| Lift a => Lift (Maybe a :: Type) | |||||
| Data a => Data (Maybe a) | |||||
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Maybe a -> c (Maybe a) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Maybe a) dataTypeOf :: Maybe a -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Maybe a)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Maybe a)) gmapT :: (forall b. Data b => b -> b) -> Maybe a -> Maybe a gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Maybe a -> r gmapQ :: (forall d. Data d => d -> u) -> Maybe a -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Maybe a -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Maybe a -> m (Maybe a) | |||||
| Semigroup a => Monoid (Maybe a) | |||||
| Semigroup a => Semigroup (Maybe a) | |||||
| Generic (Maybe a) | |||||
Defined in GHC.Generics Associated Types
| |||||
| SingKind a => SingKind (Maybe a) | |||||
Defined in GHC.Generics Associated Types
| |||||
| Read a => Read (Maybe a) | |||||
| Show a => Show (Maybe a) | |||||
| NFData a => NFData (Maybe a) | |||||
Defined in Control.DeepSeq | |||||
| Eq a => Eq (Maybe a) | |||||
| Ord a => Ord (Maybe a) | |||||
| SingI ('Nothing :: Maybe a) | |||||
Defined in GHC.Generics | |||||
| SingI a2 => SingI ('Just a2 :: Maybe a1) | |||||
Defined in GHC.Generics | |||||
| type Rep1 Maybe | |||||
| type DemoteRep (Maybe a) | |||||
Defined in GHC.Generics | |||||
| type Rep (Maybe a) | |||||
Defined in GHC.Generics | |||||
| data Sing (b :: Maybe a) | |||||
Instances
| Data Integer | |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Integer -> c Integer gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Integer dataTypeOf :: Integer -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Integer) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Integer) gmapT :: (forall b. Data b => b -> b) -> Integer -> Integer gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Integer -> r gmapQ :: (forall d. Data d => d -> u) -> Integer -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> Integer -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> Integer -> m Integer gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Integer -> m Integer | |
| Bits Integer | |
Defined in GHC.Bits Methods (.&.) :: Integer -> Integer -> Integer # (.|.) :: Integer -> Integer -> Integer # xor :: Integer -> Integer -> Integer complement :: Integer -> Integer # shift :: Integer -> Int -> Integer rotate :: Integer -> Int -> Integer setBit :: Integer -> Int -> Integer clearBit :: Integer -> Int -> Integer complementBit :: Integer -> Int -> Integer testBit :: Integer -> Int -> Bool bitSizeMaybe :: Integer -> Maybe Int shiftL :: Integer -> Int -> Integer unsafeShiftL :: Integer -> Int -> Integer shiftR :: Integer -> Int -> Integer unsafeShiftR :: Integer -> Int -> Integer rotateL :: Integer -> Int -> Integer | |
| Enum Integer | |
| Ix Integer | |
| Num Integer | |
| Read Integer | |
| Integral Integer | |
Defined in GHC.Real | |
| Real Integer | |
Defined in GHC.Real Methods toRational :: Integer -> Rational # | |
| Show Integer | |
| PrintfArg Integer | |
Defined in Text.Printf | |
| NFData Integer | |
Defined in Control.DeepSeq | |
| Eq Integer | |
| Ord Integer | |
| Lift Integer | |
Instances
| MonadFail IO | |
Defined in Control.Monad.Fail | |
| MonadFix IO | |
Defined in Control.Monad.Fix | |
| MonadIO IO | |
Defined in Control.Monad.IO.Class | |
| Alternative IO | |
| Applicative IO | |
| Functor IO | |
| Monad IO | |
| MonadPlus IO | |
| GHCiSandboxIO IO | |
Defined in GHC.GHCi Methods ghciStepIO :: IO a -> IO a | |
| Quasi IO | |
Defined in Language.Haskell.TH.Syntax Methods qReport :: Bool -> String -> IO () qRecover :: IO a -> IO a -> IO a qLookupName :: Bool -> String -> IO (Maybe Name) qReifyFixity :: Name -> IO (Maybe Fixity) qReifyType :: Name -> IO Type qReifyInstances :: Name -> [Type] -> IO [Dec] qReifyRoles :: Name -> IO [Role] qReifyAnnotations :: Data a => AnnLookup -> IO [a] qReifyModule :: Module -> IO ModuleInfo qReifyConStrictness :: Name -> IO [DecidedStrictness] qGetPackageRoot :: IO FilePath qAddDependentFile :: FilePath -> IO () qAddTempFile :: String -> IO FilePath qAddTopDecls :: [Dec] -> IO () qAddForeignFilePath :: ForeignSrcLang -> String -> IO () qAddModFinalizer :: Q () -> IO () qAddCorePlugin :: String -> IO () qGetQ :: Typeable a => IO (Maybe a) qPutQ :: Typeable a => a -> IO () qIsExtEnabled :: Extension -> IO Bool qExtsEnabled :: IO [Extension] | |
| Quote IO | |
Defined in Language.Haskell.TH.Syntax | |
| MonadError IOException IO | |
Defined in Control.Monad.Error.Class | |
| MArray IOUArray Int16 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Int16 -> IO (i, i) getNumElements :: Ix i => IOUArray i Int16 -> IO Int newArray :: Ix i => (i, i) -> Int16 -> IO (IOUArray i Int16) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Int16) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Int16) unsafeRead :: Ix i => IOUArray i Int16 -> Int -> IO Int16 unsafeWrite :: Ix i => IOUArray i Int16 -> Int -> Int16 -> IO () | |
| MArray IOUArray Int32 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Int32 -> IO (i, i) getNumElements :: Ix i => IOUArray i Int32 -> IO Int newArray :: Ix i => (i, i) -> Int32 -> IO (IOUArray i Int32) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Int32) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Int32) unsafeRead :: Ix i => IOUArray i Int32 -> Int -> IO Int32 unsafeWrite :: Ix i => IOUArray i Int32 -> Int -> Int32 -> IO () | |
| MArray IOUArray Int64 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Int64 -> IO (i, i) getNumElements :: Ix i => IOUArray i Int64 -> IO Int newArray :: Ix i => (i, i) -> Int64 -> IO (IOUArray i Int64) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Int64) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Int64) unsafeRead :: Ix i => IOUArray i Int64 -> Int -> IO Int64 unsafeWrite :: Ix i => IOUArray i Int64 -> Int -> Int64 -> IO () | |
| MArray IOUArray Int8 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Int8 -> IO (i, i) getNumElements :: Ix i => IOUArray i Int8 -> IO Int newArray :: Ix i => (i, i) -> Int8 -> IO (IOUArray i Int8) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Int8) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Int8) unsafeRead :: Ix i => IOUArray i Int8 -> Int -> IO Int8 unsafeWrite :: Ix i => IOUArray i Int8 -> Int -> Int8 -> IO () | |
| MArray IOUArray Word16 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word16 -> IO (i, i) getNumElements :: Ix i => IOUArray i Word16 -> IO Int newArray :: Ix i => (i, i) -> Word16 -> IO (IOUArray i Word16) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word16) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word16) unsafeRead :: Ix i => IOUArray i Word16 -> Int -> IO Word16 unsafeWrite :: Ix i => IOUArray i Word16 -> Int -> Word16 -> IO () | |
| MArray IOUArray Word32 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word32 -> IO (i, i) getNumElements :: Ix i => IOUArray i Word32 -> IO Int newArray :: Ix i => (i, i) -> Word32 -> IO (IOUArray i Word32) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word32) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word32) unsafeRead :: Ix i => IOUArray i Word32 -> Int -> IO Word32 unsafeWrite :: Ix i => IOUArray i Word32 -> Int -> Word32 -> IO () | |
| MArray IOUArray Word64 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word64 -> IO (i, i) getNumElements :: Ix i => IOUArray i Word64 -> IO Int newArray :: Ix i => (i, i) -> Word64 -> IO (IOUArray i Word64) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word64) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word64) unsafeRead :: Ix i => IOUArray i Word64 -> Int -> IO Word64 unsafeWrite :: Ix i => IOUArray i Word64 -> Int -> Word64 -> IO () | |
| MArray IOUArray Word8 IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word8 -> IO (i, i) getNumElements :: Ix i => IOUArray i Word8 -> IO Int newArray :: Ix i => (i, i) -> Word8 -> IO (IOUArray i Word8) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word8) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word8) unsafeRead :: Ix i => IOUArray i Word8 -> Int -> IO Word8 unsafeWrite :: Ix i => IOUArray i Word8 -> Int -> Word8 -> IO () | |
| MArray IOUArray Bool IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Bool -> IO (i, i) getNumElements :: Ix i => IOUArray i Bool -> IO Int newArray :: Ix i => (i, i) -> Bool -> IO (IOUArray i Bool) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Bool) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Bool) unsafeRead :: Ix i => IOUArray i Bool -> Int -> IO Bool unsafeWrite :: Ix i => IOUArray i Bool -> Int -> Bool -> IO () | |
| MArray IOUArray Char IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Char -> IO (i, i) getNumElements :: Ix i => IOUArray i Char -> IO Int newArray :: Ix i => (i, i) -> Char -> IO (IOUArray i Char) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Char) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Char) unsafeRead :: Ix i => IOUArray i Char -> Int -> IO Char unsafeWrite :: Ix i => IOUArray i Char -> Int -> Char -> IO () | |
| MArray IOUArray Double IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Double -> IO (i, i) getNumElements :: Ix i => IOUArray i Double -> IO Int newArray :: Ix i => (i, i) -> Double -> IO (IOUArray i Double) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Double) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Double) unsafeRead :: Ix i => IOUArray i Double -> Int -> IO Double unsafeWrite :: Ix i => IOUArray i Double -> Int -> Double -> IO () | |
| MArray IOUArray Float IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Float -> IO (i, i) getNumElements :: Ix i => IOUArray i Float -> IO Int newArray :: Ix i => (i, i) -> Float -> IO (IOUArray i Float) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Float) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Float) unsafeRead :: Ix i => IOUArray i Float -> Int -> IO Float unsafeWrite :: Ix i => IOUArray i Float -> Int -> Float -> IO () | |
| MArray IOUArray Int IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Int -> IO (i, i) getNumElements :: Ix i => IOUArray i Int -> IO Int newArray :: Ix i => (i, i) -> Int -> IO (IOUArray i Int) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Int) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Int) unsafeRead :: Ix i => IOUArray i Int -> Int -> IO Int unsafeWrite :: Ix i => IOUArray i Int -> Int -> Int -> IO () | |
| MArray IOUArray Word IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i Word -> IO (i, i) getNumElements :: Ix i => IOUArray i Word -> IO Int newArray :: Ix i => (i, i) -> Word -> IO (IOUArray i Word) newArray_ :: Ix i => (i, i) -> IO (IOUArray i Word) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i Word) unsafeRead :: Ix i => IOUArray i Word -> Int -> IO Word unsafeWrite :: Ix i => IOUArray i Word -> Int -> Word -> IO () | |
| Storable e => MArray StorableArray e IO | |
Defined in Data.Array.Storable.Internals Methods getBounds :: Ix i => StorableArray i e -> IO (i, i) getNumElements :: Ix i => StorableArray i e -> IO Int newArray :: Ix i => (i, i) -> e -> IO (StorableArray i e) newArray_ :: Ix i => (i, i) -> IO (StorableArray i e) unsafeNewArray_ :: Ix i => (i, i) -> IO (StorableArray i e) unsafeRead :: Ix i => StorableArray i e -> Int -> IO e unsafeWrite :: Ix i => StorableArray i e -> Int -> e -> IO () | |
| MArray IOArray e IO | |
Defined in Data.Array.Base Methods getBounds :: Ix i => IOArray i e -> IO (i, i) getNumElements :: Ix i => IOArray i e -> IO Int newArray :: Ix i => (i, i) -> e -> IO (IOArray i e) newArray_ :: Ix i => (i, i) -> IO (IOArray i e) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOArray i e) unsafeRead :: Ix i => IOArray i e -> Int -> IO e unsafeWrite :: Ix i => IOArray i e -> Int -> e -> IO () | |
| MArray IOUArray (FunPtr a) IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i (FunPtr a) -> IO (i, i) getNumElements :: Ix i => IOUArray i (FunPtr a) -> IO Int newArray :: Ix i => (i, i) -> FunPtr a -> IO (IOUArray i (FunPtr a)) newArray_ :: Ix i => (i, i) -> IO (IOUArray i (FunPtr a)) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i (FunPtr a)) unsafeRead :: Ix i => IOUArray i (FunPtr a) -> Int -> IO (FunPtr a) unsafeWrite :: Ix i => IOUArray i (FunPtr a) -> Int -> FunPtr a -> IO () | |
| MArray IOUArray (Ptr a) IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i (Ptr a) -> IO (i, i) getNumElements :: Ix i => IOUArray i (Ptr a) -> IO Int newArray :: Ix i => (i, i) -> Ptr a -> IO (IOUArray i (Ptr a)) newArray_ :: Ix i => (i, i) -> IO (IOUArray i (Ptr a)) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i (Ptr a)) unsafeRead :: Ix i => IOUArray i (Ptr a) -> Int -> IO (Ptr a) unsafeWrite :: Ix i => IOUArray i (Ptr a) -> Int -> Ptr a -> IO () | |
| MArray IOUArray (StablePtr a) IO | |
Defined in Data.Array.IO.Internals Methods getBounds :: Ix i => IOUArray i (StablePtr a) -> IO (i, i) getNumElements :: Ix i => IOUArray i (StablePtr a) -> IO Int newArray :: Ix i => (i, i) -> StablePtr a -> IO (IOUArray i (StablePtr a)) newArray_ :: Ix i => (i, i) -> IO (IOUArray i (StablePtr a)) unsafeNewArray_ :: Ix i => (i, i) -> IO (IOUArray i (StablePtr a)) unsafeRead :: Ix i => IOUArray i (StablePtr a) -> Int -> IO (StablePtr a) unsafeWrite :: Ix i => IOUArray i (StablePtr a) -> Int -> StablePtr a -> IO () | |
| Monoid a => Monoid (IO a) | |
| Semigroup a => Semigroup (IO a) | |
| a ~ () => HPrintfType (IO a) | |
Defined in Text.Printf | |
| a ~ () => PrintfType (IO a) | |
Defined in Text.Printf | |