| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Rainbox.Core
Description
Contains the innards of Rainbox. You shouldn't need anything
in here. Some functions here are partial or have undefined results
if their inputs don't respect particular invariants.
Synopsis
- data Alignment a
- data Horizontal
- data Vertical
- center :: Alignment a
- centerH :: Alignment Horizontal
- centerV :: Alignment Vertical
- left :: Alignment Vertical
- right :: Alignment Vertical
- top :: Alignment Horizontal
- bottom :: Alignment Horizontal
- newtype Height = Height Int
- newtype Width = Width Int
- class HasHeight a where
- class HasWidth a where
- newtype Core = Core (Either (Chunk Text) (Height, Width))
- newtype Rod = Rod (Either (Int, Radiant) (Chunk Text))
- data RodRows
- = RodRowsWithHeight (Seq (Seq Rod))
- | RodRowsNoHeight Int
- rodRowsFromCore :: Radiant -> Core -> RodRows
- chunksFromRodRows :: RodRows -> Seq (Seq (Chunk Text))
- data Payload a = Payload (Alignment a) Radiant (Either RodRows Core)
- addVerticalPadding :: Box Horizontal -> Seq RodRows
- horizontalMerge :: Seq RodRows -> RodRows
- split :: Int -> (Int, Int)
- addHorizontalPadding :: Box Vertical -> Seq RodRows
- verticalMerge :: Seq RodRows -> RodRows
- newtype Box a = Box (Seq (Payload a))
- class Orientation a where
- class LeftRight a where
- class UpDown a where
- fromChunk :: Alignment a -> Radiant -> Chunk Text -> Box a
- blank :: Alignment a -> Radiant -> Height -> Width -> Box a
- wrap :: Orientation a => Alignment b -> Radiant -> Box a -> Box b
- render :: Orientation a => Box a -> Seq (Chunk Text)
- data Cell = Cell {
- _rows :: Seq (Seq (Chunk Text))
- _horizontal :: Alignment Horizontal
- _vertical :: Alignment Vertical
- _background :: Radiant
- background :: Functor f => (Radiant -> f Radiant) -> Cell -> f Cell
- vertical :: Functor f => (Alignment Vertical -> f (Alignment Vertical)) -> Cell -> f Cell
- horizontal :: Functor f => (Alignment Horizontal -> f (Alignment Horizontal)) -> Cell -> f Cell
- rows :: Functor f => (Seq (Seq (Chunk Text)) -> f (Seq (Seq (Chunk Text)))) -> Cell -> f Cell
- separator :: Radiant -> Int -> Cell
- tableByRows :: Seq (Seq Cell) -> Box Vertical
- rowToBoxV :: Box Horizontal -> Box Vertical
- cellToBoxV :: Cell -> (Box Vertical, Alignment Horizontal, Radiant)
- toBoxH :: (Box Vertical, Alignment Horizontal, Radiant) -> Box Horizontal
- addWidthMap :: Seq (Seq (Box Vertical, b, c)) -> (Map Int (Int, Int), Seq (Seq (Box Vertical, b, c)))
- padBoxV :: Map Int (Int, Int) -> Seq (Seq (Box Vertical, a, b)) -> Seq (Seq (Box Vertical, a, b))
- widestCellMap :: Seq (Seq (Box Vertical)) -> Map Int (Int, Int)
- tableByColumns :: Seq (Seq Cell) -> Box Horizontal
- rowToBoxH :: Box Vertical -> Box Horizontal
- cellToBoxH :: Cell -> (Box Horizontal, Alignment Vertical, Radiant)
- addHeightMap :: Seq (Seq (Box Horizontal, b, c)) -> (Map Int (Int, Int), Seq (Seq (Box Horizontal, b, c)))
- tallestCellMap :: Seq (Seq (Box Horizontal)) -> Map Int (Int, Int)
- padBoxH :: Map Int (Int, Int) -> Seq (Seq (Box Horizontal, a, b)) -> Seq (Seq (Box Horizontal, a, b))
- toBoxV :: (Box Horizontal, Alignment Vertical, Radiant) -> Box Vertical
- equalize :: a -> Seq (Seq a) -> Seq (Seq a)
- mconcatSeq :: Monoid a => Seq a -> a
- intersperse :: a -> Seq a -> Seq a
Documentation
Alignment. Used in conjunction with Horizontal and Vertical,
this determines how a payload aligns with the axis of a Box.
Instances
| Functor Alignment # | |
| Foldable Alignment # | |
Defined in Rainbox.Core Methods fold :: Monoid m => Alignment m -> m # foldMap :: Monoid m => (a -> m) -> Alignment a -> m # foldr :: (a -> b -> b) -> b -> Alignment a -> b # foldr' :: (a -> b -> b) -> b -> Alignment a -> b # foldl :: (b -> a -> b) -> b -> Alignment a -> b # foldl' :: (b -> a -> b) -> b -> Alignment a -> b # foldr1 :: (a -> a -> a) -> Alignment a -> a # foldl1 :: (a -> a -> a) -> Alignment a -> a # toList :: Alignment a -> [a] # length :: Alignment a -> Int # elem :: Eq a => a -> Alignment a -> Bool # maximum :: Ord a => Alignment a -> a # minimum :: Ord a => Alignment a -> a # | |
| Traversable Alignment # | |
| Eq a => Eq (Alignment a) # | |
| Ord a => Ord (Alignment a) # | |
Defined in Rainbox.Core | |
| Show a => Show (Alignment a) # | |
| Semigroup (Alignment a) # | |
| Monoid (Alignment a) # |
|
data Horizontal #
Determines how a payload aligns with a horizontal axis.
Instances
Determines how a payload aligns with a vertical axis.
Place this payload so that it is centered on the vertical axis or horizontal axis.
centerH :: Alignment Horizontal #
Center horizontally; like center, but monomorphic.
top :: Alignment Horizontal #
Place this payload's top edge on the horizontal axis.
bottom :: Alignment Horizontal #
Place this payload's bottom edge on the horizontal axis.
A count of rows.
A count of columns.
Instances
| HasHeight RodRows # | |
Defined in Rainbox.Core | |
| HasHeight Core # | |
Defined in Rainbox.Core | |
| HasHeight Height # | |
Defined in Rainbox.Core | |
| HasHeight (Chunk a) # | |
Defined in Rainbox.Core | |
| HasHeight (Box Vertical) # | |
| HasHeight (Box Horizontal) # | |
Defined in Rainbox.Core Methods height :: Box Horizontal -> Int # | |
| HasHeight (Payload a) # | |
Defined in Rainbox.Core | |
| (HasHeight a, HasHeight b) => HasHeight (Either a b) # | |
Defined in Rainbox.Core | |
Instances
| HasWidth RodRows # | |
Defined in Rainbox.Core | |
| HasWidth Rod # | |
Defined in Rainbox.Core | |
| HasWidth Core # | |
Defined in Rainbox.Core | |
| HasWidth Width # | |
Defined in Rainbox.Core | |
| HasWidth (Chunk Text) # | |
| HasWidth (Box Vertical) # | |
| HasWidth (Box Horizontal) # | |
Defined in Rainbox.Core Methods width :: Box Horizontal -> Int # | |
| HasWidth (Payload a) # | |
Defined in Rainbox.Core | |
| (HasWidth a, HasWidth b) => HasWidth (Either a b) # | |
Defined in Rainbox.Core | |
An intermediate type used in rendering; it consists either of
text Chunk or of a number of spaces coupled with a background color.
A list of screen rows; each screen row is a Seq of Rod.
A RodRows with width but no height does nothing if rendered
alone, but it can affect the width of other RodRows if combined
with them.
Constructors
| RodRowsWithHeight (Seq (Seq Rod)) | Each outer The outer |
| RodRowsNoHeight Int | A |
A Payload holds a RodRows, which determines the number
and content of the screen rows. The Payload also has an
Alignment, which specifies how the payload aligns with the axis.
Whether the Alignment is Horizontal or Vertical determines
the orientation of the Payload. The Payload also contains a
background color, which is type Radiant. The background color
extends continuously from the Payload in both directions that are
perpendicular to the axis.
Instances
| Eq a => Eq (Payload a) # | |
| Ord a => Ord (Payload a) # | |
| Show a => Show (Payload a) # | |
| UpDown (Payload Horizontal) # | |
Defined in Rainbox.Core | |
| LeftRight (Payload Vertical) # | |
| HasWidth (Payload a) # | |
Defined in Rainbox.Core | |
| HasHeight (Payload a) # | |
Defined in Rainbox.Core | |
addVerticalPadding :: Box Horizontal -> Seq RodRows #
Adds padding to the top and bottom of each Payload. A Payload with a Core is converted to a RodRows and has padding added; a Payload with a RodRows has necessary padding added to the top and bottom. The number of elements in the resulting Seq is the same as the number of elements in the input Seq; no merging is performed.
horizontalMerge :: Seq RodRows -> RodRows #
Merges multiple horizontal RodRows into a single RodRows. All RodRows must already have been the same height; if they are not the same height, undefined behavior occurs.
Split a number into two parts, so that the sum of the two parts is equal to the original number.
addHorizontalPadding :: Box Vertical -> Seq RodRows #
Adds padding to the left and right of each Payload. A Payload with a Core is converted to a RodRows and has padding added; a Payload with a RodRows has necessary padding added to the left and right. The number of elements in the resulting Seq is the same as the number of elements in the input Seq; no merging is performed.
verticalMerge :: Seq RodRows -> RodRows #
Merge multiple vertical RodRows into a single RodRows. Each RodRows should already be the same width.
A Box is the central building block. It consists of zero or
more payloads; each payload has the same orientation, which is either
Horizontal or Vertical. This orientation also determines
the orientation of the entire Box.
A Box is a Monoid so you can combine them using the usual
monoid functions. For a Box Vertical, the leftmost values
added with mappend are at the top of the Box; for a Box
Horizontal, the leftmost values added with mappend are on the
left side of the Box.
Instances
| Eq a => Eq (Box a) # | |
| Ord a => Ord (Box a) # | |
| Show a => Show (Box a) # | |
| Semigroup (Box a) # | |
| Monoid (Box a) # | |
| UpDown (Box Horizontal) # | |
Defined in Rainbox.Core | |
| LeftRight (Box Vertical) # | |
| HasWidth (Box Vertical) # | |
| HasWidth (Box Horizontal) # | |
Defined in Rainbox.Core Methods width :: Box Horizontal -> Int # | |
| HasHeight (Box Vertical) # | |
| HasHeight (Box Horizontal) # | |
Defined in Rainbox.Core Methods height :: Box Horizontal -> Int # | |
class Orientation a where #
This typeclass is responsible for transforming a Box into
Rainbow Chunk so they can be printed to your screen. This
requires adding appropriate whitespace with the right colors, as
well as adding newlines in the right places.
Methods
spacer :: Radiant -> Int -> Box a #
Builds a one-dimensional box of the given size; its single
dimension is parallel to the axis. When added to a
box, it will insert blank space of the given length. For a Box
Horizontal, this produces a horizontal line; for a Box
Vertical, a vertical line.
spreader :: Alignment a -> Int -> Box a #
Builds a one-dimensional box of the given size; its single
dimension is perpendicular to the axis. This can be used to make
a Box Vertical wider or a Box Horizontal taller.
Instances
| Orientation Vertical # | |
| Orientation Horizontal # | |
Defined in Rainbox.Core Methods rodRows :: Box Horizontal -> RodRows # spacer :: Radiant -> Int -> Box Horizontal # spreader :: Alignment Horizontal -> Int -> Box Horizontal # | |
Things that are oriented around a vertical axis.
Methods
Length to the left of the vertical axis.
Length to the right of the vertical axis.
Things that are oriented around a horizontal axis.
Methods
Number of lines above the horizontal axis.
Number of lines below the horizontal axis.
Instances
| UpDown (Box Horizontal) # | |
Defined in Rainbox.Core | |
| UpDown (Payload Horizontal) # | |
Defined in Rainbox.Core | |
Arguments
| :: Alignment a | |
| -> Radiant | Background color. The background color in the |
| -> Chunk Text | |
| -> Box a |
Construct a box from a single Chunk.
Arguments
| :: Orientation a | |
| => Alignment b | Alignment for new |
| -> Radiant | Background color for new box |
| -> Box a | |
| -> Box b |
A single cell in a spreadsheet-like grid.
Constructors
| Cell | |
Fields
| |
Instances
| Eq Cell # | |
| Ord Cell # | |
| Show Cell # | |
| Semigroup Cell # | |
| Monoid Cell # |
|
horizontal :: Functor f => (Alignment Horizontal -> f (Alignment Horizontal)) -> Cell -> f Cell #
separator :: Radiant -> Int -> Cell #
Creates a blank Cell with the given background color and width;
useful for adding separators between columns.
tableByRows :: Seq (Seq Cell) -> Box Vertical #
Create a table where each inner Seq is a row of cells,
from left to right. If necessary, blank cells are added to the end
of a row to ensure that each row has the same number of cells as
the longest row.
cellToBoxV :: Cell -> (Box Vertical, Alignment Horizontal, Radiant) #
toBoxH :: (Box Vertical, Alignment Horizontal, Radiant) -> Box Horizontal #
addWidthMap :: Seq (Seq (Box Vertical, b, c)) -> (Map Int (Int, Int), Seq (Seq (Box Vertical, b, c))) #
tableByColumns :: Seq (Seq Cell) -> Box Horizontal #
Create a table where each inner Seq is a column of cells,
from top to bottom. If necessary, blank cells are added to the end
of a column to ensure that each column has the same number of cells
as the longest column.
cellToBoxH :: Cell -> (Box Horizontal, Alignment Vertical, Radiant) #
addHeightMap :: Seq (Seq (Box Horizontal, b, c)) -> (Map Int (Int, Int), Seq (Seq (Box Horizontal, b, c))) #
tallestCellMap :: Seq (Seq (Box Horizontal)) -> Map Int (Int, Int) #
padBoxH :: Map Int (Int, Int) -> Seq (Seq (Box Horizontal, a, b)) -> Seq (Seq (Box Horizontal, a, b)) #
equalize :: a -> Seq (Seq a) -> Seq (Seq a) #
Ensures that each inner Seq is the same length by adding the
given empty element where needed.
mconcatSeq :: Monoid a => Seq a -> a #
intersperse :: a -> Seq a -> Seq a #
Like intersperse in Data.List, but works on Seq.