{ lib }: rec { /* The identity function For when you need a function that does “nothing”. Type: id :: a -> a */ id = x: x; /* The constant function Ignores the second argument. Or: Construct a function that always returns a static value. Type: const :: a -> b -> a Example: let f = const 5; in f 10 => 5 */ const = x: y: x; ## Named versions corresponding to some builtin operators. /* Concat two strings */ concat = x: y: x ++ y; /* boolean “or” */ or = x: y: x || y; /* boolean “and” */ and = x: y: x && y; /* Convert a boolean to a string. Note that toString on a bool returns "1" and "". */ boolToString = b: if b then "true" else "false"; /* Merge two attribute sets shallowly, right side trumps left Example: mergeAttrs { a = 1; b = 2; } { b = 3; c = 4; } => { a = 1; b = 3; c = 4; } */ mergeAttrs = x: y: x // y; # Flip the order of the arguments of a binary function. flip = f: a: b: f b a; # Apply function if argument is non-null mapNullable = f: a: if isNull a then a else f a; # Pull in some builtins not included elsewhere. inherit (builtins) pathExists readFile isBool isInt add sub lessThan seq deepSeq genericClosure; inherit (lib.strings) fileContents; release = fileContents ../.version; versionSuffix = let suffixFile = ../.version-suffix; in if pathExists suffixFile then fileContents suffixFile else "pre-git"; # Return the Nixpkgs version number. version = release + versionSuffix; nixpkgsVersion = builtins.trace "`lib.nixpkgsVersion` is deprecated, use `lib.version` instead!" version; # Whether we're being called by nix-shell. inNixShell = builtins.getEnv "IN_NIX_SHELL" != ""; # Return minimum/maximum of two numbers. min = x: y: if x < y then x else y; max = x: y: if x > y then x else y; /* Integer modulus Example: mod 11 10 => 1 mod 1 10 => 1 */ mod = base: int: base - (int * (builtins.div base int)); /* C-style comparisons a < b, compare a b => -1 a == b, compare a b => 0 a > b, compare a b => 1 */ compare = a: b: if a < b then -1 else if a > b then 1 else 0; /* Split type into two subtypes by predicate `p`, take all elements of the first subtype to be less than all the elements of the second subtype, compare elements of a single subtype with `yes` and `no` respectively. Example: let cmp = splitByAndCompare (hasPrefix "foo") compare compare; in cmp "a" "z" => -1 cmp "fooa" "fooz" => -1 cmp "f" "a" => 1 cmp "fooa" "a" => -1 # while compare "fooa" "a" => 1 */ splitByAndCompare = p: yes: no: a: b: if p a then if p b then yes a b else -1 else if p b then 1 else no a b; /* Reads a JSON file. */ importJSON = path: builtins.fromJSON (builtins.readFile path); /* See https://github.com/NixOS/nix/issues/749. Eventually we'd like these to expand to Nix builtins that carry metadata so that Nix can filter out the INFO messages without parsing the message string. Usage: { foo = lib.warn "foo is deprecated" oldFoo; } TODO: figure out a clever way to integrate location information from something like __unsafeGetAttrPos. */ warn = msg: builtins.trace "WARNING: ${msg}"; info = msg: builtins.trace "INFO: ${msg}"; # | Add metadata about expected function arguments to a function. # The metadata should match the format given by # builtins.functionArgs, i.e. a set from expected argument to a bool # representing whether that argument has a default or not. # setFunctionArgs : (a → b) → Map String Bool → (a → b) # # This function is necessary because you can't dynamically create a # function of the { a, b ? foo, ... }: format, but some facilities # like callPackage expect to be able to query expected arguments. setFunctionArgs = f: args: { # TODO: Should we add call-time "type" checking like built in? __functor = self: f; __functionArgs = args; }; # | Extract the expected function arguments from a function. # This works both with nix-native { a, b ? foo, ... }: style # functions and functions with args set with 'setFunctionArgs'. It # has the same return type and semantics as builtins.functionArgs. # setFunctionArgs : (a → b) → Map String Bool. functionArgs = f: f.__functionArgs or (builtins.functionArgs f); isFunction = f: builtins.isFunction f || (f ? __functor && isFunction (f.__functor f)); }