-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Convert between Haskell, Markdown, Literate Haskell, TeX -- -- See the README.md @package lima @version 0.2.1.2 module Converter.Internal -- | A wrapper for prettyprinting strings newtype Pretty a Pretty :: String -> Pretty a -- | A class for prettyprinting data on multiple lines in haddocks. -- -- It's not meant to be used outside of this library. class Show a => PrettyPrint a -- | A printing function -- -- It's not meant to be used outside of this library. pp :: PrettyPrint a => a -> Pretty String -- | Escaped hash character escapedHash :: Text -- | Hash character hash :: Text -- | Drop a prefix of a line with length of a given line dropLen :: Text -> Text -> Text -- | Check if a list starts with a given list startsWith :: Text -> Text -> Bool -- | Check if a list ends with a given list endsWith :: Text -> Text -> Bool -- | Drop leading spaces and drop at each end of a Text the number -- of characters as in the supplied prefix and suffix. stripEnds :: Text -> Text -> Text -> Text -- | Drop spaces at the start and the end of a Text. stripSpaces :: Text -> Text -- | Strip the given value from the beginning and the end of a list. stripList :: Eq a => a -> [a] -> [a] -- | Pad a Text with a given number of spaces indentN :: Int -> Text -> Text -- | Show the name of a constructor. constructorName :: Data a => a -> String -- | Remove empty lines from the beginning and the end of a list. stripEmpties :: [Text] -> [Text] -- | Drop leading empty strings dropEmpties :: [Text] -> [Text] -- | Check if a line without leading spaces is surrounded by the given -- Texts. isEnclosedWith :: Text -> Text -> Text -> Bool -- | Count leading spaces in a Text. countSpaces :: Text -> Int -- | Show error with line number for a token. errorEmptyCommentAt :: Int -- -> String errorEmptyCommentAt :: Show a1 => a1 -> a2 -- | Prepend start of a TeX comment ('% ') to a -- Text. prependTexComment :: Text -> Text -- | Drop start of a TeX comment from a Text. dropTexComment :: Show a => Text -> a -> Text -- | Start a TeX comment. texComment :: Text -- | Start a TeX comment plus a space. texCommentSpace :: Text -- | Start a Literate Haskell comment. lhsComment :: Text -- | Start a Literate Haskell comment plus a space. lhsCommentSpace :: Text -- | Start a Literate Haskell line of Haskell code. lhsHsCode :: Text -- | Start a Literate Haskell line of Haskell code plus a -- space. lhsHsCodeSpace :: Text -- | Prepend start of a TeX comment ('% ') to a -- Text. prependLhsComment :: Text -> Text -- | Drop start of a TeX comment from a Text. dropLhsComment :: Show a => Text -> a -> Text -- | Replace "\#" with "#" in a Text prefix. lhsUnescapeHash :: Text -> Text -- | Replace "#" with "\#" in a Text prefix. lhsEscapeHash :: Text -> Text -- | Open a Markdown comment. mdCommentOpen :: Text -- | Close a Markdown comment. mdCommentClose :: Text -- | Open a Markdown comment plus a space. mdCommentOpenSpace :: Text -- | A space plus close a Markdown comment. mdCommentCloseSpace :: Text -- | Strip comment markers from a Text. stripMdComment :: Text -> Text -- | Check if a line is a Markdown comment. isMdComment :: Text -> Bool -- | Open a Haskell multi-line comment. hsCommentOpen :: Text -- | Open a Haskell multi-line comment plus a space. hsCommentOpenSpace :: Text -- | Close a Haskell multi-line comment. hsCommentClose :: Text -- | A space plus close a Haskell multi-line comment. hsCommentCloseSpace :: Text -- | Drop leading spaces and drop at each end of a Text the number -- of characters as in the supplied prefix and suffix. stripHsComment :: Text -> Text -- | Check if a line without leading zeros is a multi-line Haskell -- comment isHsComment :: Text -> Bool instance Converter.Internal.PrettyPrint GHC.Base.String instance Converter.Internal.PrettyPrint Data.Text.Internal.Text instance GHC.Show.Show a => GHC.Show.Show (Converter.Internal.Pretty a) -- |

Terms

-- --

format - specific encoding of some information. See -- Format.
document - Text in a specific format, e.g., -- Haskell (.hs) file.
document block - consecutive lines of a document.
Token - a representation of a document block as a -- Haskell type.
Tokens - a list of Tokens.
parser - a function that reads a document line by line -- and converts it to Tokens. Example: hsToTokens.
printer - a function that converts Tokens to a -- document. Example: hsFromTokens.
tag - a marker that affects how Tokens are -- parsed.
- Each parser recognizes tags of a specific -- form.
- Tags can be represented as a wrapper and a name.E.g., in -- '% LIMA_DISABLE some text', a TeX tag, the wrapper -- is '% ' and the name is 'LIMA_DISABLE some -- text'.
- Parsers recognize the tag names that start -- with tag names specified in a Config.E.g., in the example -- above, a parser will recognize the _disable tag and will become -- disabled.
- When a parser is disabled, it copies lines verbatim -- into a Disabled Token and doesn't recognize any tags -- until it finds an _enable tag.

-- --

Assumptions

-- -- The following assumptions must hold for outputs of parsers and inputs -- of printers: -- --

Tokens are in the same order as the corresponding blocks of -- document.

Lines inside Tokens are reversed compared to the document. -- Example:

Literate Haskell document:
```
line 1 line 2
--   % line 3 % line 4 
```

Corresponding Tokens:

[
--   Text {manyLines = ["line2","line 1"]}, Comment {someLines = "line 4"
--   :| ["", "line 3"]} ]

There are no leading or trailing empty lines inside of -- Tokens.

-- -- There are several forms of Haskell code blocks in -- Literate Haskell recognized by GHC. -- --

Code between begin{code} and end{code} -- tags.
```
begin{code} a = 42 end{code} begin{code} b = a end{code}
--   
```
- The line starting with begin{code} cannot have -- other non-space characters after begin{code}.
- The -- indentation of all expressions in code blocks must be the -- same.
Code lines starting with '> '.
```
begin{mycode} >
--   a = 42 end{mycode} begin{mycode} > b = a end{mycode}
--   
```
- There must be at least a single empty line before and -- after each Haskell code block.
- Any text may surround -- Haskell code blocks.
- The indentation of all -- expressions in code blocks must be the same.

-- -- This library supports only the second form as this form is more -- versatile. -- -- Moreover, this form does not require writing Markdown tags -- like '```haskell'. -- -- Such tags will automatically be printed when converting Literate -- Haskell to Markdown. module Converter -- | Calculates the mode for data. type family Mode a -- | Marks data supplied by a user. type User = 'User -- | Marks data for internal usage. type Internal = 'Internal -- | Configuration of tag names. -- -- The default values of Config User are all Nothings. -- -- Inside the library functions, Config User is converted to -- Config Internal. -- -- The below examples show the names from Config Internal. -- --

--   >>> pp (def :: Config User)
--   Config {
--     _disable = "LIMA_DISABLE",
--     _enable = "LIMA_ENABLE",
--     _indent = "LIMA_INDENT",
--     _dedent = "LIMA_DEDENT",
--     _mdHaskellCodeStart = "```haskell",
--     _mdHaskellCodeEnd = "```",
--     _texHaskellCodeStart = "\\begin{mycode}",
--     _texHaskellCodeEnd = "\\end{mycode}",
--     _texSingleLineCommentStart = "SINGLE_LINE ",
--     _lhsSingleLineCommentStart = "SINGLE_LINE "
--   }
--

-- -- It's possible to override these names. -- --

--   >>> pp ((def :: Config User) & disable ?~ "off" & enable ?~ "on" & indent ?~ "indent" & dedent ?~ "dedent")
--   Config {
--     _disable = "off",
--     _enable = "on",
--     _indent = "indent",
--     _dedent = "dedent",
--     _mdHaskellCodeStart = "```haskell",
--     _mdHaskellCodeEnd = "```",
--     _texHaskellCodeStart = "\\begin{mycode}",
--     _texHaskellCodeEnd = "\\end{mycode}",
--     _texSingleLineCommentStart = "SINGLE_LINE ",
--     _lhsSingleLineCommentStart = "SINGLE_LINE "
--   }
--

data Config (a :: Mode') Config :: Mode a -> Mode a -> Mode a -> Mode a -> Mode a -> Mode a -> Mode a -> Mode a -> Mode a -> Mode a -> Config (a :: Mode') -- | Make parser ignore tags and just copy the following lines verbatim. -- -- Set indentation to 0. [$sel:_disable:Config] :: Config (a :: Mode') -> Mode a -- | Stop parser from ignoring tags. [$sel:_enable:Config] :: Config (a :: Mode') -> Mode a -- | Set code indentation to a given Int. [$sel:_indent:Config] :: Config (a :: Mode') -> Mode a -- | Set code indentation to 0. [$sel:_dedent:Config] :: Config (a :: Mode') -> Mode a -- | Mark the start of a Haskell code block in Markdown. [$sel:_mdHaskellCodeStart:Config] :: Config (a :: Mode') -> Mode a -- | Mark the end of a Haskell code block in Markdown. [$sel:_mdHaskellCodeEnd:Config] :: Config (a :: Mode') -> Mode a -- | Mark the start of a Haskell code block in TeX. [$sel:_texHaskellCodeStart:Config] :: Config (a :: Mode') -> Mode a -- | Mark the end of a Haskell code block in TeX. [$sel:_texHaskellCodeEnd:Config] :: Config (a :: Mode') -> Mode a -- | Mark start of a comment that must be single-line in TeX. [$sel:_texSingleLineCommentStart:Config] :: Config (a :: Mode') -> Mode a -- | Mark start of a comment that must be single-line in Literate -- Haskell. [$sel:_lhsSingleLineCommentStart:Config] :: Config (a :: Mode') -> Mode a -- | The default value for this type. def :: Default a => a -- | Convert a user Config to an internal Config with -- user-supplied values. -- -- It's important to do this conversion at a single entrypoint. -- -- Otherwise, repeated conversions will accumulate changes such as -- appended spaces. toConfigInternal :: Config User -> Config Internal disable :: forall a_a8VL. Lens' (Config a_a8VL) (Mode a_a8VL) enable :: forall a_a8VL. Lens' (Config a_a8VL) (Mode a_a8VL) indent :: forall a_a8VL. Lens' (Config a_a8VL) (Mode a_a8VL) dedent :: forall a_a8VL. Lens' (Config a_a8VL) (Mode a_a8VL) mdHaskellCodeStart :: forall a_a8VL. Lens' (Config a_a8VL) (Mode a_a8VL) mdHaskellCodeEnd :: forall a_a8VL. Lens' (Config a_a8VL) (Mode a_a8VL) texHaskellCodeStart :: forall a_a8VL. Lens' (Config a_a8VL) (Mode a_a8VL) texHaskellCodeEnd :: forall a_a8VL. Lens' (Config a_a8VL) (Mode a_a8VL) texSingleLineCommentStart :: forall a_a8VL. Lens' (Config a_a8VL) (Mode a_a8VL) lhsSingleLineCommentStart :: forall a_a8VL. Lens' (Config a_a8VL) (Mode a_a8VL) -- | & is a reverse application operator. This provides -- notational convenience. Its precedence is one higher than that of the -- forward application operator $, which allows & to be -- nested in $. -- --

--   >>> 5 & (+1) & show
--   "6"
--

(&) :: a -> (a -> b) -> b infixl 1 & -- | (?~) is a version of (.~) that wraps the value into -- Just before setting. -- --

--   l ?~ b = l .~ Just b
--

-- -- It can be useful in combination with at: -- --

--   >>> Map.empty & at 3 ?~ x
--   fromList [(3,x)]
--

(?~) :: ASetter s t a (Maybe b) -> b -> s -> t infixr 4 ?~ -- | A format of a document. data Format -- |

--   Haskell
--

Hs :: Format -- |

--   Literate Haskell
--

Lhs :: Format -- |

--   Markdown
--

Md :: Format -- |

--   TeX
--

TeX :: Format -- | Compose a function that converts a document in one Format to a -- document in another Format. convertTo :: Format -> Format -> Config User -> Text -> Text -- | Show a Format as a file extension. -- --

--   >>> showFormatExtension Lhs
--   "lhs"
--

showFormatExtension :: Format -> String -- | Show a Format as a full name. -- --

--   >>> showFormatName Lhs
--   "Literate Haskell"
--

showFormatName :: Format -> String -- | Internal representation of a document. -- -- A printer processes Tokens one by one. -- -- A Token can have: -- --

Action - how this Token affects the subsequent -- Tokens.
Target - a type of Tokens that are affected by this -- Token.
Range - the nearest Token until which this Token -- affects the subsequent Tokens.

data Token -- |

Action: set indentation to n.
Target: HaskellCode.
Range: Indent, Dedent, or Disabled.

Indent :: Int -> Token [$sel:n:Indent] :: Token -> Int -- |

Action: set indentation to 0.
Target: HaskellCode.
Range: Indent, Dedent, or Disabled.

Dedent :: Token -- | A block that should be invisible when rendered outside of -- .hs. -- --

Action: set indentation to 0.
Target: HaskellCode.
Range: Indent, Dedent, or Disabled.

Disabled :: [Text] -> Token [$sel:manyLines:Indent] :: Token -> [Text] -- | Lines copied verbatim while a parser was in a Haskell code -- block. HaskellCode :: [Text] -> Token [$sel:manyLines:Indent] :: Token -> [Text] -- | Lines copied verbatim while a parser was in a text block. Text :: NonEmpty Text -> Token [$sel:someLines:Indent] :: Token -> NonEmpty Text -- | Lines copied verbatim while a parser was in a comment block. Comment :: NonEmpty Text -> Token [$sel:someLines:Indent] :: Token -> NonEmpty Text -- | A line of a comment that must be kept on a single-line. -- -- E.g., {- FOURMOLU_DISABLE -} from a .hs. CommentSingleLine :: Text -> Token [$sel:someLine:Indent] :: Token -> Text -- | A list of Tokens. type Tokens = [Token] -- | Select a printer function based on a given format. selectFromTokens :: Config User -> Format -> Tokens -> Text -- | Select a parser function based on a given format. selectToTokens :: Config User -> Format -> Text -> Tokens -- | Merge specific consecutive Tokens. -- --

--   >>> pp exampleNonTexTokens'
--   [
--     Indent {n = 3},
--     Disabled {manyLines = ["-- What's the answer?"]},
--     Indent {n = 1},
--     Indent {n = 2},
--     Text {someLines = "- Intermediate results" :| []},
--     HaskellCode {manyLines = ["   b = a 4","   a = const 3"]},
--     Dedent,
--     HaskellCode {manyLines = ["answer = b * 14"]},
--     Comment {someLines = "Hello from comments," :| []},
--     Comment {someLines = "world!" :| []},
--     CommentSingleLine {someLine = "Comment on a single line."},
--     Text {someLines = "Hello from text," :| []},
--     Text {someLines = "world!" :| []}
--   ]
--

-- --

--   >>> pp $ mergeTokens exampleNonTexTokens'
--   [
--     Indent {n = 3},
--     Disabled {manyLines = ["-- What's the answer?"]},
--     Indent {n = 1},
--     Indent {n = 2},
--     Text {someLines = "- Intermediate results" :| []},
--     HaskellCode {manyLines = ["   b = a 4","   a = const 3"]},
--     Dedent,
--     HaskellCode {manyLines = ["answer = b * 14"]},
--     Comment {someLines = "world!" :| ["","Hello from comments,"]},
--     CommentSingleLine {someLine = "Comment on a single line."},
--     Text {someLines = "world!" :| ["","Hello from text,"]}
--   ]
--

mergeTokens :: Tokens -> Tokens -- | Strip empty lines and leading spaces in Tokens. -- --

Remove empty lines in Tokens.
Shift lines in HaskellCode to the left by the minimal -- number of leading spaces in nonempty lines.

-- --

--   >>> pp exampleNonTexTokens'
--   [
--     Indent {n = 3},
--     Disabled {manyLines = ["-- What's the answer?"]},
--     Indent {n = 1},
--     Indent {n = 2},
--     Text {someLines = "- Intermediate results" :| []},
--     HaskellCode {manyLines = ["   b = a 4","   a = const 3"]},
--     Dedent,
--     HaskellCode {manyLines = ["answer = b * 14"]},
--     Comment {someLines = "Hello from comments," :| []},
--     Comment {someLines = "world!" :| []},
--     CommentSingleLine {someLine = "Comment on a single line."},
--     Text {someLines = "Hello from text," :| []},
--     Text {someLines = "world!" :| []}
--   ]
--

-- --

--   >>> pp $ stripTokens exampleNonTexTokens'
--   [
--     Indent {n = 3},
--     Disabled {manyLines = ["-- What's the answer?"]},
--     Indent {n = 1},
--     Indent {n = 2},
--     Text {someLines = "- Intermediate results" :| []},
--     HaskellCode {manyLines = ["b = a 4","a = const 3"]},
--     Dedent,
--     HaskellCode {manyLines = ["answer = b * 14"]},
--     Comment {someLines = "Hello from comments," :| []},
--     Comment {someLines = "world!" :| []},
--     CommentSingleLine {someLine = "Comment on a single line."},
--     Text {someLines = "Hello from text," :| []},
--     Text {someLines = "world!" :| []}
--   ]
--

stripTokens :: Tokens -> Tokens -- | mergeTokens and stripTokens. -- --

--   >>> pp $ normalizeTokens exampleNonTexTokens
--   [
--     Indent {n = 3},
--     Disabled {manyLines = ["-- What's the answer?"]},
--     Indent {n = 1},
--     Indent {n = 2},
--     Text {someLines = "- Intermediate results" :| []},
--     HaskellCode {manyLines = ["b = a 4","a = const 3"]},
--     Dedent,
--     HaskellCode {manyLines = ["answer = b * 14"]},
--     Comment {someLines = "world!" :| ["","Hello from comments,"]},
--     CommentSingleLine {someLine = "Comment on a single line."},
--     Text {someLines = "world!" :| ["","Hello from text,"]}
--   ]
--

normalizeTokens :: Tokens -> Tokens -- | Convert Tokens to Haskell code. -- -- Rules -- --

Certain assumptions must hold for inputs.
These are the relations between Tokens and document blocks -- when the default Config values are used.
- Indent ~ -- '{- LIMA_INDENT N -}' where N is an -- Int.
- Dedent ~ '{- LIMA_DEDENT -- -}'.
- Disabled ~ '{- LIMA_DISABLE -}' and -- '{- LIMA_ENABLE -}' and lines between them.
```
{-
--   LIMA_DISABLE -} disabled {- LIMA_ENABLE -} 
```
- Text -- ~ a multiline comment starting with '{-\n' and ending with -- '\n-}'.
```
{- line 1 -} 
```
  - Consecutive -- Texts are merged into a single Text.
  - There must -- be at list one nonempty line inside this -- comment.
- CommentSingleLine ~ a multiline -- comment on a single line.
```
{- line -} 
```
- Comment -- ~ a multiline comment starting with '{- TEXT', where -- TEXT is nonempty text, and ending with \n-}
```
{-
--   line 1 line 2 -} 
```
  - Consecutive Comments are merged -- into a single Comment.
- HaskellCode ~ -- other lines.

-- --

Example

-- --

--   >>> pp $ hsFromTokens def exampleNonTexTokens
--   {- LIMA_INDENT 3 -}
--   
--   {- LIMA_DISABLE -}
--   
--   -- What's the answer?
--   
--   {- LIMA_ENABLE -}
--   
--   {- LIMA_INDENT 1 -}
--   
--   {- LIMA_INDENT 2 -}
--   
--   {-
--   - Intermediate results
--   -}
--   
--   a = const 3
--   b = a 4
--   
--   {- LIMA_DEDENT -}
--   
--   answer = b * 14
--   
--   {- Hello from comments,
--   
--   world!
--   -}
--   
--   {- Comment on a single line. -}
--   
--   {-
--   Hello from text,
--   
--   world!
--   -}
--

hsFromTokens :: Config User -> Tokens -> Text -- | Convert Tokens to Haskell code. -- -- Each Token becomes a Text in a list. -- -- These Texts are concatenated in hsFromTokens. hsFromTokens' :: Config User -> Tokens -> [Text] -- | Convert Tokens to Literate Haskell code. -- -- Rules -- --

Certain assumptions must hold for inputs.
These are the relations between document blocks and tokens when -- the default Config values are used.
- Indent ~ -- '% LIMA_INDENT N' (N is an -- Int).
- Dedent ~ '% -- LIMA_DEDENT'.
- Disabled ~ Lines between and -- including '% LIMA_DISABLE' and '% -- LIMA_ENABLE'.
  - There must be at least one nonempty line -- between these tags.
- CommentSingleLine ~ a -- line starting with '% SINGLE_LINE '.
```
% SINGLE_LINE line
--   
```
- Comment ~ consecutive lines, either empty or -- starting with '% '.
```
% Hello, % world! % Hello, % user!
--   
```
  - At least one line must have nonempty text after '% -- '
- HaskellCode ~ consecutive lines -- starting with '> '.
```
> a4 = 4 > a2 = 2
--   
```
  - Inside a Token, code is shifted to the left. See -- normalizeTokens.
  - During printing, code is indented -- according to previous Tokens.
- Text ~ -- other lines.

-- --

Example

-- --

--   >>> pp $ lhsFromTokens def exampleNonTexTokens
--   % LIMA_INDENT 3
--   
--   % LIMA_DISABLE
--   
--   % -- What's the answer?
--   
--   % LIMA_ENABLE
--   
--   % LIMA_INDENT 1
--   
--   % LIMA_INDENT 2
--   
--   - Intermediate results
--   
--   >   a = const 3
--   >   b = a 4
--   
--   % LIMA_DEDENT
--   
--   > answer = b * 14
--   
--   % Hello from comments,
--   
--   % world!
--   
--   % SINGLE_LINE Comment on a single line.
--   
--   Hello from text,
--   
--   world!
--

lhsFromTokens :: Config User -> Tokens -> Text -- | Convert Tokens to Literate Haskell code. -- -- Each Token becomes a Text in a list. -- -- These Texts are concatenated in lhsFromTokens. lhsFromTokens' :: Config User -> Tokens -> [Text] -- | Convert Tokens to Markdown code. -- -- Rules -- --

Certain assumptions must hold for inputs.
These are the relations between document blocks and tokens when -- the default Config values are used.
- Indent ~ -- '', where N is an -- Int.
- Dedent ~ ''.
- Disabled ~ a multiline comment starting -- with ''.
```
 
```
- CommentSingleLine ~ a line -- starting with ''.
```
line -- 
```
- Comment ~ a -- multiline comment starting with '
--   
```
  - Consecutive Comments are merged into a single -- Comment.
- HaskellCode ~ possibly -- indented block starting with '```haskell' and ending with -- '```'.
```
 ```haskell a4 = 2 ``` 
```
- Text -- ~ other lines.

-- --

Example

-- --

--   >>> pp $ mdFromTokens def exampleNonTexTokens
--      <!-- LIMA_INDENT 3 -->
--   
--   <!-- LIMA_DISABLE
--   
--   -- What's the answer?
--   
--   LIMA_ENABLE -->
--   
--    <!-- LIMA_INDENT 1 -->
--   
--     <!-- LIMA_INDENT 2 -->
--   
--   - Intermediate results
--   
--     ```haskell
--     a = const 3
--     b = a 4
--     ```
--   
--   <!-- LIMA_DEDENT -->
--   
--   ```haskell
--   answer = b * 14
--   ```
--   
--   <!-- Hello from comments,
--   
--   world!
--   -->
--   
--   <!-- Comment on a single line. -->
--   
--   Hello from text,
--   
--   world!
--

mdFromTokens :: Config User -> Tokens -> Text -- | Convert Tokens to Haskell code. -- -- Each Token becomes a Text in a list. -- -- These Texts are concatenated in mdFromTokens. mdFromTokens' :: Config User -> Tokens -> [Text] -- | Convert Tokens to TeX code. -- -- Rules -- --

Certain assumptions must hold for inputs.
These are the relations between tokens and document blocks when -- the default Config values are used.
- Indent ~ -- '% LIMA_INDENT N' (N is an -- Int).
- Dedent ~ '% -- LIMA_DEDENT'.
- Disabled ~ '% LIMA_DISABLE' -- and '% LIMA_ENABLE' and lines between -- them.
- CommentSingleLine ~ a line starting with '% -- SINGLE_LINE '.
```
% SINGLE_LINE line
--   
```
- Comment ~ consecutive lines, either empty or -- starting with '% '.
```
% Hello, % world! % Hello, % user!
--   
```
  - At least one line must have nonempty text after '% -- '.
- HaskellCode ~ lines between possibly -- indented tags '\begin{code}' and -- '\end{code}'.
  - Inside a Token, code will be -- shifted to the left. See normalizeTokens.
  - When printing -- the Tokens, code will be indented according to previous -- Tokens.
- Text ~ other -- lines.

-- --

Example

-- --

--   >>> pp $ texFromTokens def exampleTexTokens
--   % LIMA_INDENT 3
--   
--   % LIMA_DISABLE
--   
--   % -- What's the answer?
--   
--   % LIMA_ENABLE
--   
--   % LIMA_INDENT 1
--   
--   % LIMA_INDENT 0
--   
--   Intermediate results
--   
--   \begin{mycode}
--   a = const 3
--   b = a 4
--   \end{mycode}
--   
--   % LIMA_DEDENT
--   
--   \begin{mycode}
--   answer = b * 14
--   \end{mycode}
--   
--   % Hello from comments,
--   
--   % world!
--   
--   % SINGLE_LINE Comment on a single line.
--

texFromTokens :: Config User -> Tokens -> Text -- | Convert Tokens to TeX code. -- -- Each Token becomes a Text in a list. -- -- These Texts are concatenated in texFromTokens. texFromTokens' :: Config User -> Tokens -> [Text] -- | Convert Tokens to Haskell code. -- -- Inverse of hsFromTokens. -- --

--   >>> (hsToTokens def $ hsFromTokens def exampleNonTexTokens) == exampleNonTexTokens
--   True
--

hsToTokens :: Config User -> Text -> Tokens -- | Convert Tokens to Markdown code. -- -- Inverse of lhsFromTokens. -- --

--   >>> (lhsToTokens def $ lhsFromTokens def exampleNonTexTokens) == exampleNonTexTokens
--   True
--

lhsToTokens :: Config User -> Text -> Tokens -- | Convert Tokens to Markdown code. -- -- Inverse of mdFromTokens. -- --

--   >>> (mdToTokens def $ mdFromTokens def exampleNonTexTokens) == exampleNonTexTokens
--   True
--

mdToTokens :: Config User -> Text -> Tokens -- | Convert Tokens to TeX code. -- -- Inverse of texFromTokens. -- --

--   >>> (texToTokens def $ texFromTokens def exampleTexTokens) == exampleTexTokens
--   True
--

texToTokens :: Config User -> Text -> Tokens -- | Compose a function from Tokens to a Text. mkFromTokens :: (Config User -> Tokens -> [Text]) -> Config User -> Tokens -> Text -- | Compose a function from a Text to Tokens. mkToTokens :: (State -> [(Int, Text)] -> [Token] -> [Token]) -> Text -> Tokens -- | Parse a single line to a token. -- --

Merge comments

parseLineToToken :: Config Internal -> Format -> Token -> Text -> Int -> Tokens -- | Show error with line number for a token. errorExpectedToken :: (Data a1, Show a2, Show a3) => a2 -> a3 -> a1 -> a4 errorNotEnoughTokens :: Format -> a -- | A printing function -- -- It's not meant to be used outside of this library. pp :: PrettyPrint a => a -> Pretty String -- | Example non-TeX Tokens. See exampleTexTokens. -- -- When printed to a TeX document, these Tokens can't be -- correctly parsed. This is because they don't have necessary tags -- surrounding Haskell code blocks. -- --

--   >>> pp $ exampleNonTexTokens'
--   [
--     Indent {n = 3},
--     Disabled {manyLines = ["-- What's the answer?"]},
--     Indent {n = 1},
--     Indent {n = 2},
--     Text {someLines = "- Intermediate results" :| []},
--     HaskellCode {manyLines = ["   b = a 4","   a = const 3"]},
--     Dedent,
--     HaskellCode {manyLines = ["answer = b * 14"]},
--     Comment {someLines = "Hello from comments," :| []},
--     Comment {someLines = "world!" :| []},
--     CommentSingleLine {someLine = "Comment on a single line."},
--     Text {someLines = "Hello from text," :| []},
--     Text {someLines = "world!" :| []}
--   ]
--

exampleNonTexTokens' :: Tokens -- | Normalized exampleNonTexTokens'. -- --

--   >>> pp $ exampleNonTexTokens
--   [
--     Indent {n = 3},
--     Disabled {manyLines = ["-- What's the answer?"]},
--     Indent {n = 1},
--     Indent {n = 2},
--     Text {someLines = "- Intermediate results" :| []},
--     HaskellCode {manyLines = ["b = a 4","a = const 3"]},
--     Dedent,
--     HaskellCode {manyLines = ["answer = b * 14"]},
--     Comment {someLines = "world!" :| ["","Hello from comments,"]},
--     CommentSingleLine {someLine = "Comment on a single line."},
--     Text {someLines = "world!" :| ["","Hello from text,"]}
--   ]
--

exampleNonTexTokens :: Tokens -- | same as exampleNonTexTokens, but with TeX-specific -- tags that make Haskell code blocks correctly parsable. -- --

--   >>> pp $ exampleTexTokens
--   [
--     Indent {n = 3},
--     Disabled {manyLines = ["-- What's the answer?"]},
--     Indent {n = 1},
--     Indent {n = 0},
--     Text {someLines = "\\begin{mycode}" :| ["","Intermediate results"]},
--     HaskellCode {manyLines = ["b = a 4","a = const 3"]},
--     Text {someLines = "\\end{mycode}" :| []},
--     Dedent,
--     Text {someLines = "\\begin{mycode}" :| []},
--     HaskellCode {manyLines = ["answer = b * 14"]},
--     Text {someLines = "\\end{mycode}" :| []},
--     Comment {someLines = "world!" :| ["","Hello from comments,"]},
--     CommentSingleLine {someLine = "Comment on a single line."}
--   ]
--

exampleTexTokens :: Tokens instance GHC.Classes.Eq Converter.Format instance GHC.Classes.Eq Converter.Token instance Data.Data.Data Converter.Token instance GHC.Show.Show Converter.Token instance GHC.Generics.Generic Converter.State instance GHC.Show.Show (Converter.Config Converter.User) instance GHC.Classes.Eq (Converter.Config Converter.User) instance GHC.Show.Show (Converter.Config Converter.Internal) instance Data.Default.Class.Default (Converter.Config Converter.User) instance Data.Default.Class.Default Converter.State instance Converter.Internal.PrettyPrint Converter.Tokens instance Converter.Internal.PrettyPrint (Converter.Config Converter.User) instance Data.Default.Class.Default (Converter.Config Converter.Internal) instance GHC.Generics.Generic (Converter.Config a)