{-# language CPP #-}
{-# language AllowAmbiguousTypes #-}

{-# options_ghc -fno-warn-name-shadowing #-}

module Nix.Pretty where

import           Nix.Prelude             hiding ( toList, group )
import           Control.Monad.Free             ( Free(Free) )
import           Data.Fix                       ( Fix(..)
                                                , foldFix )
import           Data.HashMap.Lazy              ( toList )
import qualified Data.HashMap.Lazy             as M
import qualified Data.HashSet                  as HashSet
import qualified Data.List.NonEmpty            as NE
import           Data.Text                      ( replace
                                                , strip
                                                )
import qualified Data.Text                     as Text
import           Prettyprinter           hiding ( list )
import           Nix.Atoms
import           Nix.Cited
import           Nix.Expr.Types
import           Nix.Expr.Types.Annotated
import           Nix.Expr.Strings
import           Nix.Normal
import           Nix.Parser
import           Nix.String
import           Nix.Thunk
import           Nix.Value

-- | This type represents a pretty printed nix expression
-- together with some information about the expression.
data NixDoc ann = NixDoc
  { -- | Rendered expression. Without surrounding parenthesis.
    forall ann. NixDoc ann -> Doc ann
getDoc :: Doc ann

    -- | 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.
  , forall ann. NixDoc ann -> NOperatorDef
rootOp :: NOperatorDef
  , forall ann. NixDoc ann -> Bool
wasPath :: Bool -- This is needed so that when a path is used in a selector path
                    -- we can add brackets appropriately
  }

-- | Represent Nix antiquotes.
--
-- >
-- > ${ expr }
-- >
antiquote :: NixDoc ann -> Doc ann
antiquote :: forall ann. NixDoc ann -> Doc ann
antiquote NixDoc ann
x = Doc ann
"${" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc NixDoc ann
x Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"}"

mkNixDoc :: NOperatorDef -> Doc ann -> NixDoc ann
mkNixDoc :: forall ann. NOperatorDef -> Doc ann -> NixDoc ann
mkNixDoc NOperatorDef
o Doc ann
d = NixDoc { getDoc :: Doc ann
getDoc = Doc ann
d, rootOp :: NOperatorDef
rootOp = NOperatorDef
o, wasPath :: Bool
wasPath = Bool
False }

-- | 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).
simpleExpr :: Doc ann -> NixDoc ann
simpleExpr :: forall ann. Doc ann -> NixDoc ann
simpleExpr =
  NOperatorDef -> Doc ann -> NixDoc ann
forall ann. NOperatorDef -> Doc ann -> NixDoc ann
mkNixDoc (NOperatorDef -> Doc ann -> NixDoc ann)
-> NOperatorDef -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$ NSpecialOp -> NAssoc -> NOpPrecedence -> NOpName -> NOperatorDef
NSpecialDef NSpecialOp
NTerm NAssoc
NAssoc NOpPrecedence
forall a. Bounded a => a
minBound NOpName
"simple expr"

pathExpr :: Doc ann -> NixDoc ann
pathExpr :: forall ann. Doc ann -> NixDoc ann
pathExpr Doc ann
d = (Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
simpleExpr Doc ann
d) { wasPath = True }

-- | 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).
leastPrecedence :: Doc ann -> NixDoc ann
leastPrecedence :: forall ann. Doc ann -> NixDoc ann
leastPrecedence =
  NOperatorDef -> Doc ann -> NixDoc ann
forall ann. NOperatorDef -> Doc ann -> NixDoc ann
mkNixDoc (NOperatorDef -> Doc ann -> NixDoc ann)
-> NOperatorDef -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$ NSpecialOp -> NAssoc -> NOpPrecedence -> NOpName -> NOperatorDef
NSpecialDef NSpecialOp
NTerm NAssoc
NAssoc NOpPrecedence
forall a. Bounded a => a
maxBound NOpName
"least precedence"


data WrapMode
  = ProcessAllWrap
  | PrecedenceWrap
 deriving WrapMode -> WrapMode -> Bool
(WrapMode -> WrapMode -> Bool)
-> (WrapMode -> WrapMode -> Bool) -> Eq WrapMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WrapMode -> WrapMode -> Bool
== :: WrapMode -> WrapMode -> Bool
$c/= :: WrapMode -> WrapMode -> Bool
/= :: WrapMode -> WrapMode -> Bool
Eq

needsParens
  :: WrapMode
  -> NOperatorDef
  -> NOperatorDef
  -> Bool
needsParens :: WrapMode -> NOperatorDef -> NOperatorDef -> Bool
needsParens WrapMode
mode NOperatorDef
host NOperatorDef
sub =
  NOperatorDef -> NOpPrecedence
forall a. NOp a => a -> NOpPrecedence
getOpPrecedence NOperatorDef
host NOpPrecedence -> NOpPrecedence -> Bool
forall a. Ord a => a -> a -> Bool
> NOperatorDef -> NOpPrecedence
forall a. NOp a => a -> NOpPrecedence
getOpPrecedence NOperatorDef
sub
  Bool -> Bool -> Bool
|| Bool -> Bool -> Bool -> Bool
forall a. a -> a -> Bool -> a
bool
    Bool
False
    ( NAssoc
NAssoc NAssoc -> NAssoc -> Bool
forall a. Eq a => a -> a -> Bool
/=  NOperatorDef -> NAssoc
forall a. NOp a => a -> NAssoc
getOpAssoc      NOperatorDef
host
      Bool -> Bool -> Bool
&& (NAssoc -> NAssoc -> Bool)
-> (NOperatorDef -> NAssoc) -> NOperatorDef -> NOperatorDef -> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on NAssoc -> NAssoc -> Bool
forall a. Eq a => a -> a -> Bool
(==) NOperatorDef -> NAssoc
forall a. NOp a => a -> NAssoc
getOpAssoc      NOperatorDef
host NOperatorDef
sub
      Bool -> Bool -> Bool
&& (NOpPrecedence -> NOpPrecedence -> Bool)
-> (NOperatorDef -> NOpPrecedence)
-> NOperatorDef
-> NOperatorDef
-> Bool
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on NOpPrecedence -> NOpPrecedence -> Bool
forall a. Eq a => a -> a -> Bool
(==) NOperatorDef -> NOpPrecedence
forall a. NOp a => a -> NOpPrecedence
getOpPrecedence NOperatorDef
host NOperatorDef
sub
    )
    (WrapMode
ProcessAllWrap WrapMode -> WrapMode -> Bool
forall a. Eq a => a -> a -> Bool
== WrapMode
mode)

maybeWrapDoc :: WrapMode -> NOperatorDef -> NixDoc ann -> Doc ann
maybeWrapDoc :: forall ann. WrapMode -> NOperatorDef -> NixDoc ann -> Doc ann
maybeWrapDoc WrapMode
mode NOperatorDef
host NixDoc ann
sub =
  (Doc ann -> Doc ann)
-> (Doc ann -> Doc ann) -> Bool -> Doc ann -> Doc ann
forall a. a -> a -> Bool -> a
bool
    Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens
    Doc ann -> Doc ann
forall a. a -> a
id
    (WrapMode -> NOperatorDef -> NOperatorDef -> Bool
needsParens WrapMode
mode NOperatorDef
host (NixDoc ann -> NOperatorDef
forall ann. NixDoc ann -> NOperatorDef
rootOp NixDoc ann
sub))
    (NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc NixDoc ann
sub)

-- | Determine if to return doc wraped into parens,
-- according the given operator.
wrap :: NOperatorDef -> NixDoc ann -> Doc ann
wrap :: forall ann. NOperatorDef -> NixDoc ann -> Doc ann
wrap = WrapMode -> NOperatorDef -> NixDoc ann -> Doc ann
forall ann. WrapMode -> NOperatorDef -> NixDoc ann -> Doc ann
maybeWrapDoc WrapMode
ProcessAllWrap

precedenceWrap :: NOperatorDef -> NixDoc ann -> Doc ann
precedenceWrap :: forall ann. NOperatorDef -> NixDoc ann -> Doc ann
precedenceWrap = WrapMode -> NOperatorDef -> NixDoc ann -> Doc ann
forall ann. WrapMode -> NOperatorDef -> NixDoc ann -> Doc ann
maybeWrapDoc WrapMode
PrecedenceWrap

-- Used in the selector case to print a path in a selector as
-- "${./abc}"
wrapPath :: NOperatorDef -> NixDoc ann -> Doc ann
wrapPath :: forall ann. NOperatorDef -> NixDoc ann -> Doc ann
wrapPath NOperatorDef
op NixDoc ann
sub =
  Doc ann -> Doc ann -> Bool -> Doc ann
forall a. a -> a -> Bool -> a
bool
    (NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
wrap NOperatorDef
op NixDoc ann
sub)
    (Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
dquotes (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
antiquote NixDoc ann
sub)
    (NixDoc ann -> Bool
forall ann. NixDoc ann -> Bool
wasPath NixDoc ann
sub)

-- | Handle Output representation of the string escape codes.
prettyString :: NString (NixDoc ann) -> Doc ann
prettyString :: forall ann. NString (NixDoc ann) -> Doc ann
prettyString (DoubleQuoted [Antiquoted Text (NixDoc ann)]
parts) =
  Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
dquotes (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ (Antiquoted Text (NixDoc ann) -> Doc ann)
-> [Antiquoted Text (NixDoc ann)] -> Doc ann
forall m a. Monoid m => (a -> m) -> [a] -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap Antiquoted Text (NixDoc ann) -> Doc ann
forall {ann}. Antiquoted Text (NixDoc ann) -> Doc ann
prettyPart [Antiquoted Text (NixDoc ann)]
parts
 where
  prettyPart :: Antiquoted Text (NixDoc ann) -> Doc ann
prettyPart (Plain Text
t)      = Text -> Doc ann
forall ann. Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Text -> Doc ann) -> Text -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text -> Text
escapeString Text
t
  prettyPart Antiquoted Text (NixDoc ann)
EscapedNewline = Doc ann
"''\\n"
  prettyPart (Antiquoted NixDoc ann
r) = NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
antiquote NixDoc ann
r
prettyString (Indented Int
_ [Antiquoted Text (NixDoc ann)]
parts) =
  Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
group (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vcat [Doc ann
"''", Doc ann
content, Doc ann
"''"]
 where
  content :: Doc ann
content = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep ([Doc ann] -> Doc ann)
-> ([Antiquoted Text (NixDoc ann)] -> [Doc ann])
-> [Antiquoted Text (NixDoc ann)]
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Antiquoted Text (NixDoc ann)] -> Doc ann)
-> [[Antiquoted Text (NixDoc ann)]] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Antiquoted Text (NixDoc ann)] -> Doc ann
forall ann. [Antiquoted Text (NixDoc ann)] -> Doc ann
prettyLine ([[Antiquoted Text (NixDoc ann)]] -> [Doc ann])
-> ([Antiquoted Text (NixDoc ann)]
    -> [[Antiquoted Text (NixDoc ann)]])
-> [Antiquoted Text (NixDoc ann)]
-> [Doc ann]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Antiquoted Text (NixDoc ann)]]
-> [[Antiquoted Text (NixDoc ann)]]
forall r. [[Antiquoted Text r]] -> [[Antiquoted Text r]]
stripLastIfEmpty ([[Antiquoted Text (NixDoc ann)]]
 -> [[Antiquoted Text (NixDoc ann)]])
-> ([Antiquoted Text (NixDoc ann)]
    -> [[Antiquoted Text (NixDoc ann)]])
-> [Antiquoted Text (NixDoc ann)]
-> [[Antiquoted Text (NixDoc ann)]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Antiquoted Text (NixDoc ann)] -> [[Antiquoted Text (NixDoc ann)]]
forall r. [Antiquoted Text r] -> [[Antiquoted Text r]]
splitLines ([Antiquoted Text (NixDoc ann)] -> Doc ann)
-> [Antiquoted Text (NixDoc ann)] -> Doc ann
forall a b. (a -> b) -> a -> b
$ [Antiquoted Text (NixDoc ann)]
parts
  stripLastIfEmpty :: [[Antiquoted Text r]] -> [[Antiquoted Text r]]
  stripLastIfEmpty :: forall r. [[Antiquoted Text r]] -> [[Antiquoted Text r]]
stripLastIfEmpty =
    ([Antiquoted Text r] -> Bool)
-> [[Antiquoted Text r]] -> [[Antiquoted Text r]]
forall a. (a -> Bool) -> [a] -> [a]
filter [Antiquoted Text r] -> Bool
forall r. [Antiquoted Text r] -> Bool
flt
   where
    flt :: [Antiquoted Text r] -> Bool
    flt :: forall r. [Antiquoted Text r] -> Bool
flt [Plain Text
t] | Text -> Bool
Text.null (Text -> Text
strip Text
t) = Bool
False
    flt [Antiquoted Text r]
_ = Bool
True

  prettyLine :: [Antiquoted Text (NixDoc ann)] -> Doc ann
  prettyLine :: forall ann. [Antiquoted Text (NixDoc ann)] -> Doc ann
prettyLine =
    [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hcat ([Doc ann] -> Doc ann)
-> ([Antiquoted Text (NixDoc ann)] -> [Doc ann])
-> [Antiquoted Text (NixDoc ann)]
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Antiquoted Text (NixDoc ann) -> Doc ann)
-> [Antiquoted Text (NixDoc ann)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Antiquoted Text (NixDoc ann) -> Doc ann
forall {ann}. Antiquoted Text (NixDoc ann) -> Doc ann
prettyPart
   where
    prettyPart :: Antiquoted Text (NixDoc ann) -> Doc ann
    prettyPart :: forall {ann}. Antiquoted Text (NixDoc ann) -> Doc ann
prettyPart (Plain Text
t) =
      Text -> Doc ann
forall ann. Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Text -> Doc ann) -> (Text -> Text) -> Text -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Text -> Text -> Text -> Text
Text -> Text -> Text -> Text
replace Text
"${" Text
"''${" (Text -> Text) -> (Text -> Text) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HasCallStack => Text -> Text -> Text -> Text
Text -> Text -> Text -> Text
replace Text
"''" Text
"'''" (Text -> Doc ann) -> Text -> Doc ann
forall a b. (a -> b) -> a -> b
$ Text
t
    prettyPart Antiquoted Text (NixDoc ann)
EscapedNewline = Doc ann
"\\n"
    prettyPart (Antiquoted NixDoc ann
r) = NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
antiquote NixDoc ann
r

prettyVarName :: VarName -> Doc ann
prettyVarName :: forall ann. VarName -> Doc ann
prettyVarName = forall a ann. Pretty a => a -> Doc ann
pretty @Text (Text -> Doc ann) -> (VarName -> Text) -> VarName -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VarName -> Text
forall a b. Coercible a b => a -> b
coerce

prettyParams :: Params (NixDoc ann) -> Doc ann
prettyParams :: forall ann. Params (NixDoc ann) -> Doc ann
prettyParams (Param VarName
n           ) = VarName -> Doc ann
forall ann. VarName -> Doc ann
prettyVarName VarName
n
prettyParams (ParamSet Maybe VarName
mname Variadic
variadic ParamSet (NixDoc ann)
pset) =
  Variadic -> ParamSet (NixDoc ann) -> Doc ann
forall ann. Variadic -> ParamSet (NixDoc ann) -> Doc ann
prettyParamSet Variadic
variadic ParamSet (NixDoc ann)
pset Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>
    VarName -> Doc ann
forall ann. VarName -> Doc ann
toDoc (VarName -> Doc ann) -> Maybe VarName -> Doc ann
forall b a. Monoid b => (a -> b) -> Maybe a -> b
`whenJust` Maybe VarName
mname
 where
  toDoc :: VarName -> Doc ann
  toDoc :: forall ann. VarName -> Doc ann
toDoc (VarName -> Text
forall a b. Coercible a b => a -> b
coerce -> Text
name) =
    (Doc ann
"@" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Text -> Doc ann
forall ann. Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Text
name) Doc ann -> Bool -> Doc ann
forall a. Monoid a => a -> Bool -> a
`whenFalse` Text -> Bool
Text.null Text
name

prettyParamSet :: forall ann . Variadic -> ParamSet (NixDoc ann) -> Doc ann
prettyParamSet :: forall ann. Variadic -> ParamSet (NixDoc ann) -> Doc ann
prettyParamSet Variadic
variadic ParamSet (NixDoc ann)
args =
  Doc ann -> Doc ann -> Doc ann -> [Doc ann] -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann -> [Doc ann] -> Doc ann
encloseSep
    Doc ann
"{ "
    (Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
align Doc ann
" }")
    (Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
align Doc ann
", ")
    (((VarName, Maybe (NixDoc ann)) -> Doc ann)
-> ParamSet (NixDoc ann) -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (VarName, Maybe (NixDoc ann)) -> Doc ann
prettySetArg ParamSet (NixDoc ann)
args [Doc ann] -> [Doc ann] -> [Doc ann]
forall a. Semigroup a => a -> a -> a
<> OneItem [Doc ann] -> [Doc ann]
forall x. One x => OneItem x -> x
one Doc ann
OneItem [Doc ann]
"..." [Doc ann] -> Bool -> [Doc ann]
forall a. Monoid a => a -> Bool -> a
`whenTrue` (Variadic
variadic Variadic -> Variadic -> Bool
forall a. Eq a => a -> a -> Bool
== Variadic
Variadic))
 where
  prettySetArg :: (VarName, Maybe (NixDoc ann)) -> Doc ann
  prettySetArg :: (VarName, Maybe (NixDoc ann)) -> Doc ann
prettySetArg (VarName
n, Maybe (NixDoc ann)
maybeDef) =
    (VarName -> Doc ann
forall ann. VarName -> Doc ann
prettyVarName VarName
n Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>) (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ ((Doc ann
" ? " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>) (Doc ann -> Doc ann)
-> (NixDoc ann -> Doc ann) -> NixDoc ann -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc) (NixDoc ann -> Doc ann) -> Maybe (NixDoc ann) -> Doc ann
forall b a. Monoid b => (a -> b) -> Maybe a -> b
`whenJust` Maybe (NixDoc ann)
maybeDef

prettyBind :: Binding (NixDoc ann) -> Doc ann
prettyBind :: forall ann. Binding (NixDoc ann) -> Doc ann
prettyBind (NamedVar NAttrPath (NixDoc ann)
n NixDoc ann
v NSourcePos
_p) =
  NAttrPath (NixDoc ann) -> Doc ann
forall ann. NAttrPath (NixDoc ann) -> Doc ann
prettySelector NAttrPath (NixDoc ann)
n Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
" = " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc NixDoc ann
v Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
";"
prettyBind (Inherit Maybe (NixDoc ann)
s [VarName]
ns NSourcePos
_p) =
  Doc ann
"inherit " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
scope Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
align ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
fillSep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ VarName -> Doc ann
forall ann. VarName -> Doc ann
prettyVarName (VarName -> Doc ann) -> [VarName] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [VarName]
ns) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
";"
 where
  scope :: Doc ann
scope =
    ((Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
" ") (Doc ann -> Doc ann)
-> (NixDoc ann -> Doc ann) -> NixDoc ann -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
parens (Doc ann -> Doc ann)
-> (NixDoc ann -> Doc ann) -> NixDoc ann -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc) (NixDoc ann -> Doc ann) -> Maybe (NixDoc ann) -> Doc ann
forall b a. Monoid b => (a -> b) -> Maybe a -> b
`whenJust` Maybe (NixDoc ann)
s

prettyKeyName :: NKeyName (NixDoc ann) -> Doc ann
prettyKeyName :: forall ann. NKeyName (NixDoc ann) -> Doc ann
prettyKeyName (StaticKey VarName
key) =
  Doc ann -> Doc ann -> Bool -> Doc ann
forall a. a -> a -> Bool -> a
bool
    Doc ann
"\"\""
    ((Doc ann -> Doc ann)
-> (Doc ann -> Doc ann) -> Bool -> Doc ann -> Doc ann
forall a. a -> a -> Bool -> a
bool
      Doc ann -> Doc ann
forall a. a -> a
id
      Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
dquotes
      (VarName -> HashSet VarName -> Bool
forall a. (Eq a, Hashable a) => a -> HashSet a -> Bool
HashSet.member VarName
key HashSet VarName
reservedNames)
      (VarName -> Doc ann
forall ann. VarName -> Doc ann
prettyVarName VarName
key)
    )
    (Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Text -> Bool
Text.null (Text -> Bool) -> Text -> Bool
forall a b. (a -> b) -> a -> b
$ VarName -> Text
forall a b. Coercible a b => a -> b
coerce VarName
key)
prettyKeyName (DynamicKey Antiquoted (NString (NixDoc ann)) (NixDoc ann)
key) =
  NString (NixDoc ann)
-> (NString (NixDoc ann) -> Doc ann)
-> (NixDoc ann -> Doc ann)
-> Antiquoted (NString (NixDoc ann)) (NixDoc ann)
-> Doc ann
forall v a r. v -> (v -> a) -> (r -> a) -> Antiquoted v r -> a
runAntiquoted
    ([Antiquoted Text (NixDoc ann)] -> NString (NixDoc ann)
forall r. [Antiquoted Text r] -> NString r
DoubleQuoted ([Antiquoted Text (NixDoc ann)] -> NString (NixDoc ann))
-> [Antiquoted Text (NixDoc ann)] -> NString (NixDoc ann)
forall a b. (a -> b) -> a -> b
$ OneItem [Antiquoted Text (NixDoc ann)]
-> [Antiquoted Text (NixDoc ann)]
forall x. One x => OneItem x -> x
one (OneItem [Antiquoted Text (NixDoc ann)]
 -> [Antiquoted Text (NixDoc ann)])
-> OneItem [Antiquoted Text (NixDoc ann)]
-> [Antiquoted Text (NixDoc ann)]
forall a b. (a -> b) -> a -> b
$ Text -> Antiquoted Text (NixDoc ann)
forall v r. v -> Antiquoted v r
Plain Text
"\n")
    NString (NixDoc ann) -> Doc ann
forall ann. NString (NixDoc ann) -> Doc ann
prettyString
    NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
antiquote
    Antiquoted (NString (NixDoc ann)) (NixDoc ann)
key

prettySelector :: NAttrPath (NixDoc ann) -> Doc ann
prettySelector :: forall ann. NAttrPath (NixDoc ann) -> Doc ann
prettySelector = [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hcat ([Doc ann] -> Doc ann)
-> (NAttrPath (NixDoc ann) -> [Doc ann])
-> NAttrPath (NixDoc ann)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
"." ([Doc ann] -> [Doc ann])
-> (NAttrPath (NixDoc ann) -> [Doc ann])
-> NAttrPath (NixDoc ann)
-> [Doc ann]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NKeyName (NixDoc ann) -> Doc ann)
-> [NKeyName (NixDoc ann)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NKeyName (NixDoc ann) -> Doc ann
forall ann. NKeyName (NixDoc ann) -> Doc ann
prettyKeyName ([NKeyName (NixDoc ann)] -> [Doc ann])
-> (NAttrPath (NixDoc ann) -> [NKeyName (NixDoc ann)])
-> NAttrPath (NixDoc ann)
-> [Doc ann]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NAttrPath (NixDoc ann) -> [NKeyName (NixDoc ann)]
forall a. NonEmpty a -> [a]
NE.toList

prettyAtom :: NAtom -> NixDoc ann
prettyAtom :: forall ann. NAtom -> NixDoc ann
prettyAtom = Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
simpleExpr (Doc ann -> NixDoc ann)
-> (NAtom -> Doc ann) -> NAtom -> NixDoc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Doc ann
forall ann. Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Text -> Doc ann) -> (NAtom -> Text) -> NAtom -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NAtom -> Text
atomText

prettyNix :: NExpr -> Doc ann
prettyNix :: forall ann. NExpr -> Doc ann
prettyNix = NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc (NixDoc ann -> Doc ann)
-> (NExpr -> NixDoc ann) -> NExpr -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NExprF (NixDoc ann) -> NixDoc ann) -> NExpr -> NixDoc ann
forall (f :: * -> *) a. Functor f => (f a -> a) -> Fix f -> a
foldFix NExprF (NixDoc ann) -> NixDoc ann
forall ann. NExprF (NixDoc ann) -> NixDoc ann
exprFNixDoc

prettyOriginExpr
  :: forall t f m ann
   . HasCitations1 m (NValue t f m) f
  => NExprLocF (Maybe (NValue t f m))
  -> Doc ann
prettyOriginExpr :: forall t (f :: * -> *) (m :: * -> *) ann.
HasCitations1 m (NValue t f m) f =>
NExprLocF (Maybe (NValue t f m)) -> Doc ann
prettyOriginExpr = NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc (NixDoc ann -> Doc ann)
-> (NExprLocF (Maybe (NValue t f m)) -> NixDoc ann)
-> NExprLocF (Maybe (NValue t f m))
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NExprLocF (Maybe (NValue t f m)) -> NixDoc ann
go
 where
  go :: NExprLocF (Maybe (NValue t f m)) -> NixDoc ann
  go :: NExprLocF (Maybe (NValue t f m)) -> NixDoc ann
go = NExprF (NixDoc ann) -> NixDoc ann
forall ann. NExprF (NixDoc ann) -> NixDoc ann
exprFNixDoc (NExprF (NixDoc ann) -> NixDoc ann)
-> (NExprLocF (Maybe (NValue t f m)) -> NExprF (NixDoc ann))
-> NExprLocF (Maybe (NValue t f m))
-> NixDoc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AnnF SrcSpan NExprF (NixDoc ann) -> NExprF (NixDoc ann)
forall ann (f :: * -> *) r. AnnF ann f r -> f r
stripAnnF (AnnF SrcSpan NExprF (NixDoc ann) -> NExprF (NixDoc ann))
-> (NExprLocF (Maybe (NValue t f m))
    -> AnnF SrcSpan NExprF (NixDoc ann))
-> NExprLocF (Maybe (NValue t f m))
-> NExprF (NixDoc ann)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe (NValue t f m) -> NixDoc ann)
-> NExprLocF (Maybe (NValue t f m))
-> AnnF SrcSpan NExprF (NixDoc ann)
forall a b.
(a -> b)
-> Compose (AnnUnit SrcSpan) NExprF a
-> Compose (AnnUnit SrcSpan) NExprF b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Maybe (NValue t f m) -> NixDoc ann
render
   where
    render :: Maybe (NValue t f m) -> NixDoc ann
    render :: Maybe (NValue t f m) -> NixDoc ann
render Maybe (NValue t f m)
Nothing = Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
simpleExpr Doc ann
"_"
    render (Just (Free ([Provenance m (NValue t f m)] -> [Provenance m (NValue t f m)]
forall a. [a] -> [a]
reverse ([Provenance m (NValue t f m)] -> [Provenance m (NValue t f m)])
-> (NValue' t f m (NValue t f m) -> [Provenance m (NValue t f m)])
-> NValue' t f m (NValue t f m)
-> [Provenance m (NValue t f m)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) v a.
HasCitations m v a =>
a -> [Provenance m v]
citations @m -> Provenance m (NValue t f m)
p:[Provenance m (NValue t f m)]
_))) = NExprLocF (Maybe (NValue t f m)) -> NixDoc ann
go (Provenance m (NValue t f m) -> NExprLocF (Maybe (NValue t f m))
forall (m :: * -> *) v. Provenance m v -> NExprLocF (Maybe v)
getOriginExpr Provenance m (NValue t f m)
p)
    render Maybe (NValue t f m)
_       = Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
simpleExpr Doc ann
"?"
      -- render (Just (NValue (citations -> ps))) =
          -- simpleExpr $ foldr ((\x y -> vsep [x, y]) . parens . indent 2 . getDoc
          --                           . go . originExpr)
          --     mempty (reverse ps)

-- | Takes original expression from inside provenance information.
-- Prettifies that expression.
prettyExtractFromProvenance
  :: forall t f m ann
   . HasCitations1 m (NValue t f m) f
  => [Provenance m (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
prettyExtractFromProvenance =
  [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
sep ([Doc ann] -> Doc ann)
-> ([Provenance m (NValue t f m)] -> [Doc ann])
-> [Provenance m (NValue t f m)]
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    (Provenance m (NValue t f m) -> Doc ann)
-> [Provenance m (NValue t f m)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (NExprLocF (Maybe (NValue t f m)) -> Doc ann
forall t (f :: * -> *) (m :: * -> *) ann.
HasCitations1 m (NValue t f m) f =>
NExprLocF (Maybe (NValue t f m)) -> Doc ann
prettyOriginExpr (NExprLocF (Maybe (NValue t f m)) -> Doc ann)
-> (Provenance m (NValue t f m)
    -> NExprLocF (Maybe (NValue t f m)))
-> Provenance m (NValue t f m)
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Provenance m (NValue t f m) -> NExprLocF (Maybe (NValue t f m))
forall (m :: * -> *) v. Provenance m v -> NExprLocF (Maybe v)
getOriginExpr)

exprFNixDoc :: forall ann . NExprF (NixDoc ann) -> NixDoc ann
exprFNixDoc :: forall ann. NExprF (NixDoc ann) -> NixDoc ann
exprFNixDoc = \case
  NConstant NAtom
atom -> NAtom -> NixDoc ann
forall ann. NAtom -> NixDoc ann
prettyAtom NAtom
atom
  NStr      NString (NixDoc ann)
str  -> Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
simpleExpr (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$ NString (NixDoc ann) -> Doc ann
forall ann. NString (NixDoc ann) -> Doc ann
prettyString NString (NixDoc ann)
str
  NList [NixDoc ann]
xs ->
    Doc ann
-> (NixDoc ann -> Doc ann) -> Doc ann -> [NixDoc ann] -> NixDoc ann
forall {ann} {a}.
Doc ann -> (a -> Doc ann) -> Doc ann -> [a] -> NixDoc ann
prettyContainer Doc ann
"[" (NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
precedenceWrap NOperatorDef
appOpDef) Doc ann
"]" [NixDoc ann]
xs
  NSet Recursivity
NonRecursive [Binding (NixDoc ann)]
xs ->
    Doc ann
-> (Binding (NixDoc ann) -> Doc ann)
-> Doc ann
-> [Binding (NixDoc ann)]
-> NixDoc ann
forall {ann} {a}.
Doc ann -> (a -> Doc ann) -> Doc ann -> [a] -> NixDoc ann
prettyContainer Doc ann
"{" Binding (NixDoc ann) -> Doc ann
forall ann. Binding (NixDoc ann) -> Doc ann
prettyBind Doc ann
"}" [Binding (NixDoc ann)]
xs
  NSet Recursivity
Recursive [Binding (NixDoc ann)]
xs ->
    Doc ann
-> (Binding (NixDoc ann) -> Doc ann)
-> Doc ann
-> [Binding (NixDoc ann)]
-> NixDoc ann
forall {ann} {a}.
Doc ann -> (a -> Doc ann) -> Doc ann -> [a] -> NixDoc ann
prettyContainer Doc ann
"rec {" Binding (NixDoc ann) -> Doc ann
forall ann. Binding (NixDoc ann) -> Doc ann
prettyBind Doc ann
"}" [Binding (NixDoc ann)]
xs
  NAbs Params (NixDoc ann)
args NixDoc ann
body ->
    Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
leastPrecedence (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$
      Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$
        [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep
          [ Params (NixDoc ann) -> Doc ann
forall ann. Params (NixDoc ann) -> Doc ann
prettyParams Params (NixDoc ann)
args Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
":"
          , NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc NixDoc ann
body
          ]
  NApp NixDoc ann
fun NixDoc ann
arg ->
    NOperatorDef -> Doc ann -> NixDoc ann
forall ann. NOperatorDef -> Doc ann -> NixDoc ann
mkNixDoc NOperatorDef
appOpDef (NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
wrap NOperatorDef
appOpDef NixDoc ann
fun Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
" " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
precedenceWrap NOperatorDef
appOpDef NixDoc ann
arg)
  NBinary NBinaryOp
op NixDoc ann
r1 NixDoc ann
r2 ->
    NOperatorDef -> Doc ann -> NixDoc ann
forall ann. NOperatorDef -> Doc ann -> NixDoc ann
mkNixDoc
      NOperatorDef
opDef (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$
      [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep
        [ NAssoc -> NixDoc ann -> Doc ann
pickWrapMode NAssoc
NAssocLeft NixDoc ann
r1
        , forall a ann. Pretty a => a -> Doc ann
pretty @Text (Text -> Doc ann) -> Text -> Doc ann
forall a b. (a -> b) -> a -> b
$ forall a b. Coercible a b => a -> b
forall a b. Coercible a b => a -> b
coerce @NOpName (NOpName -> Text) -> NOpName -> Text
forall a b. (a -> b) -> a -> b
$ NBinaryOp -> NOpName
forall a. NOp a => a -> NOpName
getOpName NBinaryOp
op
        , NAssoc -> NixDoc ann -> Doc ann
pickWrapMode NAssoc
NAssocRight NixDoc ann
r2
        ]
   where
    opDef :: NOperatorDef
opDef = NBinaryOp -> NOperatorDef
forall a. NOp a => a -> NOperatorDef
getOpDef NBinaryOp
op

    pickWrapMode :: NAssoc -> NixDoc ann -> Doc ann
    pickWrapMode :: NAssoc -> NixDoc ann -> Doc ann
pickWrapMode NAssoc
x =
      (NOperatorDef -> NixDoc ann -> Doc ann)
-> (NOperatorDef -> NixDoc ann -> Doc ann)
-> Bool
-> NOperatorDef
-> NixDoc ann
-> Doc ann
forall a. a -> a -> Bool -> a
bool
        NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
wrap
        NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
precedenceWrap
        (NOperatorDef -> NAssoc
forall a. NOp a => a -> NAssoc
getOpAssoc NOperatorDef
opDef NAssoc -> NAssoc -> Bool
forall a. Eq a => a -> a -> Bool
/= NAssoc
x)
        NOperatorDef
opDef
  NUnary NUnaryOp
op NixDoc ann
r1 ->
    NOperatorDef -> Doc ann -> NixDoc ann
forall ann. NOperatorDef -> Doc ann -> NixDoc ann
mkNixDoc
      NOperatorDef
opDef (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$
      forall a ann. Pretty a => a -> Doc ann
pretty @Text (NOpName -> Text
forall a b. Coercible a b => a -> b
coerce (NOpName -> Text) -> NOpName -> Text
forall a b. (a -> b) -> a -> b
$ NUnaryOp -> NOpName
forall a. NOp a => a -> NOpName
getOpName NUnaryOp
op) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
wrap NOperatorDef
opDef NixDoc ann
r1
   where
    opDef :: NOperatorDef
opDef = NUnaryOp -> NOperatorDef
forall a. NOp a => a -> NOperatorDef
getOpDef NUnaryOp
op
  NSelect Maybe (NixDoc ann)
o NixDoc ann
r' NAttrPath (NixDoc ann)
attr ->
    (Doc ann -> NixDoc ann)
-> (NixDoc ann -> Doc ann -> NixDoc ann)
-> Maybe (NixDoc ann)
-> Doc ann
-> NixDoc ann
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
      (NOperatorDef -> Doc ann -> NixDoc ann
forall ann. NOperatorDef -> Doc ann -> NixDoc ann
mkNixDoc NOperatorDef
selectOp)
      ((Doc ann -> NixDoc ann) -> NixDoc ann -> Doc ann -> NixDoc ann
forall a b. a -> b -> a
const Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
leastPrecedence)
      Maybe (NixDoc ann)
o
      (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$ NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
wrapPath NOperatorDef
selectOp (NOperatorDef -> Doc ann -> NixDoc ann
forall ann. NOperatorDef -> Doc ann -> NixDoc ann
mkNixDoc NOperatorDef
selectOp (NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
wrap NOperatorDef
appOpDef NixDoc ann
r')) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"." Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NAttrPath (NixDoc ann) -> Doc ann
forall ann. NAttrPath (NixDoc ann) -> Doc ann
prettySelector NAttrPath (NixDoc ann)
attr Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>
        ((Doc ann
" or " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>) (Doc ann -> Doc ann)
-> (NixDoc ann -> Doc ann) -> NixDoc ann -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
precedenceWrap NOperatorDef
appOpDef) (NixDoc ann -> Doc ann) -> Maybe (NixDoc ann) -> Doc ann
forall b a. Monoid b => (a -> b) -> Maybe a -> b
`whenJust` Maybe (NixDoc ann)
o
   where
    selectOp :: NOperatorDef
    selectOp :: NOperatorDef
selectOp = NSpecialOp -> NOperatorDef
forall a. NOp a => a -> NOperatorDef
getOpDef NSpecialOp
NSelectOp

  NHasAttr NixDoc ann
r NAttrPath (NixDoc ann)
attr ->
    NOperatorDef -> Doc ann -> NixDoc ann
forall ann. NOperatorDef -> Doc ann -> NixDoc ann
mkNixDoc NOperatorDef
hasAttrOp (NOperatorDef -> NixDoc ann -> Doc ann
forall ann. NOperatorDef -> NixDoc ann -> Doc ann
wrap NOperatorDef
hasAttrOp NixDoc ann
r Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
" ? " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NAttrPath (NixDoc ann) -> Doc ann
forall ann. NAttrPath (NixDoc ann) -> Doc ann
prettySelector NAttrPath (NixDoc ann)
attr)
   where
    hasAttrOp :: NOperatorDef
    hasAttrOp :: NOperatorDef
hasAttrOp = NSpecialOp -> NOperatorDef
forall a. NOp a => a -> NOperatorDef
getOpDef NSpecialOp
NHasAttrOp

  NEnvPath     Path
p -> Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
simpleExpr (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$ forall a ann. Pretty a => a -> Doc ann
pretty @String (String -> Doc ann) -> String -> Doc ann
forall a b. (a -> b) -> a -> b
$ String
"<" String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Path -> String
forall a b. Coercible a b => a -> b
coerce Path
p String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
">"
  NLiteralPath Path
p ->
    Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
pathExpr (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$
      forall a ann. Pretty a => a -> Doc ann
pretty @FilePath (String -> Doc ann) -> String -> Doc ann
forall a b. (a -> b) -> a -> b
$ Path -> String
forall a b. Coercible a b => a -> b
coerce (Path -> String) -> Path -> String
forall a b. (a -> b) -> a -> b
$
        case Path
p of
          Path
"./"  -> Path
"./."
          Path
"../" -> Path
"../."
          Path
".."  -> Path
"../."
          Path
path  ->
            Path -> Path -> Bool -> Path
forall a. a -> a -> Bool -> a
bool
              (Path
"./" Path -> Path -> Path
forall a. Semigroup a => a -> a -> a
<> Path
path)
              Path
path
              ((String -> Bool) -> [String] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (String -> String -> Bool
forall a. Eq a => [a] -> [a] -> Bool
`isPrefixOf` Path -> String
forall a b. Coercible a b => a -> b
coerce Path
path) [String
"/", String
"~/", String
"./", String
"../"])
  NSym VarName
name -> Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
simpleExpr (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$ VarName -> Doc ann
forall ann. VarName -> Doc ann
prettyVarName VarName
name
  NLet [Binding (NixDoc ann)]
binds NixDoc ann
body ->
    Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
leastPrecedence (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$
      Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
group (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$
        [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep
          [ Doc ann
"let"
          , Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 ([Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep ([Doc ann] -> Doc ann) -> [Doc ann] -> Doc ann
forall a b. (a -> b) -> a -> b
$ (Binding (NixDoc ann) -> Doc ann)
-> [Binding (NixDoc ann)] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Binding (NixDoc ann) -> Doc ann
forall ann. Binding (NixDoc ann) -> Doc ann
prettyBind [Binding (NixDoc ann)]
binds)
          , Doc ann
"in " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc NixDoc ann
body
          ]
  NIf NixDoc ann
cond NixDoc ann
trueBody NixDoc ann
falseBody ->
    Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
leastPrecedence (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$
      Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
group (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$
        Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 Doc ann
ifThenElse
   where
    ifThenElse :: Doc ann
    ifThenElse :: Doc ann
ifThenElse =
      [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
sep
        [         Doc ann
"if "   Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc NixDoc ann
cond
        , Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
align (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann
"then " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc NixDoc ann
trueBody
        , Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
align (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Doc ann
"else " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc NixDoc ann
falseBody
        ]
  NWith NixDoc ann
scope NixDoc ann
body ->
    Doc ann -> NixDoc ann -> NixDoc ann -> NixDoc ann
forall {ann}. Doc ann -> NixDoc ann -> NixDoc ann -> NixDoc ann
prettyAddScope Doc ann
"with " NixDoc ann
scope NixDoc ann
body
  NAssert NixDoc ann
cond NixDoc ann
body ->
    Doc ann -> NixDoc ann -> NixDoc ann -> NixDoc ann
forall {ann}. Doc ann -> NixDoc ann -> NixDoc ann -> NixDoc ann
prettyAddScope Doc ann
"assert " NixDoc ann
cond NixDoc ann
body
  NSynHole VarName
name -> Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
simpleExpr (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$ forall a ann. Pretty a => a -> Doc ann
pretty @Text (Text
"^" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> VarName -> Text
forall a b. Coercible a b => a -> b
coerce VarName
name)
 where
  prettyContainer :: Doc ann -> (a -> Doc ann) -> Doc ann -> [a] -> NixDoc ann
prettyContainer Doc ann
h a -> Doc ann
f Doc ann
t [a]
c =
    NixDoc ann -> ([a] -> NixDoc ann) -> [a] -> NixDoc ann
forall (t :: * -> *) b a. Foldable t => b -> (t a -> b) -> t a -> b
handlePresence
      (Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
simpleExpr (Doc ann
h Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
t))
      (NixDoc ann -> [a] -> NixDoc ann
forall a b. a -> b -> a
const (NixDoc ann -> [a] -> NixDoc ann)
-> NixDoc ann -> [a] -> NixDoc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
simpleExpr (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$ Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
group (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
nest Int
2 (Doc ann
h Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
forall ann. Doc ann
line Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep (a -> Doc ann
f (a -> Doc ann) -> [a] -> [Doc ann]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [a]
c)) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
forall ann. Doc ann
line Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
t)
      [a]
c

  prettyAddScope :: Doc ann -> NixDoc ann -> NixDoc ann -> NixDoc ann
prettyAddScope Doc ann
h NixDoc ann
c NixDoc ann
b =
    Doc ann -> NixDoc ann
forall ann. Doc ann -> NixDoc ann
leastPrecedence (Doc ann -> NixDoc ann) -> Doc ann -> NixDoc ann
forall a b. (a -> b) -> a -> b
$
      [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
vsep
        [Doc ann
h Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc NixDoc ann
c Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
";", Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann
align (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$ NixDoc ann -> Doc ann
forall ann. NixDoc ann -> Doc ann
getDoc NixDoc ann
b]


valueToExpr :: forall t f m . MonadDataContext f m => NValue t f m -> NExpr
valueToExpr :: forall t (f :: * -> *) (m :: * -> *).
MonadDataContext f m =>
NValue t f m -> NExpr
valueToExpr = NExpr -> (NValue' t f m NExpr -> NExpr) -> NValue t f m -> NExpr
forall (f :: * -> *) (m :: * -> *) r t.
MonadDataContext f m =>
r -> (NValue' t f m r -> r) -> NValue t f m -> r
iterNValueByDiscardWith NExpr
thk (NExprF NExpr -> NExpr
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NExprF NExpr -> NExpr)
-> (NValue' t f m NExpr -> NExprF NExpr)
-> NValue' t f m NExpr
-> NExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NValue' t f m NExpr -> NExprF NExpr
phi)
 where
  thk :: NExpr
thk = NExprF NExpr -> NExpr
forall (f :: * -> *). f (Fix f) -> Fix f
Fix (NExprF NExpr -> NExpr)
-> (VarName -> NExprF NExpr) -> VarName -> NExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VarName -> NExprF NExpr
forall r. VarName -> NExprF r
NSym (VarName -> NExpr) -> VarName -> NExpr
forall a b. (a -> b) -> a -> b
$ VarName
"<expr>"

  phi :: NValue' t f m NExpr -> NExprF NExpr
  phi :: NValue' t f m NExpr -> NExprF NExpr
phi (NVConstant' NAtom
a     ) = NAtom -> NExprF NExpr
forall r. NAtom -> NExprF r
NConstant NAtom
a
  phi (NVStr'      NixString
ns    ) = NString NExpr -> NExprF NExpr
forall r. NString r -> NExprF r
NStr (NString NExpr -> NExprF NExpr) -> NString NExpr -> NExprF NExpr
forall a b. (a -> b) -> a -> b
$ [Antiquoted Text NExpr] -> NString NExpr
forall r. [Antiquoted Text r] -> NString r
DoubleQuoted ([Antiquoted Text NExpr] -> NString NExpr)
-> [Antiquoted Text NExpr] -> NString NExpr
forall a b. (a -> b) -> a -> b
$ OneItem [Antiquoted Text NExpr] -> [Antiquoted Text NExpr]
forall x. One x => OneItem x -> x
one (OneItem [Antiquoted Text NExpr] -> [Antiquoted Text NExpr])
-> OneItem [Antiquoted Text NExpr] -> [Antiquoted Text NExpr]
forall a b. (a -> b) -> a -> b
$ Text -> Antiquoted Text NExpr
forall v r. v -> Antiquoted v r
Plain (Text -> Antiquoted Text NExpr) -> Text -> Antiquoted Text NExpr
forall a b. (a -> b) -> a -> b
$ NixString -> Text
ignoreContext NixString
ns
  phi (NVList'     [NExpr]
l     ) = [NExpr] -> NExprF NExpr
forall r. [r] -> NExprF r
NList [NExpr]
l
  phi (NVSet'      PositionSet
p    AttrSet NExpr
s) = Recursivity -> [Binding NExpr] -> NExprF NExpr
forall r. Recursivity -> [Binding r] -> NExprF r
NSet Recursivity
forall a. Monoid a => a
mempty
    [ NAttrPath NExpr -> NExpr -> NSourcePos -> Binding NExpr
forall r. NAttrPath r -> r -> NSourcePos -> Binding r
NamedVar (OneItem (NAttrPath NExpr) -> NAttrPath NExpr
forall x. One x => OneItem x -> x
one (OneItem (NAttrPath NExpr) -> NAttrPath NExpr)
-> OneItem (NAttrPath NExpr) -> NAttrPath NExpr
forall a b. (a -> b) -> a -> b
$ VarName -> NKeyName NExpr
forall r. VarName -> NKeyName r
StaticKey VarName
k) NExpr
v (NSourcePos -> Maybe NSourcePos -> NSourcePos
forall a. a -> Maybe a -> a
fromMaybe NSourcePos
nullPos (Maybe NSourcePos -> NSourcePos) -> Maybe NSourcePos -> NSourcePos
forall a b. (a -> b) -> a -> b
$ (VarName -> PositionSet -> Maybe NSourcePos
forall k v. (Eq k, Hashable k) => k -> HashMap k v -> Maybe v
`M.lookup` PositionSet
p) VarName
k)
    | (VarName
k, NExpr
v) <- AttrSet NExpr -> [(VarName, NExpr)]
forall k v. HashMap k v -> [(k, v)]
toList AttrSet NExpr
s
    ]
  phi (NVClosure'  Params ()
_    NValue t f m -> m NExpr
_) = VarName -> NExprF NExpr
forall r. VarName -> NExprF r
NSym VarName
"<closure>"
  phi (NVPath'     Path
p     ) = Path -> NExprF NExpr
forall r. Path -> NExprF r
NLiteralPath Path
p
  phi (NVBuiltin'  VarName
name NValue t f m -> m NExpr
_) = VarName -> NExprF NExpr
forall r. VarName -> NExprF r
NSym (VarName -> NExprF NExpr) -> VarName -> NExprF NExpr
forall a b. (a -> b) -> a -> b
$ (Text -> Text) -> VarName -> VarName
forall a b. Coercible a b => a -> b
coerce ((forall a. Monoid a => a -> a -> a
mappend @Text) Text
"builtins.") VarName
name

prettyNValue
  :: forall t f m ann . MonadDataContext f m => NValue t f m -> Doc ann
prettyNValue :: forall t (f :: * -> *) (m :: * -> *) ann.
MonadDataContext f m =>
NValue t f m -> Doc ann
prettyNValue = NExpr -> Doc ann
forall ann. NExpr -> Doc ann
prettyNix (NExpr -> Doc ann)
-> (NValue t f m -> NExpr) -> NValue t f m -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NValue t f m -> NExpr
forall t (f :: * -> *) (m :: * -> *).
MonadDataContext f m =>
NValue t f m -> NExpr
valueToExpr

-- | 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".
data ValueOrigin = WasThunk | Value
 deriving ValueOrigin -> ValueOrigin -> Bool
(ValueOrigin -> ValueOrigin -> Bool)
-> (ValueOrigin -> ValueOrigin -> Bool) -> Eq ValueOrigin
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ValueOrigin -> ValueOrigin -> Bool
== :: ValueOrigin -> ValueOrigin -> Bool
$c/= :: ValueOrigin -> ValueOrigin -> Bool
/= :: ValueOrigin -> ValueOrigin -> Bool
Eq

prettyProv
  :: 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
prettyProv :: 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 -> NValue t f m -> Doc ann
prettyProv ValueOrigin
wasThunk NValue t f m
v =
  (Doc ann -> Doc ann)
-> ([Provenance m (NValue t f m)] -> Doc ann -> Doc ann)
-> [Provenance m (NValue t f m)]
-> Doc ann
-> Doc ann
forall (t :: * -> *) b a. Foldable t => b -> (t a -> b) -> t a -> b
handlePresence
    Doc ann -> Doc ann
forall a. a -> a
id
    (\ [Provenance m (NValue t f m)]
ps Doc ann
pv ->
      [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
fillSep
        [ Doc ann
pv
        , Int -> Doc ann -> Doc ann
forall ann. Int -> Doc ann -> Doc ann
indent Int
2 (Doc ann -> Doc ann) -> Doc ann -> Doc ann
forall a b. (a -> b) -> a -> b
$
          Doc ann
"(" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> (Doc ann
"thunk " Doc ann -> Bool -> Doc ann
forall a. Monoid a => a -> Bool -> a
`whenTrue` (ValueOrigin
wasThunk ValueOrigin -> ValueOrigin -> Bool
forall a. Eq a => a -> a -> Bool
== ValueOrigin
WasThunk) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
"from: " Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> [Provenance m (NValue t f m)] -> Doc ann
forall t (f :: * -> *) (m :: * -> *) ann.
HasCitations1 m (NValue t f m) f =>
[Provenance m (NValue t f m)] -> Doc ann
prettyExtractFromProvenance [Provenance m (NValue t f m)]
ps) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Doc ann
")"
        ]
    )
    (forall (m :: * -> *) v a.
HasCitations m v a =>
a -> [Provenance m v]
citations @m @(NValue t f m) NValue t f m
v)
    (NValue t f m -> Doc ann
forall t (f :: * -> *) (m :: * -> *) ann.
MonadDataContext f m =>
NValue t f m -> Doc ann
prettyNValue NValue t f m
v)

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
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
prettyNValueProv =
  ValueOrigin -> NValue t f m -> Doc ann
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 -> NValue t f m -> Doc ann
prettyProv ValueOrigin
Value

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)
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)
prettyNThunk t
t =
  ValueOrigin -> NValue t f m -> Doc ann
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 -> NValue t f m -> Doc ann
prettyProv ValueOrigin
WasThunk (NValue t f m -> Doc ann) -> m (NValue t f m) -> m (Doc ann)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> t -> m (NValue t f m)
forall t (m :: * -> *) (f :: * -> *).
(MonadThunk t m (NValue t f m), MonadDataContext f m) =>
t -> m (NValue t f m)
dethunk t
t

-- | This function is used only by the testing code.
printNix :: forall t f m . MonadDataContext f m => NValue t f m -> Text
printNix :: forall t (f :: * -> *) (m :: * -> *).
MonadDataContext f m =>
NValue t f m -> Text
printNix =
  Text -> (NValue' t f m Text -> Text) -> NValue t f m -> Text
forall (f :: * -> *) (m :: * -> *) r t.
MonadDataContext f m =>
r -> (NValue' t f m r -> r) -> NValue t f m -> r
iterNValueByDiscardWith Text
thunkStubText NValue' t f m Text -> Text
phi
 where
  phi :: NValue' t f m Text -> Text
  phi :: NValue' t f m Text -> Text
phi (NVConstant' NAtom
a ) = NAtom -> Text
atomText NAtom
a
  phi (NVStr'      NixString
ns) = Text
"\"" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> Text
escapeString (NixString -> Text
ignoreContext NixString
ns) Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"\""
  phi (NVList'     [Text]
l ) = Text
"[ " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> [Text] -> Text
forall t. IsText t "unwords" => [t] -> t
unwords [Text]
l Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" ]"
  phi (NVSet' PositionSet
_ AttrSet Text
s) =
    Text
"{ " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
      [Text] -> Text
forall m. Monoid m => [m] -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold
        [ Text -> Text
check Text
k Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
" = " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
v Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"; "
        | (VarName -> Text
forall a b. Coercible a b => a -> b
coerce -> Text
k, Text
v) <- [(VarName, Text)] -> [(VarName, Text)]
forall a. Ord a => [a] -> [a]
sort ([(VarName, Text)] -> [(VarName, Text)])
-> [(VarName, Text)] -> [(VarName, Text)]
forall a b. (a -> b) -> a -> b
$ AttrSet Text -> [(VarName, Text)]
forall k v. HashMap k v -> [(k, v)]
toList AttrSet Text
s
        ] Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"}"
   where
    check :: Text -> Text
    check :: Text -> Text
check Text
v =
      Text -> Maybe Text -> Text
forall a. a -> Maybe a -> a
fromMaybe
        Text
v
        (forall a. (Read a, Show a) => Maybe Text
tryRead @Int Maybe Text -> Maybe Text -> Maybe Text
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> forall a. (Read a, Show a) => Maybe Text
tryRead @Float)
     where
      tryRead :: forall a . (Read a, Show a) => Maybe Text
      tryRead :: forall a. (Read a, Show a) => Maybe Text
tryRead = (a -> Text) -> Maybe a -> Maybe Text
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((\ Text
s -> Text
"\"" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
s Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
"\"") (Text -> Text) -> (a -> Text) -> a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Text
forall b a. (Show a, IsString b) => a -> b
show) (Maybe a -> Maybe Text) -> Maybe a -> Maybe Text
forall a b. (a -> b) -> a -> b
$ forall a. Read a => String -> Maybe a
readMaybe @a (String -> Maybe a) -> String -> Maybe a
forall a b. (a -> b) -> a -> b
$ Text -> String
forall a. ToString a => a -> String
toString Text
v
  phi NVClosure'{}        = Text
"<<lambda>>"
  phi (NVPath' Path
fp       ) = String -> Text
forall a. IsString a => String -> a
fromString (String -> Text) -> String -> Text
forall a b. (a -> b) -> a -> b
$ Path -> String
forall a b. Coercible a b => a -> b
coerce Path
fp
  phi (NVBuiltin' VarName
name NValue t f m -> m Text
_) = Text
"<<builtin " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> VarName -> Text
forall a b. Coercible a b => a -> b
coerce VarName
name Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
">>"