-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Layout text as grid or table.
--   
--   `table-layout` is a library for text-based table layout, it provides
--   several functions and types which help in this task from the ground
--   up, although using them is not necessary. It provides the following
--   layout features:
--   
--   <ul>
--   <li>Fixed-size and arbitrarily sized columns and limiting versions of
--   those</li>
--   <li>Positional alignment of content in a column</li>
--   <li>Alignment of content within a column at a character occurence</li>
--   <li>Cut marks show that content has been trimmed</li>
--   <li>Fancy tables with optional headers and user styles</li>
--   <li>Justified text layout over multiple rows</li>
--   </ul>
--   
--   <i>Note:</i> This package is currently under development and may not
--   be suited for productive use.
@package table-layout
@version 0.3.0.0


-- | This module contains primitive modifiers for lists and <a>String</a>s
--   to be filled or fitted to a specific length.
module Text.Layout.Table.PrimMod

-- | Specifies how the place looks where a <a>String</a> has been cut. Note
--   that the cut mark may be cut itself, to fit into a column.
data CutMarkSpec

-- | Display custom characters on a cut.
cutMark :: String -> String -> CutMarkSpec
spaces :: Int -> String
fillLeft' :: Int -> Int -> String -> String

-- | Fill on the left until the <a>String</a> has the desired length.
fillLeft :: Int -> String -> String

-- | Fill on the right until the <a>String</a> has the desired length.
fillRight :: Int -> String -> String
fillCenter' :: Int -> Int -> String -> String

-- | Fill on both sides equally until the <a>String</a> has the desired
--   length.
fillCenter :: Int -> String -> String

-- | Fits to the given length by either trimming or filling it to the
--   right.
fitRightWith :: CutMarkSpec -> Int -> String -> String

-- | Fits to the given length by either trimming or filling it to the
--   right.
fitLeftWith :: CutMarkSpec -> Int -> String -> String

-- | Fits to the given length by either trimming or filling it on both
--   sides, but when only 1 character should be trimmed it will trim left.
fitCenterWith :: CutMarkSpec -> Int -> String -> String

-- | Applies a <a>CutMarkSpec</a> to the left of a <a>String</a>, while
--   preserving the length.
applyMarkLeftWith :: CutMarkSpec -> String -> String

-- | Applies a <a>CutMarkSpec</a> to the right of a <a>String</a>, while
--   preserving the length.
applyMarkRightWith :: CutMarkSpec -> String -> String
fillStart' :: a -> Int -> Int -> [a] -> [a]
fillStart :: a -> Int -> [a] -> [a]
fillEnd :: a -> Int -> [a] -> [a]
fillBoth' :: a -> Int -> Int -> [a] -> [a]
fillBoth :: a -> Int -> [a] -> [a]
instance GHC.Show.Show Text.Layout.Table.PrimMod.CutMarkSpec


-- | Produce justified text, which is spread over multiple rows, and join
--   it with other columns. For a simple cut, <tt>chunksOf</tt> from the
--   <tt>split</tt> package is best suited.
module Text.Layout.Table.Justify

-- | Justifies texts and presents the resulting lines in a grid structure
--   (each text in one column).
justifyTextsAsGrid :: [(Int, String)] -> [[String]]

-- | Justifies lists of words and presents the resulting lines in a grid
--   structure (each list of words in one column). This is useful if you
--   don't want to split just at whitespaces.
justifyWordListsAsGrid :: [(Int, [String])] -> [[String]]

-- | Uses <a>words</a> to split the text into words and justifies it with
--   <a>justify</a>.
--   
--   <pre>
--   &gt;&gt;&gt; justifyText 10 "This text will not fit on one line."
--   ["This  text","will   not","fit on one","line."]
--   </pre>
justifyText :: Int -> String -> [String]

-- | Fits as many words on a line, depending on the given width. Every
--   line, but the last one, gets equally filled with spaces between the
--   words, as far as possible.
justify :: Int -> [String] -> [String]

-- | Splits a given number into summands of 2 different values, where the
--   first one is exactly one bigger than the second one. Splitting 40
--   spaces into 9 almost equal parts would result in:
--   
--   <pre>
--   &gt;&gt;&gt; dimorphicSummands 40 9
--   [5,5,5,5,4,4,4,4,4]
--   </pre>
dimorphicSummands :: Int -> Int -> [Int]
dimorphicSummandsBy :: (Int -> a) -> Int -> Int -> [a]
data VertPosSpec
TopVPos :: VertPosSpec
CenterVPos :: VertPosSpec
BottomVPos :: VertPosSpec

-- | Merges multiple columns together and merges them to a valid grid
--   without holes. The following example clarifies this:
--   
--   <pre>
--   &gt;&gt;&gt; columnsAsGrid TopVPos [justifyText 10 "This text will not fit on one line.", ["42", "23"]]
--   [["This  text","42"],["will   not","23"],["fit on one",""],["line.",""]]
--   </pre>
columnsAsGrid :: VertPosSpec -> [[[a]]] -> [[[a]]]

-- | Fill all sublists to the same length.
vpadCols :: VertPosSpec -> a -> [[a]] -> [[a]]


-- | This module provides a primitive styling facility. To make your own
--   style have a look at
--   <a>https://en.wikipedia.org/wiki/Box-drawing_character</a>.
module Text.Layout.Table.Style

-- | Specifies the different letters to construct the non-content structure
--   of a table.
data TableStyle
TableStyle :: Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> Char -> TableStyle
[headerSepH] :: TableStyle -> Char
[headerSepLC] :: TableStyle -> Char
[headerSepRC] :: TableStyle -> Char
[headerSepC] :: TableStyle -> Char
[headerTopL] :: TableStyle -> Char
[headerTopR] :: TableStyle -> Char
[headerTopC] :: TableStyle -> Char
[headerTopH] :: TableStyle -> Char
[headerV] :: TableStyle -> Char
[groupV] :: TableStyle -> Char
[groupSepH] :: TableStyle -> Char
[groupSepC] :: TableStyle -> Char
[groupSepLC] :: TableStyle -> Char
[groupSepRC] :: TableStyle -> Char
[groupTopC] :: TableStyle -> Char
[groupTopL] :: TableStyle -> Char
[groupTopR] :: TableStyle -> Char
[groupTopH] :: TableStyle -> Char
[groupBottomC] :: TableStyle -> Char
[groupBottomL] :: TableStyle -> Char
[groupBottomR] :: TableStyle -> Char
[groupBottomH] :: TableStyle -> Char

-- | My usual ASCII table style.
asciiRoundS :: TableStyle

-- | Uses special unicode characters to draw clean thin boxes.
unicodeS :: TableStyle

-- | Same as <a>unicodeS</a> but uses bold headers.
unicodeBoldHeaderS :: TableStyle

-- | Same as <a>unicodeS</a> but uses round edges.
unicodeRoundS :: TableStyle

-- | Uses bold lines.
unicodeBoldS :: TableStyle

-- | Uses bold lines with exception of group seperators, which are striped
--   slim.
unicodeBoldStripedS :: TableStyle


-- | This module provides tools to layout text as grid or table. Besides
--   basic things like specifying column positioning, alignment on the same
--   character and length restriction it also provides advanced features
--   like justifying text and fancy tables with styling support.
--   
--   <h2>Some examples</h2>
--   
--   Layouting text as a plain grid:
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ layoutToString [["a", "b"], ["c", "d"]] (repeat defaultL)
--   a b
--   c d
--   </pre>
--   
--   Fancy table without header:
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ layoutTableToString [rowGroup [["Jack", "184.74"]], rowGroup [["Jane", "162.2"]]] Nothing [defaultL, numL] unicodeRoundS
--   ╭──────┬────────╮
--   │ Jack │ 184.74 │
--   ├──────┼────────┤
--   │ Jane │ 162.2  │
--   ╰──────┴────────╯
--   </pre>
--   
--   Fancy table with header:
--   
--   <pre>
--   &gt;&gt;&gt; putStrLn $ layoutTableToString [ rowGroup [["A very long text", "0.42000000"]]
--                                      , rowGroup [["Short text", "100200.5"]]
--                                      ]
--                                      (Just (["Title", "Length"], repeat centerHL))
--                                      [ fixedLeftL 20
--                                      , LayoutSpec (Fixed 10)
--                                                   CenterPos
--                                                   dotAlign
--                                                   ellipsisCutMark
--                                      ]
--                                      unicodeRoundS
--   ╭──────────────────────┬────────────╮
--   │        Title         │   Length   │
--   ╞══════════════════════╪════════════╡
--   │ A very long text     │    0.4200… │
--   ├──────────────────────┼────────────┤
--   │ Short text           │ …200.5     │
--   ╰──────────────────────┴────────────╯
--   </pre>
module Text.Layout.Table

-- | Determines the layout of a column.
data LayoutSpec
LayoutSpec :: LenSpec -> PosSpec -> AlignSpec -> CutMarkSpec -> LayoutSpec
[lenSpec] :: LayoutSpec -> LenSpec
[posSpec] :: LayoutSpec -> PosSpec
[alignSpec] :: LayoutSpec -> AlignSpec
[cutMarkSpec] :: LayoutSpec -> CutMarkSpec

-- | The default layout will allow maximum expand and is positioned on the
--   left.
defaultL :: LayoutSpec

-- | Numbers are positioned on the right and aligned on the floating point
--   dot.
numL :: LayoutSpec

-- | Fixes the column length and positions according to the given
--   <a>PosSpec</a>.
fixedL :: Int -> PosSpec -> LayoutSpec

-- | Fixes the column length and positions on the left.
fixedLeftL :: Int -> LayoutSpec

-- | Determines how long a column will be.
data LenSpec
Expand :: LenSpec
Fixed :: Int -> LenSpec
ExpandUntil :: Int -> LenSpec
FixedUntil :: Int -> LenSpec

-- | Determines how a column will be positioned. Note that on an odd number
--   of space, centering is left-biased.
data PosSpec
LeftPos :: PosSpec
RightPos :: PosSpec
CenterPos :: PosSpec

-- | Determines whether a column will align at a specific letter.
data AlignSpec

-- | Don't align text.
noAlign :: AlignSpec
charAlign :: Char -> AlignSpec
predAlign :: (Char -> Bool) -> AlignSpec

-- | Align all text at the dot.
dotAlign :: AlignSpec
isAligned :: AlignSpec -> Bool

-- | Specifies an occurence of a letter.
data OccSpec

-- | Specifies how the place looks where a <a>String</a> has been cut. Note
--   that the cut mark may be cut itself, to fit into a column.
data CutMarkSpec

-- | Default cut mark used when cutting off text.
defaultCutMark :: CutMarkSpec

-- | A single unicode character showing three dots is used as cut mark.
ellipsisCutMark :: CutMarkSpec

-- | Don't use a cut mark.
noCutMark :: CutMarkSpec

-- | Use the same cut mark for left and right.
singleCutMark :: String -> CutMarkSpec

-- | Display custom characters on a cut.
cutMark :: String -> String -> CutMarkSpec

-- | Modifies cells according to the given <a>LayoutSpec</a>.
layoutToCells :: [[String]] -> [LayoutSpec] -> [[String]]

-- | Behaves like <tt>layoutCells</tt> but produces lines by joining with
--   whitespace.
layoutToLines :: [[String]] -> [LayoutSpec] -> [String]

-- | Behaves like <tt>layoutCells</tt> but produces a <a>String</a> by
--   joining with the newline character.
layoutToString :: [[String]] -> [LayoutSpec] -> String

-- | Applies functions alternating to given lines. This makes it easy to
--   color lines to improve readability in a row.
altLines :: [a -> b] -> [a] -> [b]

-- | Applies functions alternating to cells for every line, every other
--   line gets shifted by one. This is useful for distinguishability of
--   single cells in a grid arrangement.
checkeredCells :: (a -> b) -> (a -> b) -> [[a]] -> [[b]]

-- | Groups rows together, which are not seperated from each other.
data RowGroup

-- | Construct a row group from a list of rows.
rowGroup :: [[String]] -> RowGroup

-- | Specifies how a header is layout, by omitting the cut mark it will use
--   the one specified in the <a>LayoutSpec</a> like the other cells in
--   that column.
data HeaderLayoutSpec
HeaderLayoutSpec :: PosSpec -> (Maybe CutMarkSpec) -> HeaderLayoutSpec

-- | A centered header layout.
centerHL :: HeaderLayoutSpec

-- | A left-positioned header layout.
leftHL :: HeaderLayoutSpec

-- | Layouts a good-looking table with a optional header. Note that
--   specifying fewer layout specifications than columns or vice versa will
--   result in not showing them.
layoutTableToLines :: [RowGroup] -> Maybe ([String], [HeaderLayoutSpec]) -> [LayoutSpec] -> TableStyle -> [String]
layoutTableToString :: [RowGroup] -> Maybe ([String], [HeaderLayoutSpec]) -> [LayoutSpec] -> TableStyle -> String

-- | Fits as many words on a line, depending on the given width. Every
--   line, but the last one, gets equally filled with spaces between the
--   words, as far as possible.
justify :: Int -> [String] -> [String]

-- | Uses <a>words</a> to split the text into words and justifies it with
--   <a>justify</a>.
--   
--   <pre>
--   &gt;&gt;&gt; justifyText 10 "This text will not fit on one line."
--   ["This  text","will   not","fit on one","line."]
--   </pre>
justifyText :: Int -> String -> [String]
data VertPosSpec
TopVPos :: VertPosSpec
CenterVPos :: VertPosSpec
BottomVPos :: VertPosSpec

-- | Merges multiple columns together and merges them to a valid grid
--   without holes. The following example clarifies this:
--   
--   <pre>
--   &gt;&gt;&gt; columnsAsGrid TopVPos [justifyText 10 "This text will not fit on one line.", ["42", "23"]]
--   [["This  text","42"],["will   not","23"],["fit on one",""],["line.",""]]
--   </pre>
columnsAsGrid :: VertPosSpec -> [[[a]]] -> [[[a]]]

-- | Justifies texts and presents the resulting lines in a grid structure
--   (each text in one column).
justifyTextsAsGrid :: [(Int, String)] -> [[String]]

-- | Justifies lists of words and presents the resulting lines in a grid
--   structure (each list of words in one column). This is useful if you
--   don't want to split just at whitespaces.
justifyWordListsAsGrid :: [(Int, [String])] -> [[String]]

-- | Assume the given length is greater or equal than the length of the
--   <a>String</a> passed. Pads the given <a>String</a> accordingly, using
--   the position specification.
--   
--   <pre>
--   &gt;&gt;&gt; pad LeftPos 10 "foo"
--   "foo       "
--   </pre>
pad :: PosSpec -> Int -> String -> String

-- | If the given text is too long, the <a>String</a> will be shortened
--   according to the position specification, also adds some dots to
--   indicate that the column has been trimmed in length, otherwise behaves
--   like <a>pad</a>.
--   
--   <pre>
--   &gt;&gt;&gt; trimOrPad LeftPos (singleCutMark "..") 10 "A longer text."
--   "A longer.."
--   </pre>
trimOrPad :: PosSpec -> CutMarkSpec -> Int -> String -> String

-- | Align a column by first finding the position to pad with and then
--   padding the missing lengths to the maximum value. If no such position
--   is found, it will align it such that it gets aligned before that
--   position.
--   
--   This function assumes:
--   
--   <pre>
--   ai &lt;&gt; deriveAlignInfo s = ai
--   </pre>
align :: OccSpec -> AlignInfo -> String -> String

-- | Aligns a column using a fixed width, fitting it to the width by either
--   filling or cutting while respecting the alignment.
alignFixed :: PosSpec -> CutMarkSpec -> Int -> OccSpec -> AlignInfo -> String -> String

-- | Specifies how a column should be modified.
data ColModInfo
FillAligned :: OccSpec -> AlignInfo -> ColModInfo
FillTo :: Int -> ColModInfo
FitTo :: Int -> (Maybe (OccSpec, AlignInfo)) -> ColModInfo

-- | Get the exact width after the modification.
widthCMI :: ColModInfo -> Int

-- | Remove alignment from a <a>ColModInfo</a>. This is used to change
--   alignment of headers, while using the combined width information.
unalignedCMI :: ColModInfo -> ColModInfo

-- | Ensures that the modification provides a minimum width, but only if it
--   is not limited.
ensureWidthCMI :: Int -> PosSpec -> ColModInfo -> ColModInfo

-- | Ensures that the given <a>String</a> will fit into the modified
--   columns.
ensureWidthOfCMI :: String -> PosSpec -> ColModInfo -> ColModInfo

-- | Generates a function which modifies a given <a>String</a> according to
--   <a>PosSpec</a>, <a>CutMarkSpec</a> and <a>ColModInfo</a>.
columnModifier :: PosSpec -> CutMarkSpec -> ColModInfo -> (String -> String)

-- | Specifies the length before and after a letter.
data AlignInfo
AlignInfo :: Int -> Int -> AlignInfo

-- | The column width when using the <a>AlignInfo</a>.
widthAI :: AlignInfo -> Int

-- | Derive the <a>ColModInfo</a> by using layout specifications and
--   looking at the cells.
deriveColModInfos :: [(LenSpec, AlignSpec)] -> [[String]] -> [ColModInfo]

-- | Generate the <a>AlignInfo</a> of a cell using the <a>OccSpec</a>.
deriveAlignInfo :: OccSpec -> String -> AlignInfo
instance GHC.Show.Show Text.Layout.Table.AlignInfo
instance GHC.Show.Show Text.Layout.Table.PosSpec
instance GHC.Show.Show Text.Layout.Table.LenSpec
instance GHC.Base.Monoid Text.Layout.Table.AlignInfo