{ description = "Nix builtins/intrinsics."; inputs = {}; # No Inputs! outputs = { ... }: let # Cannot use import, because import is itself an intrinsic function. lib = { #! Abort Nix expression evaluation and print the error message. abort#: string -> ! = builtins.abort; #! Return the sum of two numbers. add#: number -> number -> number = builtins.add or (p: q: p + q); #! TODO: Documentation addErrorContext#: T -> T = builtins.addErrorContext; #! Return `true` if the function returns `true` for all elements of the list, and `false` otherwise. all#: (T -> bool) -> [ T ] -> bool = builtins.all; #! Return `true` if the function returns `true` for at least one element of the list, and `false` otherwise. any#: (T -> bool) -> [ T ] -> bool = builtins.any; #! TODO: Documentation appendContext#: T -> T = builtins.appendContext; #! Return the names of the attributes in the set in an alphabetically sorted list. #! For instance, `attrNames { y = 1; x = "foo"; }` evaluates to `[ "x" "y" ]`. attrNames#: { string -> T } -> [ string ] = builtins.attrNames; #! Return the values of the attributes in the set in the order corresponding to the sorted attribute names. attrValues#: { string -> T } -> [ T ] = builtins.attrValues; #! Return the base name of an expression that can be coerced to a string. #! That is, everything following the final slash in the string, or the full string, if no slash is present. #! This is similar to the GNU basename command. baseNameOf#: ToString -> string = builtins.baseNameOf; #! Return the bitwise conjunction of two integers. bitAnd#: integer -> integer -> integer = builtins.bitAnd; #! Return the bitwise disjunction of two integers. bitOr#: integer -> integer -> integer = builtins.bitOr; #! Return the bitwise exclusive disjunction of two integers. bitXor#: integer -> integer -> integer = builtins.bitXor; #! In debug mode (enabled using `--debugger`), #! pause Nix expression evaluation and enter the REPL. #! Otherwise, return the argument `v`. break#: T -> T = builtins.break or (x: x); #! Collect each attribute named attr from a list of attribute sets. #! Attrsets that do not contain the named attribute are ignored. #! For example, #! ``` #! catAttrs "a" [{a = 1;} {b = 0;} {a = 2;}] #! ``` #! evaluates to `[1 2]`. catAttrs#: string -> [ { string -> T } ] -> [ T ] = builtins.catAttrs; #! Converts an IEEE-754 double-precision floating-point number (double) to the next higher integer. #! If the datatype is neither an `integer` nor a `float`, an evaluation error will be thrown. ceil#: integer | float -> integer = builtins.ceil; #! Compare two strings representing versions and return #! * `-1` if the first version is older than the second version, #! * `0` if they are the same, and #! * `1` if the first is newer than the second. #! The version comparison algorithm is the same #! as the one used by `nix-env -u ../command-ref/nix-env.md#operation---upgrade`. compareVersions#: string -> string -> integer = builtins.compareVersions; #! Concatenate a list of lists into a single list. concatLists#: [ [ T ] ] -> [ T ] = builtins.concatLists; #! This function is equivalent to `f: list: concatLists (map f list)` but is more efficient. concatMap#: (T -> U) -> [ T ] -> U = builtins.concatMap; #! Concatenate a list of strings with a separator between each element, #! e.g. `concatStringsSep "/" ["usr" "local" "bin"]` returns `"usr/local/bin"`. concatStringsSep#: string -> [ string ] -> string = builtins.concatStringsSep; #! This is like `seq e1 e2`, except that `e1` is evaluated deeply: #! if it is a `list` or `set`, its elements or attributes are also evaluated recursively. deepSeq#: T -> T = builtins.deepSeq; #! TODO: Documentation derivation#: = builtins.derivation; #! Construct (as a unobservable side effect) a Nix derivation expression #! that performs the derivation described by the argument set. #! Returns the original set extended with the following attributes: #! * `outPath' containing the primary output path of the derivation; #! * `drvPath' containing the path of the Nix expression; and #! * `type' set to `derivation' to indicate that this is a derivation. derivationStrict#: T -> T = builtins.derivationStrict; #! Return the base name of an expression that can be coerced to a string. #! That is, everything before the final slash in the string. #! This is similar to the GNU `dirname` command. dirOf#: T -> T = builtins.dirOf; #! Return the quotient of the numbers e1 and e2. div#: number -> number -> number = builtins.div or (p: q: p / q); #! Return true if a given value occurs in the list, and false otherwise. elem#: T -> [ T ] -> bool = builtins.elem; #! Return element by index from the list. #! Elements are counted starting from 0. #! A fatal error occurs if the index is out of bounds. elemAt#: [ T ] -> integer -> T | ! = builtins.elemAt; #! Contradiction false#: bool = builtins.false or (1 != 1); /*#! TODO: Documentation fetchClojure = builtins.fetchClojure or (builtins.throw "Not available yet");*/ #! Fetch a path from git. #! Arguments can be a URL, in which case the HEAD of the repo at that URL is fetched. #! Otherwise, it can be an attribute with the following attributes (all except url optional): #! *[url] The URL of the repo. #! *[name] The name of the directory the repo should be exported to in the store. #! Defaults to the basename of the URL. #! *[rev] The git revision to fetch. #! Defaults to the tip of ref. #! *[ref] The git ref to look for the requested revision under. #! This is often a branch or tag name. Defaults to HEAD. #! By default, the ref value is prefixed with refs/heads/. #! As of Nix 2.3.0 Nix will not prefix refs/heads/ if ref starts with refs/. #! *[submodules] A Boolean parameter that specifies whether submodules should be checked out. #! Defaults to false. #! *[allRefs] Whether to fetch all refs of the repository. #! With this argument being true, it is possible to load a rev from any ref. #! By default only revs from the specified ref are supported. #! # Examples #! Here are some examples of how to use fetchGit: #! * To fetch a private repository over SSH: #! ``` #! fetchGit { #! url = "git@github.com:my-secret/repository.git"; #! ref = "master"; #! rev = "adab8b916a45068c044658c4158d81878f9ed1c3"; #! } #! ``` #! * To fetch an arbitrary reference: #! ``` #! fetchGit { #! url = "https://github.com/NixOS/nix.git"; #! ref = "refs/heads/0.5-release"; #! } #! ``` #! * If the revision you are looking for is in the default branch of the git repository #! you do not strictly need to specify the branch name in the ref attribute. #! However, if the revision you are looking for is in a future branch for the non-default branch #! you will need to specify the the ref attribute as well. #! ``` #! fetchGit { #! url = "https://github.com/nixos/nix.git"; #! rev = "841fcbd04755c7a2865c51c1e2d3b045976b7452"; #! ref = "1.11-maintenance"; #! } #! ``` #! It is nice to always specify the branch which a revision belongs to. #! Without the branch being specified, the fetcher might fail if the default branch changes. #! Additionally, it can be confusing to try a commit from a non-default branch and see the fetch fail. #! If the branch is specified the fault is much more obvious. #! If the revision you are looking for is in the default branch of the git repository #! you may omit the ref attribute. #! ``` #! fetchGit { #! url = "https://github.com/nixos/nix.git"; #! rev = "841fcbd04755c7a2865c51c1e2d3b045976b7452"; #! } #! ``` #! * To fetch a specific tag: #! ``` #! fetchGit { #! url = "https://github.com/nixos/nix.git"; #! ref = "refs/tags/1.9"; #! } #! ``` #! * To fetch the latest version of a remote branch: #! ``` #! fetchGit { #! url = "ssh://git@github.com/nixos/nix.git"; #! ref = "master"; #! } #! ``` #! Nix will refetch the branch in accordance with the option tarball-ttl. #! This behavior is disabled in Pure evaluation mode. fetchGit#: { # allRefs: bool = false; # name: string?; # ref: string?; # rev: string?; # submodules: bool = false; # url: string; # } | string -> path = builtins.fetchGit; #! TODO: Documentation fetchMercurial#: T -> T = builtins.fetchMercurial; #! Download the specified URL, unpack it and return the path of the unpacked tree. #! The file must be a tape archive (.tar) compressed with gzip, bzip2 or xz. #! The top-level path component of the files in the tarball is removed, #! so it is best if the tarball contains a single directory at top level. #! The typical use of the function is to obtain external Nix expression dependencies, #! such as a particular version of Nixpkgs, e.g. #! ``` #! with import (fetchTarball "https://github.com/NixOS/nixpkgs/archive/nixos-14.12.tar.gz") {}; #! stdenv.mkDerivation { … } #! ``` #! The fetched tarball is cached for a certain amount of time (1 hour by default) in ~/.cache/nix/tarballs/. #! You can change the cache timeout either on the command line with `--tarball-ttl number-of-seconds` or #! in the Nix configuration file by adding the line `tarball-ttl = number-of-seconds`. #! Note that when obtaining the hash with nix-prefetch-url the option `--unpack` is required. #! This function can also verify the contents against a hash. #! In that case, the function takes a set instead of a URL. #! The set requires the attribute url and the attribute `sha256`, e.g. #! ``` #! with import (fetchTarball { #! url = "https://github.com/NixOS/nixpkgs/archive/nixos-14.12.tar.gz"; #! sha256 = "1jppksrfvbk5ypiqdz4cddxdl8z6zyzdb2srq8fcffr327ld5jj2"; #! }) {}; #! stdenv.mkDerivation { … } #! ``` #! This function is not available if restricted evaluation mode ../command-ref/conf-file.md is enabled. fetchTarball#: { # url: string; # sha256: string; # } | string -> path = builtins.fetchTarball; #! TODO: Documentation fetchTree#: T -> T = builtins.fetchTree; #! Download the specified URL and return the path of the downloaded file. #! This function is not available if restricted evaluation mode ../command-ref/conf-file.md is enabled. fetchurl#: { # url: string; # sha256: string; # } | string -> path = builtins.fetchurl; #! Return a list consisting of the elements of the list for which the function returns true filter#: (T -> bool) -> [ T ] -> [ T ] = builtins.filter; #! TODO: Documentation, too long for now filterSource#: T -> T = builtins.filterSource; #! TODO: Documentation findFile#: T -> T = builtins.findFile; #! Converts an IEEE-754 double-precision floating-point number (double) to the next lower integer. #! If the datatype is neither an integer nor a float, an evaluation error will be thrown. floor#: integer | float -> integer = builtins.floor; #! Reduce a list by applying a binary operator, from left to right, #! e.g. `foldl' op nul [x0 x1 x2 ...]` returns `op (op (op nul x0) x1) x2) …`. #! The operator is applied strictly, i.e., #! its arguments are evaluated first. #! For example, `foldl' (x: y: x + y) 0 [1 2 3]` evaluates to `6`. foldl'#: (S -> T -> S) -> S -> [ T ] -> S = builtins.foldl'; #! Convert a JSON string to a Nix value. #! For example, #! ``` #! fromJSON ''{"x": [1, 2, 3], "y": null}'' #! ``` #! returns the value `{ x = [ 1 2 3 ]; y = null; }`. fromJSON#: string -> T = builtins.fromJSON; #! Convert a TOML string to a Nix value. fromTOML#: string -> T = builtins.fromTOML; #! Return a set containing the names of the formal arguments expected by the function f. #! The value of each attribute is a bool denoting whether the corresponding argument has a default value. #! For instance, `functionArgs ({ x, y ? 123}: ...)` returns `{ x = false; y = true; }`. #! "Formal argument" here refers to the attributes pattern-matched by the function. #! Plain lambdas are not included, e.g. `functionArgs (x: ...)` returns `{ }`. functionArgs#: (T -> U) -> { string: bool } = builtins.functionArgs; #! Generate list of size length, with each element i equal to the value returned by generator i. #! For example, `genList (x: x * x) 5` returns the list `[ 0 1 4 9 16 ]`. genList#: T -> T = builtins.genList; #! Take an attrset with values named startSet and operator in order to return a list of attrsets #! by starting with the startSet, recursively applying the operator function to each element. #! The attrsets in the startSet and produced by the operator must each contain value named key, #! which are comparable to each other. #! The result is produced by repeatedly calling the operator for each element encountered with a unique key, #! terminating when no new elements are produced. #! For example, #! ``` #! genericClosure { #! startSet = [ {key = 5;} ]; #! operator = item: [{ #! key = if (item.key / 2 ) * 2 == item.key #! then item.key / 2 #! else 3 * item.key + 1; #! }]; #! } #! ``` #! evaluates to `[ { key = 5; } { key = 16; } { key = 8; } { key = 4; } { key = 2; } { key = 1; } ]`. genericClosure#: { # startSet: [ { key: T; ... } ]; # operator: T -> [ { key: T; ... } ] # } -> [ { key: T; ... } ] = builtins.genericClosure; #! Returns a attribute from set. #! Evaluation aborts if the attribute does not exist. #! This is a dynamic version of the . operator, since the attribute is an expression rather than an identifier. getAttr#: string -> { string -> T } -> T | ! = builtins.getAttr; #! TODO: Documentation getContext#: T -> T = builtins.getContext; #! Returns the value of an environment variable, or an empty string if the variable does not exist. #! This function should be used with care, #! as it can introduce all sorts of nasty environment dependencies in your Nix expression. #! It is used in Nix Packages to locate the file ~/.nixpkgs/config.nix, #! which contains user-local settings for Nix Packages. #! That is, it does a getEnv "HOME" to locate the user’s home directory. getEnv#: string -> string = builtins.getEnv; #! Fetch a flake from a flake reference, and return its output attributes and some metadata. #! For example: #! ``` #! (getFlake "nix/55bc52401966fbffa525c574c14f67b00bc4fb3a").packages.x86_64-linux.nix #! ``` #! Unless impure evaluation is allowed (--impure), the flake reference must be "locked", #! e.g. contain a Git revision or content hash. #! An example of an unlocked usage is: #! ``` #! (getFlake "github:edolstra/dwarffs").rev #! ``` #! This function is only available if you enable the experimental feature flakes. getFlake#: { ... } | string -> flake = builtins.getFlake; #! Groups elements of list together by the string returned from the function f called on each element. #! It returns an attribute set #! where each attribute value contains the elements of list #! that are mapped to the same corresponding attribute name returned by f. #! For example, `groupBy (substring 0 1) ["foo" "bar" "baz"]` #! evaluates to `{ b = [ "bar" "baz" ]; f = [ "foo" ]; }` groupBy#: (T -> string) -> [ T ] -> { string -> [ T ] } = builtins.groupBy; #! hasAttr returns true if set has an attribute named s, and false otherwise. #! This is a dynamic version of the ? operator, since s is an expression rather than an identifier. hasAttr#: string -> { string -> T } -> bool = builtins.hasAttr or (name: attrs: attrs.${name} or true == attrs.${name} or false); #! TODO: Documentation hasContext#: T -> bool = builtins.hasContext; #! Return a base-16 representation of the cryptographic hash of the file at given path. #! The hash algorithm specified must be one of "md5", "sha1", "sha256" or "sha512". hashFile#: algorithm: string -> path -> T where algorithm in [ "md5" "sha1" "sha256" "sha512" ] = builtins.hashFile; #! Return a base-16 representation of the cryptographic hash of given string. #! The hash algorithm specified must be one of "md5", "sha1", "sha256" or "sha512". hashString#: algorithm: string -> string -> T where algorithm in [ "md5" "sha1" "sha256" "sha512" ] = builtins.hashString; #! Return the first element of a list; abort evaluation if the argument is not a list or is an empty list. #! You can test whether a list is empty by comparing it with []. head#: [ T ] -> T | ! = builtins.head; #! TODO: Too long for now import#: path -> T = builtins.import; #! Return a set consisting of the attributes in the second set that also exist in the first set. intersectAttrs#: { string -> T } -> { string -> U } -> { string -> U } = builtins.intersectAttrs; #! Return true if e evaluates to a set, and false otherwise. isAttrs#: T -> bool = builtins.isAttrs; #! Return true if e evaluates to a bool, and false otherwise. isBool#: T -> bool = builtins.isBool or (x: x == true || x == false); #! Return true if e evaluates to a float, and false otherwise. isFloat#: T -> bool = builtins.isFloat; #! Return true if e evaluates to a function, and false otherwise. isFunction#: T -> bool = builtins.isFunction; #! Return true if e evaluates to an integer, and false otherwise. isInt#: T -> bool = builtins.isInt; #! Return true if e evaluates to a list, and false otherwise. isList#: T -> bool = builtins.isList; #! DEPRECATED: #! Return true if e evaluates to null, and false otherwise. #! Just write e == null instead. isNull#: T -> bool = builtins.isNull or (x: x == null); #! Return true if e evaluates to a path, and false otherwise. isPath#: T -> bool = builtins.isPath; #! Return true if e evaluates to a string, and false otherwise. isString#: T -> bool = builtins.isString; #! TODO: Documentation langVersion#: integer = builtins.langVersion; #! Return the length of a list. length#: [ T ] -> integer = builtins.length; #! Return true if the first number is less than the second number, and false otherwise. lessThan#: number -> number -> bool = builtins.lessThan or (p: q: p < q); #! Construct a set from a list specifying the names and values of each attribute. #! Each element of the list should be a set consisting of a string-valued attribute name #! specifying the name of the attribute, and an attribute value specifying its value. #! # Example #! ``` #! listToAttrs #! [ { name = "foo"; value = 123; } #! { name = "bar"; value = 456; } #! ] #! ``` #! evaluates to `{ foo = 123; bar = 456; }`. listToAttrs#: [ { name: string; value: T; } ] -> { string -> T } = builtins.listToAttrs; #! Apply the function to each element in the list. #! # Example #! ``` #! map (x: "foo" + x) [ "bar" "bla" "abc" ] #! ``` #! evaluates to `[ "foobar" "foobla" "fooabc" ]`. map#: (T -> U) -> [ T ] -> [ U ] = builtins.map; #! Apply function to every element of attrset. #! # Example #! ``` #! mapAttrs (name: value: value * 10) { a = 1; b = 2; } #! ``` #! evaluates to `{ a = 10; b = 20; }`. mapAttrs#: (string -> T -> U) -> { string -> T } -> { string -> U } = builtins.mapAttrs; #! TODO: Too long for now match#: regex -> string -> [ T ] | null where T: string | [ T ] = builtins.match; #! Return the product of the two numbers. mul#: number -> number -> number = builtins.mul or (p: q: p * q); #! TODO: Documentation nixPath#: [ { path: string; prefix: string; } ] = builtins.nixPath; #! TODO: Documentation nixVersion#: string = builtins.nixVersion; #! The value of the unit type. null#: null = builtins.null; #! Split the string into a package name and version. #! The package name is everything up to but not including the first dash followed by a digit, #! and the version is everything following that dash. #! The result is returned in a set `{ name, version }`. #! Thus, `parseDrvName "nix-0.12pre12876"` returns `{ name = "nix"; version = "0.12pre12876"; }`. parseDrvName#: string -> { name: string; version: string; } = builtins.parseDrvName; #! Given a predicate function, #! this function returns an attrset containing a list named right, #! containing the elements in list for which the predicate returned true, #! and a list named wrong, #! containing the elements for which it returned false. #! # Examples #! ``` #! partition (x: x > 10) [1 23 9 3 42] #! ``` #! evaluates to #! ``` #! { right = [ 23 42 ]; wrong = [ 1 9 3 ]; } #! ``` partition#: (T -> bool) -> [ T ] -> { right: [ T ]; wrong: [ T ]; } = builtins.partition; #! TODO: Too long for now path#: T -> path = builtins.path; #! Return true if the path path exists at evaluation time, and false otherwise. pathExists#: path -> bool = builtins.pathExists; #! Return a placeholder string for the specified output #! that will be substituted by the corresponding output path at build time. #! Typical outputs would be "out", "bin" or "dev". placeholder#: string -> string = builtins.placeholder; #! Return the contents of the directory path as a set mapping directory entries to the corresponding file type. #! For instance, if directory A contains a regular file B and another directory C, #! then `readDir ./A` will return the set `{ B = "regular"; C = "directory"; }`. #! The possible values for the file type are "regular", "directory", "symlink" and "unknown". readDir#: path -> { string -> string } = builtins.readDir; #! Return the contents of the file path as a string. readFile#: path -> string = builtins.readFile; #! Remove the attributes listed in list from set. The attributes don’t have to exist in set. #! # Example #! ``` #! removeAttrs { x = 1; y = 2; z = 3; } [ "a" "x" "z" ] #! ``` #! evaluates to `{ y = 2; }`. removeAttrs#: { string -> T } -> [ string ] -> { string -> T } = builtins.removeAttrs; #! Given string, replace every occurrence of the strings #! in the first list #! with the corresponding string in second list. #! # Example #! ``` #! builtins.replaceStrings ["oo" "a"] ["a" "i"] "foobar" #! ``` #! evaluates to `"fabir"`. replaceStrings#: [ string ] -> [ string ] -> string -> string = builtins.replaceStrings; #! TODO: Documentation scopedImport#: path -> T -> T = builtins.scopedImport; #! Evaluate the first expression, #! then evaluate and return the second. #! This ensures that a computation is strict in the value of the first expression. seq#: T -> U -> U = builtins.seq; #! Return list in sorted order. #! It repeatedly calls the function comparator with two elements. #! The comparator should return true if the first element is less than the second, and false otherwise. #! # Example #! ``` #! sort lessThan [ 483 249 526 147 42 77 ] #! ``` #! evaluates to `[ 42 77 147 249 483 526 ]`. #! This is a stable sort: #! It preserves the relative order of elements deemed equal by the comparator. sort#: (T -> bool) -> [ T ] -> [ T ] = builtins.sort; #! TODO: Too long for now split#: regex -> string -> [ T ] where T: string | [ T ] = builtins.split; #! Split a string representing a version into its components, #! by the same version splitting logic underlying the version comparison #! in `nix-env -u ../command-ref/nix-env.md#operation---upgrade`. #! It basically splits the string at `.` and `-`. splitVersion#: string -> [ string ] = builtins.splitVersion; #! TODO: Documentation storeDir = builtins.storeDir; #! This function allows you to define a dependency on an already existing store path. #! For example, #! the derivation attribute `src = storePath /nix/store/f1d18v1y…-source` #! causes the derivation to depend on the specified path, #! which must exist or be substitutable. #! Note that this differs from a plain path (e.g. `src = /nix/store/f1d18v1y…-source`) #! in that the latter causes the path to be copied again to the Nix store, #! resulting in a new path (e.g. `/nix/store/ld01dnzc…-source-source`). #! This function is not available in pure evaluation mode. storePath#: path -> path = builtins.storePath; #! Return the length of the string in bytes. #! Note that it does not know about unicode. stringLength#: string -> integer = builtins.stringLength; #! Return the difference between the two numbers. sub#: number -> number -> number = builtins.sub or (p: q: p - q); #! Return the substring of a given string from character zero-based position start up to but not including start + len. #! If start is greater than the length of the string, #! an empty string is returned, and #! if start + len lies beyond the end of the string, #! only the substring up to the end of the string is returned. #! The offset start must be non-negative. #! For example `substring 0 3 "nixos"` evaluates to `"nix"`. substring#: integer -> integer -> string -> string | ! = builtins.substring; #! Return the second to last elements of a list; abort evaluation if the argument is an empty list. #! Warning: This function should generally be avoided since it is inefficient: #! Unlike Haskell's tail, it takes O(n) time, #! so recursing over a list by repeatedly calling tail takes O(n^2) time. tail#: [ T ] -> [ T ] | ! = builtins.tail; #! Throw an error message. #! This usually aborts Nix expression evaluation, #! but in nix-env -qa and other commands that try to evaluate a set of derivations #! to get information about those derivations, #! a derivation that throws an error is silently skipped (which is not the case for abort). throw#: string -> ! = builtins.throw; #! TODO: Too long for now toFile#: T -> path = builtins.toFile; #! Return a string containing a JSON representation the given expression. #! Strings, integers, floats, booleans, nulls and lists are mapped to their JSON equivalents. #! Sets (except derivations) are represented as objects. #! Derivations are translated to a JSON string containing the derivation’s output path. #! Paths are copied to the store and represented as a JSON string of the resulting store path. toJSON#: T -> string = builtins.toJSON; #! DEPRECATED. #! Use /. + "/path" to convert a string into an absolute path. #! For relative paths, use ./. + "/path". toPath#: T -> path = builtins.toPath; #! Convert the expression to a string. #! The expression can be: #! * A string (in which case the string is returned unmodified). #! * A path (e.g., toString /foo/bar yields "/foo/bar".) #! * A set containing { __toString = self: ...; } or { outPath = ...; }. #! * An integer or float. #! * A list, in which case the string representations of its elements are joined with spaces. #! * A bool (false yields "", true yields "1"). #! * null, which yields the empty string. #! Note that `toString` does not return an actual store path for paths, #! even if the path is a store-path, e.g. when building a flake. #! To ensure a path is copied to the nix store, use `"${fileName}"`. toString#: T -> string where T: bool | float integer | null | path | string | [ T ] | { string -> T } = builtins.toString; #! TODO: Too long for now toXML#: T -> string = builtins.toXML; #! Evaluate the first expression and print its abstract syntax representation on standard error. #! Then return the second expression. #! This function is useful for debugging. trace#: T -> U -> U = builtins.trace or (x: x); #! Tautology true#: bool = builtins.true or (1 == 1); #! Try to shallowly evaluate the expression. #! Return a set containing the attributes #! *[success] true if e evaluated successfully, false if an error was thrown #! *[value] equalling the expression if successful and false otherwise. #! `tryEval` will only prevent errors created by throw or assert from being thrown. #! Errors tryEval will not catch are for example those created by abort and type errors generated by builtins. #! Also note that this does not evaluate the expression deeply, #! so `let e = { x = throw ""; }; in (tryEval e).success` will be true. #! Using `deepSeq` one can get the expected result: #! ``` #! let #! e = { x = throw ""; }; #! in #! (tryEval (deepSeq e e)).success #! ``` #! will be evaluated to false. tryEval#: T -> { success: bool; value: T; } = builtins.tryEval; #! Return a string representing the type of the value, #! namely "int", "bool", "string", "path", "null", "set", "list", "lambda" or "float". typeOf#: T -> string = builtins.typeOf; #! TODO: Documentation unsafeDiscardOutputDependency#: T -> T = builtins.unsafeDiscardOutputDependency; #! TODO: Documentation unsafeDiscardStringContext#: T -> T = builtins.unsafeDiscardStringContext; #! TODO: Documentation unsafeGetAttrPos#: T -> T = builtins.unsafeGetAttrPos; #! Transpose a list of attribute sets into an attribute set of lists, then apply mapAttrs. #! The function receives two arguments: #! The attribute name and #! a non-empty list of all values encountered for that attribute name. #! The result is an attribute set where the attribute names are the union of the attribute names in each element of the list. #! The attribute values are the return values of the function. #! # Examples #! ``` #! zipAttrsWith #! (name: values: { inherit name values; }) #! [ { a = "x"; } { a = "y"; b = "z"; } ] #! ``` #! evaluates to #! ``` #! { #! a = { name = "a"; values = [ "x" "y" ]; }; #! b = { name = "b"; values = [ "z" ]; }; #! } #! ``` zipAttrsWith#: T -> T = builtins.zipAttrsWith; }; in { inherit lib; }; }