2017-07-29 00:05:35 +00:00
|
|
|
|
{ lib }:
|
2018-07-25 22:10:53 +00:00
|
|
|
|
|
2009-02-09 16:51:03 +00:00
|
|
|
|
rec {
|
|
|
|
|
|
2018-07-25 22:03:51 +00:00
|
|
|
|
## Simple (higher order) functions
|
|
|
|
|
|
2017-03-15 17:29:33 +00:00
|
|
|
|
/* The identity function
|
|
|
|
|
For when you need a function that does “nothing”.
|
|
|
|
|
|
|
|
|
|
Type: id :: a -> a
|
|
|
|
|
*/
|
2018-10-27 14:40:04 +00:00
|
|
|
|
id =
|
|
|
|
|
# The value to return
|
|
|
|
|
x: x;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2017-03-15 17:29:33 +00:00
|
|
|
|
/* The constant function
|
2018-10-27 14:40:04 +00:00
|
|
|
|
|
|
|
|
|
Ignores the second argument. If called with only one argument,
|
|
|
|
|
constructs a function that always returns a static value.
|
2017-03-15 17:29:33 +00:00
|
|
|
|
|
|
|
|
|
Type: const :: a -> b -> a
|
|
|
|
|
Example:
|
|
|
|
|
let f = const 5; in f 10
|
|
|
|
|
=> 5
|
|
|
|
|
*/
|
2018-10-27 14:40:04 +00:00
|
|
|
|
const =
|
|
|
|
|
# Value to return
|
|
|
|
|
x:
|
|
|
|
|
# Value to ignore
|
|
|
|
|
y: x;
|
2009-02-09 16:51:03 +00:00
|
|
|
|
|
2019-10-18 15:57:33 +00:00
|
|
|
|
/* Pipes a value through a list of functions, left to right.
|
|
|
|
|
|
|
|
|
|
Type: pipe :: a -> [<functions>] -> <return type of last function>
|
|
|
|
|
Example:
|
|
|
|
|
pipe 2 [
|
|
|
|
|
(x: x + 2) # 2 + 2 = 4
|
|
|
|
|
(x: x * 2) # 4 * 2 = 8
|
|
|
|
|
]
|
|
|
|
|
=> 8
|
|
|
|
|
|
|
|
|
|
# ideal to do text transformations
|
|
|
|
|
pipe [ "a/b" "a/c" ] [
|
|
|
|
|
|
|
|
|
|
# create the cp command
|
|
|
|
|
(map (file: ''cp "${src}/${file}" $out\n''))
|
|
|
|
|
|
|
|
|
|
# concatenate all commands into one string
|
|
|
|
|
lib.concatStrings
|
|
|
|
|
|
|
|
|
|
# make that string into a nix derivation
|
|
|
|
|
(pkgs.runCommand "copy-to-out" {})
|
|
|
|
|
|
|
|
|
|
]
|
|
|
|
|
=> <drv which copies all files to $out>
|
|
|
|
|
|
|
|
|
|
The output type of each function has to be the input type
|
|
|
|
|
of the next function, and the last function returns the
|
|
|
|
|
final value.
|
|
|
|
|
*/
|
|
|
|
|
pipe = val: functions:
|
|
|
|
|
let reverseApply = x: f: f x;
|
|
|
|
|
in builtins.foldl' reverseApply val functions;
|
2022-01-30 00:53:24 +00:00
|
|
|
|
|
|
|
|
|
# note please don’t add a function like `compose = flip pipe`.
|
|
|
|
|
# This would confuse users, because the order of the functions
|
|
|
|
|
# in the list is not clear. With pipe, it’s obvious that it
|
|
|
|
|
# goes first-to-last. With `compose`, not so much.
|
2017-03-15 17:29:33 +00:00
|
|
|
|
|
|
|
|
|
## Named versions corresponding to some builtin operators.
|
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
/* Concatenate two lists
|
|
|
|
|
|
|
|
|
|
Type: concat :: [a] -> [a] -> [a]
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
concat [ 1 2 ] [ 3 4 ]
|
|
|
|
|
=> [ 1 2 3 4 ]
|
|
|
|
|
*/
|
2009-02-09 16:51:03 +00:00
|
|
|
|
concat = x: y: x ++ y;
|
2017-03-15 17:29:33 +00:00
|
|
|
|
|
|
|
|
|
/* boolean “or” */
|
2009-02-09 16:51:03 +00:00
|
|
|
|
or = x: y: x || y;
|
2017-03-15 17:29:33 +00:00
|
|
|
|
|
|
|
|
|
/* boolean “and” */
|
2009-02-09 16:51:03 +00:00
|
|
|
|
and = x: y: x && y;
|
2017-03-15 17:29:33 +00:00
|
|
|
|
|
2018-06-10 19:25:48 +00:00
|
|
|
|
/* bitwise “and” */
|
2018-07-25 22:10:53 +00:00
|
|
|
|
bitAnd = builtins.bitAnd
|
2018-09-03 12:10:54 +00:00
|
|
|
|
or (import ./zip-int-bits.nix
|
|
|
|
|
(a: b: if a==1 && b==1 then 1 else 0));
|
2018-06-10 19:25:48 +00:00
|
|
|
|
|
|
|
|
|
/* bitwise “or” */
|
2018-07-25 22:10:53 +00:00
|
|
|
|
bitOr = builtins.bitOr
|
2018-09-03 12:10:54 +00:00
|
|
|
|
or (import ./zip-int-bits.nix
|
|
|
|
|
(a: b: if a==1 || b==1 then 1 else 0));
|
2018-06-10 19:25:48 +00:00
|
|
|
|
|
|
|
|
|
/* bitwise “xor” */
|
2018-07-25 22:10:53 +00:00
|
|
|
|
bitXor = builtins.bitXor
|
2018-09-03 12:10:54 +00:00
|
|
|
|
or (import ./zip-int-bits.nix
|
|
|
|
|
(a: b: if a!=b then 1 else 0));
|
2018-06-10 19:25:48 +00:00
|
|
|
|
|
|
|
|
|
/* bitwise “not” */
|
|
|
|
|
bitNot = builtins.sub (-1);
|
|
|
|
|
|
2017-04-11 16:08:51 +00:00
|
|
|
|
/* Convert a boolean to a string.
|
2018-10-27 14:40:04 +00:00
|
|
|
|
|
|
|
|
|
This function uses the strings "true" and "false" to represent
|
|
|
|
|
boolean values. Calling `toString` on a bool instead returns "1"
|
|
|
|
|
and "" (sic!).
|
|
|
|
|
|
|
|
|
|
Type: boolToString :: bool -> string
|
2017-04-11 16:08:51 +00:00
|
|
|
|
*/
|
|
|
|
|
boolToString = b: if b then "true" else "false";
|
|
|
|
|
|
2017-03-15 17:29:33 +00:00
|
|
|
|
/* Merge two attribute sets shallowly, right side trumps left
|
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
mergeAttrs :: attrs -> attrs -> attrs
|
|
|
|
|
|
2017-03-15 17:29:33 +00:00
|
|
|
|
Example:
|
2017-04-25 06:36:22 +00:00
|
|
|
|
mergeAttrs { a = 1; b = 2; } { b = 3; c = 4; }
|
2017-03-15 17:29:33 +00:00
|
|
|
|
=> { a = 1; b = 3; c = 4; }
|
|
|
|
|
*/
|
2018-10-27 14:40:04 +00:00
|
|
|
|
mergeAttrs =
|
|
|
|
|
# Left attribute set
|
|
|
|
|
x:
|
|
|
|
|
# Right attribute set (higher precedence for equal keys)
|
|
|
|
|
y: x // y;
|
2013-11-12 12:48:19 +00:00
|
|
|
|
|
2018-07-25 22:03:51 +00:00
|
|
|
|
/* Flip the order of the arguments of a binary function.
|
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
Type: flip :: (a -> b -> c) -> (b -> a -> c)
|
|
|
|
|
|
2018-07-25 22:03:51 +00:00
|
|
|
|
Example:
|
|
|
|
|
flip concat [1] [2]
|
|
|
|
|
=> [ 2 1 ]
|
|
|
|
|
*/
|
2009-10-23 07:34:56 +00:00
|
|
|
|
flip = f: a: b: f b a;
|
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
/* Apply function if the supplied argument is non-null.
|
2018-07-25 22:03:51 +00:00
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
mapNullable (x: x+1) null
|
|
|
|
|
=> null
|
|
|
|
|
mapNullable (x: x+1) 22
|
|
|
|
|
=> 23
|
|
|
|
|
*/
|
2018-10-27 14:40:04 +00:00
|
|
|
|
mapNullable =
|
|
|
|
|
# Function to call
|
|
|
|
|
f:
|
|
|
|
|
# Argument to check for null before passing it to `f`
|
2019-04-24 03:48:22 +00:00
|
|
|
|
a: if a == null then a else f a;
|
2017-04-17 20:48:10 +00:00
|
|
|
|
|
2013-11-12 12:48:19 +00:00
|
|
|
|
# Pull in some builtins not included elsewhere.
|
|
|
|
|
inherit (builtins)
|
2018-01-31 19:02:19 +00:00
|
|
|
|
pathExists readFile isBool
|
2018-06-30 19:13:49 +00:00
|
|
|
|
isInt isFloat add sub lessThan
|
2015-07-23 15:41:35 +00:00
|
|
|
|
seq deepSeq genericClosure;
|
2013-11-12 12:48:19 +00:00
|
|
|
|
|
2016-07-31 12:59:30 +00:00
|
|
|
|
|
2021-04-05 10:13:33 +00:00
|
|
|
|
## nixpkgs version strings
|
2018-04-24 18:33:35 +00:00
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
/* Returns the current full nixpkgs version number. */
|
2018-04-26 08:31:05 +00:00
|
|
|
|
version = release + versionSuffix;
|
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
/* Returns the current nixpkgs release number as string. */
|
2018-07-25 22:03:51 +00:00
|
|
|
|
release = lib.strings.fileContents ../.version;
|
|
|
|
|
|
2022-03-09 13:41:43 +00:00
|
|
|
|
/* The latest release that is supported, at the time of release branch-off,
|
|
|
|
|
if applicable.
|
|
|
|
|
|
|
|
|
|
Ideally, out-of-tree modules should be able to evaluate cleanly with all
|
|
|
|
|
supported Nixpkgs versions (master, release and old release until EOL).
|
|
|
|
|
So if possible, deprecation warnings should take effect only when all
|
|
|
|
|
out-of-tree expressions/libs/modules can upgrade to the new way without
|
|
|
|
|
losing support for supported Nixpkgs versions.
|
|
|
|
|
|
|
|
|
|
This release number allows deprecation warnings to be implemented such that
|
|
|
|
|
they take effect as soon as the oldest release reaches end of life. */
|
|
|
|
|
oldestSupportedRelease =
|
|
|
|
|
# Update on master only. Do not backport.
|
|
|
|
|
2111;
|
|
|
|
|
|
|
|
|
|
/* Whether a feature is supported in all supported releases (at the time of
|
|
|
|
|
release branch-off, if applicable). See `oldestSupportedRelease`. */
|
|
|
|
|
isInOldestRelease =
|
|
|
|
|
/* Release number of feature introduction as an integer, e.g. 2111 for 21.11.
|
|
|
|
|
Set it to the upcoming release, matching the nixpkgs/.version file.
|
|
|
|
|
*/
|
|
|
|
|
release:
|
|
|
|
|
release <= lib.trivial.oldestSupportedRelease;
|
|
|
|
|
|
2018-11-15 20:51:29 +00:00
|
|
|
|
/* Returns the current nixpkgs release code name.
|
|
|
|
|
|
|
|
|
|
On each release the first letter is bumped and a new animal is chosen
|
|
|
|
|
starting with that new letter.
|
|
|
|
|
*/
|
2021-11-22 22:10:53 +00:00
|
|
|
|
codeName = "Quokka";
|
2018-11-15 20:51:29 +00:00
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
/* Returns the current nixpkgs version suffix as string. */
|
2018-07-25 22:03:51 +00:00
|
|
|
|
versionSuffix =
|
|
|
|
|
let suffixFile = ../.version-suffix;
|
|
|
|
|
in if pathExists suffixFile
|
|
|
|
|
then lib.strings.fileContents suffixFile
|
|
|
|
|
else "pre-git";
|
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
/* Attempts to return the the current revision of nixpkgs and
|
|
|
|
|
returns the supplied default value otherwise.
|
|
|
|
|
|
|
|
|
|
Type: revisionWithDefault :: string -> string
|
|
|
|
|
*/
|
|
|
|
|
revisionWithDefault =
|
|
|
|
|
# Default value to return if revision can not be determined
|
|
|
|
|
default:
|
2018-10-05 14:48:42 +00:00
|
|
|
|
let
|
|
|
|
|
revisionFile = "${toString ./..}/.git-revision";
|
|
|
|
|
gitRepo = "${toString ./..}/.git";
|
2020-01-19 23:44:07 +00:00
|
|
|
|
in if lib.pathIsGitRepo gitRepo
|
2018-10-05 14:48:42 +00:00
|
|
|
|
then lib.commitIdFromGitRepo gitRepo
|
|
|
|
|
else if lib.pathExists revisionFile then lib.fileContents revisionFile
|
|
|
|
|
else default;
|
|
|
|
|
|
2018-04-26 08:31:05 +00:00
|
|
|
|
nixpkgsVersion = builtins.trace "`lib.nixpkgsVersion` is deprecated, use `lib.version` instead!" version;
|
2014-02-19 17:47:48 +00:00
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
/* Determine whether the function is being called from inside a Nix
|
|
|
|
|
shell.
|
|
|
|
|
|
|
|
|
|
Type: inNixShell :: bool
|
|
|
|
|
*/
|
2016-08-11 14:35:06 +00:00
|
|
|
|
inNixShell = builtins.getEnv "IN_NIX_SHELL" != "";
|
2014-02-19 18:00:51 +00:00
|
|
|
|
|
2018-07-25 22:03:51 +00:00
|
|
|
|
|
|
|
|
|
## Integer operations
|
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
/* Return minimum of two numbers. */
|
2015-02-16 10:57:36 +00:00
|
|
|
|
min = x: y: if x < y then x else y;
|
2018-10-27 14:40:04 +00:00
|
|
|
|
|
|
|
|
|
/* Return maximum of two numbers. */
|
2015-02-16 10:57:36 +00:00
|
|
|
|
max = x: y: if x > y then x else y;
|
|
|
|
|
|
2017-08-30 12:32:04 +00:00
|
|
|
|
/* Integer modulus
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
mod 11 10
|
|
|
|
|
=> 1
|
|
|
|
|
mod 1 10
|
|
|
|
|
=> 1
|
|
|
|
|
*/
|
|
|
|
|
mod = base: int: base - (int * (builtins.div base int));
|
|
|
|
|
|
2018-07-25 22:03:51 +00:00
|
|
|
|
|
|
|
|
|
## Comparisons
|
|
|
|
|
|
2017-12-07 21:26:30 +00:00
|
|
|
|
/* 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.
|
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
Type: (a -> bool) -> (a -> a -> int) -> (a -> a -> int) -> (a -> a -> int)
|
2017-12-07 21:26:30 +00:00
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
Example:
|
2017-12-07 21:26:30 +00:00
|
|
|
|
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
|
|
|
|
|
*/
|
2018-10-27 14:40:04 +00:00
|
|
|
|
splitByAndCompare =
|
|
|
|
|
# Predicate
|
|
|
|
|
p:
|
|
|
|
|
# Comparison function if predicate holds for both values
|
|
|
|
|
yes:
|
|
|
|
|
# Comparison function if predicate holds for neither value
|
|
|
|
|
no:
|
|
|
|
|
# First value to compare
|
|
|
|
|
a:
|
|
|
|
|
# Second value to compare
|
|
|
|
|
b:
|
2017-12-07 21:26:30 +00:00
|
|
|
|
if p a
|
|
|
|
|
then if p b then yes a b else -1
|
|
|
|
|
else if p b then 1 else no a b;
|
|
|
|
|
|
2018-07-25 22:03:51 +00:00
|
|
|
|
|
2018-10-27 14:40:04 +00:00
|
|
|
|
/* Reads a JSON file.
|
|
|
|
|
|
|
|
|
|
Type :: path -> any
|
|
|
|
|
*/
|
2016-02-28 16:35:27 +00:00
|
|
|
|
importJSON = path:
|
|
|
|
|
builtins.fromJSON (builtins.readFile path);
|
2016-08-15 17:54:23 +00:00
|
|
|
|
|
2020-08-16 13:39:52 +00:00
|
|
|
|
/* Reads a TOML file.
|
|
|
|
|
|
|
|
|
|
Type :: path -> any
|
|
|
|
|
*/
|
|
|
|
|
importTOML = path:
|
|
|
|
|
builtins.fromTOML (builtins.readFile path);
|
2018-07-25 22:03:51 +00:00
|
|
|
|
|
2018-08-08 17:26:52 +00:00
|
|
|
|
## Warnings
|
2018-07-25 22:03:51 +00:00
|
|
|
|
|
2018-10-27 14:40:04 +00: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;
|
2021-04-27 10:56:51 +00:00
|
|
|
|
# bar = lib.warnIf (bar == "") "Empty bar is deprecated" bar;
|
2018-10-27 14:40:04 +00:00
|
|
|
|
# }
|
|
|
|
|
#
|
|
|
|
|
# TODO: figure out a clever way to integrate location information from
|
|
|
|
|
# something like __unsafeGetAttrPos.
|
2016-08-15 17:54:23 +00:00
|
|
|
|
|
2021-08-25 16:35:16 +00:00
|
|
|
|
/*
|
|
|
|
|
Print a warning before returning the second argument. This function behaves
|
|
|
|
|
like `builtins.trace`, but requires a string message and formats it as a
|
|
|
|
|
warning, including the `warning: ` prefix.
|
|
|
|
|
|
|
|
|
|
To get a call stack trace and abort evaluation, set the environment variable
|
|
|
|
|
`NIX_ABORT_ON_WARN=true` and set the Nix options `--option pure-eval false --show-trace`
|
|
|
|
|
|
|
|
|
|
Type: string -> a -> a
|
|
|
|
|
*/
|
|
|
|
|
warn =
|
|
|
|
|
if lib.elem (builtins.getEnv "NIX_ABORT_ON_WARN") ["1" "true" "yes"]
|
|
|
|
|
then msg: builtins.trace "[1;31mwarning: ${msg}[0m" (abort "NIX_ABORT_ON_WARN=true; warnings are treated as unrecoverable errors.")
|
|
|
|
|
else msg: builtins.trace "[1;31mwarning: ${msg}[0m";
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
Like warn, but only warn when the first argument is `true`.
|
|
|
|
|
|
|
|
|
|
Type: bool -> string -> a -> a
|
|
|
|
|
*/
|
2021-04-27 10:56:51 +00:00
|
|
|
|
warnIf = cond: msg: if cond then warn msg else id;
|
|
|
|
|
|
2021-12-22 12:05:55 +00:00
|
|
|
|
/*
|
|
|
|
|
Like the `assert b; e` expression, but with a custom error message and
|
|
|
|
|
without the semicolon.
|
|
|
|
|
|
|
|
|
|
If true, return the identity function, `r: r`.
|
|
|
|
|
|
|
|
|
|
If false, throw the error message.
|
|
|
|
|
|
|
|
|
|
Calls can be juxtaposed using function application, as `(r: r) a = a`, so
|
|
|
|
|
`(r: r) (r: r) a = a`, and so forth.
|
|
|
|
|
|
|
|
|
|
Type: bool -> string -> a -> a
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
|
|
|
|
|
throwIfNot (lib.isList overlays) "The overlays argument to nixpkgs must be a list."
|
|
|
|
|
lib.foldr (x: throwIfNot (lib.isFunction x) "All overlays passed to nixpkgs must be functions.") (r: r) overlays
|
|
|
|
|
pkgs
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
throwIfNot = cond: msg: if cond then x: x else throw msg;
|
|
|
|
|
|
2022-01-09 22:12:27 +00:00
|
|
|
|
/* Check if the elements in a list are valid values from a enum, returning the identity function, or throwing an error message otherwise.
|
|
|
|
|
|
|
|
|
|
Example:
|
|
|
|
|
let colorVariants = ["bright" "dark" "black"]
|
|
|
|
|
in checkListOfEnum "color variants" [ "standard" "light" "dark" ] colorVariants;
|
|
|
|
|
=>
|
|
|
|
|
error: color variants: bright, black unexpected; valid ones: standard, light, dark
|
|
|
|
|
|
|
|
|
|
Type: String -> List ComparableVal -> List ComparableVal -> a -> a
|
|
|
|
|
*/
|
|
|
|
|
checkListOfEnum = msg: valid: given:
|
|
|
|
|
let
|
|
|
|
|
unexpected = lib.subtractLists valid given;
|
|
|
|
|
in
|
|
|
|
|
lib.throwIfNot (unexpected == [])
|
|
|
|
|
"${msg}: ${builtins.concatStringsSep ", " (builtins.map builtins.toString unexpected)} unexpected; valid ones: ${builtins.concatStringsSep ", " (builtins.map builtins.toString valid)}";
|
|
|
|
|
|
2016-08-15 17:54:23 +00:00
|
|
|
|
info = msg: builtins.trace "INFO: ${msg}";
|
2018-01-31 19:02:19 +00:00
|
|
|
|
|
2021-01-25 06:57:48 +00:00
|
|
|
|
showWarnings = warnings: res: lib.foldr (w: x: warn w x) res warnings;
|
2018-07-25 22:03:51 +00:00
|
|
|
|
|
|
|
|
|
## Function annotations
|
|
|
|
|
|
|
|
|
|
/* 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.
|
|
|
|
|
*/
|
2018-01-31 19:02:19 +00:00
|
|
|
|
setFunctionArgs = f: args:
|
|
|
|
|
{ # TODO: Should we add call-time "type" checking like built in?
|
|
|
|
|
__functor = self: f;
|
|
|
|
|
__functionArgs = args;
|
|
|
|
|
};
|
|
|
|
|
|
2018-07-25 22:03:51 +00:00
|
|
|
|
/* 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.
|
|
|
|
|
*/
|
2021-07-23 19:10:31 +00:00
|
|
|
|
functionArgs = f:
|
|
|
|
|
if f ? __functor
|
|
|
|
|
then f.__functionArgs or (lib.functionArgs (f.__functor f))
|
|
|
|
|
else builtins.functionArgs f;
|
2018-01-31 19:02:19 +00:00
|
|
|
|
|
2018-07-25 22:03:51 +00:00
|
|
|
|
/* Check whether something is a function or something
|
|
|
|
|
annotated with function args.
|
|
|
|
|
*/
|
2018-01-31 19:02:19 +00:00
|
|
|
|
isFunction = f: builtins.isFunction f ||
|
|
|
|
|
(f ? __functor && isFunction (f.__functor f));
|
2020-04-20 10:00:23 +00:00
|
|
|
|
|
|
|
|
|
/* Convert the given positive integer to a string of its hexadecimal
|
|
|
|
|
representation. For example:
|
|
|
|
|
|
2020-07-20 11:14:19 +00:00
|
|
|
|
toHexString 0 => "0"
|
2020-04-20 10:00:23 +00:00
|
|
|
|
|
2020-07-20 11:14:19 +00:00
|
|
|
|
toHexString 16 => "10"
|
2020-04-20 10:00:23 +00:00
|
|
|
|
|
2020-07-20 11:14:19 +00:00
|
|
|
|
toHexString 250 => "FA"
|
2020-04-20 10:00:23 +00:00
|
|
|
|
*/
|
2020-07-20 11:14:19 +00:00
|
|
|
|
toHexString = i:
|
2020-04-20 10:00:23 +00:00
|
|
|
|
let
|
|
|
|
|
toHexDigit = d:
|
|
|
|
|
if d < 10
|
|
|
|
|
then toString d
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
"10" = "A";
|
|
|
|
|
"11" = "B";
|
|
|
|
|
"12" = "C";
|
|
|
|
|
"13" = "D";
|
|
|
|
|
"14" = "E";
|
|
|
|
|
"15" = "F";
|
|
|
|
|
}.${toString d};
|
|
|
|
|
in
|
2020-07-20 11:14:19 +00:00
|
|
|
|
lib.concatMapStrings toHexDigit (toBaseDigits 16 i);
|
2020-04-20 10:00:23 +00:00
|
|
|
|
|
2020-07-20 11:14:19 +00:00
|
|
|
|
/* `toBaseDigits base i` converts the positive integer i to a list of its
|
2020-04-20 10:00:23 +00:00
|
|
|
|
digits in the given base. For example:
|
|
|
|
|
|
2020-07-20 11:14:19 +00:00
|
|
|
|
toBaseDigits 10 123 => [ 1 2 3 ]
|
2020-04-20 10:00:23 +00:00
|
|
|
|
|
2020-07-20 11:14:19 +00:00
|
|
|
|
toBaseDigits 2 6 => [ 1 1 0 ]
|
2020-04-20 10:00:23 +00:00
|
|
|
|
|
2020-07-20 11:14:19 +00:00
|
|
|
|
toBaseDigits 16 250 => [ 15 10 ]
|
2020-04-20 10:00:23 +00:00
|
|
|
|
*/
|
2020-07-20 11:14:19 +00:00
|
|
|
|
toBaseDigits = base: i:
|
2020-04-20 10:00:23 +00:00
|
|
|
|
let
|
|
|
|
|
go = i:
|
|
|
|
|
if i < base
|
|
|
|
|
then [i]
|
|
|
|
|
else
|
|
|
|
|
let
|
|
|
|
|
r = i - ((i / base) * base);
|
|
|
|
|
q = (i - r) / base;
|
|
|
|
|
in
|
|
|
|
|
[r] ++ go q;
|
|
|
|
|
in
|
|
|
|
|
assert (base >= 2);
|
|
|
|
|
assert (i >= 0);
|
|
|
|
|
lib.reverseList (go i);
|
2009-02-09 16:51:03 +00:00
|
|
|
|
}
|