2009-02-09 09:51:03 -07:00
|
|
|
rec {
|
|
|
|
|
2017-03-15 11:29:33 -06:00
|
|
|
/* The identity function
|
|
|
|
For when you need a function that does “nothing”.
|
|
|
|
|
|
|
|
Type: id :: a -> a
|
|
|
|
*/
|
2009-02-09 09:51:03 -07:00
|
|
|
id = x: x;
|
|
|
|
|
2017-03-15 11:29:33 -06:00
|
|
|
/* 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
|
|
|
|
*/
|
2009-02-09 09:51:03 -07:00
|
|
|
const = x: y: x;
|
|
|
|
|
2017-03-15 11:29:33 -06:00
|
|
|
|
|
|
|
## Named versions corresponding to some builtin operators.
|
|
|
|
|
|
|
|
/* Concat two strings */
|
2009-02-09 09:51:03 -07:00
|
|
|
concat = x: y: x ++ y;
|
2017-03-15 11:29:33 -06:00
|
|
|
|
|
|
|
/* boolean “or” */
|
2009-02-09 09:51:03 -07:00
|
|
|
or = x: y: x || y;
|
2017-03-15 11:29:33 -06:00
|
|
|
|
|
|
|
/* boolean “and” */
|
2009-02-09 09:51:03 -07:00
|
|
|
and = x: y: x && y;
|
2017-03-15 11:29:33 -06:00
|
|
|
|
|
|
|
/* 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; }
|
|
|
|
*/
|
2009-07-02 02:58:30 -06:00
|
|
|
mergeAttrs = x: y: x // y;
|
2013-11-12 05:48:19 -07:00
|
|
|
|
2017-03-15 11:29:33 -06:00
|
|
|
|
2015-11-24 04:48:03 -07:00
|
|
|
# Compute the fixed point of the given function `f`, which is usually an
|
2015-11-24 04:59:08 -07:00
|
|
|
# attribute set that expects its final, non-recursive representation as an
|
2015-11-24 04:48:03 -07:00
|
|
|
# argument:
|
|
|
|
#
|
|
|
|
# f = self: { foo = "foo"; bar = "bar"; foobar = self.foo + self.bar; }
|
|
|
|
#
|
|
|
|
# Nix evaluates this recursion until all references to `self` have been
|
|
|
|
# resolved. At that point, the final result is returned and `f x = x` holds:
|
|
|
|
#
|
|
|
|
# nix-repl> fix f
|
|
|
|
# { bar = "bar"; foo = "foo"; foobar = "foobar"; }
|
|
|
|
#
|
|
|
|
# See https://en.wikipedia.org/wiki/Fixed-point_combinator for further
|
|
|
|
# details.
|
|
|
|
fix = f: let x = f x; in x;
|
|
|
|
|
|
|
|
# A variant of `fix` that records the original recursive attribute set in the
|
2015-11-24 04:59:08 -07:00
|
|
|
# result. This is useful in combination with the `extends` function to
|
2015-11-24 04:48:03 -07:00
|
|
|
# implement deep overriding. See pkgs/development/haskell-modules/default.nix
|
|
|
|
# for a concrete example.
|
|
|
|
fix' = f: let x = f x // { __unfix__ = f; }; in x;
|
|
|
|
|
|
|
|
# Modify the contents of an explicitly recursive attribute set in a way that
|
|
|
|
# honors `self`-references. This is accomplished with a function
|
|
|
|
#
|
|
|
|
# g = self: super: { foo = super.foo + " + "; }
|
|
|
|
#
|
|
|
|
# that has access to the unmodified input (`super`) as well as the final
|
2015-11-24 04:59:08 -07:00
|
|
|
# non-recursive representation of the attribute set (`self`). `extends`
|
2015-11-24 04:48:03 -07:00
|
|
|
# differs from the native `//` operator insofar as that it's applied *before*
|
|
|
|
# references to `self` are resolved:
|
|
|
|
#
|
|
|
|
# nix-repl> fix (extends g f)
|
|
|
|
# { bar = "bar"; foo = "foo + "; foobar = "foo + bar"; }
|
|
|
|
#
|
|
|
|
# The name of the function is inspired by object-oriented inheritance, i.e.
|
2015-11-24 04:59:08 -07:00
|
|
|
# think of it as an infix operator `g extends f` that mimics the syntax from
|
2015-11-24 04:48:03 -07:00
|
|
|
# Java. It may seem counter-intuitive to have the "base class" as the second
|
|
|
|
# argument, but it's nice this way if several uses of `extends` are cascaded.
|
|
|
|
extends = f: rattrs: self: let super = rattrs self; in super // f self super;
|
2009-02-09 09:51:03 -07:00
|
|
|
|
2016-04-29 22:19:57 -06:00
|
|
|
# Create an overridable, recursive attribute set. For example:
|
|
|
|
#
|
|
|
|
# nix-repl> obj = makeExtensible (self: { })
|
|
|
|
#
|
|
|
|
# nix-repl> obj
|
|
|
|
# { __unfix__ = «lambda»; extend = «lambda»; }
|
|
|
|
#
|
|
|
|
# nix-repl> obj = obj.extend (self: super: { foo = "foo"; })
|
|
|
|
#
|
|
|
|
# nix-repl> obj
|
|
|
|
# { __unfix__ = «lambda»; extend = «lambda»; foo = "foo"; }
|
|
|
|
#
|
|
|
|
# nix-repl> obj = obj.extend (self: super: { foo = super.foo + " + "; bar = "bar"; foobar = self.foo + self.bar; })
|
|
|
|
#
|
|
|
|
# nix-repl> obj
|
|
|
|
# { __unfix__ = «lambda»; bar = "bar"; extend = «lambda»; foo = "foo + "; foobar = "foo + bar"; }
|
2016-10-12 13:14:49 -06:00
|
|
|
makeExtensible = makeExtensibleWithCustomName "extend";
|
|
|
|
|
|
|
|
# Same as `makeExtensible` but the name of the extending attribute is
|
|
|
|
# customized.
|
|
|
|
makeExtensibleWithCustomName = extenderName: rattrs:
|
2016-04-29 22:19:57 -06:00
|
|
|
fix' rattrs // {
|
2016-10-12 13:14:49 -06:00
|
|
|
${extenderName} = f: makeExtensibleWithCustomName extenderName (extends f rattrs);
|
2016-04-29 22:19:57 -06:00
|
|
|
};
|
|
|
|
|
2009-10-23 01:34:56 -06:00
|
|
|
# Flip the order of the arguments of a binary function.
|
|
|
|
flip = f: a: b: f b a;
|
|
|
|
|
2017-04-17 14:48:10 -06:00
|
|
|
# Apply function if argument is non-null
|
|
|
|
mapNullable = f: a: if isNull a then a else f a;
|
|
|
|
|
2013-11-12 05:48:19 -07:00
|
|
|
# Pull in some builtins not included elsewhere.
|
|
|
|
inherit (builtins)
|
|
|
|
pathExists readFile isBool isFunction
|
2015-03-20 08:53:25 -06:00
|
|
|
isInt add sub lessThan
|
2015-07-23 09:41:35 -06:00
|
|
|
seq deepSeq genericClosure;
|
2013-11-12 05:48:19 -07:00
|
|
|
|
2016-07-31 06:59:30 -06:00
|
|
|
inherit (import ./strings.nix) fileContents;
|
|
|
|
|
2014-02-19 10:47:48 -07:00
|
|
|
# Return the Nixpkgs version number.
|
|
|
|
nixpkgsVersion =
|
|
|
|
let suffixFile = ../.version-suffix; in
|
2016-07-31 06:59:30 -06:00
|
|
|
fileContents ../.version
|
|
|
|
+ (if pathExists suffixFile then fileContents suffixFile else "pre-git");
|
2014-02-19 10:47:48 -07:00
|
|
|
|
2015-02-16 03:57:36 -07:00
|
|
|
# Whether we're being called by nix-shell.
|
2016-08-11 08:35:06 -06:00
|
|
|
inNixShell = builtins.getEnv "IN_NIX_SHELL" != "";
|
2014-02-19 11:00:51 -07:00
|
|
|
|
2015-02-16 03:57:36 -07:00
|
|
|
# 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;
|
|
|
|
|
2017-01-30 03:18:56 -07:00
|
|
|
/* Reads a JSON file. */
|
2016-02-28 09:35:27 -07:00
|
|
|
importJSON = path:
|
|
|
|
builtins.fromJSON (builtins.readFile path);
|
2016-08-15 11:54:23 -06:00
|
|
|
|
|
|
|
/* 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}";
|
2009-02-09 09:51:03 -07:00
|
|
|
}
|