Test.Fun.Internal.Pretty

Pretty printing of function representations.

Warning

This is an internal module: it is not subject to any versioning policy, breaking changes can happen at any time. It is made available only for debugging. Otherwise, use Test.Fun.

If something here seems useful, please open an issue to export it from an external module.

Interface

showsPrecFun :: forall a r. ShowsPrec r -> ShowsPrec (a :-> r)

Prettify function representation.

indent :: String -> String

Break up lines after braces and indent.

Example

Input:

\x -> case x :: Either _ _ of { Left x1 -> case x1 of { Left x2 -> () ; Right x2 -> case x2 of {} } ; Right x1 -> () }

Output:

\x -> case x :: Either _ _ of {
  Left x1 -> case x1 of {
    Left x2 -> () ;
    Right x2 -> case x2 of {} } ;
  Right x1 -> () }

prettyFun :: forall a r. (r -> C Expr) -> (a :-> r) -> String

Implementation

Strings

type DString = String -> String

type PrecDString = Int -> DString

sid :: DString

sstring :: String -> DString

(%) :: DString -> DString -> DString infixr 1

(~%) :: String -> DString -> DString infixr 1

sparens :: Int -> DString -> PrecDString

Pretty-printed expressions

newtype Expr

Constructors

Expr

Fields

• unExpr :: PrecDString

type Pattern = Expr

unExpr_ :: Expr -> DString

data Var

Constructors

Var String !Int

data Ctx

Constructors

(Var, Expr) :. Ctx infixr 1

defVar :: Var

defCtx :: Ctx

badCtx :: Ctx

type C a = Ctx -> a

Type of values under some context

Basic expression constructors

eWild :: Pattern

eConst :: String -> Expr

tConst :: String -> C Expr

eInt :: Integer -> Expr

eApp :: Expr -> Expr -> Expr

tShow :: Show a => a -> C Expr

tShow_ :: ShowsPrec a -> a -> C Expr

sVar :: Var -> DString

eVar :: Var -> Expr

addVar :: [Var] -> Ctx -> Ctx

Main implementation

tFun :: forall a r. (r -> C Expr) -> (a :-> r) -> C Expr

Pretty-print a function representation.

tApply :: FunName -> C Expr -> C Expr

tCoApply :: Concrete w -> w -> C Expr -> C Expr

tAbsurd :: C Expr

appendIf :: Semigroup m => Bool -> m -> m -> m

partialBranches :: Branches x r -> Bool

True if there is a Fail branch.

type CBranches = Var -> C [EBranch]

data EBranch

Constructors

EBranch Pattern Expr

EBranchEllipsis

bEllipsis :: Bin r -> CBranches

bWild :: C Expr -> CBranches

tCase :: TypeName -> CBranches -> C Expr

tBranches :: forall x r. (r -> C Expr) -> Branches x r -> CBranches

tFields :: forall x r. (r -> C Expr) -> Fields x r -> ConName -> [Var] -> CBranches

nextVar :: Var -> Var

mkPattern :: ConName -> [Var] -> Pattern

tBin :: (r -> C Expr) -> Bin r -> CBranches

data Sign

Constructors

Pos

Neg

resign :: Sign -> Integer -> Integer

tBin' :: (r -> C Expr) -> Bin r -> C [(Integer, Expr)]

ellidedBin :: Bin r -> Bool