Data.Rope.Annotated

Annotated Ropes

data Branded brand t a

Instances

Monoid t => MonadWriter t (Branded Unsafe t)

Measured v t => Measured v (Branded s t a)

Monoid t => Monad (Branded Unsafe t)

Functor (Branded s t)

Monoid t => Applicative (Branded Unsafe t)

Foldable (Branded s t)

Traversable (Branded s t)

Comonad (Branded s t)

(Monoid t, Monoid m) => Monoid (Branded Unsafe t m)

type Ann f s = (s `Branded` Rope) (f s)

class MonoidalAnn f

Instances

MonoidalAnn Unit

(MonoidalAnn f, MonoidalAnn g) => MonoidalAnn (:*: f g)

class MonoidalAnn f => PackableAnn f

Instances

PackableAnn Unit

(PackableAnn f, PackableAnn g) => PackableAnn (:*: f g)

class BreakableAnn f

Instances

BreakableAnn Unit

(BreakableAnn f, BreakableAnn g) => BreakableAnn (:*: f g)

runAnn :: Ann f a -> (forall b. Ann f b -> r) -> r

Unpacking Ropes

null :: Branded s Rope a -> Bool

head :: Unpackable t => Branded s Rope a -> t

last :: Unpackable t => Branded s Rope a -> t

unpack :: Unpackable t => Branded s Rope a -> [t]

Building Annotated Rope

empty :: MonoidalAnn f => Ann f Nil

append :: MonoidalAnn f => Ann f a -> Ann f b -> Ann f (a :<> b)

pack :: (PackableAnn f, Packable t) => t -> (forall a. Ann f (Return a) -> r) -> r

snoc :: (PackableAnn f, Packable t) => Ann f a -> t -> (forall c. Ann f (Snoc a c t) -> r) -> r

cons :: (PackableAnn f, Packable t) => t -> Ann f a -> (forall c. Ann f (Cons c t a) -> r) -> r

Cutting An Annotated Rope

splitAt :: BreakableAnn f => Int -> Ann f a -> (forall n. Ann f (Take n a) -> Ann f (Drop n a) -> r) -> r

drop :: BreakableAnn f => Int -> Ann f a -> (forall n. Ann f (Drop n a) -> r) -> r

take :: BreakableAnn f => Int -> Ann f a -> (forall n. Ann f (Take n a) -> r) -> r

break :: (BreakableAnn f, Breakable t) => (t -> Bool) -> Ann f a -> (forall n. Ann f (Take n a) -> Ann f (Drop n a) -> r) -> r

span :: (BreakableAnn f, Breakable t) => (t -> Bool) -> Ann f a -> (forall n. Ann f (Take n a) -> Ann f (Drop n a) -> r) -> r

takeWhile :: (BreakableAnn f, Breakable t) => (t -> Bool) -> Ann f a -> (forall n. Ann f (Take n a) -> r) -> r

dropWhile :: (BreakableAnn f, Breakable t) => (t -> Bool) -> Ann f a -> (forall n. Ann f (Drop n a) -> r) -> r

Inspecting the ends of the Rope

uncons :: (BreakableAnn f, Unpackable t) => Ann f a -> Maybe (t, Ann f (Tail t a))

unsnoc :: (BreakableAnn f, Unpackable t) => Ann f a -> Maybe (Ann f (Init a t), t)

Type-level constructors

type family Drop n a :: *

type family Take n a :: *

type Snoc a s t = a :<> Return (Token s t)

type Cons s t a = Token s t :> a

type Tail t a = Return (Tailed t a)

type Init a t = Return (Inited a t)

type Return a = a :> Nil

type family a :<> b :: *

data Tailed t a

data Inited a t

data Dropped n a

data Taken n a

data Nil

data a :> b

Annotations

Annotation Product

data (f :*: g) a

A Rope Annotation product.

Constructors

(f a) :*: (g a)

Instances

(Functor f, Functor g) => Functor (:*: f g)

(Applicative f, Applicative g) => Applicative (:*: f g)

(Foldable f, Foldable g) => Foldable (:*: f g)

(Traversable f, Traversable g) => Traversable (:*: f g)

(BreakableAnn f, BreakableAnn g) => BreakableAnn (:*: f g)

(PackableAnn f, PackableAnn g) => PackableAnn (:*: f g)

(MonoidalAnn f, MonoidalAnn g) => MonoidalAnn (:*: f g)

fstF :: (f :*: g) a -> f a

sndF :: (f :*: g) a -> g a

Annotation Unit

data Unit a

Instances

BreakableAnn Unit

PackableAnn Unit

MonoidalAnn Unit