### # Collection of nixpkgs library functions, those are necessary for defining our own lib # # They have been simplified and builtins are used in some places, instead of lib shims. rec { /** Does the same as the update operator '//' except that attributes are merged until the given predicate is verified. The predicate should accept 3 arguments which are the path to reach the attribute, a part of the first attribute set and a part of the second attribute set. When the predicate is satisfied, the value of the first attribute set is replaced by the value of the second attribute set. # Inputs `pred` : Predicate, taking the path to the current attribute as a list of strings for attribute names, and the two values at that path from the original arguments. `lhs` : Left attribute set of the merge. `rhs` : Right attribute set of the merge. # Type ``` recursiveUpdateUntil :: ( [ String ] -> AttrSet -> AttrSet -> Bool ) -> AttrSet -> AttrSet -> AttrSet ``` # Examples :::{.example} ## `lib.attrsets.recursiveUpdateUntil` usage example ```nix recursiveUpdateUntil (path: l: r: path == ["foo"]) { # first attribute set foo.bar = 1; foo.baz = 2; bar = 3; } { #second attribute set foo.bar = 1; foo.quz = 2; baz = 4; } => { foo.bar = 1; # 'foo.*' from the second set foo.quz = 2; # bar = 3; # 'bar' from the first set baz = 4; # 'baz' from the second set } ``` ::: */ recursiveUpdateUntil = pred: lhs: rhs: let f = attrPath: builtins.zipAttrsWith ( n: values: let here = attrPath ++ [ n ]; in if builtins.length values == 1 || pred here (builtins.elemAt values 1) (builtins.head values) then builtins.head values else f here values ); in f [ ] [ rhs lhs ]; /** A recursive variant of the update operator ‘//’. The recursion stops when one of the attribute values is not an attribute set, in which case the right hand side value takes precedence over the left hand side value. # Inputs `lhs` : Left attribute set of the merge. `rhs` : Right attribute set of the merge. # Type ``` recursiveUpdate :: AttrSet -> AttrSet -> AttrSet ``` # Examples :::{.example} ## `lib.attrsets.recursiveUpdate` usage example ```nix recursiveUpdate { boot.loader.grub.enable = true; boot.loader.grub.device = "/dev/hda"; } { boot.loader.grub.device = ""; } returns: { boot.loader.grub.enable = true; boot.loader.grub.device = ""; } ``` ::: */ recursiveUpdate = lhs: rhs: recursiveUpdateUntil ( _: lhs: rhs: !(builtins.isAttrs lhs && builtins.isAttrs rhs) ) lhs rhs; /** Determine whether a string has given prefix. # Inputs `pref` : Prefix to check for `str` : Input string # Type ``` hasPrefix :: string -> string -> bool ``` # Examples :::{.example} ## `lib.strings.hasPrefix` usage example ```nix hasPrefix "foo" "foobar" => true hasPrefix "foo" "barfoo" => false ``` ::: */ hasPrefix = pref: str: (builtins.substring 0 (builtins.stringLength pref) str == pref); /** Escape occurrence of the elements of `list` in `string` by prefixing it with a backslash. # Inputs `list` : 1\. Function argument `string` : 2\. Function argument # Type ``` escape :: [string] -> string -> string ``` # Examples :::{.example} ## `lib.strings.escape` usage example ```nix escape ["(" ")"] "(foo)" => "\\(foo\\)" ``` ::: */ escape = list: builtins.replaceStrings list (builtins.map (c: "\\${c}") list); /** Convert a string `s` to a list of characters (i.e. singleton strings). This allows you to, e.g., map a function over each character. However, note that this will likely be horribly inefficient; Nix is not a general purpose programming language. Complex string manipulations should, if appropriate, be done in a derivation. Also note that Nix treats strings as a list of bytes and thus doesn't handle unicode. # Inputs `s` : 1\. Function argument # Type ``` stringToCharacters :: string -> [string] ``` # Examples :::{.example} ## `lib.strings.stringToCharacters` usage example ```nix stringToCharacters "" => [ ] stringToCharacters "abc" => [ "a" "b" "c" ] stringToCharacters "🦄" => [ "�" "�" "�" "�" ] ``` ::: */ stringToCharacters = s: builtins.genList (p: builtins.substring p 1 s) (builtins.stringLength s); /** Turn a string `s` into an exact regular expression # Inputs `s` : 1\. Function argument # Type ``` escapeRegex :: string -> string ``` # Examples :::{.example} ## `lib.strings.escapeRegex` usage example ```nix escapeRegex "[^a-z]*" => "\\[\\^a-z]\\*" ``` ::: */ escapeRegex = escape (stringToCharacters "\\[{()^$?*+|."); /** Appends string context from string like object `src` to `target`. :::{.warning} This is an implementation detail of Nix and should be used carefully. ::: Strings in Nix carry an invisible `context` which is a list of strings representing store paths. If the string is later used in a derivation attribute, the derivation will properly populate the inputDrvs and inputSrcs. # Inputs `src` : The string to take the context from. If the argument is not a string, it will be implicitly converted to a string. `target` : The string to append the context to. If the argument is not a string, it will be implicitly converted to a string. # Type ``` addContextFrom :: string -> string -> string ``` # Examples :::{.example} ## `lib.strings.addContextFrom` usage example ```nix pkgs = import { }; addContextFrom pkgs.coreutils "bar" => "bar" ``` The context can be displayed using the `toString` function: ```nix nix-repl> builtins.getContext (lib.strings.addContextFrom pkgs.coreutils "bar") { "/nix/store/m1s1d2dk2dqqlw3j90jl3cjy2cykbdxz-coreutils-9.5.drv" = { ... }; } ``` ::: */ addContextFrom = src: target: builtins.substring 0 0 src + target; /** Cut a string with a separator and produces a list of strings which were separated by this separator. # Inputs `sep` : 1\. Function argument `s` : 2\. Function argument # Type ``` splitString :: string -> string -> [string] ``` # Examples :::{.example} ## `lib.strings.splitString` usage example ```nix splitString "." "foo.bar.baz" => [ "foo" "bar" "baz" ] splitString "/" "/usr/local/bin" => [ "" "usr" "local" "bin" ] ``` ::: */ splitString = sep: s: let splits = builtins.filter builtins.isString ( builtins.split (escapeRegex (builtins.toString sep)) (builtins.toString s) ); in builtins.map (addContextFrom s) splits; /** Remove duplicate elements from the `list`. O(n^2) complexity. # Inputs `list` : Input list # Type ``` unique :: [a] -> [a] ``` # Examples :::{.example} ## `lib.lists.unique` usage example ```nix unique [ 3 2 3 4 ] => [ 3 2 4 ] ``` ::: */ unique = builtins.foldl' (acc: e: if builtins.elem e acc then acc else acc ++ [ e ]) [ ]; /** Flip the order of the arguments of a binary function. # Inputs `f` : 1\. Function argument `a` : 2\. Function argument `b` : 3\. Function argument # Type ``` flip :: (a -> b -> c) -> (b -> a -> c) ``` # Examples :::{.example} ## `lib.trivial.flip` usage example ```nix flip concat [1] [2] => [ 2 1 ] ``` ::: */ flip = f: a: b: f b a; }