lib/brackets.nix

   1 { lib
   2 , mylib
   3 , ...
   4 }:
   5
   6 let
   7   inherit (builtins)
   8     foldl'
   9     head
  10     tail
  11     length
  12     ;
  13   inherit (mylib)
  14     isFunction
  15     foldr'
  16     ;
  17
  18   binding'' = stack: a:
  19     if !(isFunction a) && stack == [ ] then
  20       a
  21     else if isFunction a then
  22       b: binding'' ([ a ] ++ stack) b
  23     else # length stack >= 1
  24       let
  25         top = head stack;
  26         rest = tail stack;
  27       in
  28       binding'' rest (top a);
  29
  30   passing'' = stack: a:
  31     if !(isFunction a) then
  32       b: passing'' ([ a ] ++ stack) b
  33     else if length stack < 1 then
  34       a
  35     else
  36       let
  37         top = head stack;
  38         rest = tail stack;
  39       in
  40       passing'' rest (a top);
  41
  42 in
  43 rec {
  44
  45   # binding: just like function call, if arg is a function, push to stack
  46   # if not, applying stack top to it, and repeat.
  47   # binding K (map f) a {} == map f a
  48   # binding K (map f) (filter g) a {} == map f (filter g a)
  49   binding = binding'' [ ];
  50
  51   # passing: just like binding, but with reversed order
  52   # passing a (map f) K {} == map f a
  53   # passing a (filter g) (map f) K {} == map f (filter g a)
  54   passing = passing'' [ ];
  55
  56   # nArg:
  57   # mapping = nArg 2 [1 2 3] map
  58   # mapping (x: x + 1) == [2 3 4]
  59   nArg = n: x: f:
  60     if n < 1 || !(isFunction f) then f
  61     else if n == 1 then f x
  62     else a: nArg (n - 1) x (f a);
  63   nArg1 = nArg 1;
  64   nArg2 = nArg 2;
  65   nArg3 = nArg 3;
  66   nArg4 = nArg 4;
  67   nArg5 = nArg 5;
  68
  69   # rapply: list -> iv -> a
  70   # rapply [a b c d] iv == a (b (c (d iv)))
  71   # If a b c d, any of them are not function, the applying will return itself.
  72   # E.g. a is not function, (a b) == a
  73   rapply = ls: iv:
  74     foldr' (a: b: if isFunction a then a b else a) ls iv;
  75
  76   # lapply: iv -> list -> a
  77   # lapply iv [a b c d] == iv a b c d
  78   # More see rapply
  79   lapply = iv: ls:
  80     foldl' (a: b: if isFunction a then a b else a) iv ls;
  81 }