lib: etc #113661

sternenseemann · 2021-06-11T10:13:57Z

Wonder if we should use a stronger name like splitIf or splitListIf to disambiguate from builtins.split?

sternenseemann · 2021-06-11T11:01:56Z

Maybe add “where n is a number smaller than builtins.div (builtins.length l) 2. Same for the next property.

sternenseemann · 2021-06-11T11:07:56Z

The parentheses should be unnecessary here.

sternenseemann · 2021-06-11T11:02:58Z

Document these individually, so nixdoc can pick them up properly.

I think I will rename preds.true to preds.any and preds.false to preds.none to make the problematic example of @edolstra ["8.13" preds.true] read ["8.13" preds.any] instead, which looks more readable IMO.

edolstra · 2021-06-11T09:27:50Z

Please use camelCase (switchIf).

Zimmi48 · 2021-06-10T18:03:47Z

Is there a use case for a complex-clause without an out?

I think I have one somewhere, but anyway, this makes the code shorter!

Does it? I thought removing this would make this code:

switch-if (map (cl: { cond = combine cl var; out = cl.out or default; }) clauses) default;

become:

switch-if (map (cl: cl // { cond = combine cl var; }) clauses) default;

But if you actually use this, never mind.

Zimmi48 · 2021-06-10T18:04:52Z

I'm not sure what is the purpose of with versions; in this example. Did you originally intend to have a more realistic example, changed your mind, and forgot to remove with versions;?

Ahah yes this is deadcode. Well spotted!

sternenseemann · 2021-06-11T11:18:08Z

I think we should only have switch, but the magic should be explicit by checking which of those attributes the case attribute set has:

cond: Is a predicate gets converted to all (equal true) (zipListsWith equal cl.conds var)`

conds:

case: gets converted to equal x

cases: gets converted to all (equal true) (zipListsWith equal cl.cases var)

Some additional ideas:

There should be a version of switch with var as its last argument, so it can be curried easily.

Having a type of condition for boolean expressions would also be nice (maybe named cond and the current renamed to pred?), so expressions like !lib.inNixShell could be incooperated nicely.

oneof: which would be roughly builtins.any (equal true) (builtins.map (equal x) cl.oneof) could be nice

Edit: Fixed my cases example, added conds.

@sternenseemann Don't you like the fact that when some x is not a function it gets converted automatically to equal x? This looks harmless to me as it would not make sense to compare two functions, and it allows to combine both styles within cases (as in {cases = [somePred x]; ...} where somePred is really a predicate and x is not), which I think is a common usecase. Moreover it also frees cond for boolean conditions in order to subsume switchIf. I like your oneof suggestion and would also add allof for the sake of dualization.

Indeed switch is not flipable conveniently via flip... maybe we could have switchFun = cs: dft: x: switch x cs dflt?

Yeah, the “magic” is pretty cool, but I'm also a bit cautious in this regard. There is always the danger of for example a function that is partially applied by accident triggering the magic although you didn't want to — resulting in a weird and hard to debug eval error.

Not sure what the best call is here.

Zimmi48 · 2021-06-10T18:05:49Z

I'm wondering if this isn't a Frenchism. I would use Note: instead.

What would be the problem with "remark", except that it is an understatement. "Disclaimer" would be more appropriate IMO
...

sternenseemann · 2021-02-19T16:46:44Z

Wouldn't it be?

Suggested change

- truncate 4 "1.2.3-stuff"

=> "1.2.3.stuff"

- truncate 3 "1.2.3-stuff"

=> "1.2.3-stuff"

Well, the pitfall of this truncation function follows from the implementation of builtins.splitVersion, which has the following behaviour

builtins.splitVersion "1.2.3-stuff" == [ "1" "2" "3" "stuff" ]

In the same way the current (in nixpkgs master branch) majorMinor implementation satisfies the following:

lib.versions.majorMinor "1.2-stuff" == "1.2" lib.versions.majorMinor "1-stuff" == "1.stuff"

I merely abstracted away the body of the function to generalize it to majorMinorPatch.

I agree this is not intuitive, but that's the best I can do that does not break compatibility and extends the current library quite uniformly.

I see, maybe add a note on splitVersion in the documentation.

Maybe you should also add a note in the documentation of truncate that it doesn't preserve the delimiter type explicitly.

sternenseemann · 2021-02-19T16:49:20Z

I find the naming here pretty confusing and it is non obvious to a reader in another file that the version number gets truncated before the predicate is applied.

Also what is the exact motivaton for this versionAtLeast etc. can already deal with versions of different lengths.

The major difference is that versionAtLeast implements an order relation on version numbers (which is total assuming the only separator which is used is .), while the predicates I implement here are not order relations, they are not antisymmetric (in the sense that both isLe "1.1" "1.1.2" and isLe "1.1.2" "1.1" are true) and (isLe x) y should be read as «y is a version which is lower or equal to x». Contrarily to versionAtLeast, its analogous isLe uses its first argument to determine the length to truncate so that isLe "1.1" "1.1.2" is true while versionAtLeast "1.1" "1.1.2" is false...

The main motivation is to be able to combine and read them nicely with high order function such as

filter, e.g. the result of filter (versionAtLeast "1.0") [ "1.3.1" "1.0.0" "1.0" "0.9.0" "1.0.2" ], which is [ "1.0" "0.9.0" ] is very unnatural to me, both in reading versionAtLeast the wrong way around and the fact that I would like 1.0.2 to be included in the output: indeed "1.0.2" is part of the family of "1.0" versions! In comparison filter (isLe "1.0") [ "1.3.1" "1.0.0" "1.0" "0.9.0" "1.0.2" ] reads more naturally (we keep versions that are lesser or equal to "1.0") and the outcome [ "1.0.0" "1.0" "0.9.0" "1.0.2" ] matches my expectations: if I wanted to filter more precisely I would give the patch version of the first argument of isLe instead, and if I wanted to exclude all "1.0", then I would use isLt "1.0".

switch (defined in this PR), for example

nixpkgs/pkgs/development/coq-modules/mathcomp/default.nix

Lines 21 to 22 in 3daa06c

defaultVersion = with versions; switch coq.coq-version [

{ case = isGe "8.13"; out = "1.12.0"; } # lower version of coq to 8.10 when all mathcomp packages are ported

EDIT: I corrected a few typos that made it difficult to understand the first paragraph... should be better now.

I agree this should be explained in a better way inside the comment in the code. I will try my best to be clearer.

I pushed a new commit with better explanations (basically what is up here modulo transformation from github PR comment to inline code comment).

-Original file line number
+Diff line change
@@ Expand Up / @@ -15,11 +15,15 @@ let @@
         trivial = callLibs ./trivial.nix;
         fixedPoints = callLibs ./fixed-points.nix;
+        # control flow
+        switchs = callLibs ./switchs.nix;
         # datatypes
         attrsets = callLibs ./attrsets.nix;
         lists = callLibs ./lists.nix;
         strings = callLibs ./strings.nix;
         stringsWithDeps = callLibs ./strings-with-deps.nix;
+        preds = callLibs ./preds.nix;
         # packaging
         customisation = callLibs ./customisation.nix;
@@ Expand Down Expand Up / @@ -71,6 +75,7 @@ let @@
           toHexString toBaseDigits;
         inherit (self.fixedPoints) fix fix' converge extends composeExtensions
           composeManyExtensions makeExtensible makeExtensibleWithCustomName;
+        inherit (self.switchs) switch-if switch;
         inherit (self.attrsets) attrByPath hasAttrByPath setAttrByPath
           getAttrFromPath attrVals attrValues getAttrs catAttrs filterAttrs
           filterAttrsRecursive foldAttrs collect nameValuePair mapAttrs
@@ Expand All / @@ -81,7 +86,7 @@ let @@
           getLib getDev getMan chooseDevOutputs zipWithNames zip
           recurseIntoAttrs dontRecurseIntoAttrs cartesianProductOfSets;
         inherit (self.lists) singleton forEach foldr fold foldl foldl' imap0 imap1
-          concatMap flatten remove findSingle findFirst any all count
+          concatMap flatten remove findSingle findFirst splitList any all count
           optional optionals toList range partition zipListsWith zipLists
           reverseList listDfs toposort sort naturalSort compareLists take
           drop sublist last init crossLists unique intersectLists
@@ Expand Down @@

-Original file line number
+Diff line change
@@ Expand Up / @@ -200,6 +200,46 @@ rec { @@
         let found = filter pred list;
         in if found == [] then default else head found;
+      /* Takes a predicate and a list as input and
+         returns a list of lists, separated by elements that match the predicate.
+         This is analoguous to `builtins.split separator string`,
+         with a predicate instead of a separator
+         and a list instead of a string.
+         Type: splitList :: (a -> bool) -> [a] -> [ (a | [a]) ]
+         The returned list always has the form `[ [...] sep [...] ... sep [...] ]`
+         i.e. begins with a list, alternates with separators and ends with a list,
+         so that the following is true for `res = splitList pred l`:
+         - `res` has length `2 * k + 1`,
+           where `k` is the number of elements of `l` that
+           match `pred`. (ie `splitList pred l`)
+         - `elemAt res (2 * n)` is always a list,
+           which contains no element matching `pred`.
+         - `elemAt res (2 * n + 1)` is always a single element that matches `pred`.
+         Ie, for all `pred` and `l`, let `k = length (filter pred l)`, we have:
+         - `length (splitList pred l) = 2 * k + 1`,
+         - `isList (elemAt (splitList pred l) (2 * n))`, for all `n <= k`,
+         - `pred (elemAt (splitList pred l) (2 * n + 1))`, for all `n < k`,
+         - `flatten (map (pick (splitList pred l)) (range 0 (2 * k))) == l`, where
+           `pick = r: n: (if mod n 2 == 1 then singleton else id) (elemAt r n)`
+         Examples:
+         - splitList (x: x == "x") [ "y" "x" "z" "t" ]
+           => [ [ "y" ] "x" [ "z" "t" ] ]
+         - splitList (x: false) l == [ l ]
+         - splitList (x: x < 2) [ 2 1 3 4 0 1 3 1 ]
+           => [ [ 2 ] 1 [ 3 4 ] 0 [ ] 1 [ 3 ] 1 [ ] ]
+      */
+      splitList = pred: l:
+        let loop = (vv: v: l: if l == [] then vv ++ [v]
+          else let hd = head l; tl = tail l; in
+          if pred hd then loop (vv ++ [ v hd ]) [] tl else loop vv (v ++ [hd]) tl);
+        in loop [] [] l;
       /* Return true if function `pred` returns true for at least one
          element of `list`.
@@ Expand Down @@

-Original file line number
+Diff line change
@@ -0,0 +1,17 @@
+    { lib }:
+    with lib; {
+      /* Constant predicates: true and false */
+      true  = p: true;
+      false = p: false;
+      /* Predicate intersection, union, complement,
+         difference and implication */
+      inter = p: q: x: p x && q x;
+      union = p: q: x: p x || q x;
+      compl = p:    x: ! p x;
+      diff  = p: q: preds.inter p (preds.compl q);
+      impl  = p: q: x: p x -> q x;
+      /* predicate "being equal to x" */
+      equal = x: y: y == x;
+    }

-Original file line number
+Diff line change
@@ -0,0 +1,75 @@
+    { lib }:
+    with lib; {
+      /* Emulate a "switch - case" construct,
+       instead of relying on `if then else if ...` */
+      /* Usage:
+           ```nix
+           switch-if [
+             if-clause-1
+             ..
+             if-clause-k
+           ] default-out
+           ```
+           where a if-clause has the form `{ cond = b; out = r; }`
+           the first branch such as `b` is true
+         Example:
+           ```nix
+           let alphanum = n: switch-if [
+               { cond = n == 0; out = "zero"; }
+               { cond = n == 1; out = "one";  }
+             ] "I do not count beyond one"; in
+           [ (alphanum 0) (alphanum 1) (alphanum 42) ]
+           ```
+          => `[ "zero" "one" "I do not count beyond one" ]`
+      */
+      switch-if = c: d: (findFirst (getAttr "cond") {} c).out or d;
+      /* Usage:
+           ```nix
+           switch x [
+             simple-clause-1
+             ..
+             simple-clause-k
+           ] default-out
+           ```
+           where a simple-clause has the form `{ case = p; out = r; }`
+           the first branch such as `p x` is true
+           or
+           ```nix
+           switch [ x1 .. xn ] [
+             complex-clause-1
+             ..
+             complex-clause-k
+           ] default-out
+           ```
+           where a complex-clause is either a simple-clause
+           or has the form { cases = [ p1 .. pn ]; out = r; }
+           in which case the first branch such as all `pi xi` are true
+           if the variables p are not functions,
+           they are converted to a `equal p`
+           if `out` is missing then `default-out` is taken
+         Example:
+           ```nix
+           let test = v1: v2: with versions; switch [ v1 v2 ] [
+               { cases = [ (x: x * 2 < 4) 8 ]; out = "small, 8"; }
+               { case  = [ 42 42 ]; }          # no `out` means `default-out`
+               { case  = l: fold add 0 l > 42; out = "sum over 42"; }
+               { case  = [ 0 1 ];              out = "zero, one"; }
+             ] "weird"; in
+           [ (test 1 8) (test 40 3) (test 0 1) (test 42 42) (test 1 0)]
+           ```
+          => `[ "small, 8" "sum over 42" "zero, one" "weird" "weird" ]`
+      */
+      switch = var: clauses: default: with preds; let
+          compare = f:  if isFunction f then f else equal f;
+          combine = cl: var:
+            if cl?case then compare cl.case var
+            else all (equal true) (zipListsWith compare cl.cases var); in
+        switch-if (map (cl: { cond = combine cl var;
+                              out = cl.out or default; }) clauses) default;
+    }

-Original file line number
+Diff line change
@@ Expand Up / @@ -13,8 +13,6 @@ @@
     , csdp ? null
     , version, coq-version ? null,
     }@args:
-    let lib' = lib; in
-    let lib = import ../../../../build-support/coq/extra-lib.nix {lib = lib';}; in
     with builtins; with lib;
     let
       release = {
@@ Expand Down @@

-Original file line number
+Diff line change
@@ -1,5 +1,4 @@
     { lib, stdenv, coqPackages, coq, fetchzip }@args:
-    let lib = import ./extra-lib.nix {inherit (args) lib;}; in
     with builtins; with lib;
     let
       isGitHubDomain = d: match "^github.*" d != null;
@@ Expand Down Expand Up / @@ -74,7 +73,7 @@ stdenv.mkDerivation (removeAttrs ({ @@
       meta = ({ platforms = coq.meta.platforms; } //
         (switch domain [{
-            case = pred.union isGitHubDomain isGitLabDomain;
+            case = preds.union isGitHubDomain isGitLabDomain;
             out = { homepage = "https://${domain}/${owner}/${repo}"; };
           }] {}) //
         optionalAttrs (fetched.broken or false) { coqFilter = true; broken = true; }) //
@@ Expand Down @@

Uh oh!

lib: etc #113661

Are you sure you want to change the base?

Uh oh!

lib: etc #113661

Uh oh!

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

sternenseemann Jun 11, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CohenCyril Jun 11, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CohenCyril Feb 22, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CohenCyril Feb 22, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

CohenCyril Feb 22, 2021 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

sternenseemann Jun 11, 2021 •

edited

Loading

CohenCyril Jun 11, 2021 •

edited

Loading

CohenCyril Feb 22, 2021 •

edited

Loading

CohenCyril Feb 22, 2021 •

edited

Loading

CohenCyril Feb 22, 2021 •

edited

Loading