Data.Char.Frame

Documentation

data Horizontal a

Constructors

Horizontal

Fields

• left, right :: a

Instances

Functor Horizontal

Methods

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

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

Applicative Horizontal

Methods

pure :: a -> Horizontal a

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

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

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

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

Foldable Horizontal

Methods

fold :: Monoid m => Horizontal m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Horizontal a -> a

foldl1 :: (a -> a -> a) -> Horizontal a -> a

toList :: Horizontal a -> [a]

null :: Horizontal a -> Bool

length :: Horizontal a -> Int

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

maximum :: Ord a => Horizontal a -> a

minimum :: Ord a => Horizontal a -> a

sum :: Num a => Horizontal a -> a

product :: Num a => Horizontal a -> a

Traversable Horizontal

Methods

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

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

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

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

Eq a => Eq (Horizontal a)

Methods

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

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

Show a => Show (Horizontal a)

Methods

showsPrec :: Int -> Horizontal a -> ShowS

show :: Horizontal a -> String

showList :: [Horizontal a] -> ShowS

Semigroup a => Semigroup (Horizontal a)

Methods

(<>) :: Horizontal a -> Horizontal a -> Horizontal a

sconcat :: NonEmpty (Horizontal a) -> Horizontal a

stimes :: Integral b => b -> Horizontal a -> Horizontal a

Monoid a => Monoid (Horizontal a)

Methods

mempty :: Horizontal a

mappend :: Horizontal a -> Horizontal a -> Horizontal a

mconcat :: [Horizontal a] -> Horizontal a

data Vertical a

Constructors

Vertical

Fields

• up, down :: a

Instances

Functor Vertical

Methods

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

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

Applicative Vertical

Methods

pure :: a -> Vertical a

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

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

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

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

Foldable Vertical

Methods

fold :: Monoid m => Vertical m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Vertical a -> a

foldl1 :: (a -> a -> a) -> Vertical a -> a

toList :: Vertical a -> [a]

null :: Vertical a -> Bool

length :: Vertical a -> Int

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

maximum :: Ord a => Vertical a -> a

minimum :: Ord a => Vertical a -> a

sum :: Num a => Vertical a -> a

product :: Num a => Vertical a -> a

Traversable Vertical

Methods

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

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

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

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

Eq a => Eq (Vertical a)

Methods

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

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

Show a => Show (Vertical a)

Methods

showsPrec :: Int -> Vertical a -> ShowS

show :: Vertical a -> String

showList :: [Vertical a] -> ShowS

Semigroup a => Semigroup (Vertical a)

Methods

(<>) :: Vertical a -> Vertical a -> Vertical a

sconcat :: NonEmpty (Vertical a) -> Vertical a

stimes :: Integral b => b -> Vertical a -> Vertical a

Monoid a => Monoid (Vertical a)

Methods

mempty :: Vertical a

mappend :: Vertical a -> Vertical a -> Vertical a

mconcat :: [Vertical a] -> Vertical a

data Parts a

Constructors

Parts (Vertical a) (Horizontal a)

Instances

Functor Parts

Methods

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

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

Applicative Parts

Methods

pure :: a -> Parts a

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

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

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

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

Foldable Parts

Methods

fold :: Monoid m => Parts m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Parts a -> a

foldl1 :: (a -> a -> a) -> Parts a -> a

toList :: Parts a -> [a]

null :: Parts a -> Bool

length :: Parts a -> Int

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

maximum :: Ord a => Parts a -> a

minimum :: Ord a => Parts a -> a

sum :: Num a => Parts a -> a

product :: Num a => Parts a -> a

Traversable Parts

Methods

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

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

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

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

Eq a => Eq (Parts a)

Methods

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

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

Show a => Show (Parts a)

Methods

showsPrec :: Int -> Parts a -> ShowS

show :: Parts a -> String

showList :: [Parts a] -> ShowS

Semigroup a => Semigroup (Parts a)

Methods

(<>) :: Parts a -> Parts a -> Parts a

sconcat :: NonEmpty (Parts a) -> Parts a

stimes :: Integral b => b -> Parts a -> Parts a

Monoid a => Monoid (Parts a)

Methods

mempty :: Parts a

mappend :: Parts a -> Parts a -> Parts a

mconcat :: [Parts a] -> Parts a

simple :: Parts Bool -> Char

data Weight

Constructors

Empty

Light

Heavy

Instances

Bounded Weight

Methods

minBound :: Weight

maxBound :: Weight

Enum Weight

Methods

succ :: Weight -> Weight

pred :: Weight -> Weight

toEnum :: Int -> Weight

fromEnum :: Weight -> Int

enumFrom :: Weight -> [Weight]

enumFromThen :: Weight -> Weight -> [Weight]

enumFromTo :: Weight -> Weight -> [Weight]

enumFromThenTo :: Weight -> Weight -> Weight -> [Weight]

Eq Weight

Methods

(==) :: Weight -> Weight -> Bool

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

Ord Weight

Methods

compare :: Weight -> Weight -> Ordering

(<) :: Weight -> Weight -> Bool

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

(>) :: Weight -> Weight -> Bool

(>=) :: Weight -> Weight -> Bool

max :: Weight -> Weight -> Weight

min :: Weight -> Weight -> Weight

Show Weight

Methods

showsPrec :: Int -> Weight -> ShowS

show :: Weight -> String

showList :: [Weight] -> ShowS

weighted :: Parts Weight -> Char

data Directions a

Constructors

Directions

Fields

• vertical, horizontal :: a

Instances

Functor Directions

Methods

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

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

Applicative Directions

Methods

pure :: a -> Directions a

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

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

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

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

Foldable Directions

Methods

fold :: Monoid m => Directions m -> m

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

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

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

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

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

foldr1 :: (a -> a -> a) -> Directions a -> a

foldl1 :: (a -> a -> a) -> Directions a -> a

toList :: Directions a -> [a]

null :: Directions a -> Bool

length :: Directions a -> Int

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

maximum :: Ord a => Directions a -> a

minimum :: Ord a => Directions a -> a

sum :: Num a => Directions a -> a

product :: Num a => Directions a -> a

Traversable Directions

Methods

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

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

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

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

Eq a => Eq (Directions a)

Methods

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

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

Show a => Show (Directions a)

Methods

showsPrec :: Int -> Directions a -> ShowS

show :: Directions a -> String

showList :: [Directions a] -> ShowS

double :: Directions Bool -> Parts Bool -> Char

This function is not total because half-width and half-height double bars are missing.

doubleMaybe :: Directions Bool -> Parts Bool -> Maybe Char