Nix.Expr.Shorthands

Put NAtom as expression

Put null.

Put boolean.

Put integer.

Put floating point number.

Put a regular (double-quoted) string.

Put an indented string.

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

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

Put a path which references a relative path.

Put a variable (symbol).

Put syntactic hole.

Put a binary operator. @since

Put an unary operator.

Logical negation: not.

Number negation: -.

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

Put a binary operator. @since 0.15.0

Args:

1. Maybe name:

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

2. key:expr pairs

3. Is variadic or not:

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

Put a non-recursive set.

{ .. }

General set builder function.

Empty set.

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

Put a list.

Wrap in a let.

(Evaluate the second argument after introducing the bindings.)

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

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

Put:

if expr1
  then expr2
  else expr3

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

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

An inherit clause with an expression to pull from.

An inherit clause without an expression to pull from.

Nix = (bind operator).

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

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`.

Applies a transformation to the body of a Nix function.

A let statement with multiple assignments.

Wrapper for a single-variable let.

Make a non-recursive attribute set.

Make a recursive attribute set.

Dot-reference into an attribute set: attrSet.k

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

s.x or y

Function application (' ' in f x)

List concatenation: ++

Multiplication: *

Division: /

Addition: +

Subtraction: -

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

Greater than: >

Greater than OR equal: >=

Less than OR equal: <=

Less than: <

Equality: ==

Inequality: !=

AND: &&

OR: ||

Logical implication: ->

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

Deprecated: Please, use mkOp Put an unary operator.

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

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

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