Text.Space

A sum type for space characters

Documentation

data HorizontalSpace

HorizontalSpace is a subset of Char. To move back and forth betwen it and Char, String, or Text, use _HorizontalSpace

Constructors

Space

Tab

Instances

Eq HorizontalSpace

Methods

(==) :: HorizontalSpace -> HorizontalSpace -> Bool

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

Ord HorizontalSpace

Methods

compare :: HorizontalSpace -> HorizontalSpace -> Ordering

(<) :: HorizontalSpace -> HorizontalSpace -> Bool

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

(>) :: HorizontalSpace -> HorizontalSpace -> Bool

(>=) :: HorizontalSpace -> HorizontalSpace -> Bool

max :: HorizontalSpace -> HorizontalSpace -> HorizontalSpace

min :: HorizontalSpace -> HorizontalSpace -> HorizontalSpace

Show HorizontalSpace

Methods

showsPrec :: Int -> HorizontalSpace -> ShowS

show :: HorizontalSpace -> String

showList :: [HorizontalSpace] -> ShowS

NFData HorizontalSpace

Methods

rnf :: HorizontalSpace -> ()

AsHorizontalSpace HorizontalSpace

Methods

_HorizontalSpace :: Prism' HorizontalSpace HorizontalSpace

_Space :: Prism' HorizontalSpace ()

_Tab :: Prism' HorizontalSpace ()

class AsHorizontalSpace r where

Classy prisms for HorizontalSpaces

Minimal complete definition

_HorizontalSpace

Methods

_HorizontalSpace :: Prism' r HorizontalSpace

_Space :: Prism' r ()

_Tab :: Prism' r ()

Instances

AsHorizontalSpace Char

Methods

_HorizontalSpace :: Prism' Char HorizontalSpace

_Space :: Prism' Char ()

_Tab :: Prism' Char ()

AsHorizontalSpace HorizontalSpace

Methods

_HorizontalSpace :: Prism' HorizontalSpace HorizontalSpace

_Space :: Prism' HorizontalSpace ()

_Tab :: Prism' HorizontalSpace ()

type Spaces = Vector HorizontalSpace

Helpful alias for lists of Spaces

single :: Spaces

One space

manySpaces :: Int -> Spaces

As many spaces as you'd like

tab :: Spaces

One tab

spaceToChar :: HorizontalSpace -> Char

Turn a Space into a Char. To go the other way, see charToSpace

charToSpace :: Char -> Maybe HorizontalSpace

Try to turn a Char into a Space. To go the other way, see spaceToChar

spacesText :: Prism' Text Spaces

Parse Text into Spaces, or turn spaces into Text

spacesString :: Prism' String Spaces

Parse String into Spaces, or convert Spaces into String

data Spaced a

Spaced is a value with zero or many horizontal spaces around it on both sides.

Constructors

Spaced

Fields

• _before :: Spaces
• _after :: Spaces
• _value :: a

Instances

Functor Spaced

Methods

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

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

Applicative Spaced

Appends the right parameter on the inside of the left parameter

Spaced "   " () " " *> Spaced "\t\t\t" () "\t \t" == Spaced "   \t\t\t" () "\t \t "

Methods

pure :: a -> Spaced a

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

liftA2 :: (a -> b -> c) -> Spaced a -> Spaced b -> Spaced c

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

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

Foldable Spaced

Methods

fold :: Monoid m => Spaced m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Spaced a -> a

foldl1 :: (a -> a -> a) -> Spaced a -> a

toList :: Spaced a -> [a]

null :: Spaced a -> Bool

length :: Spaced a -> Int

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

maximum :: Ord a => Spaced a -> a

minimum :: Ord a => Spaced a -> a

sum :: Num a => Spaced a -> a

product :: Num a => Spaced a -> a

Traversable Spaced

Methods

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

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

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

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

Eq a => Eq (Spaced a)

Methods

(==) :: Spaced a -> Spaced a -> Bool

(/=) :: Spaced a -> Spaced a -> Bool

Ord a => Ord (Spaced a)

Methods

compare :: Spaced a -> Spaced a -> Ordering

(<) :: Spaced a -> Spaced a -> Bool

(<=) :: Spaced a -> Spaced a -> Bool

(>) :: Spaced a -> Spaced a -> Bool

(>=) :: Spaced a -> Spaced a -> Bool

max :: Spaced a -> Spaced a -> Spaced a

min :: Spaced a -> Spaced a -> Spaced a

Show a => Show (Spaced a)

Methods

showsPrec :: Int -> Spaced a -> ShowS

show :: Spaced a -> String

showList :: [Spaced a] -> ShowS

Generic (Spaced a)

Associated Types

type Rep (Spaced a) :: * -> *

Methods

from :: Spaced a -> Rep (Spaced a) x

to :: Rep (Spaced a) x -> Spaced a

NFData a => NFData (Spaced a)

Methods

rnf :: Spaced a -> ()

MonadReader (Vector (SpacedField s)) (DecodeState s)

Methods

ask :: DecodeState s (Vector (SpacedField s))

local :: (Vector (SpacedField s) -> Vector (SpacedField s)) -> DecodeState s a -> DecodeState s a

reader :: (Vector (SpacedField s) -> a) -> DecodeState s a

HasSpaced (Spaced a) (Spaced b) a b

Methods

spaced :: Lens (Spaced a) (Spaced b) (Spaced a) (Spaced b)

after :: Lens (Spaced a) (Spaced b) Spaces Spaces

before :: Lens (Spaced a) (Spaced b) Spaces Spaces

spacedValue :: Lens (Spaced a) (Spaced b) a b

type Rep (Spaced a)

type Rep (Spaced a) = D1 * (MetaData "Spaced" "Text.Space" "sv-0.1-LEjGD2ajzYS6ZNIUObPicZ" False) (C1 * (MetaCons "Spaced" PrefixI True) ((:*:) * (S1 * (MetaSel (Just Symbol "_before") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Spaces)) ((:*:) * (S1 * (MetaSel (Just Symbol "_after") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * Spaces)) (S1 * (MetaSel (Just Symbol "_value") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 * a)))))

class HasSpaced s t a b | s -> a, t -> b, s b -> t, t a -> s where

Classy lenses for Spaced

Minimal complete definition

spaced

Methods

spaced :: Lens s t (Spaced a) (Spaced b)

after :: s ~ t => Lens s t Spaces Spaces

before :: s ~ t => Lens s t Spaces Spaces

spacedValue :: Lens s t a b

after :: (s ~ t, a ~ b) => Lens s t Spaces Spaces

before :: (s ~ t, a ~ b) => Lens s t Spaces Spaces

spacedValue :: (s ~ t, a ~ b) => Lens s t a b

Instances

HasSpaced (Spaced a) (Spaced b) a b

Methods

spaced :: Lens (Spaced a) (Spaced b) (Spaced a) (Spaced b)

after :: Lens (Spaced a) (Spaced b) Spaces Spaces

before :: Lens (Spaced a) (Spaced b) Spaces Spaces

spacedValue :: Lens (Spaced a) (Spaced b) a b

betwixt :: Spaces -> a -> Spaces -> Spaced a

betwixt is just the constructor for Spaced with a different argument order, which is sometimes useful.

uniform :: Spaces -> a -> Spaced a

uniform puts the same spacing both before and after something.

unspaced :: a -> Spaced a

Places its argument in a Spaced with no spaces.

removeSpaces :: Spaced a -> Spaced a

Remove spaces from the argument