Calculates the mode for data.

Marks data supplied by a user.

Marks data for internal usage.

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 "
}

The default value for this type.

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.

& 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"

Since: base-4.8.0.0

(?~) 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)]

A format of a document.

Compose a function that converts a document in one Format to a document in another Format.

Show a Format as a file extension.

>>> showFormatExtension Lhs
"lhs"

Show a Format as a full name.

>>> showFormatName Lhs
"Literate Haskell"

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.

A list of Tokens.

Select a printer function based on a given format.

Select a parser function based on a given format.

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,"]}
]

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!" :| []}
]

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,"]}
]

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!
-}

Convert Tokens to Haskell code.

Each Token becomes a Text in a list.

These Texts are concatenated in hsFromTokens.

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!

Convert Tokens to Literate Haskell code.

Each Token becomes a Text in a list.

These Texts are concatenated in lhsFromTokens.

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 ~ '<!-- LIMA_INDENT N -->', where N is an Int.
  • Dedent ~ '<!-- LIMA_DEDENT -->'.

  • Disabled ~ a multiline comment starting with '<!-- LIMA_DISABLE\n' and ending with '\nLIMA_ENABLE -->'.

    <!-- LIMA_DISABLE
    a4 = 4
    a2 = 2
    LIMA_ENABLE -->
    

  • CommentSingleLine ~ a line starting with '<!-- ' and ending with ' -->'.

    line --
    

  • Comment ~ a multiline comment starting with '<!-- {text}', where {text} is nonempty text.

    <!-- line 1
    line 2
    -->
    

    • 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!

Convert Tokens to Haskell code.

Each Token becomes a Text in a list.

These Texts are concatenated in mdFromTokens.

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.

Convert Tokens to TeX code.

Each Token becomes a Text in a list.

These Texts are concatenated in texFromTokens.

Convert Tokens to Haskell code.

Inverse of hsFromTokens.

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

Convert Tokens to Markdown code.

Inverse of lhsFromTokens.

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

Convert Tokens to Markdown code.

Inverse of mdFromTokens.

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

Convert Tokens to TeX code.

Inverse of texFromTokens.

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

Compose a function from Tokens to a Text.

Compose a function from a Text to Tokens.

Parse a single line to a token.

• Merge comments

Show error with line number for a token.

A printing function

It's not meant to be used outside of this library.

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!" :| []}
]

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,"]}
]

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."}
]