tvl-depot/tests/lang/eval-okay-xml.nix

rec {

  x = 123;

  a = "foo";

  b = "bar";

  c = "foo" + "bar";

  f = {z, x, y}: if y then x else z;

  id = x: x;

  at = args@{x, y, z}: x;

  ellipsis = {x, y, z, ...}: x;

}
* Test for `nix-instantiate --eval-only --xml'. 2006-08-17 13:28:29 +02:00			`rec {`

			`x = 123;`

			`a = "foo";`

			`b = "bar";`

			`c = "foo" + "bar";`

* Removed the "valid values" feature. Nobody uses it anyway. 2008-08-11 15:36:40 +02:00			`f = {z, x, y}: if y then x else z;`
* Test for `nix-instantiate --eval-only --xml'. 2006-08-17 13:28:29 +02:00
* Refactoring: combine functions that take an attribute set and functions that take a single argument (plain lambdas) into one AST node (Function) that contains a Pattern node describing the arguments. Current patterns are single lazy arguments (VarPat) and matching against an attribute set (AttrsPat). This refactoring allows other kinds of patterns to be added easily, such as Haskell-style @-patterns, or list pattern matching. 2008-08-14 12:04:22 +02:00			`id = x: x;`

* @-patterns as in Haskell. For instance, in a function definition f = args @ {x, y, z}: ...; `args' refers to the argument as a whole, which is further pattern-matched against the attribute set pattern {x, y, z}. 2008-08-14 14:53:29 +02:00			`at = args@{x, y, z}: x;`

* Added an experimental feature suggested by Andres: ellipses ("...") in attribute set pattern matches. This allows defining a function that takes at least the listed attributes, while ignoring additional attributes. For instance, {stdenv, fetchurl, fuse, ...}: stdenv.mkDerivation { ... }; defines a function that requires an attribute set that contains the specified attributes but ignores others. The main advantage is that we can then write in all-packages.nix aefs = import ../bla/aefs pkgs; instead of aefs = import ../bla/aefs { inherit stdenv fetchurl fuse; }; This saves a lot of typing (not to mention not having to update all-packages.nix with purely mechanical changes). It saves as much typing as the "args: with args;" style, but has the advantage that the function arguments are properly declared (not implicit in what the body of the "with" uses). 2008-08-14 16:00:44 +02:00			`ellipsis = {x, y, z, ...}: x;`

* Refactoring: combine functions that take an attribute set and functions that take a single argument (plain lambdas) into one AST node (Function) that contains a Pattern node describing the arguments. Current patterns are single lazy arguments (VarPat) and matching against an attribute set (AttrsPat). This refactoring allows other kinds of patterns to be added easily, such as Haskell-style @-patterns, or list pattern matching. 2008-08-14 12:04:22 +02:00			`}`