Nix Language Quirks - Revision history

DoggoBit: propose merge

2025-06-14T23:14:43Z

propose merge

← Older revision		Revision as of 23:14, 14 June 2025
Line 1:		Line 1:
	{{merge\|Nix ~~Expression Language\|same type of information in the expression~~ language ~~article~~}}		{{merge\|Nix (language)}}

	== <code>with</code> and <code>let</code> ==		== <code>with</code> and <code>let</code> ==

Fidgetingbits: Some formatting changes and link to a separate quirk list

2024-12-15T04:37:38Z

Some formatting changes and link to a separate quirk list

← Older revision		Revision as of 04:37, 15 December 2024
Line 36:		Line 36:
	Note, that it isn't equivalent to <code>with rec { x = 1; y = x + 1; body = y; }; body</code> because of mentioned <code>with</code> and <code>let</code> quirk, but is same as <code>rec { x = 1; y = x + 1; body = y; }.body</code>		Note, that it isn't equivalent to <code>with rec { x = 1; y = x + 1; body = y; }; body</code> because of mentioned <code>with</code> and <code>let</code> quirk, but is same as <code>rec { x = 1; y = x + 1; body = y; }.body</code>

	== Default values are not bound in @ syntax ==		== Default values are not bound in <code>@</code> syntax ==

	Destructured arguments can have default values, but those default values are part of the full function argument.		Destructured arguments can have default values, but those default values are part of the full function argument.
Line 87:		Line 87:
	consider the use of <code>import</code> here similar to using <code>qualified import ...</code> in Haskell or <code>import ...</code> in Python. Another (discouraged and increasingly uncommon) way of importing is [https://nix.dev/manual/nix/2.24/language/syntax#with-expressions <code>with import ...;</code>], which corresponds to Python <code>from ... import *</code>. This use of <code>with</code> imports everything from the target into scope, which has numerous potential gotchas and problems, and so using [https://nix.dev/guides/best-practices#with-scopes <code>inherit</code>] instead is encouraged and preferred.		consider the use of <code>import</code> here similar to using <code>qualified import ...</code> in Haskell or <code>import ...</code> in Python. Another (discouraged and increasingly uncommon) way of importing is [https://nix.dev/manual/nix/2.24/language/syntax#with-expressions <code>with import ...;</code>], which corresponds to Python <code>from ... import *</code>. This use of <code>with</code> imports everything from the target into scope, which has numerous potential gotchas and problems, and so using [https://nix.dev/guides/best-practices#with-scopes <code>inherit</code>] instead is encouraged and preferred.

	== builtins.replaceStrings key match on "" ==		== <code>builtins.replaceStrings</code> key match on "" ==

	Syntax:		Syntax:
Line 247:		Line 247:
	There is an example in <code>coq</code> package code [https://github.com/NixOS/nixpkgs/blob/5185539c51ba658e70b29e01c0c320a85f4e2098/pkgs/build-support/coq/extra-lib.nix#L98 here] where someone used this behavior to build a reusable function <code>switch</code>.		There is an example in <code>coq</code> package code [https://github.com/NixOS/nixpkgs/blob/5185539c51ba658e70b29e01c0c320a85f4e2098/pkgs/build-support/coq/extra-lib.nix#L98 here] where someone used this behavior to build a reusable function <code>switch</code>.

	== builtins.toString true and false ~~handling are~~ inconsistent ==		== <code>builtins.toString</code> handling of <code>true</code> and <code>false</code> is inconsistent ==

	<syntaxHighlight lang=nix>		<syntaxHighlight lang=nix>
Line 290:		Line 290:
	nix-repl> let code = "(x: x) ''id function was called''"; in import (builtins.toFile "eval" code)		nix-repl> let code = "(x: x) ''id function was called''"; in import (builtins.toFile "eval" code)
	"id function was called"</syntaxHighlight>		"id function was called"</syntaxHighlight>

			= Resources =

			* [https://md.darmstadt.ccc.de/xtNP7JuIQ5iNW1FjuhUccw# A separately maintained list of Nix language quirks]

	[[Category:Nix Language]]		[[Category:Nix Language]]

Fidgetingbits: Add quirk related to builtins.toString handling of true vs false

2024-12-15T04:32:19Z

Add quirk related to builtins.toString handling of true vs false

← Older revision		Revision as of 04:32, 15 December 2024
Line 246:		Line 246:

	There is an example in <code>coq</code> package code [https://github.com/NixOS/nixpkgs/blob/5185539c51ba658e70b29e01c0c320a85f4e2098/pkgs/build-support/coq/extra-lib.nix#L98 here] where someone used this behavior to build a reusable function <code>switch</code>.		There is an example in <code>coq</code> package code [https://github.com/NixOS/nixpkgs/blob/5185539c51ba658e70b29e01c0c320a85f4e2098/pkgs/build-support/coq/extra-lib.nix#L98 here] where someone used this behavior to build a reusable function <code>switch</code>.

			== builtins.toString true and false handling are inconsistent ==

			<syntaxHighlight lang=nix>
			nix-repl> builtins.toString true
			"1"

			nix-repl> builtins.toString false
			""
			</syntaxHighlight>

	== Nix Language FAQ ==		== Nix Language FAQ ==

Fidgetingbits: /* Mimicking case statements with attribute sets */ remove typo from example

2024-10-22T02:02:13Z

Mimicking case statements with attribute sets: remove typo from example

← Older revision		Revision as of 02:02, 22 October 2024
Line 228:		Line 228:
	"b" = "hi";		"b" = "hi";
	"c" = "ciao";		"c" = "ciao";
	}." ${x}";		}."${x}";
	</syntaxHighlight>		</syntaxHighlight>

Fidgetingbits: /* Imports and namespaces */ grammar

2024-10-22T01:16:01Z

Imports and namespaces: grammar

← Older revision		Revision as of 01:16, 22 October 2024
Line 85:		Line 85:
	pkgs.runCommand (lib.strings.removePrefix ".... </syntaxHighlight>		pkgs.runCommand (lib.strings.removePrefix ".... </syntaxHighlight>

	consider the use of <code>import</code> here similar to using <code>qualified import ...</code> in Haskell or <code>import ...</code> in Python. Another (discouraged and increasingly uncommon) way of importing is [https://nix.dev/manual/nix/2.24/language/syntax#with-expressions <code>with import ...;</code>], which corresponds to Python <code>from ... import *</code>. This use of <code>with</code> imports everything from the target into scope, which has numerous potential gotchas and problems, and so ~~instead~~ using [https://nix.dev/guides/best-practices#with-scopes <code>inherit</code>] is encouraged and preferred.		consider the use of <code>import</code> here similar to using <code>qualified import ...</code> in Haskell or <code>import ...</code> in Python. Another (discouraged and increasingly uncommon) way of importing is [https://nix.dev/manual/nix/2.24/language/syntax#with-expressions <code>with import ...;</code>], which corresponds to Python <code>from ... import *</code>. This use of <code>with</code> imports everything from the target into scope, which has numerous potential gotchas and problems, and so using [https://nix.dev/guides/best-practices#with-scopes <code>inherit</code>] instead is encouraged and preferred.

	== builtins.replaceStrings key match on "" ==		== builtins.replaceStrings key match on "" ==

Fidgetingbits: Add case statement example

2024-10-22T01:14:53Z

Add case statement example

← Older revision		Revision as of 01:14, 22 October 2024
Line 216:		Line 216:
	9		9
	</syntaxHighlight>		</syntaxHighlight>

			== Mimicking case statements with attribute sets ==

			Nix doesn't include native support for case statements, however when dealing with string types it's possible to use some string interpolation behavior to achieve something similar to case statement behavior, as described in this [https://discourse.nixos.org/t/case-statement-expr/27741/12 thread].

			In the example from the thread, given some string argument <code>x</code>, the following code would place different values into a text file depending on it's value:

			<syntaxHighlight lang=nix>
			environment.etc."just/for/test".text = {
			"a" = "hello";
			"b" = "hi";
			"c" = "ciao";
			}." ${x}";
			</syntaxHighlight>

			So if <code>x</code> is set to the string <code>"a"</code> then the <code>just/for/test</code> file contents would be set to the string <code>"hello"</code>. The code above is the same in behavior to the following, more common, if-else-style construct:

			<syntaxHighlight lang=nix>
			environment.etc."just/for/test".text =
			if x == "a" then
			"hello"
			else if x == "b" then
			"hi"
			else if x == "c" then
			"ciao"
			else
			abort "x is invalid";
			</syntaxHighlight>

			There is an example in <code>coq</code> package code [https://github.com/NixOS/nixpkgs/blob/5185539c51ba658e70b29e01c0c320a85f4e2098/pkgs/build-support/coq/extra-lib.nix#L98 here] where someone used this behavior to build a reusable function <code>switch</code>.

	== Nix Language FAQ ==		== Nix Language FAQ ==

Fidgetingbits: Add example of using fromTOML for parsing hex/octal/binary number formats

2024-10-22T00:48:30Z

Add example of using fromTOML for parsing hex/octal/binary number formats

@@ Line 200: / Line 200: @@
 <syntaxHighlight lang=nix>
 { a = "b"; } // (if true then { foo = "bar"; } else { } )
 </syntaxHighlight>

Fidgetingbits: /* Imports and namespaces */ Reword and link to relevant with/import links. Also removed the last part about let binding inherit priority and different "types" of inherit, because it was completely wrong/misleading afaik

2024-10-22T00:35:11Z

Imports and namespaces: Reword and link to relevant with/import links. Also removed the last part about let binding inherit priority and different "types" of inherit, because it was completely wrong/misleading afaik

@@ Line 75: / Line 75: @@
 == Imports and namespaces ==
-There is a keyword <code>import</code>, but it's equivalent in other languages is  <code>eval</code>. It can be used for namespacing too:
+Nix includes a keyword <code>import</code>, but it's equivalent in other languages is <code>eval</code>.
   <syntaxHighlight lang=nix>let
@@ Line 83: / Line 85: @@
    pkgs.runCommand (lib.strings.removePrefix ".... </syntaxHighlight>
-consider using <code>import</code> here as using <code>qualified import ...</code> in Haskell or <code>import ...</code> in Python.
+consider the use of <code>import</code> here similar to using <code>qualified import ...</code> in Haskell or <code>import ...</code> in Python. Another (discouraged and increasingly uncommon) way of importing is [https://nix.dev/manual/nix/2.24/language/syntax#with-expressions <code>with import ...;</code>], which corresponds to Python <code>from ... import *</code>. This use of <code>with</code> imports everything from the target into scope, which has numerous potential gotchas and problems, and so instead using [https://nix.dev/guides/best-practices#with-scopes <code>inherit</code>] is encouraged and preferred.
 == builtins.replaceStrings key match on "" ==

Fidgetingbits: /* Indented strings trim leading whitespace */ Remove unnecessary sentence and clarify wording

2024-10-20T08:39:00Z

Indented strings trim leading whitespace: Remove unnecessary sentence and clarify wording

← Older revision		Revision as of 08:39, 20 October 2024
Line 125:		Line 125:
	== Indented strings trim leading whitespace ==		== Indented strings trim leading whitespace ==

	~~Not really surprising, but ...~~		Leading spaces are removed from both single-line and multi-line <strong>indented strings</strong>.

	Leading spaces are removed ~~also in~~ single-line <strong>indented strings</strong>.

	<syntaxHighlight lang=nix>		<syntaxHighlight lang=nix>

Fidgetingbits: /* Old let syntax */ add link to 2017 thread mentioning old syntax

2024-10-20T08:35:20Z

Old let syntax: add link to 2017 thread mentioning old syntax

← Older revision		Revision as of 08:35, 20 October 2024
Line 28:		Line 28:
	== Old <code>let</code> syntax ==		== Old <code>let</code> syntax ==

	This is an old Nix syntax, that probably isn't used much		This is an [https://github.com/NixOS/nix/issues/1361#issuecomment-323050690 old] Nix syntax, that probably isn't used much
	<syntaxHighlight lang=nix>		<syntaxHighlight lang=nix>
	nix-repl> let { x = 1; y = x + 1; body = y; }		nix-repl> let { x = 1; y = x + 1; body = y; }