Text.Reprinter

Documentation

module Data.Functor.Identity

type Span = (Position, Position)

Two positions give the lower and upper bounds of a source span

type Position = (Line, Col)

A position in a text (imagine a cursor)

initPosition :: Position

The initial position

initCol :: Col

Columns start at 1

initLine :: Line

Lines start at 1

mkCol :: Int -> Either String Col

Smart constructor for a Col, checks that column >= 1

mkLine :: Int -> Either String Line

Smart constructor for a Line, checks that line >= 1

advanceCol :: Position -> Position

Given a position, advance by one column

advanceLine :: Position -> Position

Given a position, go down a line, going back to the initial column

data RefactorType

Specify a refactoring type

Constructors

Before

After

Replace

Instances

Show RefactorType

Defined in Text.Reprinter

Methods

showsPrec :: Int -> RefactorType -> ShowS

show :: RefactorType -> String

showList :: [RefactorType] -> ShowS

class Refactorable t where

Infrastructure for building the reprinter "plugins"

Methods

isRefactored :: t -> Maybe RefactorType

getSpan :: t -> Span

Instances

Refactorable (Expr Bool)

Defined in Text.Reprinter.Example

Methods

isRefactored :: Expr Bool -> Maybe RefactorType

getSpan :: Expr Bool -> Span

type Reprinting i m = forall node. Typeable node => node -> m (Maybe (RefactorType, i, Span))

Type of a reprinting function

i is the input type (something with a '[Char]'-like interface)

catchAll :: Monad m => a -> m (Maybe b)

Catch all generic query

genReprinting :: (Monad m, Refactorable t, Typeable t, StringLike i) => (t -> m i) -> t -> m (Maybe (RefactorType, i, Span))

Essentially wraps the refactorable interface

reprint :: (Monad m, Data ast, StringLike i) => Reprinting i m -> ast -> i -> m i

The reprint algorithm takes a refactoring (parameteric in | some monad m) and turns an arbitrary pretty-printable type ast | into a monadic 'StringLike i' transformer.

reprintSort :: (Monad m, Data ast, StringLike i) => Reprinting i m -> ast -> i -> m i

The reprint algorithm takes a refactoring (parameteric in | some monad m) and turns an arbitrary pretty-printable type ast | into a monadic 'StringLike i' transformer.