Safe Haskell | None |
---|
- (<>) :: Monoid a => a -> a -> a
- (++) :: [a] -> [a] -> [a]
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- ($!) :: (a -> b) -> a -> b
- data Double
- class Binary t
- data Char
- data Either a b
- type Endom a = a -> a
- class Eq a where
- class Num a => Fractional a where
- (/) :: a -> a -> a
- recip :: a -> a
- fromRational :: Rational -> a
- class Functor f where
- fmap :: (a -> b) -> f a -> f b
- data IO a
- class Initializable a where
- initial :: a
- data Integer
- class (Real a, Enum a) => Integral a where
- class Bounded a where
- class Enum a where
- succ :: a -> a
- pred :: a -> a
- toEnum :: Int -> a
- fromEnum :: a -> Int
- enumFrom :: a -> [a]
- enumFromThen :: a -> a -> [a]
- enumFromTo :: a -> a -> [a]
- enumFromThenTo :: a -> a -> a -> [a]
- data Maybe a
- class Monad m where
- class Num a where
- class Eq a => Ord a where
- class Read a where
- class (Num a, Ord a) => Real a where
- toRational :: a -> Rational
- class (Real a, Fractional a) => RealFrac a where
- newtype ReaderT r m a = ReaderT {
- runReaderT :: r -> m a
- class SemiNum absolute relative | absolute -> relative where
- type String = [Char]
- class Typeable a
- commonPrefix :: Eq a => [[a]] -> [a]
- discard :: Functor f => f a -> f ()
- dummyPut :: a -> Put
- dummyGet :: Initializable a => Get a
- every :: Traversable t => Accessor whole part -> Accessor (t whole) (t part)
- findPL :: (a -> Bool) -> [a] -> Maybe (PointedList a)
- focusA :: Accessor (PointedList a) a
- fromIntegral :: (Integral a, Num b) => a -> b
- fst :: (a, b) -> a
- fst3 :: (a, b, c) -> a
- groupBy' :: (a -> a -> Bool) -> [a] -> [[a]]
- list :: b -> (a -> [a] -> b) -> [a] -> b
- head :: [a] -> a
- init :: [a] -> [a]
- io :: MonadIO m => IO a -> m a
- last :: [a] -> a
- lookup :: Eq a => a -> [(a, b)] -> Maybe b
- mapAdjust' :: Ord k => (a -> a) -> k -> Map k a -> Map k a
- mapAlter' :: Ord k => (Maybe a -> Maybe a) -> k -> Map k a -> Map k a
- mapFromFoldable :: (Foldable t, Ord k) => t (k, a) -> Map k a
- module Data.Accessor
- module Data.Accessor.Monad.MTL.State
- putA :: MonadState r m => T r a -> a -> m ()
- getA :: MonadState r m => T r a -> m a
- modA :: MonadState r m => T r a -> (a -> a) -> m ()
- data Rope
- fromString :: String -> Rope
- toString :: Rope -> String
- toReverseString :: Rope -> String
- null :: Rope -> Bool
- empty :: Rope
- take :: Int -> Rope -> Rope
- drop :: Int -> Rope -> Rope
- length :: Rope -> Int
- reverse :: Rope -> Rope
- countNewLines :: Rope -> Int
- split :: Word8 -> Rope -> [Rope]
- splitAt :: Int -> Rope -> (Rope, Rope)
- splitAtLine :: Int -> Rope -> (Rope, Rope)
- append :: Rope -> Rope -> Rope
- concat :: [Rope] -> Rope
- readFile :: FilePath -> IO Rope
- writeFile :: FilePath -> Rope -> IO ()
- splitAtChunkBefore :: Int -> Rope -> (Rope, Rope)
- module Yi.Debug
- module Yi.Monad
- nubSet :: Ord a => [a] -> [a]
- null :: [a] -> Bool
- print :: Show a => a -> IO ()
- putStrLn :: String -> IO ()
- replicate :: Int -> a -> [a]
- read :: Read a => String -> a
- seq :: a -> b -> b
- singleton :: a -> [a]
- snd :: (a, b) -> b
- snd3 :: (a, b, c) -> b
- swapFocus :: (PointedList a -> PointedList a) -> PointedList a -> PointedList a
- tail :: [a] -> [a]
- trd3 :: (a, b, c) -> c
- undefined :: a
- unlines :: [String] -> String
- when :: Monad m => Bool -> m () -> m ()
- writeFile :: FilePath -> String -> IO ()
Documentation
(++) :: [a] -> [a] -> [a]
($!) :: (a -> b) -> a -> b
data Double
Enum Double | |
Eq Double | |
Floating Double | |
Fractional Double | |
Data Double | |
Num Double | |
Ord Double | |
Read Double | |
Real Double | |
RealFloat Double | |
RealFrac Double | |
Show Double | |
Typeable Double | |
Generic Double | |
Arbitrary Double | |
CoArbitrary Double | |
Hashable Double | |
Random Double | |
Binary Double | |
PrintfArg Double | |
IArray UArray Double | |
MArray (STUArray s) Double (ST s) |
class Binary t
data Char
Bounded Char | |
Enum Char | |
Eq Char | |
Data Char | |
Ord Char | |
Read Char | |
Show Char | |
Ix Char | |
Typeable Char | |
Generic Char | |
Arbitrary Char | |
CoArbitrary Char | |
Lift Char | |
Hashable Char | |
Outputable Char | |
Random Char | |
Extract String | |
ErrorList Char | |
Binary Char | |
PrintfArg Char | |
IsChar Char | |
RegexLike Regex String | |
IArray UArray Char | |
MkSnippetCmd String () | |
Monad m => Stream ByteString m Char | |
Monad m => Stream ByteString m Char | |
Monad m => Stream Text m Char | |
Monad m => Stream Text m Char | |
RegexContext Regex String String | |
RegexMaker Regex CompOption ExecOption String | |
RegexMaker Regex CompOption ExecOption (Seq Char) | |
RegexLike Regex (Seq Char) | |
RegexContext Regex (Seq Char) (Seq Char) | |
IsString [Char] | |
IsString (DList Char) | |
MArray (STUArray s) Char (ST s) | |
YiVariable (Map String History) |
data Either a b
Typeable2 Either | |
MonadError e (Either e) | |
Monad (Either e) | |
Functor (Either a) | |
MonadFix (Either e) | |
Error e => MonadPlus (Either e) | |
Applicative (Either e) | |
Generic1 (Either a) | |
~ * e SomeException => MonadThrow (Either e) | |
Error e => Alternative (Either e) | |
(Eq a, Eq b) => Eq (Either a b) | |
(Data a, Data b) => Data (Either a b) | |
(Ord a, Ord b) => Ord (Either a b) | |
(Read a, Read b) => Read (Either a b) | |
(Show a, Show b) => Show (Either a b) | |
Generic (Either a b) | |
(Arbitrary a, Arbitrary b) => Arbitrary (Either a b) | |
(CoArbitrary a, CoArbitrary b) => CoArbitrary (Either a b) | |
(Lift a, Lift b) => Lift (Either a b) | |
(Hashable a, Hashable b) => Hashable (Either a b) | |
(Binary a, Binary b) => Binary (Either a b) |
class Eq a where
Eq Bool | |
Eq Char | |
Eq Double | |
Eq Float | |
Eq Int | |
Eq Int8 | |
Eq Int16 | |
Eq Int32 | |
Eq Int64 | |
Eq Integer | |
Eq Ordering | |
Eq Word | |
Eq Word8 | |
Eq Word16 | |
Eq Word32 | |
Eq Word64 | |
Eq Exp | |
Eq Match | |
Eq Clause | |
Eq Pat | |
Eq Type | |
Eq Dec | |
Eq Name | |
Eq FunDep | |
Eq Pred | |
Eq TyVarBndr | |
Eq () | |
Eq DI | |
Eq DL | |
Eq TypeRep | |
Eq ConcreteTypeRep | |
Eq ModName | |
Eq PkgName | |
Eq OccName | |
Eq NameFlavour | |
Eq Body | |
Eq Callconv | |
Eq Con | |
Eq FamFlavour | |
Eq Fixity | |
Eq FixityDirection | |
Eq Foreign | |
Eq Guard | |
Eq Inline | |
Eq NameSpace | |
Eq Phases | |
Eq Pragma | |
Eq Range | |
Eq RuleBndr | |
Eq RuleMatch | |
Eq Safety | |
Eq Stmt | |
Eq Strict | |
Eq TyLit | |
Eq Tool | |
Eq Boxed | |
Eq SrcLoc | |
Eq Alt | |
Eq FieldUpdate | |
Eq QualStmt | |
Eq Stmt | |
Eq PatField | |
Eq RPat | |
Eq RPatOp | |
Eq PXAttr | |
Eq Pat | |
Eq WarningText | |
Eq RuleVar | |
Eq Rule | |
Eq Activation | |
Eq Overlap | |
Eq ModulePragma | |
Eq CallConv | |
Eq Safety | |
Eq Splice | |
Eq Bracket | |
Eq XAttr | |
Eq XName | |
Eq Exp | |
Eq Sign | |
Eq Literal | |
Eq Asst | |
Eq FunDep | |
Eq Kind | |
Eq TyVarBind | |
Eq Promoted | |
Eq Type | |
Eq GuardedRhs | |
Eq Rhs | |
Eq BangType | |
Eq InstDecl | |
Eq ClassDecl | |
Eq GadtDecl | |
Eq ConDecl | |
Eq QualConDecl | |
Eq Match | |
Eq IPBind | |
Eq Binds | |
Eq DataOrNew | |
Eq BooleanFormula | |
Eq Annotation | |
Eq TypeEqn | |
Eq Decl | |
Eq Assoc | |
Eq ImportSpec | |
Eq ImportDecl | |
Eq Namespace | |
Eq ExportSpec | |
Eq Module | |
Eq CName | |
Eq Op | |
Eq QOp | |
Eq IPName | |
Eq Name | |
Eq QName | |
Eq SpecialCon | |
Eq ModuleName | |
Eq Lit | |
Eq ArithException | |
Eq MaskingState | |
Eq ArrayException | |
Eq AsyncException | |
Eq IOException | |
Eq SrcSpan | |
Eq SrcSpanInfo | |
Eq PhantomModule | |
Eq TyThing | |
Eq ModuleElem | |
Eq Extension | |
Eq All | |
Eq Any | |
Eq Message | |
Eq SourcePos | |
Eq Pattern | |
Eq PatternSet | |
Eq PatternSetCharacterClass | |
Eq PatternSetCollatingElement | |
Eq PatternSetEquivalenceClass | |
Eq DoPa | |
Eq OP | |
Eq QT | |
Eq WhichTest | |
Eq TagTask | |
Eq TagUpdate | |
Eq Action | |
Eq DelimPolicy | |
Eq CondensePolicy | |
Eq EndPolicy | |
Eq Constr | |
Eq ConstrRep | |
Eq DataRep | |
Eq Fixity | |
Eq TypeRepKey | |
Eq TyCon | |
Eq Handle | |
Eq ByteString | |
Eq ByteString | |
Eq Text | |
Eq Text | |
Eq CCc | |
Eq CDev | |
Eq CIno | |
Eq CMode | |
Eq CNlink | |
Eq COff | |
Eq CPid | |
Eq CRLim | |
Eq CSpeed | |
Eq CSsize | |
Eq CTcflag | |
Eq Fd | |
Eq CGid | |
Eq CUid | |
Eq GroupEntry | |
Eq UserEntry | |
Eq DisplayRegion | |
Eq Key | |
Eq Modifier | |
Eq Button | |
Eq Event | |
Eq Image | |
Eq Attr | |
Eq FixedAttr | |
Eq Color | |
Eq Lexeme | |
Eq ModuleName | |
Eq Version | |
Eq VersionRange | |
Eq VersionIntervals | |
Eq UpperBound | |
Eq LowerBound | |
Eq Bound | |
Eq PackageName | |
Eq PackageIdentifier | |
Eq InstalledPackageId | |
Eq Dependency | |
Eq IntSet | |
Eq ThreadId | |
Eq CChar | |
Eq ThreadStatus | |
Eq BlockReason | |
Eq CInt | |
Eq IOMode | |
Eq NewlineMode | |
Eq Newline | |
Eq BufferMode | |
Eq HandlePosn | |
Eq TimeZone | |
Eq TimeOfDay | |
Eq LocalTime | |
Eq UTCTime | |
Eq NominalDiffTime | |
Eq UniversalTime | |
Eq DiffTime | |
Eq Day | |
Eq TimeLocale | |
Eq CSize | |
Eq Finalizers | |
Eq ExitCode | |
Eq CLong | |
Eq IOErrorType | |
Eq Permissions | |
Eq TestType | |
Eq TestSuiteInterface | |
Eq TestSuite | |
Eq SourceRepo | |
Eq RepoType | |
Eq RepoKind | |
Eq PackageDescription | |
Eq Library | |
Eq GenericPackageDescription | |
Eq FlagName | |
Eq Flag | |
Eq Executable | |
Eq ConfVar | |
Eq BuildType | |
Eq BuildInfo | |
Eq BenchmarkType | |
Eq BenchmarkInterface | |
Eq Benchmark | |
Eq GeneralCategory | |
Eq CULong | |
Eq Rope | |
Eq Direction | |
Eq WindowRef | |
Eq Size | |
Eq Point | |
Eq BufferRef | |
Eq Mark | |
Eq SearchOption | |
Eq Rectangle | |
Eq AnyLayoutManager | |
Eq Orientation | |
Eq Event | |
Eq Key | |
Eq Modifier | |
Eq Window | |
Eq Tab | Equality on tab identity (the |
Eq Color | |
Eq Attributes | |
Eq MarkValue | |
Eq Overlay | |
Eq OvlLayer | |
Eq IndentBehaviour | |
Eq IndentSettings | |
Eq FBuffer | |
Eq BoundarySide | |
Eq RegionStyle | |
Eq CUChar | |
Eq CSChar | |
Eq CWchar | |
Eq CUShort | |
Eq CUSeconds | |
Eq CULLong | |
Eq CUIntPtr | |
Eq CUIntMax | |
Eq CUInt | |
Eq CTime | |
Eq CSigAtomic | |
Eq CShort | |
Eq CSUSeconds | |
Eq CPtrdiff | |
Eq CLLong | |
Eq CIntPtr | |
Eq CIntMax | |
Eq CFloat | |
Eq CDouble | |
Eq CClock | |
Eq Posn | |
Eq SpecConstrAnnotation | |
Eq Token | |
Eq ReservedOp | |
Eq Reserved | |
Eq Token | |
Eq OpType | |
Eq ReservedType | |
Eq CommentType | |
Eq Token | |
Eq Operator | |
Eq Reserved | |
Eq Token | |
Eq HlState | |
Eq Token | |
Eq QueuedUpdate | |
Eq Report | |
Eq Warning | |
Eq Error | |
Eq Number | |
Eq SearchResult | |
Eq VimMode | |
Eq RepeatableAction | |
Eq Fixity | |
Eq Associativity | |
Eq Arity | |
Eq Field | |
Eq TraceBinIFaceReading | |
Eq CheckHiWay | |
Eq LabelSet | |
Eq Unique | |
Eq Label | |
Eq Var | |
Eq Discr | |
Eq ChangeFlag | |
Eq TickDensity | |
Eq RecompileRequired | |
Eq AltCon | |
Eq Loc | |
Eq UniqueSet | |
Eq TyLit | |
Eq Prec | |
Eq MarkInfo | |
Eq DependentMarks | |
Eq BufferMarks | |
Eq a => Eq [a] | |
Eq a => Eq (Ratio a) | |
Eq (StablePtr a) | |
Eq (Ptr a) | |
Eq (FunPtr a) | |
Eq a => Eq (Diff a) | |
Eq a => Eq (Loc a) | |
Eq a => Eq (DList a) | |
Eq a => Eq (Maybe a) | |
Eq l => Eq (ModuleName l) | |
Eq l => Eq (SpecialCon l) | |
Eq l => Eq (QName l) | |
Eq l => Eq (Name l) | |
Eq l => Eq (IPName l) | |
Eq l => Eq (QOp l) | |
Eq l => Eq (Op l) | |
Eq l => Eq (CName l) | |
Eq l => Eq (Module l) | |
Eq l => Eq (ModuleHead l) | |
Eq l => Eq (ExportSpecList l) | |
Eq l => Eq (ExportSpec l) | |
Eq l => Eq (Namespace l) | |
Eq l => Eq (ImportDecl l) | |
Eq l => Eq (ImportSpecList l) | |
Eq l => Eq (ImportSpec l) | |
Eq l => Eq (Assoc l) | |
Eq l => Eq (Decl l) | |
Eq l => Eq (TypeEqn l) | |
Eq l => Eq (Annotation l) | |
Eq l => Eq (BooleanFormula l) | |
Eq l => Eq (DataOrNew l) | |
Eq l => Eq (DeclHead l) | |
Eq l => Eq (InstRule l) | |
Eq l => Eq (InstHead l) | |
Eq l => Eq (Deriving l) | |
Eq l => Eq (Binds l) | |
Eq l => Eq (IPBind l) | |
Eq l => Eq (Match l) | |
Eq l => Eq (QualConDecl l) | |
Eq l => Eq (ConDecl l) | |
Eq l => Eq (FieldDecl l) | |
Eq l => Eq (GadtDecl l) | |
Eq l => Eq (ClassDecl l) | |
Eq l => Eq (InstDecl l) | |
Eq l => Eq (BangType l) | |
Eq l => Eq (Rhs l) | |
Eq l => Eq (GuardedRhs l) | |
Eq l => Eq (Type l) | |
Eq l => Eq (Promoted l) | |
Eq l => Eq (TyVarBind l) | |
Eq l => Eq (Kind l) | |
Eq l => Eq (FunDep l) | |
Eq l => Eq (Context l) | |
Eq l => Eq (Asst l) | |
Eq l => Eq (Literal l) | |
Eq l => Eq (Sign l) | |
Eq l => Eq (Exp l) | |
Eq l => Eq (XName l) | |
Eq l => Eq (XAttr l) | |
Eq l => Eq (Bracket l) | |
Eq l => Eq (Splice l) | |
Eq l => Eq (Safety l) | |
Eq l => Eq (CallConv l) | |
Eq l => Eq (ModulePragma l) | |
Eq l => Eq (Overlap l) | |
Eq l => Eq (Activation l) | |
Eq l => Eq (Rule l) | |
Eq l => Eq (RuleVar l) | |
Eq l => Eq (WarningText l) | |
Eq l => Eq (Pat l) | |
Eq l => Eq (PXAttr l) | |
Eq l => Eq (RPatOp l) | |
Eq l => Eq (RPat l) | |
Eq l => Eq (PatField l) | |
Eq l => Eq (Stmt l) | |
Eq l => Eq (QualStmt l) | |
Eq l => Eq (FieldUpdate l) | |
Eq l => Eq (Alt l) | |
Eq a => Eq (Dual a) | |
Eq a => Eq (First a) | |
Eq a => Eq (Last a) | |
Eq a => Eq (Product a) | |
Eq a => Eq (Sum a) | |
Eq a => Eq (PointedList a) | |
Eq a => Eq (Chunk a) | |
Eq (ForeignPtr a) | |
Eq a => Eq (Vector a) | |
Eq v => Eq (MaybeDefault v) | |
Eq a => Eq (Tree a) | |
Eq a => Eq (Set a) | |
Eq a => Eq (Seq a) | |
Eq a => Eq (IntMap a) | |
Eq (TVar a) | |
Eq (MVar a) | |
Eq (IORef a) | |
Eq (Chan a) | |
Eq (Fixed a) | |
Eq c => Eq (Condition c) | |
Eq a => Eq (ViewR a) | |
Eq a => Eq (ViewL a) | |
Eq lm => Eq (Transposed lm) | |
Eq a => Eq (Layout a) | |
Eq a => Eq (Down a) | |
Eq (Tok a) | |
Eq ele => Eq (UniqFM ele) | |
Eq v => Eq (LabelMap v) | |
Eq id => Eq (Tickish id) | |
Eq v => Eq (UniqueMap v) | |
(Eq a, Eq b) => Eq (Either a b) | |
(Eq a, Eq b) => Eq (a, b) | |
(Eq a, Eq (s a)) => Eq (ViewL s a) | |
(Eq a, Eq (s a)) => Eq (ViewR s a) | |
Eq a => Eq (FingerTree v a) | |
(Eq k, Eq v) => Eq (Leaf k v) | |
(Eq k, Eq v) => Eq (HashMap k v) | |
Eq a => Eq (Stream Id a) | |
(Ix i, Eq e) => Eq (Array i e) | |
(Ix ix, Eq e, IArray UArray e) => Eq (UArray ix e) | |
(Eq k, Eq a) => Eq (Map k a) | |
Eq (STRef s a) | |
Eq t => Eq (::: t doc) | |
(Eq a, Eq b, Eq c) => Eq (a, b, c) | |
(Eq v, Eq c, Eq a) => Eq (CondTree v c a) | |
Eq (STArray s i e) | |
Eq (STUArray s i e) | |
(Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) | |
(Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) | |
(Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) |
class Num a => Fractional a where
Fractional Double | |
Fractional Float | |
Fractional NominalDiffTime | |
Fractional DiffTime | |
Fractional CFloat | |
Fractional CDouble | |
Integral a => Fractional (Ratio a) | |
HasResolution a => Fractional (Fixed a) |
class Functor f where
fmap :: (a -> b) -> f a -> f b
data IO a
class Initializable a whereSource
The default value. If a function tries to get a copy of the state, but the state
hasn't yet been created, initial
will be called to supply *some* value. The value
of initial will probably be something like Nothing, [], "", or empty
- compare
the mempty
of Data.Monoid.
Initializable WindowRef | |
Initializable DynamicValues | |
Initializable ConfigVariables | |
Initializable AnyLayoutManager | The default layout is |
Initializable RegionStyle | |
Initializable TempBufferNameHint | |
Initializable History | |
Initializable VimTagStack | |
Initializable ArticleDB | |
Initializable VimState | |
Initializable VimMode | |
Initializable CabalBuffer | |
Initializable Evaluator | |
Initializable DependentMarks | |
Initializable BufferMarks | |
Initializable (Maybe a) | |
Initializable a => Initializable (Layout a) | The initial layout consists of a single window |
(Typeable k, Typeable v) => Initializable (Map k v) |
data Integer
class (Real a, Enum a) => Integral a where
quot :: a -> a -> a
rem :: a -> a -> a
div :: a -> a -> a
mod :: a -> a -> a
quotRem :: a -> a -> (a, a)
divMod :: a -> a -> (a, a)
Integral Int | |
Integral Int8 | |
Integral Int16 | |
Integral Int32 | |
Integral Int64 | |
Integral Integer | |
Integral Word | |
Integral Word8 | |
Integral Word16 | |
Integral Word32 | |
Integral Word64 | |
Integral CDev | |
Integral CIno | |
Integral CMode | |
Integral CNlink | |
Integral COff | |
Integral CPid | |
Integral CRLim | |
Integral CSsize | |
Integral CTcflag | |
Integral Fd | |
Integral CGid | |
Integral CUid | |
Integral CChar | |
Integral CInt | |
Integral CSize | |
Integral CLong | |
Integral CULong | |
Integral Size | |
Integral Point | |
Integral CUChar | |
Integral CSChar | |
Integral CWchar | |
Integral CUShort | |
Integral CULLong | |
Integral CUIntPtr | |
Integral CUIntMax | |
Integral CUInt | |
Integral CSigAtomic | |
Integral CShort | |
Integral CPtrdiff | |
Integral CLLong | |
Integral CIntPtr | |
Integral CIntMax |
class Bounded a where
class Enum a where
succ :: a -> a
pred :: a -> a
toEnum :: Int -> a
fromEnum :: a -> Int
enumFrom :: a -> [a]
enumFromThen :: a -> a -> [a]
enumFromTo :: a -> a -> [a]
enumFromThenTo :: a -> a -> a -> [a]
Enum Bool | |
Enum Char | |
Enum Double | |
Enum Float | |
Enum Int | |
Enum Int8 | |
Enum Int16 | |
Enum Int32 | |
Enum Int64 | |
Enum Integer | |
Enum Ordering | |
Enum Word | |
Enum Word8 | |
Enum Word16 | |
Enum Word32 | |
Enum Word64 | |
Enum () | |
Enum Message | |
Enum DoPa | |
Enum WhichTest | |
Enum CCc | |
Enum CDev | |
Enum CIno | |
Enum CMode | |
Enum CNlink | |
Enum COff | |
Enum CPid | |
Enum CRLim | |
Enum CSpeed | |
Enum CSsize | |
Enum CTcflag | |
Enum Fd | |
Enum CGid | |
Enum CUid | |
Enum CChar | |
Enum CInt | |
Enum IOMode | |
Enum NominalDiffTime | |
Enum DiffTime | |
Enum Day | |
Enum CSize | |
Enum CLong | |
Enum GeneralCategory | |
Enum CULong | |
Enum Direction | |
Enum WindowRef | |
Enum Size | |
Enum Point | |
Enum CUChar | |
Enum CSChar | |
Enum CWchar | |
Enum CUShort | |
Enum CUSeconds | |
Enum CULLong | |
Enum CUIntPtr | |
Enum CUIntMax | |
Enum CUInt | |
Enum CTime | |
Enum CSigAtomic | |
Enum CShort | |
Enum CSUSeconds | |
Enum CPtrdiff | |
Enum CLLong | |
Enum CIntPtr | |
Enum CIntMax | |
Enum CFloat | |
Enum CDouble | |
Enum CClock | |
Integral a => Enum (Ratio a) | |
Enum (Fixed a) |
data Maybe a
Monad Maybe | |
Functor Maybe | |
Typeable1 Maybe | |
MonadFix Maybe | |
MonadPlus Maybe | |
Applicative Maybe | |
Foldable Maybe | |
Traversable Maybe | |
Generic1 Maybe | |
MonadThrow Maybe | |
Alternative Maybe | |
Eq a => Eq (Maybe a) | |
Data a => Data (Maybe a) | |
Ord a => Ord (Maybe a) | |
Read a => Read (Maybe a) | |
Show a => Show (Maybe a) | |
Generic (Maybe a) | |
Arbitrary a => Arbitrary (Maybe a) | |
CoArbitrary a => CoArbitrary (Maybe a) | |
Lift a => Lift (Maybe a) | |
Hashable a => Hashable (Maybe a) | |
Monoid a => Monoid (Maybe a) | |
Binary a => Binary (Maybe a) | |
Initializable (Maybe a) |
class Monad m where
Monad [] | |
Monad IO | |
Monad Q | |
Monad Rose | |
Monad Gen | |
Monad DList | |
Monad Maybe | |
Monad Ghc | |
Monad P | |
Monad Identity | |
Monad Vector | |
Monad Id | |
Monad Box | |
Monad ReadPrec | |
Monad ReadP | |
Monad P | |
Monad STM | |
Monad Tree | |
Monad Seq | |
Monad PutM | |
Monad Get | |
Monad PprM | |
Monad Id | |
Monad BufferM | |
Monad EditorM | |
Monad YiM | |
Monad ConfigM | |
Monad ParseResult | |
Monad Assembler | |
Monad BcM | |
Monad TM | |
Monad TE | |
Monad SimpleUniqueMonad | |
Monad ((->) r) | |
Monad (Either e) | |
Monad m => Monad (MTLAdapter m) | |
Monad m => Monad (GhcT m) | |
Monad m => Monad (InterpreterT m) | |
Monad m => Monad (ListT m) | |
Monad (ST s) | |
Monad m => Monad (MaybeT m) | |
Monad m => Monad (IdentityT m) | |
Monad (ST s) | |
ArrowApply a => Monad (ArrowMonad a) | |
Monad (Parser s) | |
Monad (State s) | |
Monad (RegM freeRegs) | |
Monad m => Monad (InfiniteFuelMonad m) | |
Monad m => Monad (CheckingFuelMonad m) | |
Monad m => Monad (UniqueMonadT m) | |
Monad (ContT r m) | |
(Monad m, Error e) => Monad (ErrorT e m) | |
Monad m => Monad (ReaderT r m) | |
Monad m => Monad (StateT s m) | |
Monad m => Monad (StateT s m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
(Monoid w, Monad m) => Monad (WriterT w m) | |
Monad (I event w) | |
Monad (ParsecT s u m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) | |
(Monoid w, Monad m) => Monad (RWST r w s m) |
class Num a where
(+) :: a -> a -> a
(*) :: a -> a -> a
(-) :: a -> a -> a
negate :: a -> a
abs :: a -> a
signum :: a -> a
fromInteger :: Integer -> a
Num Double | |
Num Float | |
Num Int | |
Num Int8 | |
Num Int16 | |
Num Int32 | |
Num Int64 | |
Num Integer | |
Num Word | |
Num Word8 | |
Num Word16 | |
Num Word32 | |
Num Word64 | |
Num CCc | |
Num CDev | |
Num CIno | |
Num CMode | |
Num CNlink | |
Num COff | |
Num CPid | |
Num CRLim | |
Num CSpeed | |
Num CSsize | |
Num CTcflag | |
Num Fd | |
Num CGid | |
Num CUid | |
Num CChar | |
Num CInt | |
Num NominalDiffTime | |
Num DiffTime | |
Num CSize | |
Num CLong | |
Num CULong | |
Num Size | |
Num Point | |
Num BufferRef | |
Num CUChar | |
Num CSChar | |
Num CWchar | |
Num CUShort | |
Num CUSeconds | |
Num CULLong | |
Num CUIntPtr | |
Num CUIntMax | |
Num CUInt | |
Num CTime | |
Num CSigAtomic | |
Num CShort | |
Num CSUSeconds | |
Num CPtrdiff | |
Num CLLong | |
Num CIntPtr | |
Num CIntMax | |
Num CFloat | |
Num CDouble | |
Num CClock | |
Integral a => Num (Ratio a) | |
HasResolution a => Num (Fixed a) | |
Num t => Num (::: t doc) |
compare :: a -> a -> Ordering
(<) :: a -> a -> Bool
(>=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(<=) :: a -> a -> Bool
max :: a -> a -> a
min :: a -> a -> a
Ord Bool | |
Ord Char | |
Ord Double | |
Ord Float | |
Ord Int | |
Ord Int8 | |
Ord Int16 | |
Ord Int32 | |
Ord Int64 | |
Ord Integer | |
Ord Ordering | |
Ord Word | |
Ord Word8 | |
Ord Word16 | |
Ord Word32 | |
Ord Word64 | |
Ord Name | |
Ord () | |
Ord DL | |
Ord TypeRep | |
Ord ModName | |
Ord PkgName | |
Ord OccName | |
Ord NameFlavour | |
Ord NameSpace | |
Ord Tool | |
Ord Boxed | |
Ord SrcLoc | |
Ord Alt | |
Ord FieldUpdate | |
Ord QualStmt | |
Ord Stmt | |
Ord PatField | |
Ord RPat | |
Ord RPatOp | |
Ord PXAttr | |
Ord Pat | |
Ord WarningText | |
Ord RuleVar | |
Ord Rule | |
Ord Activation | |
Ord Overlap | |
Ord ModulePragma | |
Ord CallConv | |
Ord Safety | |
Ord Splice | |
Ord Bracket | |
Ord XAttr | |
Ord XName | |
Ord Exp | |
Ord Sign | |
Ord Literal | |
Ord Asst | |
Ord FunDep | |
Ord Kind | |
Ord TyVarBind | |
Ord Promoted | |
Ord Type | |
Ord GuardedRhs | |
Ord Rhs | |
Ord BangType | |
Ord InstDecl | |
Ord ClassDecl | |
Ord GadtDecl | |
Ord ConDecl | |
Ord QualConDecl | |
Ord Match | |
Ord IPBind | |
Ord Binds | |
Ord DataOrNew | |
Ord BooleanFormula | |
Ord Annotation | |
Ord TypeEqn | |
Ord Decl | |
Ord Assoc | |
Ord ImportSpec | |
Ord ImportDecl | |
Ord Namespace | |
Ord ExportSpec | |
Ord Module | |
Ord CName | |
Ord Op | |
Ord QOp | |
Ord IPName | |
Ord Name | |
Ord QName | |
Ord SpecialCon | |
Ord ModuleName | |
Ord ArithException | |
Ord ArrayException | |
Ord AsyncException | |
Ord SrcSpan | |
Ord SrcSpanInfo | |
Ord TyThing | |
Ord All | |
Ord Any | |
Ord Message | |
Ord SourcePos | |
Ord PatternSetCharacterClass | |
Ord PatternSetCollatingElement | |
Ord PatternSetEquivalenceClass | |
Ord DoPa | |
Ord WhichTest | |
Ord TypeRepKey | |
Ord TyCon | |
Ord ByteString | |
Ord ByteString | |
Ord Text | |
Ord Text | |
Ord CCc | |
Ord CDev | |
Ord CIno | |
Ord CMode | |
Ord CNlink | |
Ord COff | |
Ord CPid | |
Ord CRLim | |
Ord CSpeed | |
Ord CSsize | |
Ord CTcflag | |
Ord Fd | |
Ord CGid | |
Ord CUid | |
Ord Key | |
Ord Modifier | |
Ord Button | |
Ord Event | |
Ord ModuleName | |
Ord Version | |
Ord UpperBound | |
Ord LowerBound | |
Ord PackageName | |
Ord PackageIdentifier | |
Ord InstalledPackageId | |
Ord IntSet | |
Ord ThreadId | |
Ord CChar | |
Ord ThreadStatus | |
Ord BlockReason | |
Ord CInt | |
Ord IOMode | |
Ord NewlineMode | |
Ord Newline | |
Ord BufferMode | |
Ord TimeZone | |
Ord TimeOfDay | |
Ord LocalTime | |
Ord UTCTime | |
Ord NominalDiffTime | |
Ord UniversalTime | |
Ord DiffTime | |
Ord Day | |
Ord TimeLocale | |
Ord CSize | |
Ord ExitCode | |
Ord CLong | |
Ord Permissions | |
Ord RepoType | |
Ord RepoKind | |
Ord FlagName | |
Ord GeneralCategory | |
Ord CULong | |
Ord Direction | |
Ord WindowRef | |
Ord Size | |
Ord Point | |
Ord BufferRef | |
Ord Mark | |
Ord Event | |
Ord Key | |
Ord Modifier | |
Ord Color | |
Ord Attributes | |
Ord MarkValue | |
Ord Overlay | |
Ord OvlLayer | |
Ord CUChar | |
Ord CSChar | |
Ord CWchar | |
Ord CUShort | |
Ord CUSeconds | |
Ord CULLong | |
Ord CUIntPtr | |
Ord CUIntMax | |
Ord CUInt | |
Ord CTime | |
Ord CSigAtomic | |
Ord CShort | |
Ord CSUSeconds | |
Ord CPtrdiff | |
Ord CLLong | |
Ord CIntPtr | |
Ord CIntMax | |
Ord CFloat | |
Ord CDouble | |
Ord CClock | |
Ord Posn | |
Ord Token | |
Ord QueuedUpdate | |
Ord Fixity | |
Ord Associativity | |
Ord Arity | |
Ord LabelSet | |
Ord Unique | |
Ord Label | |
Ord Var | |
Ord Discr | |
Ord ChangeFlag | |
Ord AltCon | |
Ord Loc | |
Ord UniqueSet | |
Ord TyLit | |
Ord Prec | |
Ord MarkInfo | |
Ord a => Ord [a] | |
Integral a => Ord (Ratio a) | |
Ord (Ptr a) | |
Ord (FunPtr a) | |
Ord a => Ord (Loc a) | |
Ord a => Ord (DList a) | |
Ord a => Ord (Maybe a) | |
Ord l => Ord (ModuleName l) | |
Ord l => Ord (SpecialCon l) | |
Ord l => Ord (QName l) | |
Ord l => Ord (Name l) | |
Ord l => Ord (IPName l) | |
Ord l => Ord (QOp l) | |
Ord l => Ord (Op l) | |
Ord l => Ord (CName l) | |
Ord l => Ord (Module l) | |
Ord l => Ord (ModuleHead l) | |
Ord l => Ord (ExportSpecList l) | |
Ord l => Ord (ExportSpec l) | |
Ord l => Ord (Namespace l) | |
Ord l => Ord (ImportDecl l) | |
Ord l => Ord (ImportSpecList l) | |
Ord l => Ord (ImportSpec l) | |
Ord l => Ord (Assoc l) | |
Ord l => Ord (Decl l) | |
Ord l => Ord (TypeEqn l) | |
Ord l => Ord (Annotation l) | |
Ord l => Ord (BooleanFormula l) | |
Ord l => Ord (DataOrNew l) | |
Ord l => Ord (DeclHead l) | |
Ord l => Ord (InstRule l) | |
Ord l => Ord (InstHead l) | |
Ord l => Ord (Deriving l) | |
Ord l => Ord (Binds l) | |
Ord l => Ord (IPBind l) | |
Ord l => Ord (Match l) | |
Ord l => Ord (QualConDecl l) | |
Ord l => Ord (ConDecl l) | |
Ord l => Ord (FieldDecl l) | |
Ord l => Ord (GadtDecl l) | |
Ord l => Ord (ClassDecl l) | |
Ord l => Ord (InstDecl l) | |
Ord l => Ord (BangType l) | |
Ord l => Ord (Rhs l) | |
Ord l => Ord (GuardedRhs l) | |
Ord l => Ord (Type l) | |
Ord l => Ord (Promoted l) | |
Ord l => Ord (TyVarBind l) | |
Ord l => Ord (Kind l) | |
Ord l => Ord (FunDep l) | |
Ord l => Ord (Context l) | |
Ord l => Ord (Asst l) | |
Ord l => Ord (Literal l) | |
Ord l => Ord (Sign l) | |
Ord l => Ord (Exp l) | |
Ord l => Ord (XName l) | |
Ord l => Ord (XAttr l) | |
Ord l => Ord (Bracket l) | |
Ord l => Ord (Splice l) | |
Ord l => Ord (Safety l) | |
Ord l => Ord (CallConv l) | |
Ord l => Ord (ModulePragma l) | |
Ord l => Ord (Overlap l) | |
Ord l => Ord (Activation l) | |
Ord l => Ord (Rule l) | |
Ord l => Ord (RuleVar l) | |
Ord l => Ord (WarningText l) | |
Ord l => Ord (Pat l) | |
Ord l => Ord (PXAttr l) | |
Ord l => Ord (RPatOp l) | |
Ord l => Ord (RPat l) | |
Ord l => Ord (PatField l) | |
Ord l => Ord (Stmt l) | |
Ord l => Ord (QualStmt l) | |
Ord l => Ord (FieldUpdate l) | |
Ord l => Ord (Alt l) | |
Ord a => Ord (Dual a) | |
Ord a => Ord (First a) | |
Ord a => Ord (Last a) | |
Ord a => Ord (Product a) | |
Ord a => Ord (Sum a) | |
Ord (ForeignPtr a) | |
Ord a => Ord (Vector a) | |
Ord a => Ord (Set a) | |
Ord a => Ord (Seq a) | |
Ord a => Ord (IntMap a) | |
Ord (Fixed a) | |
Ord a => Ord (ViewR a) | |
Ord a => Ord (ViewL a) | |
Ord a => Ord (Down a) | |
Ord v => Ord (LabelMap v) | |
Ord id => Ord (Tickish id) | |
Ord v => Ord (UniqueMap v) | |
(Ord a, Ord b) => Ord (Either a b) | |
(Ord a, Ord b) => Ord (a, b) | |
(Ord a, Ord (s a)) => Ord (ViewL s a) | |
(Ord a, Ord (s a)) => Ord (ViewR s a) | |
Ord a => Ord (FingerTree v a) | |
Ord a => Ord (Stream Id a) | |
(Ix i, Ord e) => Ord (Array i e) | |
(Ix ix, Ord e, IArray UArray e) => Ord (UArray ix e) | |
(Ord k, Ord v) => Ord (Map k v) | |
(Ord a, Ord b, Ord c) => Ord (a, b, c) | |
(Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) | |
(Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) | |
(Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (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) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) | |
(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) |
class Read a where
Read Bool | |
Read Char | |
Read Double | |
Read Float | |
Read Int | |
Read Int8 | |
Read Int16 | |
Read Int32 | |
Read Int64 | |
Read Integer | |
Read Ordering | |
Read Word | |
Read Word8 | |
Read Word16 | |
Read Word32 | |
Read Word64 | |
Read () | |
Read ModuleElem | |
Read Extension | |
Read All | |
Read Any | |
Read StdGen | |
Read CompOption | |
Read ExecOption | |
Read ByteString | |
Read ByteString | |
Read Text | |
Read Text | |
Read CCc | |
Read CDev | |
Read CIno | |
Read CMode | |
Read CNlink | |
Read COff | |
Read CPid | |
Read CRLim | |
Read CSpeed | |
Read CSsize | |
Read CTcflag | |
Read Fd | |
Read CGid | |
Read CUid | |
Read GroupEntry | |
Read UserEntry | |
Read Lexeme | |
Read ModuleName | |
Read Version | |
Read VersionRange | |
Read PackageName | |
Read PackageIdentifier | |
Read InstalledPackageId | |
Read Dependency | |
Read IntSet | |
Read CChar | |
Read CInt | |
Read IOMode | |
Read NewlineMode | |
Read Newline | |
Read BufferMode | |
Read TimeZone | |
Read TimeOfDay | |
Read ZonedTime | |
Read LocalTime | |
Read UTCTime | |
Read Day | |
Read CSize | |
Read ExitCode | |
Read CLong | |
Read Permissions | |
Read TestType | |
Read TestSuiteInterface | |
Read TestSuite | |
Read SourceRepo | |
Read RepoType | |
Read RepoKind | |
Read PackageDescription | |
Read Library | |
Read FlagName | |
Read Executable | |
Read BuildType | |
Read BuildInfo | |
Read BenchmarkType | |
Read BenchmarkInterface | |
Read Benchmark | |
Read GeneralCategory | |
Read CULong | |
Read CUChar | |
Read CSChar | |
Read CWchar | |
Read CUShort | |
Read CUSeconds | |
Read CULLong | |
Read CUIntPtr | |
Read CUIntMax | |
Read CUInt | |
Read CTime | |
Read CSigAtomic | |
Read CShort | |
Read CSUSeconds | |
Read CPtrdiff | |
Read CLLong | |
Read CIntPtr | |
Read CIntMax | |
Read CFloat | |
Read CDouble | |
Read CClock | |
Read Fixity | |
Read Associativity | |
Read Arity | |
Read a => Read [a] | |
(Integral a, Read a) => Read (Ratio a) | |
Read a => Read (DList a) | |
Read a => Read (Maybe a) | |
Read a => Read (Dual a) | |
Read a => Read (First a) | |
Read a => Read (Last a) | |
Read a => Read (Product a) | |
Read a => Read (Sum a) | |
Read a => Read (Vector a) | |
Read a => Read (Tree a) | |
(Read a, Ord a) => Read (Set a) | |
Read a => Read (Seq a) | |
Read e => Read (IntMap e) | |
HasResolution a => Read (Fixed a) | |
Read a => Read (ViewR a) | |
Read a => Read (ViewL a) | |
(Read a, Read b) => Read (Either a b) | |
(Read a, Read b) => Read (a, b) | |
(Read a, Read (s a)) => Read (ViewL s a) | |
(Read a, Read (s a)) => Read (ViewR s a) | |
(Eq k, Hashable k, Read k, Read e) => Read (HashMap k e) | |
(Ix a, Read a, Read b) => Read (Array a b) | |
(Ord k, Read k, Read e) => Read (Map k e) | |
(Read a, Read b, Read c) => Read (a, b, c) | |
(Read a, Read b, Read c, Read d) => Read (a, b, c, d) | |
(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) |
class (Num a, Ord a) => Real a where
toRational :: a -> Rational
Real Double | |
Real Float | |
Real Int | |
Real Int8 | |
Real Int16 | |
Real Int32 | |
Real Int64 | |
Real Integer | |
Real Word | |
Real Word8 | |
Real Word16 | |
Real Word32 | |
Real Word64 | |
Real CCc | |
Real CDev | |
Real CIno | |
Real CMode | |
Real CNlink | |
Real COff | |
Real CPid | |
Real CRLim | |
Real CSpeed | |
Real CSsize | |
Real CTcflag | |
Real Fd | |
Real CGid | |
Real CUid | |
Real CChar | |
Real CInt | |
Real NominalDiffTime | |
Real DiffTime | |
Real CSize | |
Real CLong | |
Real CULong | |
Real Size | |
Real Point | |
Real CUChar | |
Real CSChar | |
Real CWchar | |
Real CUShort | |
Real CUSeconds | |
Real CULLong | |
Real CUIntPtr | |
Real CUIntMax | |
Real CUInt | |
Real CTime | |
Real CSigAtomic | |
Real CShort | |
Real CSUSeconds | |
Real CPtrdiff | |
Real CLLong | |
Real CIntPtr | |
Real CIntMax | |
Real CFloat | |
Real CDouble | |
Real CClock | |
Integral a => Real (Ratio a) | |
HasResolution a => Real (Fixed a) |
class (Real a, Fractional a) => RealFrac a where
newtype ReaderT r m a
The reader monad transformer, which adds a read-only environment to the given monad.
The return
function ignores the environment, while >>=
passes
the inherited environment to both subcomputations.
ReaderT | |
|
MonadError e m => MonadError e (ReaderT r m) | |
Monad m => MonadReader r (ReaderT r m) | |
MonadState s m => MonadState s (ReaderT r m) | |
MonadWriter w m => MonadWriter w (ReaderT r m) | |
MonadTrans (ReaderT r) | |
Monad m => Monad (ReaderT r m) | |
Functor m => Functor (ReaderT r m) | |
MonadFix m => MonadFix (ReaderT r m) | |
MonadPlus m => MonadPlus (ReaderT r m) | |
Applicative m => Applicative (ReaderT r m) | |
MonadThrow m => MonadThrow (ReaderT r m) | |
MonadCatch m => MonadCatch (ReaderT r m) | |
MonadMask m => MonadMask (ReaderT r m) | |
MonadIO m => MonadIO (ReaderT r m) | |
Alternative m => Alternative (ReaderT r m) |
class SemiNum absolute relative | absolute -> relative whereSource
class Typeable a
commonPrefix :: Eq a => [[a]] -> [a]Source
Return the longest common prefix of a set of lists.
P(xs) === all (isPrefixOf (commonPrefix xs)) xs length s > length (commonPrefix xs) --> not (all (isPrefixOf s) xs)
dummyGet :: Initializable a => Get aSource
every :: Traversable t => Accessor whole part -> Accessor (t whole) (t part)Source
Lift an accessor to a traversable structure. (This can be seen as a generalization of fmap)
findPL :: (a -> Bool) -> [a] -> Maybe (PointedList a)Source
Finds the first element satisfying the predicate, and returns a zipper pointing at it.
focusA :: Accessor (PointedList a) aSource
fromIntegral :: (Integral a, Num b) => a -> b
fst :: (a, b) -> a
groupBy' :: (a -> a -> Bool) -> [a] -> [[a]]Source
Alternative to groupBy.
groupBy' (\a b -> abs (a - b) <= 1) [1,2,3] = [[1,2,3]]
whereas
groupBy (\a b -> abs (a - b) <= 1) [1,2,3] = [[1,2],[3]]
TODO: Check in ghc 6.12 release if groupBy == groupBy'.
head :: [a] -> a
init :: [a] -> [a]
last :: [a] -> a
mapAdjust' :: Ord k => (a -> a) -> k -> Map k a -> Map k aSource
As Map.adjust, but the combining function is applied strictly.
mapAlter' :: Ord k => (Maybe a -> Maybe a) -> k -> Map k a -> Map k aSource
As Map.alter, but the newly inserted element is forced with the map.
mapFromFoldable :: (Foldable t, Ord k) => t (k, a) -> Map k aSource
Generalisation of fromList
to arbitrary foldables.
module Data.Accessor
putA :: MonadState r m => T r a -> a -> m ()Source
getA :: MonadState r m => T r a -> m aSource
modA :: MonadState r m => T r a -> (a -> a) -> m ()Source
Conversions to Rope
fromString :: String -> RopeSource
Conversions from Rope
toReverseString :: Rope -> StringSource
List-like functions
Get the length of the string. (This information cached, so O(1) amortized runtime.)
countNewLines :: Rope -> IntSource
Count the number of newlines in the strings. (This information cached, so O(1) amortized runtime.)
splitAtLine :: Int -> Rope -> (Rope, Rope)Source
Split before the specified line. Lines are indexed from 0.
IO
Low level functions
splitAtChunkBefore :: Int -> Rope -> (Rope, Rope)Source
Split the rope on a chunk, so that the desired position lies within the first chunk of the second rope.
module Yi.Debug
module Yi.Monad
null :: [a] -> Bool
replicate :: Int -> a -> [a]
seq :: a -> b -> b
snd :: (a, b) -> b
swapFocus :: (PointedList a -> PointedList a) -> PointedList a -> PointedList aSource
Given a function which moves the focus from index A to index B, return a function which swaps the elements at indexes A and B and then moves the focus. See Yi.Editor.swapWinWithFirstE for an example.
tail :: [a] -> [a]
undefined :: a