Nix.Expr.Shorthands

Shorthands for making Nix expressions.

Functions with an F suffix return a more general type (base functor F a) without the outer Fix wrapper that creates a.

Basic expression builders

mkConst :: NAtom -> NExpr

Put NAtom as expression

mkNull :: NExpr

Put null.

mkBool :: Bool -> NExpr

Put boolean.

mkInt :: Integer -> NExpr

Put integer.

mkFloat :: Float -> NExpr

Put floating point number.

mkStr :: Text -> NExpr

Put a regular (double-quoted) string.

mkIndentedStr :: Int -> Text -> NExpr

Put an indented string.

mkPath :: Bool -> FilePath -> NExpr

Put a path. Use True if the path should be read from the environment, else use False.

mkEnvPath :: FilePath -> NExpr

Put a path expression which pulls from the NIX_PATH env variable.

mkRelPath :: FilePath -> NExpr

Put a path which references a relative path.

mkSym :: Text -> NExpr

Put a variable (symbol).

mkSynHole :: Text -> NExpr

Put syntactic hole.

mkSelector :: Text -> NAttrPath NExpr

mkOp :: NUnaryOp -> NExpr -> NExpr

Put an unary operator. @since 0.15.0

mkNot :: NExpr -> NExpr

Logical negation: not.

mkNeg :: NExpr -> NExpr

Number negation: -.

Negation in the language works with integers and floating point. @since 0.15.0

mkOp2 :: NBinaryOp -> NExpr -> NExpr -> NExpr

Put a binary operator. @since 0.15.0

mkParamSet :: [(Text, Maybe NExpr)] -> Params NExpr

{ x }

Since: 0.15.0

mkVariadicParamSet :: [(Text, Maybe NExpr)] -> Params NExpr

{ x, ... }

Since: 0.15.0

mkNamedParamSet :: Text -> [(Text, Maybe NExpr)] -> Params NExpr

s@{ x }

Since: 0.15.0

mkNamedVariadicParamSet :: Text -> [(Text, Maybe NExpr)] -> Params NExpr

s@{ x, ... }

Since: 0.15.0

mkGeneralParamSet :: Maybe Text -> [(Text, Maybe NExpr)] -> Bool -> Params NExpr

Args:

1. Maybe name:

Nothing  ->   {}
Just "s" -> s@{}

1. key:expr pairs
2. Is variadic or not:

True  -> {...}
False -> {}

Since: 0.15.0

mkRecSet :: [Binding NExpr] -> NExpr

rec { .. }

mkNonRecSet :: [Binding NExpr] -> NExpr

Put a non-recursive set.

{ .. }

mkSet :: Recursivity -> [Binding NExpr] -> NExpr

General set builder function.

emptySet :: NExpr

Empty set.

Monoid. Use // operation (shorthand $//) to extend the set. @since 0.15.0

mkList :: [NExpr] -> NExpr

Put a list.

emptyList :: NExpr

mkLets :: [Binding NExpr] -> NExpr -> NExpr

Wrap in a let.

(Evaluate the second argument after introducing the bindings.)

Haskell	Nix
mkLets bindings expr	let bindings; in expr

mkWith :: NExpr -> NExpr -> NExpr

Create a whith: 1st expr - what to bring into the scope. 2nd - expression that recieves the scope extention.

Haskell	Nix
mkWith body main	with body; expr

mkAssert :: NExpr -> NExpr -> NExpr

Create an assert: 1st expr - asserting itself, must return true. 2nd - main expression to evaluated after assertion.

Haskell	Nix
mkAssert check eval	assert check; eval

mkIf :: NExpr -> NExpr -> NExpr -> NExpr

Put:

if expr1
  then expr2
  else expr3

mkFunction :: Params NExpr -> NExpr -> NExpr

Lambda function, analog of Haskell's \ x -> x:

Haskell	Nix
mkFunction x expr	x: expr

getRefOrDefault :: Maybe NExpr -> NExpr -> Text -> NExpr

General dot-reference with optional alternative if the jey does not exist. @since 0.15.0

Base functor builders for basic expressions builders *sic

mkNullF :: NExprF a

Unfixed mkNull.

mkBoolF :: Bool -> NExprF a

Unfixed mkBool.

mkIntF :: Integer -> NExprF a

Unfixed mkInt.

mkFloatF :: Float -> NExprF a

Unfixed mkFloat.

mkPathF :: Bool -> FilePath -> NExprF a

Unfixed mkPath.

mkEnvPathF :: FilePath -> NExprF a

Unfixed mkEnvPath.

mkRelPathF :: FilePath -> NExprF a

Unfixed mkRelPath.

mkSymF :: Text -> NExprF a

Unfixed mkSym.

mkSynHoleF :: Text -> NExprF a

Unfixed mkSynHole.

Other

inheritFrom :: e -> [VarName] -> Binding e

An inherit clause with an expression to pull from.

Hask	Nix	pseudocode
inheritFrom x [a, b]	inherit (x) a b;	a = x.a; b = x.b;

inherit :: [VarName] -> Binding e

An inherit clause without an expression to pull from.

Hask	Nix	pseudocode
inheritFrom [a, b]	inherit a b;	a = outside.a; b = outside.b;

($=) :: Text -> NExpr -> Binding NExpr infixr 2

Nix = (bind operator).

bindTo :: Text -> NExpr -> Binding NExpr

Shorthand for producing a binding of a name to an expression: Nix's =.

appendBindings :: [Binding NExpr] -> NExpr -> NExpr

Append a list of bindings to a set or let expression. For example: adding `[a = 1, b = 2]` to `let c = 3; in 4` produces `let a = 1; b = 2; c = 3; in 4`.

modifyFunctionBody :: (NExpr -> NExpr) -> NExpr -> NExpr

Applies a transformation to the body of a Nix function.

letsE :: [(Text, NExpr)] -> NExpr -> NExpr

A let statement with multiple assignments.

letE :: Text -> NExpr -> NExpr -> NExpr

Wrapper for a single-variable let.

attrsE :: [(Text, NExpr)] -> NExpr

Make a non-recursive attribute set.

recAttrsE :: [(Text, NExpr)] -> NExpr

Make a recursive attribute set.

Nix binary operators

(@@) :: NExpr -> NExpr -> NExpr infixl 8

Function application (' ' in f x)

($==) :: NExpr -> NExpr -> NExpr infix 3

Equality: ==

($!=) :: NExpr -> NExpr -> NExpr infix 3

Inequality: !=

($<) :: NExpr -> NExpr -> NExpr infix 4

Less than: <

($<=) :: NExpr -> NExpr -> NExpr infix 4

Less than OR equal: <=

($>) :: NExpr -> NExpr -> NExpr infix 4

Greater than: >

($>=) :: NExpr -> NExpr -> NExpr infix 4

Greater than OR equal: >=

($&&) :: NExpr -> NExpr -> NExpr infixl 2

AND: &&

($||) :: NExpr -> NExpr -> NExpr infixl 2

OR: ||

($->) :: NExpr -> NExpr -> NExpr infix 1

Logical implication: ->

($//) :: NExpr -> NExpr -> NExpr infixr 5

Extendoverride the left attr set, with the right one: @/@

($+) :: NExpr -> NExpr -> NExpr infixl 5

Addition: +

($-) :: NExpr -> NExpr -> NExpr infixl 5

Subtraction: -

($*) :: NExpr -> NExpr -> NExpr infixl 6

Multiplication: *

($/) :: NExpr -> NExpr -> NExpr infixl 6

Division: /

($++) :: NExpr -> NExpr -> NExpr infixr 7

List concatenation: ++

(@.) :: NExpr -> Text -> NExpr infix 9

Dot-reference into an attribute set: attrSet.k

(@.<|>) :: NExpr -> Text -> NExpr -> NExpr infix 9

Dot-reference into an attribute set with alternative if the key does not exist.

s.x or y

Since: 0.15.0

(==>) :: Params NExpr -> NExpr -> NExpr infixr 1

Lambda function, analog of Haskell's \ x -> x:

Haskell	Nix
x ==> expr	x: expr

Under deprecation

mkOper :: NUnaryOp -> NExpr -> NExpr

Deprecated: Please, use mkOp Put an unary operator.

mkOper2 :: NBinaryOp -> NExpr -> NExpr -> NExpr

Deprecated: Please, use mkOp2 | Put a binary operator.

mkBinop :: NBinaryOp -> NExpr -> NExpr -> NExpr

Deprecated: Please, use mkOp2 | Nix binary operator builder.

mkParamset :: [(Text, Maybe NExpr)] -> Bool -> Params NExpr

Deprecated: Please, use: * mkParamSet is for closed sets; * mkVariadicSet is for variadic; * mkGeneralParamSet a general constructor.