yi-0.7.2: The Haskell-Scriptable Editor

Safe HaskellNone

Yi.Prelude

Contents

Synopsis

Documentation

(<>) :: Monoid a => a -> a -> aSource

(++) :: [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

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

Binary Bool 
Binary Char 
Binary Double 
Binary Float 
Binary Int 
Binary Int8 
Binary Int16 
Binary Int32 
Binary Int64 
Binary Integer 
Binary Ordering 
Binary Word 
Binary Word8 
Binary Word16 
Binary Word32 
Binary Word64 
Binary () 
Binary SerialRep 
Binary ConcreteTypeRep 
Binary ByteString 
Binary ByteString 
Binary Version 
Binary PackageName 
Binary PackageIdentifier 
Binary InstalledPackageId 
Binary IntSet 
Binary UTCTime 
Binary License 
Binary Editor 
Binary Rope 
Binary Direction 
Binary WindowRef 
Binary Size 
Binary Point 
Binary BufferRef 
Binary Mark 
Binary Killring 
Binary SearchOption 
Binary SearchExp 
Binary DynamicValues 
Binary Region 
Binary Jump 
Binary Window 
Binary Tab 
Binary MarkValue 
Binary Update 
Binary UIUpdate 
Binary Change 
Binary URList 
Binary FBuffer 
Binary RegionStyle 
Binary TempBufferNameHint 
Binary History 
Binary TagTable 
Binary VimTagStack 
Binary ArticleDB 
Binary VimState 
Binary GotoCharCommand 
Binary VimMode 
Binary Register 
Binary RepeatableAction 
Binary CabalBuffer 
Binary MarkInfo 
Binary DependentMarks 
Binary BufferMarks 
Binary a => Binary [a] 
(Binary a, Integral a) => Binary (Ratio a) 
Binary a => Binary (Maybe a) 
Binary a_1627392523 => Binary (PointedList a_1627392523) 
Binary e => Binary (Tree e) 
(Ord a, Binary a) => Binary (Set a) 
Binary e => Binary (Seq e) 
Binary e => Binary (IntMap e) 
Binary a_1627574056 => Binary (MarkSet a_1627574056) 
Binary (Mode syntax) 
Binary m => Binary (InstalledPackageInfo_ m) 
(Binary a, Binary b) => Binary (Either a b) 
(Binary a, Binary b) => Binary (a, b) 
(Eq k, Hashable k, Binary k, Binary v) => Binary (HashMap k v) 
(Binary i, Ix i, Binary e) => Binary (Array i e) 
(Binary i, Ix i, Binary e, IArray UArray e) => Binary (UArray i e) 
(Ord k, Binary k, Binary e) => Binary (Map k e) 
(Binary a, Binary b, Binary c) => Binary (a, b, c) 
(Binary a, Binary b, Binary c, Binary d) => Binary (a, b, c, d) 
(Binary a, Binary b, Binary c, Binary d, Binary e) => Binary (a, b, c, d, e) 
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f) => Binary (a, b, c, d, e, f) 
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g) => Binary (a, b, c, d, e, f, g) 
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h) => Binary (a, b, c, d, e, f, g, h) 
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h, Binary i) => Binary (a, b, c, d, e, f, g, h, i) 
(Binary a, Binary b, Binary c, Binary d, Binary e, Binary f, Binary g, Binary h, Binary i, Binary j) => Binary (a, b, c, d, e, f, g, h, i, j) 

data Either a b

Constructors

Left a 
Right 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) 

type Endom a = a -> aSource

class Eq a where

Methods

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

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

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 tkey)

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

Methods

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

recip :: a -> a

fromRational :: Rational -> a

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

Functor [] 
Functor IO 
Functor Q 
Functor Rose 
Functor Gen 
Functor DList 
Functor Handler 
Functor Maybe 
Functor Ghc 
Functor ModuleName 
Functor SpecialCon 
Functor QName 
Functor Name 
Functor IPName 
Functor QOp 
Functor Op 
Functor CName 
Functor Module 
Functor ModuleHead 
Functor ExportSpecList 
Functor ExportSpec 
Functor Namespace 
Functor ImportDecl 
Functor ImportSpecList 
Functor ImportSpec 
Functor Assoc 
Functor Decl 
Functor TypeEqn 
Functor Annotation 
Functor BooleanFormula 
Functor DataOrNew 
Functor DeclHead 
Functor InstRule 
Functor InstHead 
Functor Deriving 
Functor Binds 
Functor IPBind 
Functor Match 
Functor QualConDecl 
Functor ConDecl 
Functor FieldDecl 
Functor GadtDecl 
Functor ClassDecl 
Functor InstDecl 
Functor BangType 
Functor Rhs 
Functor GuardedRhs 
Functor Type 
Functor Promoted 
Functor TyVarBind 
Functor Kind 
Functor FunDep 
Functor Context 
Functor Asst 
Functor Literal 
Functor Sign 
Functor Exp 
Functor XName 
Functor XAttr 
Functor Bracket 
Functor Splice 
Functor Safety 
Functor CallConv 
Functor ModulePragma 
Functor Overlap 
Functor Activation 
Functor Rule 
Functor RuleVar 
Functor WarningText 
Functor Pat 
Functor PXAttr 
Functor RPatOp 
Functor RPat 
Functor PatField 
Functor Stmt 
Functor QualStmt 
Functor FieldUpdate 
Functor Alt 
Functor Identity 
Functor Consumed 
Functor PointedList 
Functor ZipList 
Functor Vector 
Functor Id 
Functor Box 
Functor ReadPrec 
Functor ReadP 
Functor STM 
Functor Elem 
Functor Tree 
Functor Seq 
Functor PutM 
Functor IntMap 
Functor Get 
Functor Id 
Functor Node 
Functor Digit 
Functor FingerTree 
Functor Id 
Functor ViewR 
Functor ViewL 
Functor Layout 
Functor MatchResult 
Functor Span 
Functor MarkSet 
Functor BufferM 
Functor Tok 
Functor Tree 
Functor EditorM 
Functor YiM 
Functor ConfigM 
Functor UniqFM 
Functor DFunArg 
Functor AlexLastAcc 
Functor ((->) r) 
Functor (Either a) 
Functor ((,) a) 
Monad m => Functor (Handler m) 
Functor s => Functor (ViewL s) 
Functor s => Functor (ViewR s) 
Functor m => Functor (MTLAdapter m) 
Functor m => Functor (GhcT m) 
Functor m => Functor (InterpreterT m) 
Functor m => Functor (ListT m) 
Functor (Const m) 
Monad m => Functor (WrappedMonad m) 
Functor (ST s) 
Functor m => Functor (MaybeT m) 
Functor m => Functor (IdentityT m) 
Functor (HashMap k) 
Monad m => Functor (Stream m) 
Ix i => Functor (Array i) 
Functor (ST s) 
Arrow a => Functor (ArrowMonad a) 
Functor (Map k) 
Functor (Parser s) 
Functor (StateR s) 
Functor (StateL s) 
Functor (State s) 
Functor (Scanner st) 
Functor (MaybeO ex) 
Functor (MaybeC ex) 
Functor ((,,) a b) 
Functor (ContT r m) 
Functor m => Functor (ErrorT e m) 
Functor m => Functor (ReaderT r m) 
Functor m => Functor (StateT s m) 
Functor m => Functor (StateT s m) 
Functor m => Functor (WriterT w m) 
Functor m => Functor (WriterT w m) 
Functor (Reply s u) 
Arrow a => Functor (WrappedArrow a b) 
Functor (I event w) 
Functor (ParsecT s u m) 
Functor m => Functor (RWST r w s m) 
Functor m => Functor (RWST r w s m) 

data IO a

Instances

Monad IO 
Functor IO 
Typeable1 IO 
MonadFix IO 
MonadPlus IO 
Applicative IO 
Quasi IO 
MonadThrow IO 
MonadCatch IO 
MonadMask IO 
MonadIO IO 
PrimMonad IO 
MonadError IOException IO 
MArray IOArray e IO 
Typeable a => Data (IO a) 
PrintfType (IO a) 
HPrintfType (IO a) 
YiAction (IO x) x 

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.

Methods

initial :: aSource

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)

toInteger :: a -> Integer

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

Methods

minBound :: a

maxBound :: a

Instances

Bounded Bool 
Bounded Char 
Bounded Int 
Bounded Int8 
Bounded Int16 
Bounded Int32 
Bounded Int64 
Bounded Ordering 
Bounded Word 
Bounded Word8 
Bounded Word16 
Bounded Word32 
Bounded Word64 
Bounded () 
Bounded All 
Bounded Any 
Bounded CDev 
Bounded CIno 
Bounded CMode 
Bounded CNlink 
Bounded COff 
Bounded CPid 
Bounded CRLim 
Bounded CSsize 
Bounded CTcflag 
Bounded Fd 
Bounded CGid 
Bounded CUid 
Bounded CChar 
Bounded CInt 
Bounded CSize 
Bounded CLong 
Bounded GeneralCategory 
Bounded CULong 
Bounded Direction 
Bounded Point 
Bounded CUChar 
Bounded CSChar 
Bounded CWchar 
Bounded CUShort 
Bounded CULLong 
Bounded CUIntPtr 
Bounded CUIntMax 
Bounded CUInt 
Bounded CSigAtomic 
Bounded CShort 
Bounded CPtrdiff 
Bounded CLLong 
Bounded CIntPtr 
Bounded CIntMax 
Bounded a => Bounded (Dual a) 
Bounded a => Bounded (Product a) 
Bounded a => Bounded (Sum a) 
(Bounded a, Bounded b) => Bounded (a, b) 
(Bounded a, Bounded b, Bounded c) => Bounded (a, b, c) 
(Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n) 
(Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) 

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

Constructors

Nothing 
Just 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

Methods

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

(>>) :: m a -> m b -> m b

return :: a -> m a

fail :: String -> m a

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) 

class Eq a => Ord a where

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

Methods

readsPrec :: Int -> ReadS a

readList :: ReadS [a]

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

Methods

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

truncate :: Integral b => a -> b

round :: Integral b => a -> b

ceiling :: Integral b => a -> b

floor :: Integral b => a -> b

Instances

RealFrac Double 
RealFrac Float 
RealFrac NominalDiffTime 
RealFrac DiffTime 
RealFrac CFloat 
RealFrac CDouble 
Integral a => RealFrac (Ratio a) 
HasResolution a => RealFrac (Fixed a) 

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

runReaderT :: r -> m a

The underlying computation, as a function of the environment.

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

Methods

(+~) :: absolute -> relative -> absoluteSource

(-~) :: absolute -> relative -> absoluteSource

(~-) :: absolute -> absolute -> relativeSource

Instances

type String = [Char]

class Typeable a

Instances

Typeable Bool 
Typeable Char 
Typeable Double 
Typeable Float 
Typeable Int 
Typeable Int8 
Typeable Int16 
Typeable Int32 
Typeable Int64 
Typeable Integer 
Typeable Ordering 
Typeable RealWorld 
Typeable Word 
Typeable Word8 
Typeable Word16 
Typeable Word32 
Typeable Word64 
Typeable Exp 
Typeable Match 
Typeable Clause 
Typeable Pat 
Typeable Type 
Typeable Dec 
Typeable Name 
Typeable FunDep 
Typeable Pred 
Typeable TyVarBndr 
Typeable () 
Typeable TypeRep 
Typeable ConcreteTypeRep 
Typeable ModName 
Typeable PkgName 
Typeable OccName 
Typeable NameFlavour 
Typeable Body 
Typeable Callconv 
Typeable Con 
Typeable FamFlavour 
Typeable Fixity 
Typeable FixityDirection 
Typeable Foreign 
Typeable Guard 
Typeable Info 
Typeable Inline 
Typeable NameSpace 
Typeable Phases 
Typeable Pragma 
Typeable Range 
Typeable RuleBndr 
Typeable RuleMatch 
Typeable Safety 
Typeable Stmt 
Typeable Strict 
Typeable TyLit 
Typeable Tool 
Typeable Boxed 
Typeable SrcLoc 
Typeable Alt 
Typeable FieldUpdate 
Typeable QualStmt 
Typeable Stmt 
Typeable PatField 
Typeable RPat 
Typeable RPatOp 
Typeable PXAttr 
Typeable Pat 
Typeable WarningText 
Typeable RuleVar 
Typeable Rule 
Typeable Activation 
Typeable Overlap 
Typeable ModulePragma 
Typeable CallConv 
Typeable Safety 
Typeable Splice 
Typeable Bracket 
Typeable XAttr 
Typeable XName 
Typeable Exp 
Typeable Sign 
Typeable Literal 
Typeable Asst 
Typeable FunDep 
Typeable Kind 
Typeable TyVarBind 
Typeable Promoted 
Typeable Type 
Typeable GuardedRhs 
Typeable Rhs 
Typeable BangType 
Typeable InstDecl 
Typeable ClassDecl 
Typeable GadtDecl 
Typeable ConDecl 
Typeable QualConDecl 
Typeable Match 
Typeable IPBind 
Typeable Binds 
Typeable DataOrNew 
Typeable BooleanFormula 
Typeable Annotation 
Typeable TypeEqn 
Typeable Decl 
Typeable Assoc 
Typeable ImportSpec 
Typeable ImportDecl 
Typeable Namespace 
Typeable ExportSpec 
Typeable Module 
Typeable CName 
Typeable Op 
Typeable QOp 
Typeable IPName 
Typeable Name 
Typeable QName 
Typeable SpecialCon 
Typeable ModuleName 
Typeable Lit 
Typeable SomeException 
Typeable NestedAtomically 
Typeable NoMethodError 
Typeable NonTermination 
Typeable PatternMatchFail 
Typeable RecConError 
Typeable RecSelError 
Typeable RecUpdError 
Typeable ArithException 
Typeable ErrorCall 
Typeable ArrayException 
Typeable AssertionFailed 
Typeable AsyncException 
Typeable BlockedIndefinitelyOnMVar 
Typeable BlockedIndefinitelyOnSTM 
Typeable Deadlock 
Typeable IOException 
Typeable SrcSpan 
Typeable SrcSpanInfo 
Typeable Type 
Typeable MultipleInstancesNotAllowed 
Typeable InterpreterError 
Typeable SourcePos 
Typeable DataType 
Typeable TyCon 
Typeable Handle 
Typeable ByteString 
Typeable ByteString 
Typeable Text 
Typeable Text 
Typeable CCc 
Typeable CDev 
Typeable CIno 
Typeable CMode 
Typeable CNlink 
Typeable COff 
Typeable CPid 
Typeable CRLim 
Typeable CSpeed 
Typeable CSsize 
Typeable CTcflag 
Typeable Fd 
Typeable CGid 
Typeable CUid 
Typeable Version 
Typeable IntSet 
Typeable ThreadId 
Typeable CChar 
Typeable Handle__ 
Typeable CInt 
Typeable TimeZone 
Typeable TimeOfDay 
Typeable ZonedTime 
Typeable LocalTime 
Typeable UTCTime 
Typeable NominalDiffTime 
Typeable UniversalTime 
Typeable DiffTime 
Typeable Day 
Typeable E12 
Typeable CSize 
Typeable ExitCode 
Typeable CLong 
Typeable Editor 
Typeable CULong 
Typeable Direction 
Typeable WindowRef 
Typeable Point 
Typeable BufferRef 
Typeable Mark 
Typeable Dynamic 
Typeable DynamicValues 
Typeable Region 
Typeable AnyLayoutManager 
Typeable Action 
Typeable Window 
Typeable Tab 
Typeable MarkValue 
Typeable Update 
Typeable AnyMode 
Typeable IndentSettings 
Typeable FBuffer 
Typeable E9 
Typeable E6 
Typeable E3 
Typeable E2 
Typeable E1 
Typeable E0 
Typeable TextUnit 
Typeable RegionStyle 
Typeable CUChar 
Typeable CSChar 
Typeable CWchar 
Typeable CUShort 
Typeable CUSeconds 
Typeable CULLong 
Typeable CUIntPtr 
Typeable CUIntMax 
Typeable CUInt 
Typeable CTime 
Typeable CSigAtomic 
Typeable CShort 
Typeable CSUSeconds 
Typeable CPtrdiff 
Typeable CLLong 
Typeable CIntPtr 
Typeable CIntMax 
Typeable CFloat 
Typeable CDouble 
Typeable CClock 
Typeable SpecConstrAnnotation 
Typeable TempBufferNameHint 
Typeable History 
Typeable TagTable 
Typeable VimTagStack 
Typeable Yi 
Typeable ArticleDB 
Typeable VimState 
Typeable VimMode 
Typeable RepeatableAction 
Typeable CommandArguments 
Typeable FilePatternTag 
Typeable RegexTag 
Typeable CabalBuffer 
Typeable Handler 
Typeable Var 
Typeable AltCon 
Typeable Coercion 
Typeable TyLit 
Typeable Evaluator 
Typeable DependentMarks 
Typeable BufferMarks 
(Typeable1 s, Typeable a) => Typeable (s 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)

discard :: Functor f => f a -> f ()Source

dummyPut :: a -> PutSource

Write nothing. Use with dummyGet

dummyGet :: Initializable a => Get aSource

Read nothing, and return initial. Use with dummyPut.

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.

fromIntegral :: (Integral a, Num b) => a -> b

fst :: (a, b) -> a

fst3 :: (a, b, c) -> aSource

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'.

list :: b -> (a -> [a] -> b) -> [a] -> bSource

head :: [a] -> a

init :: [a] -> [a]

io :: MonadIO m => IO a -> m aSource

last :: [a] -> a

lookup :: Eq a => a -> [(a, b)] -> Maybe b

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.

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

data Rope Source

Instances

Conversions to Rope

Conversions from Rope

List-like functions

null :: Rope -> BoolSource

take :: Int -> Rope -> RopeSource

drop :: Int -> Rope -> RopeSource

length :: Rope -> IntSource

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.)

split :: Word8 -> Rope -> [Rope]Source

splitAt :: Int -> Rope -> (Rope, Rope)Source

Split the string at the specified position.

splitAtLine :: Int -> Rope -> (Rope, Rope)Source

Split before the specified line. Lines are indexed from 0.

append :: Rope -> Rope -> RopeSource

Append two strings by merging the two finger trees.

IO

readFile :: FilePath -> IO RopeSource

writeFile :: FilePath -> Rope -> IO ()Source

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

nubSet :: Ord a => [a] -> [a]Source

As nub, but with O(n*log(n)) behaviour.

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]Source

snd :: (a, b) -> b

snd3 :: (a, b, c) -> bSource

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]

trd3 :: (a, b, c) -> cSource

when :: Monad m => Bool -> m () -> m ()

writeFile :: FilePath -> String -> IO ()