Data.Char.Frame

A frame is represented as a pair of horizontal and vertical lines. These can be any items, but currently only booleans and weight objects are covered to convert the item to a corresponding character.

Line weight

data Weight

The weights of the frame lines, these can be Empty, Light or Heavy.

Constructors

Empty

The frame does not contain such line.

Light

The frame contains such line.

Heavy

The frame contains such line, in boldface.

Instances

Bounded Weight

Defined in Data.Char.Frame

Methods

minBound :: Weight

maxBound :: Weight

Enum Weight

Defined in Data.Char.Frame

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

Defined in Data.Char.Frame

Methods

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

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

Data Weight

Defined in Data.Char.Frame

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Weight -> c Weight

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Weight

toConstr :: Weight -> Constr

dataTypeOf :: Weight -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Weight)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Weight)

gmapT :: (forall b. Data b => b -> b) -> Weight -> Weight

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Weight -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Weight -> r

gmapQ :: (forall d. Data d => d -> u) -> Weight -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Weight -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Weight -> m Weight

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Weight -> m Weight

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Weight -> m Weight

Ord Weight

Defined in Data.Char.Frame

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

Read Weight

Defined in Data.Char.Frame

Methods

readsPrec :: Int -> ReadS Weight

readList :: ReadS [Weight]

readPrec :: ReadPrec Weight

readListPrec :: ReadPrec [Weight]

Show Weight

Defined in Data.Char.Frame

Methods

showsPrec :: Int -> Weight -> ShowS

show :: Weight -> String

showList :: [Weight] -> ShowS

Generic Weight

Defined in Data.Char.Frame

Associated Types

type Rep Weight :: Type -> Type

Methods

from :: Weight -> Rep Weight x

to :: Rep Weight x -> Weight

Arbitrary Weight

Defined in Data.Char.Frame

Methods

arbitrary :: Gen Weight

shrink :: Weight -> [Weight]

Hashable Weight

Defined in Data.Char.Frame

Methods

hashWithSalt :: Int -> Weight -> Int

hash :: Weight -> Int

UnicodeText (Parts Weight)

Defined in Data.Char.Frame

Methods

toUnicodeText :: Parts Weight -> Text

fromUnicodeText :: Text -> Maybe (Parts Weight)

fromUnicodeText' :: Text -> Parts Weight

UnicodeCharacter (Parts Weight)

Defined in Data.Char.Frame

Methods

toUnicodeChar :: Parts Weight -> Char

fromUnicodeChar :: Char -> Maybe (Parts Weight)

fromUnicodeChar' :: Char -> Parts Weight

type Rep Weight

Defined in Data.Char.Frame

type Rep Weight = D1 ('MetaData "Weight" "Data.Char.Frame" "unicode-tricks-0.10.0.0-AliVHfzJIeqARoOu4Sb24D" 'False) (C1 ('MetaCons "Empty" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Light" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Heavy" 'PrefixI 'False) (U1 :: Type -> Type)))

Datastructures to store the four directions

data Horizontal a

A data type that determines the state of the horizontal lines of the frame (left and right).

Constructors

Horizontal

Fields

• left :: a

  The state of the left line of the frame.

• right :: a

  The state of the right line of the frame.

Instances

Functor Horizontal

Defined in Data.Char.Frame

Methods

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

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

Applicative Horizontal

Defined in Data.Char.Frame

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

Defined in Data.Char.Frame

Methods

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

foldMap :: Monoid m => (a -> m) -> Horizontal a -> 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

Defined in Data.Char.Frame

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)

Arbitrary1 Horizontal

Defined in Data.Char.Frame

Methods

liftArbitrary :: Gen a -> Gen (Horizontal a)

liftShrink :: (a -> [a]) -> Horizontal a -> [Horizontal a]

Eq1 Horizontal

Defined in Data.Char.Frame

Methods

liftEq :: (a -> b -> Bool) -> Horizontal a -> Horizontal b -> Bool

Ord1 Horizontal

Defined in Data.Char.Frame

Methods

liftCompare :: (a -> b -> Ordering) -> Horizontal a -> Horizontal b -> Ordering

Hashable1 Horizontal

Defined in Data.Char.Frame

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Horizontal a -> Int

Bounded a => Bounded (Horizontal a)

Defined in Data.Char.Frame

Methods

minBound :: Horizontal a

maxBound :: Horizontal a

Eq a => Eq (Horizontal a)

Defined in Data.Char.Frame

Methods

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

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

Data a => Data (Horizontal a)

Defined in Data.Char.Frame

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Horizontal a -> c (Horizontal a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Horizontal a)

toConstr :: Horizontal a -> Constr

dataTypeOf :: Horizontal a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Horizontal a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Horizontal a))

gmapT :: (forall b. Data b => b -> b) -> Horizontal a -> Horizontal a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Horizontal a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Horizontal a -> r

gmapQ :: (forall d. Data d => d -> u) -> Horizontal a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Horizontal a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Horizontal a -> m (Horizontal a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Horizontal a -> m (Horizontal a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Horizontal a -> m (Horizontal a)

Ord a => Ord (Horizontal a)

Defined in Data.Char.Frame

Methods

compare :: Horizontal a -> Horizontal a -> Ordering

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

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

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

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

max :: Horizontal a -> Horizontal a -> Horizontal a

min :: Horizontal a -> Horizontal a -> Horizontal a

Read a => Read (Horizontal a)

Defined in Data.Char.Frame

Methods

readsPrec :: Int -> ReadS (Horizontal a)

readList :: ReadS [Horizontal a]

readPrec :: ReadPrec (Horizontal a)

readListPrec :: ReadPrec [Horizontal a]

Show a => Show (Horizontal a)

Defined in Data.Char.Frame

Methods

showsPrec :: Int -> Horizontal a -> ShowS

show :: Horizontal a -> String

showList :: [Horizontal a] -> ShowS

Generic (Horizontal a)

Defined in Data.Char.Frame

Associated Types

type Rep (Horizontal a) :: Type -> Type

Methods

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

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

Semigroup a => Semigroup (Horizontal a)

Defined in Data.Char.Frame

Methods

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

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

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

(Monoid a, Semigroup a) => Monoid (Horizontal a)

Defined in Data.Char.Frame

Methods

mempty :: Horizontal a

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

mconcat :: [Horizontal a] -> Horizontal a

Arbitrary a => Arbitrary (Horizontal a)

Defined in Data.Char.Frame

Methods

arbitrary :: Gen (Horizontal a)

shrink :: Horizontal a -> [Horizontal a]

Hashable a => Hashable (Horizontal a)

Defined in Data.Char.Frame

Methods

hashWithSalt :: Int -> Horizontal a -> Int

hash :: Horizontal a -> Int

Generic1 Horizontal

Defined in Data.Char.Frame

Associated Types

type Rep1 Horizontal :: k -> Type

Methods

from1 :: forall (a :: k). Horizontal a -> Rep1 Horizontal a

to1 :: forall (a :: k). Rep1 Horizontal a -> Horizontal a

type Rep (Horizontal a)

Defined in Data.Char.Frame

type Rep (Horizontal a) = D1 ('MetaData "Horizontal" "Data.Char.Frame" "unicode-tricks-0.10.0.0-AliVHfzJIeqARoOu4Sb24D" 'False) (C1 ('MetaCons "Horizontal" 'PrefixI 'True) (S1 ('MetaSel ('Just "left") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "right") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

type Rep1 Horizontal

Defined in Data.Char.Frame

type Rep1 Horizontal = D1 ('MetaData "Horizontal" "Data.Char.Frame" "unicode-tricks-0.10.0.0-AliVHfzJIeqARoOu4Sb24D" 'False) (C1 ('MetaCons "Horizontal" 'PrefixI 'True) (S1 ('MetaSel ('Just "left") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "right") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

data Vertical a

A data type that determines the state of the vertical lines of the frame (up and down).

Constructors

Vertical

Fields

• up :: a

  The state of the line in the up direction of the frame.

• down :: a

  The state of the line in the down direction of the frame.

Instances

Functor Vertical

Defined in Data.Char.Frame

Methods

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

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

Applicative Vertical

Defined in Data.Char.Frame

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

Defined in Data.Char.Frame

Methods

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

foldMap :: Monoid m => (a -> m) -> Vertical a -> 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

Defined in Data.Char.Frame

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)

Arbitrary1 Vertical

Defined in Data.Char.Frame

Methods

liftArbitrary :: Gen a -> Gen (Vertical a)

liftShrink :: (a -> [a]) -> Vertical a -> [Vertical a]

Eq1 Vertical

Defined in Data.Char.Frame

Methods

liftEq :: (a -> b -> Bool) -> Vertical a -> Vertical b -> Bool

Ord1 Vertical

Defined in Data.Char.Frame

Methods

liftCompare :: (a -> b -> Ordering) -> Vertical a -> Vertical b -> Ordering

Hashable1 Vertical

Defined in Data.Char.Frame

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Vertical a -> Int

Bounded a => Bounded (Vertical a)

Defined in Data.Char.Frame

Methods

minBound :: Vertical a

maxBound :: Vertical a

Eq a => Eq (Vertical a)

Defined in Data.Char.Frame

Methods

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

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

Data a => Data (Vertical a)

Defined in Data.Char.Frame

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Vertical a -> c (Vertical a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Vertical a)

toConstr :: Vertical a -> Constr

dataTypeOf :: Vertical a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Vertical a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Vertical a))

gmapT :: (forall b. Data b => b -> b) -> Vertical a -> Vertical a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Vertical a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Vertical a -> r

gmapQ :: (forall d. Data d => d -> u) -> Vertical a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Vertical a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Vertical a -> m (Vertical a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Vertical a -> m (Vertical a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Vertical a -> m (Vertical a)

Ord a => Ord (Vertical a)

Defined in Data.Char.Frame

Methods

compare :: Vertical a -> Vertical a -> Ordering

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

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

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

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

max :: Vertical a -> Vertical a -> Vertical a

min :: Vertical a -> Vertical a -> Vertical a

Read a => Read (Vertical a)

Defined in Data.Char.Frame

Methods

readsPrec :: Int -> ReadS (Vertical a)

readList :: ReadS [Vertical a]

readPrec :: ReadPrec (Vertical a)

readListPrec :: ReadPrec [Vertical a]

Show a => Show (Vertical a)

Defined in Data.Char.Frame

Methods

showsPrec :: Int -> Vertical a -> ShowS

show :: Vertical a -> String

showList :: [Vertical a] -> ShowS

Generic (Vertical a)

Defined in Data.Char.Frame

Associated Types

type Rep (Vertical a) :: Type -> Type

Methods

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

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

Semigroup a => Semigroup (Vertical a)

Defined in Data.Char.Frame

Methods

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

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

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

(Monoid a, Semigroup a) => Monoid (Vertical a)

Defined in Data.Char.Frame

Methods

mempty :: Vertical a

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

mconcat :: [Vertical a] -> Vertical a

Arbitrary a => Arbitrary (Vertical a)

Defined in Data.Char.Frame

Methods

arbitrary :: Gen (Vertical a)

shrink :: Vertical a -> [Vertical a]

Hashable a => Hashable (Vertical a)

Defined in Data.Char.Frame

Methods

hashWithSalt :: Int -> Vertical a -> Int

hash :: Vertical a -> Int

Generic1 Vertical

Defined in Data.Char.Frame

Associated Types

type Rep1 Vertical :: k -> Type

Methods

from1 :: forall (a :: k). Vertical a -> Rep1 Vertical a

to1 :: forall (a :: k). Rep1 Vertical a -> Vertical a

type Rep (Vertical a)

Defined in Data.Char.Frame

type Rep (Vertical a) = D1 ('MetaData "Vertical" "Data.Char.Frame" "unicode-tricks-0.10.0.0-AliVHfzJIeqARoOu4Sb24D" 'False) (C1 ('MetaCons "Vertical" 'PrefixI 'True) (S1 ('MetaSel ('Just "up") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "down") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))

type Rep1 Vertical

Defined in Data.Char.Frame

type Rep1 Vertical = D1 ('MetaData "Vertical" "Data.Char.Frame" "unicode-tricks-0.10.0.0-AliVHfzJIeqARoOu4Sb24D" 'False) (C1 ('MetaCons "Vertical" 'PrefixI 'True) (S1 ('MetaSel ('Just "up") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1 :*: S1 ('MetaSel ('Just "down") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) Par1))

data Parts a

A data type that specifies the four lines that should (not) be drawn for the frame.

Constructors

Parts (Vertical a) (Horizontal a)

Instances

Functor Parts

Defined in Data.Char.Frame

Methods

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

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

Applicative Parts

Defined in Data.Char.Frame

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

Defined in Data.Char.Frame

Methods

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

foldMap :: Monoid m => (a -> m) -> Parts a -> 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

Defined in Data.Char.Frame

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)

Arbitrary1 Parts

Defined in Data.Char.Frame

Methods

liftArbitrary :: Gen a -> Gen (Parts a)

liftShrink :: (a -> [a]) -> Parts a -> [Parts a]

Eq1 Parts

Defined in Data.Char.Frame

Methods

liftEq :: (a -> b -> Bool) -> Parts a -> Parts b -> Bool

Ord1 Parts

Defined in Data.Char.Frame

Methods

liftCompare :: (a -> b -> Ordering) -> Parts a -> Parts b -> Ordering

Hashable1 Parts

Defined in Data.Char.Frame

Methods

liftHashWithSalt :: (Int -> a -> Int) -> Int -> Parts a -> Int

Bounded a => Bounded (Parts a)

Defined in Data.Char.Frame

Methods

minBound :: Parts a

maxBound :: Parts a

Eq a => Eq (Parts a)

Defined in Data.Char.Frame

Methods

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

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

Data a => Data (Parts a)

Defined in Data.Char.Frame

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Parts a -> c (Parts a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Parts a)

toConstr :: Parts a -> Constr

dataTypeOf :: Parts a -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Parts a))

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Parts a))

gmapT :: (forall b. Data b => b -> b) -> Parts a -> Parts a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parts a -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parts a -> r

gmapQ :: (forall d. Data d => d -> u) -> Parts a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Parts a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Parts a -> m (Parts a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Parts a -> m (Parts a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Parts a -> m (Parts a)

Ord a => Ord (Parts a)

Defined in Data.Char.Frame

Methods

compare :: Parts a -> Parts a -> Ordering

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

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

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

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

max :: Parts a -> Parts a -> Parts a

min :: Parts a -> Parts a -> Parts a

Read a => Read (Parts a)

Defined in Data.Char.Frame

Methods

readsPrec :: Int -> ReadS (Parts a)

readList :: ReadS [Parts a]

readPrec :: ReadPrec (Parts a)

readListPrec :: ReadPrec [Parts a]

Show a => Show (Parts a)

Defined in Data.Char.Frame

Methods

showsPrec :: Int -> Parts a -> ShowS

show :: Parts a -> String

showList :: [Parts a] -> ShowS

Generic (Parts a)

Defined in Data.Char.Frame

Associated Types

type Rep (Parts a) :: Type -> Type

Methods

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

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

Semigroup a => Semigroup (Parts a)

Defined in Data.Char.Frame

Methods

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

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

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

(Monoid a, Semigroup a) => Monoid (Parts a)

Defined in Data.Char.Frame

Methods

mempty :: Parts a

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

mconcat :: [Parts a] -> Parts a

Arbitrary a => Arbitrary (Parts a)

Defined in Data.Char.Frame

Methods

arbitrary :: Gen (Parts a)

shrink :: Parts a -> [Parts a]

Hashable a => Hashable (Parts a)

Defined in Data.Char.Frame

Methods

hashWithSalt :: Int -> Parts a -> Int

hash :: Parts a -> Int

UnicodeText (Parts Bool)

Defined in Data.Char.Frame

Methods

toUnicodeText :: Parts Bool -> Text

fromUnicodeText :: Text -> Maybe (Parts Bool)

fromUnicodeText' :: Text -> Parts Bool

UnicodeText (Parts Weight)

Defined in Data.Char.Frame

Methods

toUnicodeText :: Parts Weight -> Text

fromUnicodeText :: Text -> Maybe (Parts Weight)

fromUnicodeText' :: Text -> Parts Weight

UnicodeCharacter (Parts Bool)

Defined in Data.Char.Frame

Methods

toUnicodeChar :: Parts Bool -> Char

fromUnicodeChar :: Char -> Maybe (Parts Bool)

fromUnicodeChar' :: Char -> Parts Bool

UnicodeCharacter (Parts Weight)

Defined in Data.Char.Frame

Methods

toUnicodeChar :: Parts Weight -> Char

fromUnicodeChar :: Char -> Maybe (Parts Weight)

fromUnicodeChar' :: Char -> Parts Weight

Generic1 Parts

Defined in Data.Char.Frame

Associated Types

type Rep1 Parts :: k -> Type

Methods

from1 :: forall (a :: k). Parts a -> Rep1 Parts a

to1 :: forall (a :: k). Rep1 Parts a -> Parts a

type Rep (Parts a)

Defined in Data.Char.Frame

type Rep (Parts a) = D1 ('MetaData "Parts" "Data.Char.Frame" "unicode-tricks-0.10.0.0-AliVHfzJIeqARoOu4Sb24D" 'False) (C1 ('MetaCons "Parts" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Vertical a)) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Horizontal a))))

type Rep1 Parts

Defined in Data.Char.Frame

type Rep1 Parts = D1 ('MetaData "Parts" "Data.Char.Frame" "unicode-tricks-0.10.0.0-AliVHfzJIeqARoOu4Sb24D" 'False) (C1 ('MetaCons "Parts" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Vertical) :*: S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec1 Horizontal)))

Type aliasses and pattern synonyms for convenient Parts

type Simple = Parts Bool

A type synonym that makes it more convenient to work with a Parts object that wraps Bools. Usually True means it should draw a line, and False that there is no line in that direction. The UnicodeCharacter instance of a Simple works by converting True to a Light, and vice versa.

type Weighted = Parts Weight

A type synonym that makes it more convenient to work with a Parts object that wraps Weight objects. These specify the weight .

pattern Frame

Arguments

:: a

The state of the line in the up direction.

-> a

The state of the line in the down direction.

-> a

The state of the line in the left direction.

-> a

The state of the line in the right direction.

-> Parts a

The Parts pattern with the state of the given lines.

A pattern that makes pattern matching and expressions with Parts more convenient.

Functions to render specific frame values

simple

Arguments

:: Simple

The given Simple frame to convert.

-> Char

The corresponding characer for this Simple frame.

Convert a Simple frame to a corresponding Char. Here True is mapped to a Light line.

simple'

Arguments

:: Simple

The given Simple frame to convert.

-> Char

The corresponding characer for this Simple frame.

Convert a Simple frame to a corresponding Char. Here True is mapped to a Heavy line.

simpleWithArc

Arguments

:: Simple

The given Simple frame to convert.

-> Char

The corresponding characer for this Simple frame.

Generate a Char where turns are done with an arc instead of a corner. This can only be done for Light lines.

weighted

Arguments

:: Weighted

The Weighted object that specifies how the lines on the four directions should look like.

-> Char

The character that represents these lines.

Converts a given Weighted to the char that can be used to render frames.

Convert a Simple to a Weighted

simpleToWeighted

Arguments

:: Weight

The Weight that is used for True values.

-> Simple

The Simple frame to convert.

-> Weighted

The resulting Weighted frame.

Convert a Simple frame to a Weighted frame by converting True to the given Weight value.

simpleToLight

Arguments

:: Simple

The Simple frame to convert.

-> Weighted

The resulting Weighted frame.

Convert a Simple frame to a Weighted frame by converting True to Light.

simpleToHeavy

Arguments

:: Simple

The 'Simple frame to convert.

-> Weighted

The resulting Weighted frame.

Convert a Simple frame to a Weighted frame by converting True to Heavy.

weightedToSimple

Arguments

:: Weighted

The Weighted object to convert.

-> Simple

The Simple object that takes "True' for parts that were Light and Heavy; and False for Empty parts.

Convert a Weighted object to a Simple object by converting the Light and Heavy parts to True and the Empty parts to False.

Convert a Character to a frame

fromWeighted

Arguments

:: Char

The given Character to convert to a Weighted object.

-> Maybe Weighted

A Weighted object wrapped in a Just if the character is a frame of Weights; Nothing otherwise.

Convert the given Character to a Parts object of Weight objects wrapped in a Just data constructor if it is a block character; Nothing otherwise.

fromWeighted'

Arguments

:: Char

The given Character to convert.

-> Weighted

The equivalent Weighted object.

Convert the given Character to a Parts object of Weight objects. If the given Character is not a frame of Weights, the result is unspecified.

fromLight

Arguments

:: Char

The given Character to convert to a Simple.

-> Maybe Simple

The equivalent Simple object wrapped in a Just data constructor if it exists; Nothing otherwise.

Convert the given Character to the equivalent Simple object wrapped in a Just data constructor if it exists; Nothing otherwise. The parts of the frame should only be Empty or Light, if it contains a Heavy object Nothing is returned.

fromLight'

Arguments

:: Char

The given Character to convert.

-> Simple

The equivalent Simple object looking at Empty and Light parts.

Convert the given Character to the equivalent Simple object if it exists; unspecified output otherwise. The parts of the frame should only be Empty or Light.

fromHeavy

Arguments

:: Char

The given Character to convert to a Simple.

-> Maybe Simple

The equivalent Simple object wrapped in a Just data constructor if it exists; Nothing otherwise.

Convert the given Character to the equivalent Simple object wrapped in a Just data constructor if it exists; Nothing otherwise. The parts of the frame should only be Empty or Heavy, if it contains a Light object Nothing is returned.

fromHeavy'

Arguments

:: Char

The given Character to convert.

-> Simple

The equivalent Simple object looking at Empty and Heavy parts.

Convert the given Character to the equivalent Simple object if it exists; unspecified output otherwise. The parts of the frame should only be Empty or Heavy.

fromSimple

Arguments

:: Char

-> Maybe Simple

Ther equivalent Simple object wrapped in a Just data constructor if it exists; Nothing otherwise.

Convert the given Character to a Simple object wrapped in a Just if such Simple object exists; Nothing otherwise. Parts that are Light or Heavy are mapped to True, and parts that are Empty are mapped to False.

fromSimple'

Arguments

:: Char

The given Character to convert'.

-> Simple

The equivalent Simple object if it exists.

Convert the given Character to a Simple, if no such Simple object exists, the output is unspecified. Parts that are Light or Heavy are mapped to True, and parts that are Empty are mapped to False.