Nix.Pretty

Documentation

data NixDoc ann

This type represents a pretty printed nix expression together with some information about the expression.

Constructors

NixDoc

Fields

• getDoc :: Doc ann

  Rendered expression. Without surrounding parenthesis.

• rootOp :: OperatorInfo

  The root operator is the operator at the root of the expression tree. For example, in '(a * b) + c', + would be the root operator. It is needed to determine if we need to wrap the expression in parentheses.

• wasPath :: Bool

antiquote :: NixDoc ann -> Doc ann

Represent Nix antiquotes.

${ expr }

mkNixDoc :: OperatorInfo -> Doc ann -> NixDoc ann

simpleExpr :: Doc ann -> NixDoc ann

A simple expression is never wrapped in parentheses. The expression behaves as if its root operator had a precedence higher than all other operators (including function application).

pathExpr :: Doc ann -> NixDoc ann

leastPrecedence :: Doc ann -> NixDoc ann

An expression that behaves as if its root operator had a precedence lower than all other operators. That ensures that the expression is wrapped in parentheses in almost always, but it's still rendered without parentheses in cases where parentheses are never required (such as in the LHS of a binding).

appOp :: OperatorInfo

appOpNonAssoc :: OperatorInfo

selectOp :: OperatorInfo

hasAttrOp :: OperatorInfo

precedenceWrap :: OperatorInfo -> NixDoc ann -> Doc ann

Determine if to return doc wraped into parens, according the given operator.

wrapPath :: OperatorInfo -> NixDoc ann -> Doc ann

prettyString :: NString (NixDoc ann) -> Doc ann

Handle Output representation of the string escape codes.

prettyVarName :: VarName -> Doc ann

prettyParams :: Params (NixDoc ann) -> Doc ann

prettyParamSet :: forall ann. Variadic -> ParamSet (NixDoc ann) -> Doc ann

prettyBind :: Binding (NixDoc ann) -> Doc ann

prettyKeyName :: NKeyName (NixDoc ann) -> Doc ann

prettySelector :: NAttrPath (NixDoc ann) -> Doc ann

prettyAtom :: NAtom -> NixDoc ann

prettyNix :: NExpr -> Doc ann

prettyOriginExpr :: forall t f m ann. HasCitations1 m (NValue t f m) f => NExprLocF (Maybe (NValue t f m)) -> Doc ann

prettyExtractFromProvenance :: forall t f m ann. HasCitations1 m (NValue t f m) f => [Provenance m (NValue t f m)] -> Doc ann

Takes original expression from inside provenance information. Prettifies that expression.

exprFNixDoc :: forall ann. NExprF (NixDoc ann) -> NixDoc ann

valueToExpr :: forall t f m. MonadDataContext f m => NValue t f m -> NExpr

prettyNValue :: forall t f m ann. MonadDataContext f m => NValue t f m -> Doc ann

data ValueOrigin

During the output, which can print only representation of value, lazy thunks need to looked into & so - be evaluated (*sic) This type is a simple manual witness "is the thunk gets shown".

Constructors

WasThunk

Value

Instances

Eq ValueOrigin

Defined in Nix.Pretty

Methods

(==) :: ValueOrigin -> ValueOrigin -> Bool

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

prettyProv

Arguments

:: forall t f m ann. (HasCitations m (NValue t f m) t, HasCitations1 m (NValue t f m) f, MonadThunk t m (NValue t f m), MonadDataContext f m)

=> ValueOrigin

Was thunk?

-> NValue t f m

-> Doc ann

prettyNValueProv :: forall t f m ann. (HasCitations m (NValue t f m) t, HasCitations1 m (NValue t f m) f, MonadThunk t m (NValue t f m), MonadDataContext f m) => NValue t f m -> Doc ann

prettyNThunk :: forall t f m ann. (HasCitations m (NValue t f m) t, HasCitations1 m (NValue t f m) f, MonadThunk t m (NValue t f m), MonadDataContext f m) => t -> m (Doc ann)

printNix :: forall t f m. MonadDataContext f m => NValue t f m -> Text

This function is used only by the testing code.