Yi.Buffer.Misc

The Buffer module defines monadic editing operations over one-dimensional buffers, maintaining a current point.

Documentation

data FBuffer

Constructors

FBuffer !(Mode syntax) !(BufferImpl syntax) !Attributes

Instances

Eq FBuffer

Methods

(==) :: FBuffer -> FBuffer -> Bool

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

MonadState FBuffer BufferM

Methods

get :: BufferM FBuffer

put :: FBuffer -> BufferM ()

state :: (FBuffer -> (a, FBuffer)) -> BufferM a

newtype BufferM a

The BufferM monad writes the updates performed.

Constructors

BufferM

Fields

• fromBufferM :: ReaderT Window (State FBuffer) a

Instances

Monad BufferM

Methods

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

(>>) :: BufferM a -> BufferM b -> BufferM b

return :: a -> BufferM a

fail :: String -> BufferM a

Functor BufferM

Methods

fmap :: (a -> b) -> BufferM a -> BufferM b

(<$) :: a -> BufferM b -> BufferM a

Applicative BufferM

Methods

pure :: a -> BufferM a

(<*>) :: BufferM (a -> b) -> BufferM a -> BufferM b

(*>) :: BufferM a -> BufferM b -> BufferM b

(<*) :: BufferM a -> BufferM b -> BufferM a

MonadReader Window BufferM

Methods

ask :: BufferM Window

local :: (Window -> Window) -> BufferM a -> BufferM a

reader :: (Window -> a) -> BufferM a

MonadState FBuffer BufferM

Methods

get :: BufferM FBuffer

put :: FBuffer -> BufferM ()

state :: (FBuffer -> (a, FBuffer)) -> BufferM a

YiAction (BufferM x) x

Methods

makeAction :: BufferM x -> Action

type WinMarks = MarkSet Mark

data MarkSet a

Constructors

MarkSet

Fields

• fromMark, insMark, selMark :: !a

Instances

Functor MarkSet

Methods

fmap :: (a -> b) -> MarkSet a -> MarkSet b

(<$) :: a -> MarkSet b -> MarkSet a

Foldable MarkSet

Methods

fold :: Monoid m => MarkSet m -> m

foldMap :: Monoid m => (a -> m) -> MarkSet a -> m

foldr :: (a -> b -> b) -> b -> MarkSet a -> b

foldr' :: (a -> b -> b) -> b -> MarkSet a -> b

foldl :: (b -> a -> b) -> b -> MarkSet a -> b

foldl' :: (b -> a -> b) -> b -> MarkSet a -> b

foldr1 :: (a -> a -> a) -> MarkSet a -> a

foldl1 :: (a -> a -> a) -> MarkSet a -> a

toList :: MarkSet a -> [a]

null :: MarkSet a -> Bool

length :: MarkSet a -> Int

elem :: Eq a => a -> MarkSet a -> Bool

maximum :: Ord a => MarkSet a -> a

minimum :: Ord a => MarkSet a -> a

sum :: Num a => MarkSet a -> a

product :: Num a => MarkSet a -> a

Traversable MarkSet

Methods

traverse :: Applicative f => (a -> f b) -> MarkSet a -> f (MarkSet b)

sequenceA :: Applicative f => MarkSet (f a) -> f (MarkSet a)

mapM :: Monad m => (a -> m b) -> MarkSet a -> m (MarkSet b)

sequence :: Monad m => MarkSet (m a) -> m (MarkSet a)

Show a => Show (MarkSet a)

Methods

showsPrec :: Int -> MarkSet a -> ShowS

show :: MarkSet a -> String

showList :: [MarkSet a] -> ShowS

Binary a => Binary (MarkSet a)

Methods

put :: MarkSet a -> Put

get :: Get (MarkSet a)

putList :: [MarkSet a] -> Put

bkey :: FBuffer -> BufferRef

getMarks :: Window -> BufferM (Maybe WinMarks)

runBuffer :: Window -> FBuffer -> BufferM a -> (a, FBuffer)

Execute a BufferM value on a given buffer and window. The new state of the buffer is returned alongside the result of the computation.

runBufferFull :: Window -> FBuffer -> BufferM a -> (a, Seq Update, FBuffer)

runBufferDummyWindow :: FBuffer -> BufferM a -> a

Execute a BufferM value on a given buffer, using a dummy window. The new state of the buffer is discarded.

screenTopLn :: BufferM Int

Top line of the screen

screenMidLn :: BufferM Int

Middle line of the screen

screenBotLn :: BufferM Int

Bottom line of the screen

curLn :: BufferM Int

Return the current line number

curCol :: BufferM Int

Current column. Note that this is different from offset or number of chars from sol. (This takes into account tabs, unicode chars, etc.)

colOf :: Point -> BufferM Int

lineOf :: Point -> BufferM Int

lineCountB :: BufferM Int

sizeB :: BufferM Point

Point of eof

pointB :: BufferM Point

Extract the current point

pointOfLineColB :: Int -> Int -> BufferM Point

solPointB :: Point -> BufferM Point

Returns start of line point for a given point p

eolPointB :: Point -> BufferM Point

Returns end of line for given point.

markLines :: BufferM (MarkSet Int)

Return line numbers of marks

moveTo :: Point -> BufferM ()

Move point in buffer to the given index

moveToColB :: Int -> BufferM ()

moveToLineColB :: Int -> Int -> BufferM ()

lineMoveRel :: Int -> BufferM Int

Move point down by n lines. n can be negative. Returns the actual difference in lines which we moved which may be negative if the requested line difference is negative.

lineUp :: BufferM ()

Move point up one line

lineDown :: BufferM ()

Move point down one line

newB :: BufferRef -> BufferId -> YiString -> FBuffer

Create buffer named nm with contents s

data MarkValue

Constructors

MarkValue

Fields

• markPoint :: !Point
• markGravity :: !Direction

Instances

Eq MarkValue

Methods

(==) :: MarkValue -> MarkValue -> Bool

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

Ord MarkValue

Methods

compare :: MarkValue -> MarkValue -> Ordering

(<) :: MarkValue -> MarkValue -> Bool

(<=) :: MarkValue -> MarkValue -> Bool

(>) :: MarkValue -> MarkValue -> Bool

(>=) :: MarkValue -> MarkValue -> Bool

max :: MarkValue -> MarkValue -> MarkValue

min :: MarkValue -> MarkValue -> MarkValue

Show MarkValue

Methods

showsPrec :: Int -> MarkValue -> ShowS

show :: MarkValue -> String

showList :: [MarkValue] -> ShowS

Generic MarkValue

Associated Types

type Rep MarkValue :: * -> *

Methods

from :: MarkValue -> Rep MarkValue x

to :: Rep MarkValue x -> MarkValue

Binary MarkValue

Methods

put :: MarkValue -> Put

get :: Get MarkValue

putList :: [MarkValue] -> Put

type Rep MarkValue

type Rep MarkValue = D1 (MetaData "MarkValue" "Yi.Buffer.Implementation" "yi-core-0.15.0-FSYwHFrYyww1PXyP8gT8tr" False) (C1 (MetaCons "MarkValue" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "markPoint") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Point)) (S1 (MetaSel (Just Symbol "markGravity") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 Direction))))

data Overlay

Instances

Eq Overlay

Methods

(==) :: Overlay -> Overlay -> Bool

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

Ord Overlay

Methods

compare :: Overlay -> Overlay -> Ordering

(<) :: Overlay -> Overlay -> Bool

(<=) :: Overlay -> Overlay -> Bool

(>) :: Overlay -> Overlay -> Bool

(>=) :: Overlay -> Overlay -> Bool

max :: Overlay -> Overlay -> Overlay

min :: Overlay -> Overlay -> Overlay

Show Overlay

Methods

showsPrec :: Int -> Overlay -> ShowS

show :: Overlay -> String

showList :: [Overlay] -> ShowS

mkOverlay :: YiString -> Region -> StyleName -> YiString -> Overlay

Create an "overlay" for the style sty between points s and e

gotoLn :: Int -> BufferM Int

Go to line number n. n is indexed from 1. Returns the actual line we went to (which may be not be the requested line, if it was out of range)

gotoLnFrom :: Int -> BufferM Int

Go to line indexed from current point Returns the actual moved difference which of course may be negative if the requested difference was negative.

leftB :: BufferM ()

Move point -1

rightB :: BufferM ()

Move cursor +1

moveN :: Int -> BufferM ()

Move point by the given number of characters. A negative offset moves backwards a positive one forward.

leftN :: Int -> BufferM ()

Move cursor -n

rightN :: Int -> BufferM ()

Move cursor +n

insertN :: YiString -> BufferM ()

Insert the YiString at current point, extending size of buffer

insertNAt :: YiString -> Point -> BufferM ()

Insert given YiString at specified point, extending size of the buffer.

insertB :: Char -> BufferM ()

Insert the char at current point, extending size of buffer

Implementation note: This just insertBs a singleton. This seems sub-optimal because we should be able to do much better without spewing chunks of size 1 everywhere. This approach is necessary however so an Update can be recorded. A possible improvement for space would be to have ‘yi-rope’ package optimise for appends with length 1.

deleteN :: Int -> BufferM ()

Delete n characters forward from the current point

nelemsB :: Int -> Point -> BufferM YiString

writeB :: Char -> BufferM ()

Write an element into the buffer at the current point.

writeN :: YiString -> BufferM ()

Write the list into the buffer at current point.

newlineB :: BufferM ()

Insert newline at current point.

deleteNAt :: Direction -> Int -> Point -> BufferM ()

deleteNAt n p deletes n characters forwards from position p

readB :: BufferM Char

Read the character at the current point

elemsB :: BufferM YiString

Return the contents of the buffer.

undosA :: HasAttributes c => Lens' c URList

undoB :: BufferM ()

redoB :: BufferM ()

getMarkB :: Maybe String -> BufferM Mark

setMarkHereB :: BufferM Mark

setNamedMarkHereB :: String -> BufferM ()

mayGetMarkB :: String -> BufferM (Maybe Mark)

getMarkValueB :: Mark -> BufferM MarkValue

markPointA :: Mark -> Lens' FBuffer Point

modifyMarkB :: Mark -> (MarkValue -> MarkValue) -> BufferM ()

newMarkB :: MarkValue -> BufferM Mark

deleteMarkB :: Mark -> BufferM ()

getVisibleSelection :: BufferM Bool

Whether the selection is highlighted

setVisibleSelection :: Bool -> BufferM ()

Highlight the selection

isUnchangedBuffer :: FBuffer -> Bool

setAnyMode :: AnyMode -> BufferM ()

Set the mode

setMode :: Mode syntax -> BufferM ()

setMode0 :: forall syntax. Mode syntax -> FBuffer -> FBuffer

modifyMode :: (forall syntax. Mode syntax -> Mode syntax) -> BufferM ()

Modify the mode

regexRegionB :: SearchExp -> Region -> BufferM [Region]

Return indices of strings in buffer matched by regex in the given region.

regexB :: Direction -> SearchExp -> BufferM [Region]

Return indices of next string in buffer matched by regex in the given direction

readAtB :: Point -> BufferM Char

Read the character at the given index This is an unsafe operation: character NUL is returned when out of bounds

getModeLine :: [Text] -> BufferM Text

Given a buffer, and some information update the modeline

N.B. the contents of modelines should be specified by user, and not hardcoded.

getPercent :: Point -> Point -> Text

Given a point, and the file size, gives us a percent string

setInserting :: Bool -> BufferM ()

savingPrefCol :: BufferM a -> BufferM a

forgetPreferCol :: BufferM ()

movingToPrefCol :: BufferM a -> BufferM a

movingToPrefVisCol :: BufferM a -> BufferM a

Moves to a visual column within the current line as shown on the editor (ie, moving within the current width of a single visual line)

preferColA :: HasAttributes c => Lens' c (Maybe Int)

markSavedB :: UTCTime -> BufferM ()

Mark the current point in the undo list as a saved state.

retroactivelyAtSavePointB :: BufferM a -> BufferM a

Undo all updates that happened since last save, perform a given action and redo all updates again. Given action must not modify undo history.

addOverlayB :: Overlay -> BufferM ()

Adds an "overlay" to the buffer

delOverlayB :: Overlay -> BufferM ()

Remove an existing "overlay"

delOverlaysOfOwnerB :: YiString -> BufferM ()

getOverlaysOfOwnerB :: YiString -> BufferM (Set Overlay)

isPointInsideOverlay :: Point -> Overlay -> Bool

savingExcursionB :: BufferM a -> BufferM a

perform a BufferM a, and return to the current point. (by using a mark)

savingPointB :: BufferM a -> BufferM a

Perform an BufferM a, and return to the current point.

savingPositionB :: BufferM a -> BufferM a

Perform an BufferM a, and return to the current line and column number. The difference between this and savingPointB is that here we attempt to return to the specific line and column number, rather than a specific number of characters from the beginning of the buffer.

In case the column is further away than EOL, the point is left at EOL: moveToLineColB is used internally.

pendingUpdatesA :: HasAttributes c => Lens' c (Seq UIUpdate)

highlightSelectionA :: Lens' FBuffer Bool

rectangleSelectionA :: Lens' FBuffer Bool

readOnlyA :: HasAttributes c => Lens' c Bool

insertingA :: HasAttributes c => Lens' c Bool

pointFollowsWindowA :: HasAttributes c => Lens' c (Set WindowRef)

revertPendingUpdatesB :: BufferM ()

Revert all the pending updates; don't touch the point.

askWindow :: (Window -> a) -> BufferM a

clearSyntax :: FBuffer -> FBuffer

update the syntax information (clear the dirty "flag")

focusSyntax :: Map WindowRef Region -> FBuffer -> FBuffer

data Mode syntax

A Mode customizes the Yi interface for editing a particular data format. It specifies when the mode should be used and controls file-specific syntax highlighting and command input, among other things.

Constructors

Mode

Fields

• modeName :: Text

  so this can be serialized, debugged.

• modeApplies :: FilePath -> YiString -> Bool

  What type of files does this mode apply to?

• modeHL :: ExtHL syntax

  Syntax highlighter

• modePrettify :: syntax -> BufferM ()

  Prettify current "paragraph"

• modeKeymap :: KeymapSet -> KeymapSet

  Buffer-local keymap modification

• modeIndent :: syntax -> IndentBehaviour -> BufferM ()

  emacs-style auto-indent line

• modeFollow :: syntax -> Action

  Follow a "link" in the file. (eg. go to location of error message)

• modeIndentSettings :: IndentSettings
• modeToggleCommentSelection :: Maybe (BufferM ())
• modeGetStrokes :: syntax -> Point -> Point -> Point -> [Stroke]

  Strokes that should be applied when displaying a syntax element should this be an Action instead?

• modeOnLoad :: BufferM ()

  An action that is to be executed when this mode is set

• modeModeLine :: [Text] -> BufferM Text

  buffer-local modeline formatting method

• modeGotoDeclaration :: BufferM ()

  go to the point where the variable is declared

modeNameA :: forall syntax. Lens' (Mode syntax) Text

modeAppliesA :: forall syntax. Lens' (Mode syntax) (FilePath -> YiString -> Bool)

modeHLA :: forall syntax. Lens' (Mode syntax) (ExtHL syntax)

modePrettifyA :: forall syntax. Lens' (Mode syntax) (syntax -> BufferM ())

modeKeymapA :: forall syntax. Lens' (Mode syntax) (KeymapSet -> KeymapSet)

modeIndentA :: forall syntax. Lens' (Mode syntax) (syntax -> IndentBehaviour -> BufferM ())

modeFollowA :: forall syntax. Lens' (Mode syntax) (syntax -> Action)

modeIndentSettingsA :: forall syntax. Lens' (Mode syntax) IndentSettings

modeToggleCommentSelectionA :: forall syntax. Lens' (Mode syntax) (Maybe (BufferM ()))

modeGetStrokesA :: forall syntax. Lens' (Mode syntax) (syntax -> Point -> Point -> Point -> [Stroke])

modeOnLoadA :: forall syntax. Lens' (Mode syntax) (BufferM ())

modeGotoDeclarationA :: forall syntax. Lens' (Mode syntax) (BufferM ())

modeModeLineA :: forall syntax. Lens' (Mode syntax) ([Text] -> BufferM Text)

data AnyMode

Constructors

AnyMode (Mode syntax)

data IndentBehaviour

Used to specify the behaviour of the automatic indent command.

Constructors

IncreaseCycle

Increase the indentation to the next higher indentation hint. If we are currently at the highest level of indentation then cycle back to the lowest.

DecreaseCycle

Decrease the indentation to the next smaller indentation hint. If we are currently at the smallest level then cycle back to the largest

IncreaseOnly

Increase the indentation to the next higher hint if no such hint exists do nothing.

DecreaseOnly

Decrease the indentation to the next smaller indentation hint, if no such hint exists do nothing.

Instances

Eq IndentBehaviour

Methods

(==) :: IndentBehaviour -> IndentBehaviour -> Bool

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

Show IndentBehaviour

Methods

showsPrec :: Int -> IndentBehaviour -> ShowS

show :: IndentBehaviour -> String

showList :: [IndentBehaviour] -> ShowS

data IndentSettings

Currently duplicates some of Vim's indent settings. Allowing a buffer to specify settings that are more dynamic, perhaps via closures, could be useful.

Constructors

IndentSettings

Fields

• expandTabs :: !Bool

  Insert spaces instead of tabs as possible

• tabSize :: !Int

  Size of a Tab

• shiftWidth :: !Int

  Indent by so many columns

Instances

Eq IndentSettings

Methods

(==) :: IndentSettings -> IndentSettings -> Bool

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

Show IndentSettings

Methods

showsPrec :: Int -> IndentSettings -> ShowS

show :: IndentSettings -> String

showList :: [IndentSettings] -> ShowS

expandTabsA :: Lens' IndentSettings Bool

tabSizeA :: Lens' IndentSettings Int

shiftWidthA :: Lens' IndentSettings Int

modeAlwaysApplies :: a -> b -> Bool

Mode applies function that always returns True.

modeNeverApplies :: a -> b -> Bool

Mode applies function that always returns False.

emptyMode :: Mode syntax

withModeB :: (forall syntax. Mode syntax -> BufferM a) -> BufferM a

withMode0 :: (forall syntax. Mode syntax -> a) -> FBuffer -> a

onMode :: (forall syntax. Mode syntax -> Mode syntax) -> AnyMode -> AnyMode

withSyntaxB :: (forall syntax. Mode syntax -> syntax -> a) -> BufferM a

withSyntaxB' :: (forall syntax. Mode syntax -> syntax -> BufferM a) -> BufferM a

keymapProcessA :: HasAttributes c => Lens' c KeymapProcess

strokesRangesB :: Maybe SearchExp -> Region -> BufferM [[Stroke]]

streamB :: Direction -> Point -> BufferM YiString

indexedStreamB :: Direction -> Point -> BufferM [(Point, Char)]

askMarks :: BufferM WinMarks

pointAt :: BufferM a -> BufferM Point

data SearchExp :: *

Instances

Binary SearchExp

Methods

put :: SearchExp -> Put

get :: Get SearchExp

putList :: [SearchExp] -> Put

lastActiveWindowA :: HasAttributes c => Lens' c Window

putBufferDyn :: (YiVariable a, MonadState FBuffer m, Functor m) => a -> m ()

Access to a value into the extensible state, keyed by its type. This allows you to save inside a BufferM monad, ie:

putBufferDyn updatedvalue

getBufferDyn :: forall m a. (Default a, YiVariable a, MonadState FBuffer m, Functor m) => m a

Access to a value into the extensible state, keyed by its type. This allows you to retrieve inside a BufferM monad, ie:

value <- getBufferDyn

shortIdentString

Arguments

:: Int

Number of characters to drop from FileBuffer names

-> FBuffer

Buffer to work with

-> Text

Gets a short identifier of a buffer. If we're given a MemBuffer then just wraps the buffer name like so: *name*. If we're given a FileBuffer, it drops the number of path components.

>>> let memBuf = newB (BufferRef 0) (MemBuffer "foo/bar/hello") ""
>>> shortIdentString 2 memBuf
"*foo/bar/hello*"
>>> let fileBuf = newB (BufferRef 0) (FileBuffer "foo/bar/hello") ""
>>> shortIdentString 2 fileBuf
"hello"

identString :: FBuffer -> Text

Gets the buffer's identifier string, emphasising the MemBuffer:

>>> let memBuf = newB (BufferRef 0) (MemBuffer "foo/bar/hello") ""
>>> identString memBuf
"*foo/bar/hello*"
>>> let fileBuf = newB (BufferRef 0) (FileBuffer "foo/bar/hello") ""
>>> identString fileBuf
"foo/bar/hello"

miniIdentString :: FBuffer -> Text

identA :: HasAttributes c => Lens' c BufferId

directoryContentA :: HasAttributes c => Lens' c Bool

data BufferId

Constructors

MemBuffer !Text

FileBuffer !FilePath

Instances

Eq BufferId

Methods

(==) :: BufferId -> BufferId -> Bool

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

Ord BufferId

Methods

compare :: BufferId -> BufferId -> Ordering

(<) :: BufferId -> BufferId -> Bool

(<=) :: BufferId -> BufferId -> Bool

(>) :: BufferId -> BufferId -> Bool

(>=) :: BufferId -> BufferId -> Bool

max :: BufferId -> BufferId -> BufferId

min :: BufferId -> BufferId -> BufferId

Show BufferId

Methods

showsPrec :: Int -> BufferId -> ShowS

show :: BufferId -> String

showList :: [BufferId] -> ShowS

Binary BufferId

Methods

put :: BufferId -> Put

get :: Get BufferId

putList :: [BufferId] -> Put

file :: FBuffer -> Maybe FilePath

lastSyncTimeA :: HasAttributes c => Lens' c UTCTime

replaceCharB :: Char -> BufferM ()

replaceCharWithBelowB :: BufferM ()

replaceCharWithAboveB :: BufferM ()

insertCharWithBelowB :: BufferM ()

insertCharWithAboveB :: BufferM ()

pointAfterCursorB :: Point -> BufferM Point

destinationOfMoveB :: BufferM a -> BufferM Point

What would be the point after doing the given action? The argument must not modify the buffer.

withEveryLineB :: BufferM () -> BufferM ()

startUpdateTransactionB :: BufferM ()

commitUpdateTransactionB :: BufferM ()

applyUpdate :: Update -> BufferM ()

betweenB

Arguments

:: Point

Point to start at

-> Point

Point to stop at

-> BufferM YiString

Returns the contents of the buffer between the two points.

If the startPoint >= endPoint, empty string is returned. If the points are out of bounds, as much of the content as possible is taken: you're not guaranteed to get endPoint - startPoint characters.

decreaseFontSize :: Int -> BufferM ()

Decreases the font size in the buffer by specified number. What this number actually means depends on the front-end.

increaseFontSize :: Int -> BufferM ()

Increases the font size in the buffer by specified number. What this number actually means depends on the front-end.

indentSettingsB :: BufferM IndentSettings

Gives the IndentSettings for the current buffer.

fontsizeVariationA :: HasAttributes c => Lens' c Int

encodingConverterNameA :: HasAttributes c => Lens' c (Maybe ConverterName)

stickyEolA :: HasAttributes c => Lens' c Bool

queryBuffer :: (forall syntax. BufferImpl syntax -> x) -> BufferM x

Orphan instances

Show FBuffer

Methods

showsPrec :: Int -> FBuffer -> ShowS

show :: FBuffer -> String

showList :: [FBuffer] -> ShowS

Binary FBuffer

Methods

put :: FBuffer -> Put

get :: Get FBuffer

putList :: [FBuffer] -> Put

Binary (Mode syntax)

Just stores the mode name.

Methods

put :: Mode syntax -> Put

get :: Get (Mode syntax)

putList :: [Mode syntax] -> Put