| Safe Haskell | None |
|---|
Yi.Prelude
- (<>) :: 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
Instances
| 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
Instances
data Char
Instances
| 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
Instances
| 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
Instances
| 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
Instances
| 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
Methods
fmap :: (a -> b) -> f a -> f b
Instances
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.
Instances
| 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
Methods
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)
Instances
| 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
Instances
class Enum a where
Methods
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]
Instances
| 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
Instances
| 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
Instances
| 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
Methods
(+) :: a -> a -> a
(*) :: a -> a -> a
(-) :: a -> a -> a
negate :: a -> a
abs :: a -> a
signum :: a -> a
fromInteger :: Integer -> a
Instances
| 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) |
Methods
compare :: a -> a -> Ordering
(<) :: a -> a -> Bool
(>=) :: a -> a -> Bool
(>) :: a -> a -> Bool
(<=) :: a -> a -> Bool
max :: a -> a -> a
min :: a -> a -> a
Instances
| 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
Instances
| 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
Methods
toRational :: a -> Rational
Instances
| 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.
Constructors
| ReaderT | |
Fields
| |
Instances
| 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
Instances
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