Text.Fixity

Machinery for deciding whether an expression needs to be wrapped in parentheses or not.

Documentation

type Precedence = Double

Fractional precedence, so that it's always possible to squeeze an operator precedence between two existing precedences. Ranges over [-20, 120]. A normal operator should have a precedence within [0, 100). It might be useful to have a negative precedence if you're trying to model some already existing system, for example in Haskell ($) has precedence 0, but clearly if b then y else f $ x should be rendered without any parens, hence the precedence of if_then_else_ is less than 0, i.e. negative.

The precedence of juxtaposition is 100. Normally you want juxtaposition to have the highest precedence, but some languages have operators that bind tighter than juxtaposition, e.g. Haskell's postfix _{_}: f z { x = y } means f (z {x = y}).

data Associativity

Associativity of an operator.

Constructors

LeftAssociative

RightAssociative

NonAssociative

Instances

Show Associativity

Defined in Text.Fixity.Internal

Methods

showsPrec :: Int -> Associativity -> ShowS

show :: Associativity -> String

showList :: [Associativity] -> ShowS

Eq Associativity

Defined in Text.Fixity.Internal

Methods

(==) :: Associativity -> Associativity -> Bool

(/=) :: Associativity -> Associativity -> Bool

data FixityOver prec

Fixity of an operator.

We allow unary operators to have associativity, because it's useful to distinguish between an expression like -(-x) (unary minus, left-associative) and ~~b (boolean NOT, right-associative).

Associativity of unary operators also matters when pretty-printing expressions like (-x) + y, which is pretty-printed as -x + y, assuming unary minus has the same fixity as + (and both the operators are left-associative). I.e. unary minus is handled just like the binary one: (0 - x) + y is pretty-printed as 0 - x + y.

Postfix operators are handled similarly. E.g. if ! is left-associative, then (x!)! is pretty-printed as x!! and if it's right-associative -- (x!)!.

The data type is parameterized, so that the user can choose precedence to be integer/fractional, bounded/unbounded, etc (we could also allows operators to be partially or totally ordered, but at the moment prec is required to implement Ord, i.e. it has to be totally ordered). By default we go with bounded fractional precedence, see the main Text.Fixity module.

Constructors

Fixity

Fields

• _fixityAssociativity :: !Associativity
• _fixityPrecedence :: !prec

Instances

Show prec => Show (FixityOver prec)

Defined in Text.Fixity.Internal

Methods

showsPrec :: Int -> FixityOver prec -> ShowS

show :: FixityOver prec -> String

showList :: [FixityOver prec] -> ShowS

Eq prec => Eq (FixityOver prec)

Defined in Text.Fixity.Internal

Methods

(==) :: FixityOver prec -> FixityOver prec -> Bool

(/=) :: FixityOver prec -> FixityOver prec -> Bool

type Fixity = FixityOver Precedence

FixityOver instantiated at Precedence.

data Direction

Direction in which pretty-printing goes. For example in x + y x is pretty-printed to the left of + and y is pretty-printed to the right of +.

Constructors

ToTheLeft

ToTheRight

Instances

Show Direction

Defined in Text.Fixity.Internal

Methods

showsPrec :: Int -> Direction -> ShowS

show :: Direction -> String

showList :: [Direction] -> ShowS

Eq Direction

Defined in Text.Fixity.Internal

Methods

(==) :: Direction -> Direction -> Bool

(/=) :: Direction -> Direction -> Bool

data RenderContextOver prec

A context that an expression is being rendered in.

Constructors

RenderContext

Fields

• _renderContextDirection :: !Direction
• _renderContextFixity :: !(FixityOver prec)

Instances

HasRenderContext RenderContext

Defined in Text.PrettyBy.Fixity

Methods

renderContext :: Lens' RenderContext RenderContext

Show prec => Show (RenderContextOver prec)

Defined in Text.Fixity.Internal

Methods

showsPrec :: Int -> RenderContextOver prec -> ShowS

show :: RenderContextOver prec -> String

showList :: [RenderContextOver prec] -> ShowS

Eq prec => Eq (RenderContextOver prec)

Defined in Text.Fixity.Internal

Methods

(==) :: RenderContextOver prec -> RenderContextOver prec -> Bool

(/=) :: RenderContextOver prec -> RenderContextOver prec -> Bool

type RenderContext = RenderContextOver Precedence

FixityOver instantiated at Precedence.

encloseIn

Arguments

:: Ord prec

=> (a -> a)

Enclose a value of type a in parens.

-> RenderContextOver prec

An outer context.

-> FixityOver prec

An inner fixity.

-> a

-> a

Enclose an a (using the provided function) if required or leave it as is. The need for enclosing is determined from an outer RenderContext and the inner fixity.

botFixity :: Fixity

A fixity with the lowest precedence. When used as a part of an outer context, never causes addition of parens.

juxtFixity :: Fixity

The fixity of juxtaposition.

unitFixity :: Fixity

The fixity of a unitary expression which is safe to render without parens in any context.

topFixity :: Fixity

A fixity with the highest precedence. When used as a part of an outer context, always causes addition of parens.

botRenderContext :: RenderContext

An initial RenderContext. An expression printed in this context never gets enclosed in parens.

topRenderContext :: RenderContext

An initial RenderContext. An expression printed in this context always gets enclosed in parens.