Data.Text.Region.Types

Documentation

data Point

Point at text: zero-based line and column

Constructors

Point

Fields

_pointLine :: Int

_pointColumn :: Int

Instances

Eq Point

Ord Point

Read Point

Show Point

ToJSON Point

FromJSON Point

Monoid Point

Group Point

ApplyMap Point

pointLine :: Lens' Point Int

pointColumn :: Lens' Point Int

type Size = 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

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

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

data Region

Region from Point to another

Constructors

Region

Fields

_regionFrom :: Point

_regionTo :: Point

Instances

Eq Region

Ord Region

Read Region

Show Region

ToJSON Region

FromJSON Region

ApplyMap Region

regionFrom :: Lens' Region Point

regionTo :: Lens' Region Point

newtype Map

Main idea is that there are only two basic actions, that changes 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 something like 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 Iso 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

Group Map

ApplyMap Map

type Contents a = [a]

Contents is list of lines, list must have at least one (maybe empty) line

emptyContents :: Monoid a => Contents a

Empty contents are contents with one empty line

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

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

Split Contents at some Point

splitted :: Editable a => Point -> Iso' (Contents a) (Contents a, Contents a)

Get splitted Contents at some Point

class Monoid a => Editable a where

Something editable, string types implements this

Methods

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

Split editable at some position

contentsLength :: a -> Int

splitLines :: a -> [a]

joinLines :: [a] -> a

Instances

Editable String

Editable Text

contents :: (Editable a, Editable b) => Iso a b (Contents a) (Contents b)

Get Contents for some Editable, splitting lines

by :: Editable a => a -> Contents a

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

Contents Size

data Replace s

Serializable edit action

Constructors

Replace

Fields

_replaceRegion :: Region

Region to replace

_replaceWith :: Contents s

Contents to replace with

Instances

Editable s => EditAction Replace s

Eq s => Eq (Replace s)

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

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

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

ApplyMap (Replace s)

replaceRegion :: forall s. Lens' (Replace s) Region

replaceWith :: forall s s. Lens (Replace s) (Replace s) (Contents s) (Contents s)

newtype Chain e s

Chain of edit actions

Constructors

Chain

Fields

_chain :: [e s]

Instances

EditAction e s => EditAction (Chain e) s

Eq (e s) => Eq (Chain e s)

Show (e s) => Show (Chain e s)

ToJSON (e s) => ToJSON (Chain e s)

FromJSON (e s) => FromJSON (Chain e s)

Monoid (Chain e s)

ApplyMap (e s) => ApplyMap (Chain e s)

chain :: forall e s e s. Iso (Chain e s) (Chain e s) [e s] [e s]

type Edit s = Chain Replace s

data ActionIso e

Some action with its inverse

Constructors

ActionIso

Fields

_action :: e

_actionBack :: e

Instances

ToJSON e => ToJSON (ActionIso e)

FromJSON e => FromJSON (ActionIso e)

Monoid e => Monoid (ActionIso e)

Monoid e => Group (ActionIso e)

action :: forall e. Lens' (ActionIso e) e

actionBack :: forall e. Lens' (ActionIso e) e

data ActionStack e

Stack of undo/redo actions

Constructors

ActionStack

Fields

_undoStack :: [ActionIso e]

_redoStack :: [ActionIso e]

Instances

ToJSON e => ToJSON (ActionStack e)

FromJSON e => FromJSON (ActionStack e)

undoStack :: forall e. Lens' (ActionStack e) [ActionIso e]

redoStack :: forall e. Lens' (ActionStack e) [ActionIso e]

emptyStack :: ActionStack e

data EditState s r

Edit state

Constructors

EditState

Fields

_history :: ActionStack (Edit s)

Edit history is stack of edit actions

_edited :: Contents s

Currently edited data

_regions :: r

Some region-based state, that will be updated on each edit

Instances

(Editable s, ToJSON s, ToJSON r) => ToJSON (EditState s r)

(Editable s, FromJSON s, FromJSON r) => FromJSON (EditState s r)

MonadState (EditState s r) (EditM s r)

editState :: Editable s => s -> r -> EditState s r

Make edit state for contents

history :: forall s r. Lens' (EditState s r) (ActionStack (Edit s))

edited :: forall s r. Lens' (EditState s r) (Contents s)

regions :: forall s r r. Lens (EditState s r) (EditState s r) r r

newtype EditM s r a

Constructors

EditM

Fields

runEditM :: State (EditState s r) a

Instances

Monad (EditM s r)

Functor (EditM s r)

Applicative (EditM s r)

MonadState (EditState s r) (EditM s r)

module Data.Group