Data.Mark

Documentation

data Point

Point at text: line and column

Constructors

Point

Fields

pointLine :: Int

pointColumn :: Int

Instances

Eq Point

Ord Point

Read Point

Show Point

ToJSON Point

FromJSON Point

Monoid Size

(.-.) :: Point -> Point -> Point

Distance between points is measured in lines and columns. And it is defined, that distance between point at l:c and point (l + 1):0 is one line no matter c is because we need to go to new line to reach destination point Columns are taken into account only if points are on the same line pt .-. base is distance from base to pt Distance can't be less then zero lines and columns

(.+.) :: Point -> Point -> Point

Opposite to ".-.", (pt .-. base) .+. base = pt

type Size = Point

linesSize :: Int -> Point

Distance in n lines

stringSize :: Int -> Point

Distance in n chars within one line

data Region

Region from Point to Point

Constructors

Region

Fields

regionFrom :: Point

regionTo :: Point

Instances

Eq Region

Ord Region

Read Region

Show Region

ToJSON Region

FromJSON Region

regionLines :: Region -> Int

Region height in lines. Any Region at least of one line height

emptyRegion :: Region -> Bool

Is Region empty

line :: Int -> Region

n'th line region, starts at the beginning of line and ends on the next line

region :: Point -> Point -> Region

Make region

regionSize :: Point -> Size -> Region

Make region from starting point and its size

at :: Editable a => Contents a -> Region -> Contents a

Get contents at specified region

Mappings

newtype Map

Main idea is that there are only two basic actions , that chances regions: inserting and cutting When something is cutted out or inserted in, region positions must be updated All editings can be represented as many cuts and inserts, so we can combine them to get function which maps source regions to regions on updated data Because insert is dual to cut (and therefore composes iso), we can also get function to map regions back Combining this functions while edit, we get function, that maps regions from source data to edited one To get back function, we must also combine opposite actions, or we can represent actions as isomorphisms Same idea goes for modifying contents, represent each action as isomorphism and combine them together

Constructors

Map

Fields

mapIso :: Iso' Region Region

Instances

Monoid Map

apply :: Map -> Region -> Region

Apply mapping

back :: Map -> Map

Back mapping

cut :: Region -> Map

Cut region mapping

insert :: Region -> Map

Opposite to "cut"

cutRegion :: Region -> Region -> Region

Update second region position as if it was data cutted at first region

insertRegion :: Region -> Region -> Region

Update second region position as if it was data inserted at first region

Edited data

type Contents a = [a]

Contents is list of lines

data Edit a

Edit data

Constructors

Edit

Map region from source contents to edited

Fields

editCts :: Contents a -> Contents a

Edit contents splitted by lines

editMap :: Map

Instances

Monoid (Edit a)

MonadState (Edit s) (EditM s)

newtype EditM s a

Edit monad is state on Edit, it also collects region mappings

Constructors

EditM

Fields

runEditM :: State (Edit s) a

Instances

Monad (EditM s)

Functor (EditM s)

Applicative (EditM s)

MonadState (Edit s) (EditM s)

editRegion :: Region -> (Region -> Edit a) -> EditM a ()

Basic edit action in monad It takes region, region edit function and contents updater and passes mapped region to these functions to get new state

mapRegion :: Region -> EditM a Region

Get mapped region

runEdit :: Editable s => EditM s a -> (a, Edit s)

Run edit monad

edit :: Editable s => s -> EditM s a -> s

Edit contents

editEval :: Editable s => s -> EditM s a -> (a, s)

Eval edit

data Prefix a

Prefix of contents cutted at some point

Constructors

Prefix

Fields

prefixLines :: [a]

prefixLine :: a

Instances

Functor Prefix

Eq a => Eq (Prefix a)

Ord a => Ord (Prefix a)

Read a => Read (Prefix a)

Show a => Show (Prefix a)

prefix :: Contents a -> Prefix a

Make prefix from full contents

data Suffix a

Suffix of contents

Constructors

Suffix

Fields

suffixLine :: a

suffixLines :: [a]

Instances

Functor Suffix

Eq a => Eq (Suffix a)

Ord a => Ord (Suffix a)

Read a => Read (Suffix a)

Show a => Show (Suffix a)

suffix :: Contents a -> Suffix a

concatCts :: Monoid a => Prefix a -> Suffix a -> Contents a

Concat prefix and suffix. First line of suffix is appended to last line of prefix

splitCts :: Editable a => Point -> Contents a -> (Prefix a, Suffix a)

Split contents at point. First argument is function to split one line at position.

Editable class

class Monoid a => Editable a where

Methods

splitAt :: Int -> a -> (a, a)

length :: a -> Int

lines :: a -> [a]

unlines :: [a] -> a

Instances

Editable String

Editable Text

measure :: Editable s => Contents s -> Size

Contents size

Actions

erase :: Editable s => Region -> EditM s ()

Erase data

write :: Editable s => Point -> Contents s -> EditM s ()

Paste data at position

replace :: Editable s => Region -> Contents s -> EditM s ()

Replace data with

data Replace s

Replace action

Constructors

Replace

Fields

replaceRegion :: Region

replaceWith :: Contents s

Instances

Eq s => Eq (Replace s)

Read s => Read (Replace s)

Show s => Show (Replace s)

(Editable s, ToJSON s) => ToJSON (Replace s)

(Editable s, FromJSON s) => FromJSON (Replace s)

eraser :: Monoid s => Region -> Replace s

writer :: Editable s => Point -> s -> Replace s

replacer :: Editable s => Region -> s -> Replace s

run :: Editable s => [Replace s] -> EditM s ()