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 Control.Applicative
- module Control.Category
- 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 ()
- module Data.Bool
- module Data.Foldable
- module Data.Function
- module Data.Int
- 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 Data.Traversable
- module Text.Show
- 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]
Append two lists, i.e.,
[x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn] [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
If the first list is not finite, the result is the first list.
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
Right-to-left Kleisli composition of monads. (
, with the arguments flipped
>=>
)
data Double
Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.
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 | |
PrintfArg Double | |
Storable Double | |
Binary Double | |
Hashable Double | |
CoArbitrary Double | |
Arbitrary Double | |
Random Double | |
IArray UArray Double | |
MArray (STUArray s) Double (ST s) |
class Binary t
The Binary
class provides put
and get
, methods to encode and
decode a Haskell value to a lazy ByteString. It mirrors the Read and
Show classes for textual representation of Haskell types, and is
suitable for serialising Haskell values to disk, over the network.
For parsing and generating simple external binary formats (e.g. C structures), Binary may be used, but in general is not suitable for complex protocols. Instead use the Put and Get primitives directly.
Instances of Binary should satisfy the following property:
decode . encode == id
That is, the get
and put
methods should be the inverse of each
other. A range of instances are provided for basic Haskell types.
data Char
The character type Char
is an enumeration whose values represent
Unicode (or equivalently ISO/IEC 10646) characters (see
http://www.unicode.org/ for details). This set extends the ISO 8859-1
(Latin-1) character set (the first 256 characters), which is itself an extension
of the ASCII character set (the first 128 characters). A character literal in
Haskell has type Char
.
To convert a Char
to or from the corresponding Int
value defined
by Unicode, use toEnum
and fromEnum
from the
Enum
class respectively (or equivalently ord
and chr
).
Bounded Char | |
Enum Char | |
Eq Char | |
Data Char | |
Ord Char | |
Read Char | |
Show Char | |
Ix Char | |
Typeable Char | |
Generic Char | |
PrintfArg Char | |
IsChar Char | |
Storable Char | |
Binary Char | |
Lift Char | |
Outputable Char | |
Hashable Char | |
ErrorList Char | |
Extract String | |
CoArbitrary Char | |
Arbitrary Char | |
Random Char | |
IArray UArray Char | |
RegexLike Regex String | |
MkSnippetCmd String () | |
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] | |
MArray (STUArray s) Char (ST s) | |
YiVariable (Map String History) |
data Either a b
The Either
type represents values with two possibilities: a value of
type
is either Either
a b
or Left
a
.
Right
b
The Either
type is sometimes used to represent a value which is
either correct or an error; by convention, the Left
constructor is
used to hold an error value and the Right
constructor is used to
hold a correct value (mnemonic: "right" also means "correct").
Typeable2 Either | |
Error e => MonadError e (Either e) | |
Monad (Either e) | |
Functor (Either a) | |
MonadFix (Either e) | |
Error e => MonadPlus (Either e) | |
Applicative (Either e) | |
Generic1 (Either a) | |
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) | |
(Binary a, Binary b) => Binary (Either a b) | |
(Lift a, Lift b) => Lift (Either a b) | |
(Hashable a, Hashable b) => Hashable (Either a b) | |
(CoArbitrary a, CoArbitrary b) => CoArbitrary (Either a b) | |
(Arbitrary a, Arbitrary b) => Arbitrary (Either a b) |
class Eq a where
The Eq
class defines equality (==
) and inequality (/=
).
All the basic datatypes exported by the Prelude are instances of Eq
,
and Eq
may be derived for any datatype whose constituents are also
instances of Eq
.
class Num a => Fractional a where
Fractional numbers, supporting real division.
Minimal complete definition: fromRational
and (recip
or (
)
/
)
(/) :: a -> a -> a
fractional division
recip :: a -> a
reciprocal fraction
fromRational :: Rational -> a
Conversion from a Rational
(that is
).
A floating literal stands for an application of Ratio
Integer
fromRational
to a value of type Rational
, so such literals have type
(
.
Fractional
a) => a
class Functor f where
The Functor
class is used for types that can be mapped over.
Instances of Functor
should satisfy the following laws:
fmap id == id fmap (f . g) == fmap f . fmap g
The instances of Functor
for lists, Maybe
and IO
satisfy these laws.
fmap :: (a -> b) -> f a -> f b
data IO a
A value of type
is a computation which, when performed,
does some I/O before returning a value of type IO
aa
.
There is really only one way to "perform" an I/O action: bind it to
Main.main
in your program. When your program is run, the I/O will
be performed. It isn't possible to perform I/O from an arbitrary
function, unless that function is itself in the IO
monad and called
at some point, directly or indirectly, from Main.main
.
IO
is a monad, so IO
actions can be combined using either the do-notation
or the >>
and >>=
operations from the Monad
class.
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
Arbitrary-precision integers.
class (Real a, Enum a) => Integral a where
quot :: a -> a -> a
integer division truncated toward zero
rem :: a -> a -> a
integer remainder, satisfying
(x `quot` y)*y + (x `rem` y) == x
div :: a -> a -> a
integer division truncated toward negative infinity
mod :: a -> a -> a
integer modulus, satisfying
(x `div` y)*y + (x `mod` y) == x
quotRem :: a -> a -> (a, a)
divMod :: a -> a -> (a, a)
conversion to Integer
class Bounded a where
The Bounded
class is used to name the upper and lower limits of a
type. Ord
is not a superclass of Bounded
since types that are not
totally ordered may also have upper and lower bounds.
The Bounded
class may be derived for any enumeration type;
minBound
is the first constructor listed in the data
declaration
and maxBound
is the last.
Bounded
may also be derived for single-constructor datatypes whose
constituent types are in Bounded
.
class Enum a where
Class Enum
defines operations on sequentially ordered types.
The enumFrom
... methods are used in Haskell's translation of
arithmetic sequences.
Instances of Enum
may be derived for any enumeration type (types
whose constructors have no fields). The nullary constructors are
assumed to be numbered left-to-right by fromEnum
from 0
through n-1
.
See Chapter 10 of the Haskell Report for more details.
For any type that is an instance of class Bounded
as well as Enum
,
the following should hold:
- The calls
andsucc
maxBound
should result in a runtime error.pred
minBound
-
fromEnum
andtoEnum
should give a runtime error if the result value is not representable in the result type. For example,
is an error.toEnum
7 ::Bool
-
enumFrom
andenumFromThen
should be defined with an implicit bound, thus:
enumFrom x = enumFromTo x maxBound enumFromThen x y = enumFromThenTo x y bound where bound | fromEnum y >= fromEnum x = maxBound | otherwise = minBound
succ :: a -> a
the successor of a value. For numeric types, succ
adds 1.
pred :: a -> a
the predecessor of a value. For numeric types, pred
subtracts 1.
Convert from an Int
.
Convert to an Int
.
It is implementation-dependent what fromEnum
returns when
applied to a value that is too large to fit in an Int
.
enumFrom :: a -> [a]
Used in Haskell's translation of [n..]
.
enumFromThen :: a -> a -> [a]
Used in Haskell's translation of [n,n'..]
.
enumFromTo :: a -> a -> [a]
Used in Haskell's translation of [n..m]
.
enumFromThenTo :: a -> a -> a -> [a]
Used in Haskell's translation of [n,n'..m]
.
data Maybe a
The Maybe
type encapsulates an optional value. A value of type
either contains a value of type Maybe
aa
(represented as
),
or it is empty (represented as Just
aNothing
). Using Maybe
is a good way to
deal with errors or exceptional cases without resorting to drastic
measures such as error
.
The Maybe
type is also a monad. It is a simple kind of error
monad, where all errors are represented by Nothing
. A richer
error monad can be built using the Either
type.
Monad Maybe | |
Functor Maybe | |
Typeable1 Maybe | |
MonadFix Maybe | |
MonadPlus Maybe | |
Applicative Maybe | |
Foldable Maybe | |
Traversable Maybe | |
Generic1 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) | |
Monoid a => Monoid (Maybe a) | Lift a semigroup into |
Binary a => Binary (Maybe a) | |
Lift a => Lift (Maybe a) | |
Hashable a => Hashable (Maybe a) | |
Initializable (Maybe a) | |
CoArbitrary a => CoArbitrary (Maybe a) | |
Arbitrary a => Arbitrary (Maybe a) |
class Monad m where
The Monad
class defines the basic operations over a monad,
a concept from a branch of mathematics known as category theory.
From the perspective of a Haskell programmer, however, it is best to
think of a monad as an abstract datatype of actions.
Haskell's do
expressions provide a convenient syntax for writing
monadic expressions.
Minimal complete definition: >>=
and return
.
Instances of Monad
should satisfy the following laws:
return a >>= k == k a m >>= return == m m >>= (\x -> k x >>= h) == (m >>= k) >>= h
Instances of both Monad
and Functor
should additionally satisfy the law:
fmap f xs == xs >>= return . f
The instances of Monad
for lists, Maybe
and IO
defined in the Prelude satisfy these laws.
(>>=) :: m a -> (a -> m b) -> m b
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
(>>) :: m a -> m b -> m b
Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.
return :: a -> m a
Inject a value into the monadic type.
Fail with a message. This operation is not part of the
mathematical definition of a monad, but is invoked on pattern-match
failure in a do
expression.
class Num a where
Basic numeric class.
Minimal complete definition: all except negate
or (-)
(+) :: a -> a -> a
(*) :: a -> a -> a
(-) :: a -> a -> a
negate :: a -> a
Unary negation.
abs :: a -> a
Absolute value.
signum :: a -> a
Sign of a number.
The functions abs
and signum
should satisfy the law:
abs x * signum x == x
For real numbers, the signum
is either -1
(negative), 0
(zero)
or 1
(positive).
fromInteger :: Integer -> a
Conversion from an Integer
.
An integer literal represents the application of the function
fromInteger
to the appropriate value of type Integer
,
so such literals have type (
.
Num
a) => 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 CDev | |
Num CIno | |
Num CMode | |
Num COff | |
Num CPid | |
Num CSsize | |
Num CGid | |
Num CNlink | |
Num CUid | |
Num CCc | |
Num CSpeed | |
Num CTcflag | |
Num CRLim | |
Num Fd | |
Num CChar | |
Num CSChar | |
Num CUChar | |
Num CShort | |
Num CUShort | |
Num CInt | |
Num CUInt | |
Num CLong | |
Num CULong | |
Num CLLong | |
Num CULLong | |
Num CFloat | |
Num CDouble | |
Num CPtrdiff | |
Num CSize | |
Num CWchar | |
Num CSigAtomic | |
Num CClock | |
Num CTime | |
Num CUSeconds | |
Num CSUSeconds | |
Num CIntPtr | |
Num CUIntPtr | |
Num CIntMax | |
Num CUIntMax | |
Num NominalDiffTime | |
Num DiffTime | |
Num Size | |
Num Point | |
Num BufferRef | |
Integral a => Num (Ratio a) | |
HasResolution a => Num (Fixed a) | |
Num t => Num (::: t doc) |
The Ord
class is used for totally ordered datatypes.
Instances of Ord
can be derived for any user-defined
datatype whose constituent types are in Ord
. The declared order
of the constructors in the data declaration determines the ordering
in derived Ord
instances. The Ordering
datatype allows a single
comparison to determine the precise ordering of two objects.
Minimal complete definition: either compare
or <=
.
Using compare
can be more efficient for complex types.
class Read a where
Parsing of String
s, producing values.
Minimal complete definition: readsPrec
(or, for GHC only, readPrec
)
Derived instances of Read
make the following assumptions, which
derived instances of Show
obey:
- If the constructor is defined to be an infix operator, then the
derived
Read
instance will parse only infix applications of the constructor (not the prefix form). - Associativity is not used to reduce the occurrence of parentheses, although precedence may be.
- If the constructor is defined using record syntax, the derived
Read
will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration. - The derived
Read
instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.
For example, given the declarations
infixr 5 :^: data Tree a = Leaf a | Tree a :^: Tree a
the derived instance of Read
in Haskell 98 is equivalent to
instance (Read a) => Read (Tree a) where readsPrec d r = readParen (d > app_prec) (\r -> [(Leaf m,t) | ("Leaf",s) <- lex r, (m,t) <- readsPrec (app_prec+1) s]) r ++ readParen (d > up_prec) (\r -> [(u:^:v,w) | (u,s) <- readsPrec (up_prec+1) r, (":^:",t) <- lex s, (v,w) <- readsPrec (up_prec+1) t]) r where app_prec = 10 up_prec = 5
Note that right-associativity of :^:
is unused.
The derived instance in GHC is equivalent to
instance (Read a) => Read (Tree a) where readPrec = parens $ (prec app_prec $ do Ident "Leaf" <- lexP m <- step readPrec return (Leaf m)) +++ (prec up_prec $ do u <- step readPrec Symbol ":^:" <- lexP v <- step readPrec return (u :^: v)) where app_prec = 10 up_prec = 5 readListPrec = readListPrecDefault
:: Int | the operator precedence of the enclosing
context (a number from |
-> ReadS a |
attempts to parse a value from the front of the string, returning a list of (parsed value, remaining string) pairs. If there is no successful parse, the returned list is empty.
Derived instances of Read
and Show
satisfy the following:
That is, readsPrec
parses the string produced by
showsPrec
, and delivers the value that
showsPrec
started with.
class (Num a, Ord a) => Real a where
toRational :: a -> Rational
the rational equivalent of its real argument with full precision
class (Real a, Fractional a) => RealFrac a where
Extracting components of fractions.
Minimal complete definition: properFraction
properFraction :: Integral b => a -> (b, a)
The function properFraction
takes a real fractional number x
and returns a pair (n,f)
such that x = n+f
, and:
-
n
is an integral number with the same sign asx
; and -
f
is a fraction with the same type and sign asx
, and with absolute value less than1
.
The default definitions of the ceiling
, floor
, truncate
and round
functions are in terms of properFraction
.
truncate :: Integral b => a -> b
returns the integer nearest truncate
xx
between zero and x
returns the nearest integer to round
xx
;
the even integer if x
is equidistant between two integers
ceiling :: Integral b => a -> b
returns the least integer not less than ceiling
xx
returns the greatest integer not greater than floor
xx
newtype ReaderT r m a
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) | |
Alternative m => Alternative (ReaderT r m) | |
MonadIO m => MonadIO (ReaderT r m) | |
MonadCatchIO m => MonadCatchIO (ReaderT r m) |
class SemiNum absolute relative | absolute -> relative whereSource
class Typeable a
The class Typeable
allows a concrete representation of a type to
be calculated.
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)
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
general coercion from integral types
fst :: (a, b) -> a
Extract the first component of a pair.
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
Extract the first element of a list, which must be non-empty.
init :: [a] -> [a]
Return all the elements of a list except the last one. The list must be non-empty.
last :: [a] -> a
Extract the last element of a list, which must be finite and non-empty.
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 Control.Applicative
module Control.Category
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
module Data.Bool
module Data.Foldable
module Data.Function
module Data.Int
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 Data.Traversable
module Text.Show
module Yi.Debug
module Yi.Monad
The print
function outputs a value of any printable type to the
standard output device.
Printable types are those that are instances of class Show
; print
converts values to strings for output using the show
operation and
adds a newline.
For example, a program to print the first 20 integers and their powers of 2 could be written as:
main = print ([(n, 2^n) | n <- [0..19]])
replicate
n x
is a list of length n
with x
the value of
every element.
It is an instance of the more general genericReplicate
,
in which n
may be of any integral type.
The read
function reads input from a string, which must be
completely consumed by the input process.
seq :: a -> b -> b
Evaluates its first argument to head normal form, and then returns its second argument as the result.
snd :: (a, b) -> b
Extract the second component of a pair.
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]
Extract the elements after the head of a list, which must be non-empty.
undefined :: a