Text.ANTLR.Pretty

I want to have something like Show whereby every time I add a new type to the system, I can implement a function that gets called by existing code which happens to have types that get parametrized by that type. I don't want to modify an existing file / centralizing all of the types in my system into a single file makes little sense because then that one file becomes a hub / single point of failure.

• I need a typeclass (no modifying existing files, but they need to call my new code without passing around a new show function)
• The prettify function of that typeclass needs to return a state monad so that recursive calls keep the state
• A pshow function needs to evalState on the prettify function with an initial indentation of zero (along with any other future state values...)

Documentation

data PState

Pretty-printing state

Constructors

PState

Fields

• indent :: Int

  current indentation level

• vis_chrs :: Int

  number of visible characters consumed so far

• str :: Text

  the string, Text, that we've constructed so far

• columns_soft :: Int

  soft limit on number of columns to consume per row

• columns_hard :: Int

  hard limit on number of columns to consume per row

• curr_col :: Int

  column number we're on in the current row of str

• curr_row :: Int

  number of rows (newlines) we've printed to str

type PrettyM val = State PState val

The pretty state monad

type Pretty = PrettyM ()

No value being threaded through the monad (because result is in str)

class Prettify t where

Define the Prettify type class for your pretty-printable type t.

Minimal complete definition

prettify

Methods

prettify :: t -> Pretty

Defines how to pretty-print some type.

prettify :: Show t => t -> Pretty

Defines how to pretty-print some type.

prettifyList :: [t] -> Pretty

Lists are pretty-printed specially.

Instances

Prettify Bool

Defined in Text.ANTLR.Pretty

Methods

prettify :: Bool -> Pretty

prettifyList :: [Bool] -> Pretty

Prettify Char

Defined in Text.ANTLR.Pretty

Methods

prettify :: Char -> Pretty

prettifyList :: [Char] -> Pretty

Prettify Double

Defined in Text.ANTLR.Pretty

Methods

prettify :: Double -> Pretty

prettifyList :: [Double] -> Pretty

Prettify Int

Defined in Text.ANTLR.Pretty

Methods

prettify :: Int -> Pretty

prettifyList :: [Int] -> Pretty

Prettify ()

Defined in Text.ANTLR.Pretty

Methods

prettify :: () -> Pretty

prettifyList :: [()] -> Pretty

Prettify v => Prettify [v]

Defined in Text.ANTLR.Pretty

Methods

prettify :: [v] -> Pretty

prettifyList :: [[v]] -> Pretty

Prettify v => Prettify (Maybe v)

Defined in Text.ANTLR.Pretty

Methods

prettify :: Maybe v -> Pretty

prettifyList :: [Maybe v] -> Pretty

(Prettify a, Hashable a, Eq a) => Prettify (HashSet a)

Defined in Text.ANTLR.Set

Methods

prettify :: HashSet a -> Pretty

prettifyList :: [HashSet a] -> Pretty

Prettify (Mutator s)

Defined in Text.ANTLR.Grammar

Methods

prettify :: Mutator s -> Pretty

prettifyList :: [Mutator s] -> Pretty

Prettify (Predicate s)

Defined in Text.ANTLR.Grammar

Methods

prettify :: Predicate s -> Pretty

prettifyList :: [Predicate s] -> Pretty

Prettify (StateFncn s)

Defined in Text.ANTLR.Grammar

Methods

prettify :: StateFncn s -> Pretty

prettifyList :: [StateFncn s] -> Pretty

Prettify ts => Prettify (Icon ts)

Defined in Text.ANTLR.Parser

Methods

prettify :: Icon ts -> Pretty

prettifyList :: [Icon ts] -> Pretty

(Prettify a, Hashable a, Eq a) => Prettify (Stacks a)

Defined in Text.ANTLR.Allstar.Stacks

Methods

prettify :: Stacks a -> Pretty

prettifyList :: [Stacks a] -> Pretty

Prettify nt => Prettify (ATNState nt)

LaTeX style ATN states. TODO: check length of NT printed and put curly braces around it if more than one character.

Defined in Text.ANTLR.Allstar.ATN

Methods

prettify :: ATNState nt -> Pretty

prettifyList :: [ATNState nt] -> Pretty

Prettify nts => Prettify (Prime nts)

Defined in Text.ANTLR.LL1

Methods

prettify :: Prime nts -> Pretty

prettifyList :: [Prime nts] -> Pretty

Prettify nts => Prettify (ItemLHS nts)

Defined in Text.ANTLR.LR

Methods

prettify :: ItemLHS nts -> Pretty

prettifyList :: [ItemLHS nts] -> Pretty

(Prettify a, Prettify b) => Prettify (a, b)

Defined in Text.ANTLR.Pretty

Methods

prettify :: (a, b) -> Pretty

prettifyList :: [(a, b)] -> Pretty

(Prettify k, Prettify v) => Prettify (Map k v)

Defined in Text.ANTLR.Pretty

Methods

prettify :: Map k v -> Pretty

prettifyList :: [Map k v] -> Pretty

(Prettify k, Prettify v, Hashable v, Eq v) => Prettify (Map k v)

Defined in Text.ANTLR.MultiMap

Methods

prettify :: Map k v -> Pretty

prettifyList :: [Map k v] -> Pretty

(Prettify n, Prettify v) => Prettify (Token n v)

Defined in Text.ANTLR.Lex.Tokenizer

Methods

prettify :: Token n v -> Pretty

prettifyList :: [Token n v] -> Pretty

(Prettify nts, Prettify ts) => Prettify (ProdElem nts ts)

Defined in Text.ANTLR.Grammar

Methods

prettify :: ProdElem nts ts -> Pretty

prettifyList :: [ProdElem nts ts] -> Pretty

(Prettify nts, Prettify t) => Prettify (AST nts t)

Defined in Text.ANTLR.Parser

Methods

prettify :: AST nts t -> Pretty

prettifyList :: [AST nts t] -> Pretty

(Prettify a, Prettify b, Prettify c) => Prettify (a, b, c)

Defined in Text.ANTLR.Pretty

Methods

prettify :: (a, b, c) -> Pretty

prettifyList :: [(a, b, c)] -> Pretty

(Prettify s, Prettify nts, Prettify ts, Hashable ts, Eq ts, Hashable nts, Eq nts, Ord ts, Ord nts) => Prettify (Grammar s nts ts)

Defined in Text.ANTLR.Grammar

Methods

prettify :: Grammar s nts ts -> Pretty

prettifyList :: [Grammar s nts ts] -> Pretty

(Prettify s, Prettify nts, Prettify ts) => Prettify (Production s nts ts)

Defined in Text.ANTLR.Grammar

Methods

prettify :: Production s nts ts -> Pretty

prettifyList :: [Production s nts ts] -> Pretty

(Prettify s, Prettify nts, Prettify ts) => Prettify (ProdRHS s nts ts)

Defined in Text.ANTLR.Grammar

Methods

prettify :: ProdRHS s nts ts -> Pretty

prettifyList :: [ProdRHS s nts ts] -> Pretty

(Prettify ast, Prettify nts, Prettify (StripEOF (Sym t)), Prettify t) => Prettify (ParseEvent ast nts t)

Defined in Text.ANTLR.Parser

Methods

prettify :: ParseEvent ast nts t -> Pretty

prettifyList :: [ParseEvent ast nts t] -> Pretty

(Prettify s, Prettify nt, Prettify t) => Prettify (Edge s nt t)

Defined in Text.ANTLR.Allstar.ATN

Methods

prettify :: Edge s nt t -> Pretty

prettifyList :: [Edge s nt t] -> Pretty

(Prettify s, Prettify nt, Prettify t, Hashable nt, Hashable t, Eq nt, Eq t) => Prettify (ATN s nt t)

Defined in Text.ANTLR.Allstar.ATN

Methods

prettify :: ATN s nt t -> Pretty

prettifyList :: [ATN s nt t] -> Pretty

(Prettify t, Prettify ast, Prettify lrstate, Eq t, Eq ast, Eq lrstate, Hashable ast, Hashable t, Hashable lrstate) => Prettify (LRResult lrstate t ast)

Defined in Text.ANTLR.LR

Methods

prettify :: LRResult lrstate t ast -> Pretty

prettifyList :: [LRResult lrstate t ast] -> Pretty

(Prettify lrstate, Prettify nts, Prettify sts, Hashable lrstate, Hashable sts, Hashable nts, Eq lrstate, Eq sts, Eq nts) => Prettify (LRAction nts sts lrstate)

Defined in Text.ANTLR.LR

Methods

prettify :: LRAction nts sts lrstate -> Pretty

prettifyList :: [LRAction nts sts lrstate] -> Pretty

(Prettify a, Prettify nts, Prettify sts) => Prettify (Item a nts sts)

Defined in Text.ANTLR.LR

Methods

prettify :: Item a nts sts -> Pretty

prettifyList :: [Item a nts sts] -> Pretty

(Prettify a, Prettify b, Prettify c, Prettify d) => Prettify (a, b, c, d)

Defined in Text.ANTLR.Pretty

Methods

prettify :: (a, b, c, d) -> Pretty

prettifyList :: [(a, b, c, d)] -> Pretty

initPState :: PState

Initial Pretty state with safe soft and hard column defaults.

pLine :: Text -> Pretty

Prettify a string by putting it on the end of the current string state

pStr' :: String -> Pretty

Pretty print a literal string by just printing the string.

pStr :: Text -> Pretty

This currently assumes all input strings contain no newlines, and that this is only called on relatively small strings because strings running over the end of the hard column limit get dumped onto the next line no matter what. T.Texts can run over the soft limit, but hitting the soft limit after a call to pStr forces a newline.

pChr :: Char -> Pretty

Print a single character to the output.

_doIf :: Monad m => m () -> Bool -> m ()

Gets rid of if-then-else lines in the Pretty monad code:

_pIndent :: Pretty

Indent by the number of spaces specified in the state.

_pNewLine :: Pretty

Insert a newline

pshow :: Prettify t => t -> Text

Run the pretty-printer, returning a Text.

pshow' :: Prettify t => t -> String

Run the pretty-printer, returning a String.

pshowIndent :: Prettify t => Int -> t -> Text

Run the pretty-printer with a specific indentation level.

rshow :: Show t => t -> Pretty

Plain-vanilla show of something in the Pretty state monad.

pParens :: StateT PState Identity a -> StateT PState Identity ()

Parenthesize something in Pretty.

incrIndent :: Int -> Pretty

Increment the indentation level by modifying the pretty-printer state.

setIndent :: Int -> Pretty

Like incrIndent but set indentation level instead of incrementing.

pCount :: Prettify v => v -> PrettyM Int

Prettify the given value and compute the number of characters consumed as a result.

pListLines :: Prettify v => [v] -> Pretty

Pretty-print a list with one entry per line.

prettifyList_ :: Prettify t => [t] -> Pretty

Prettify a list with possibly more than one entry per line.

sepBy :: Monad m => m a -> [m ()] -> m ()

Pretty-print a list of values, separated by some other pretty-printer.

_sepBy :: Monad m => m a1 -> m a2 -> m b -> m b

Reorder pretty-printer bind.