···

       
45
       
45
       
 
       
        + "</listitem>";

     

       
46
       
46
       
 
       
    in "<itemizedlist>${lib.concatStringsSep "\n" (map (p: describe (unpack p)) packages)}</itemizedlist>";

     

       
47
       
47
       
 
       


     

       
48
       
48
       
-
       
  optionsListDesc = lib.flip map optionsListVisible (opt: opt // {

     

       
48
       
48
       
+
       
  optionsListDesc = lib.forEach optionsListVisible (opt: opt // {

     

       
49
       
49
       
 
       
    # Clean up declaration sites to not refer to the NixOS source tree.

     

       
50
       
50
       
 
       
    declarations = map stripAnyPrefixes opt.declarations;

     

       
51
       
51
       
 
       
  }

     

···

       
54
       
54
       
 
       


     

       
55
       
55
       
 
       
      machinesNumbered = zipLists machines (range 1 254);

     

       
56
       
56
       
 
       


     

       
57
       
57
       
-
       
      nodes_ = flip map machinesNumbered (m: nameValuePair m.fst

     

       
57
       
57
       
+
       
      nodes_ = forEach machinesNumbered (m: nameValuePair m.fst

     

       
58
       
58
       
 
       
        [ ( { config, nodes, ... }:

     

       
59
       
59
       
 
       
            let

     

       
60
       
60
       
 
       
              interfacesNumbered = zipLists config.virtualisation.vlans (range 1 255);

     

       
61
       
61
       
-
       
              interfaces = flip map interfacesNumbered ({ fst, snd }:

     

       
61
       
61
       
+
       
              interfaces = forEach interfacesNumbered ({ fst, snd }:

     

       
62
       
62
       
 
       
                nameValuePair "eth${toString snd}" { ipv4.addresses =

     

       
63
       
63
       
 
       
                  [ { address = "192.168.${toString fst}.${toString m.snd}";

     

       
64
       
64
       
 
       
                      prefixLength = 24;

     
···

       
88
       
88
       
 
       
                         "${config.networking.hostName}\n"));

     

       
89
       
89
       
 
       


     

       
90
       
90
       
 
       
                  virtualisation.qemu.options =

     

       
91
       
91
       
-
       
                    flip map interfacesNumbered

     

       
91
       
91
       
+
       
                    forEach interfacesNumbered

     

       
92
       
92
       
 
       
                      ({ fst, snd }: qemuNICFlags snd fst m.snd);

     

       
93
       
93
       
 
       
                };

     

       
94
       
94
       
 
       
            }

     

···

       
102
       
102
       
 
       
      # builtins multiply by 4 the memory usage and the time used to compute

     

       
103
       
103
       
 
       
      # each options.

     

       
104
       
104
       
 
       
      tryCollectOptions = moduleResult:

     

       
105
       
105
       
-
       
        flip map (excludeOptions (collect isOption moduleResult)) (opt:

     

       
105
       
105
       
+
       
        forEach (excludeOptions (collect isOption moduleResult)) (opt:

     

       
106
       
106
       
 
       
          { name = showOption opt.loc; } // builtins.tryEval (strict opt.value));

     

       
107
       
107
       
 
       
     in

     

       
108
       
108
       
 
       
       keepNames (

     

···

       
248
       
248
       
 
       
    # KSM

     

       
249
       
249
       
 
       
    (mkRenamedOptionModule [ "hardware" "enableKSM" ] [ "hardware" "ksm" "enable" ])

     

       
250
       
250
       
 
       


     

       
251
       
251
       
-
       
  ] ++ (flip map [ "blackboxExporter" "collectdExporter" "fritzboxExporter"

     

       
251
       
251
       
+
       
  ] ++ (forEach [ "blackboxExporter" "collectdExporter" "fritzboxExporter"

     

       
252
       
252
       
 
       
                   "jsonExporter" "minioExporter" "nginxExporter" "nodeExporter"

     

       
253
       
253
       
 
       
                   "snmpExporter" "unifiExporter" "varnishExporter" ]

     

       
254
       
254
       
 
       
       (opt: mkRemovedOptionModule [ "services" "prometheus" "${opt}" ] ''

     

···

       
225
       
225
       
 
       
        ''

     

       
226
       
226
       
 
       
          maxstartdelay = ${toString cfg.maxStartDelay}

     

       
227
       
227
       
 
       


     

       
228
       
228
       
-
       
          ${flip concatStringsSep (flip map (attrValues cfg.ups) (ups: ups.summary)) "

     

       
228
       
228
       
+
       
          ${flip concatStringsSep (forEach (attrValues cfg.ups) (ups: ups.summary)) "

     

       
229
       
229
       
 
       


     

       
230
       
230
       
 
       
          "}

     

       
231
       
231
       
 
       
        '';

     

···

       
15
       
15
       
 
       
    ++ cfg.extraConfigFiles;

     

       
16
       
16
       
 
       


     

       
17
       
17
       
 
       
  devices = attrValues (filterAttrs (_: i: i != null) cfg.interface);

     

       
18
       
18
       
-
       
  systemdDevices = flip map devices

     

       
18
       
18
       
+
       
  systemdDevices = forEach devices

     

       
19
       
19
       
 
       
    (i: "sys-subsystem-net-devices-${utils.escapeSystemdPath i}.device");

     

       
20
       
20
       
 
       
in

     

       
21
       
21
       
 
       
{

     

···

       
7
       
7
       
 
       
  inherit (lib) concatStringsSep optionalString;

     

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
  cfg = config.services.hylafax;

     

       
10
       
10
       
-
       
  mapModems = lib.flip map (lib.attrValues cfg.modems);

     

       
10
       
10
       
+
       
  mapModems = lib.forEach (lib.attrValues cfg.modems);

     

       
11
       
11
       
 
       


     

       
12
       
12
       
 
       
  mkConfigFile = name: conf:

     

       
13
       
13
       
 
       
    # creates hylafax config file,

     

···

       
502
       
502
       
 
       


     

       
503
       
503
       
 
       
    assertions = [{ assertion = if cfg.forwardX11 then cfgc.setXAuthLocation else true;

     

       
504
       
504
       
 
       
                    message = "cannot enable X11 forwarding without setting xauth location";}]

     

       
505
       
505
       
-
       
      ++ flip map cfg.listenAddresses ({ addr, ... }: {

     

       
505
       
505
       
+
       
      ++ forEach cfg.listenAddresses ({ addr, ... }: {

     

       
506
       
506
       
 
       
        assertion = addr != null;

     

       
507
       
507
       
 
       
        message = "addr must be specified in each listenAddresses entry";

     

       
508
       
508
       
 
       
      });

     

···

       
129
       
129
       
 
       
          assertion = cfg.killer != null -> cfg.killtime >= 10;

     

       
130
       
130
       
 
       
          message = "killtime has to be at least 10 minutes according to `man xautolock`";

     

       
131
       
131
       
 
       
        }

     

       
132
       
132
       
-
       
      ] ++ (lib.flip map [ "locker" "notifier" "nowlocker" "killer" ]

     

       
132
       
132
       
+
       
      ] ++ (lib.forEach [ "locker" "notifier" "nowlocker" "killer" ]

     

       
133
       
133
       
 
       
        (option:

     

       
134
       
134
       
 
       
        {

     

       
135
       
135
       
 
       
          assertion = cfg."${option}" != null -> builtins.substring 0 1 cfg."${option}" == "/";

     

···

       
75
       
75
       
 
       
  in imap1 mkHead cfg.xrandrHeads;

     

       
76
       
76
       
 
       


     

       
77
       
77
       
 
       
  xrandrDeviceSection = let

     

       
78
       
78
       
-
       
    monitors = flip map xrandrHeads (h: ''

     

       
78
       
78
       
+
       
    monitors = forEach xrandrHeads (h: ''

     

       
79
       
79
       
 
       
      Option "monitor-${h.config.output}" "${h.name}"

     

       
80
       
80
       
 
       
    '');

     

       
81
       
81
       
 
       
    # First option is indented through the space in the config but any

     

···

       
684
       
684
       
 
       
          assertion = if args.efiSysMountPoint == null then true else hasPrefix "/" args.efiSysMountPoint;

     

       
685
       
685
       
 
       
          message = "EFI paths must be absolute, not ${args.efiSysMountPoint}";

     

       
686
       
686
       
 
       
        }

     

       
687
       
687
       
-
       
      ] ++ flip map args.devices (device: {

     

       
687
       
687
       
+
       
      ] ++ forEach args.devices (device: {

     

       
688
       
688
       
 
       
        assertion = device == "nodev" || hasPrefix "/" device;

     

       
689
       
689
       
 
       
        message = "GRUB devices must be absolute paths, not ${device} in ${args.path}";

     

       
690
       
690
       
 
       
      }));

     

···

       
74
       
74
       
 
       
        enable = true;

     

       
75
       
75
       
 
       
        networks."99-main" = genericNetwork mkDefault;

     

       
76
       
76
       
 
       
      }

     

       
77
       
77
       
-
       
      (mkMerge (flip map interfaces (i: {

     

       
77
       
77
       
+
       
      (mkMerge (forEach interfaces (i: {

     

       
78
       
78
       
 
       
        netdevs = mkIf i.virtual ({

     

       
79
       
79
       
 
       
          "40-${i.name}" = {

     

       
80
       
80
       
 
       
            netdevConfig = {

     
···

       
90
       
90
       
 
       
          name = mkDefault i.name;

     

       
91
       
91
       
 
       
          DHCP = mkForce (dhcpStr

     

       
92
       
92
       
 
       
            (if i.useDHCP != null then i.useDHCP else cfg.useDHCP && interfaceIps i == [ ]));

     

       
93
       
93
       
-
       
          address = flip map (interfaceIps i)

     

       
93
       
93
       
+
       
          address = forEach (interfaceIps i)

     

       
94
       
94
       
 
       
            (ip: "${ip.address}/${toString ip.prefixLength}");

     

       
95
       
95
       
 
       
          networkConfig.IPv6PrivacyExtensions = "kernel";

     

       
96
       
96
       
 
       
        } ];

     
···

       
102
       
102
       
 
       
            Kind = "bridge";

     

       
103
       
103
       
 
       
          };

     

       
104
       
104
       
 
       
        };

     

       
105
       
105
       
-
       
        networks = listToAttrs (flip map bridge.interfaces (bi:

     

       
105
       
105
       
+
       
        networks = listToAttrs (forEach bridge.interfaces (bi:

     

       
106
       
106
       
 
       
          nameValuePair "40-${bi}" (mkMerge [ (genericNetwork (mkOverride 999)) {

     

       
107
       
107
       
 
       
            DHCP = mkOverride 0 (dhcpStr false);

     

       
108
       
108
       
 
       
            networkConfig.Bridge = name;

     
···

       
173
       
173
       
 
       


     

       
174
       
174
       
 
       
        };

     

       
175
       
175
       
 
       


     

       
176
       
176
       
-
       
        networks = listToAttrs (flip map bond.interfaces (bi:

     

       
176
       
176
       
+
       
        networks = listToAttrs (forEach bond.interfaces (bi:

     

       
177
       
177
       
 
       
          nameValuePair "40-${bi}" (mkMerge [ (genericNetwork (mkOverride 999)) {

     

       
178
       
178
       
 
       
            DHCP = mkOverride 0 (dhcpStr false);

     

       
179
       
179
       
 
       
            networkConfig.Bond = name;

     

···

       
926
       
926
       
 
       
    warnings = concatMap (i: i.warnings) interfaces;

     

       
927
       
927
       
 
       


     

       
928
       
928
       
 
       
    assertions =

     

       
929
       
929
       
-
       
      (flip map interfaces (i: {

     

       
929
       
929
       
+
       
      (forEach interfaces (i: {

     

       
930
       
930
       
 
       
        # With the linux kernel, interface name length is limited by IFNAMSIZ

     

       
931
       
931
       
 
       
        # to 16 bytes, including the trailing null byte.

     

       
932
       
932
       
 
       
        # See include/linux/if.h in the kernel sources

     
···

       
934
       
934
       
 
       
        message = ''

     

       
935
       
935
       
 
       
          The name of networking.interfaces."${i.name}" is too long, it needs to be less than 16 characters.

     

       
936
       
936
       
 
       
        '';

     

       
937
       
937
       
-
       
      })) ++ (flip map slaveIfs (i: {

     

       
937
       
937
       
+
       
      })) ++ (forEach slaveIfs (i: {

     

       
938
       
938
       
 
       
        assertion = i.ipv4.addresses == [ ] && i.ipv6.addresses == [ ];

     

       
939
       
939
       
 
       
        message = ''

     

       
940
       
940
       
 
       
          The networking.interfaces."${i.name}" must not have any defined ips when it is a slave.

     

       
941
       
941
       
 
       
        '';

     

       
942
       
942
       
-
       
      })) ++ (flip map interfaces (i: {

     

       
942
       
942
       
+
       
      })) ++ (forEach interfaces (i: {

     

       
943
       
943
       
 
       
        assertion = i.preferTempAddress -> cfg.enableIPv6;

     

       
944
       
944
       
 
       
        message = ''

     

       
945
       
945
       
 
       
          Temporary addresses are only needed when IPv6 is enabled.

     
···

       
967
       
967
       
 
       
      "net.ipv6.conf.default.disable_ipv6" = mkDefault (!cfg.enableIPv6);

     

       
968
       
968
       
 
       
      "net.ipv6.conf.all.forwarding" = mkDefault (any (i: i.proxyARP) interfaces);

     

       
969
       
969
       
 
       
    } // listToAttrs (flip concatMap (filter (i: i.proxyARP) interfaces)

     

       
970
       
970
       
-
       
        (i: flip map [ "4" "6" ] (v: nameValuePair "net.ipv${v}.conf.${i.name}.proxy_arp" true)))

     

       
971
       
971
       
-
       
      // listToAttrs (flip map (filter (i: i.preferTempAddress) interfaces)

     

       
970
       
970
       
+
       
        (i: forEach [ "4" "6" ] (v: nameValuePair "net.ipv${v}.conf.${i.name}.proxy_arp" true)))

     

       
971
       
971
       
+
       
      // listToAttrs (forEach (filter (i: i.preferTempAddress) interfaces)

     

       
972
       
972
       
 
       
        (i: nameValuePair "net.ipv6.conf.${i.name}.use_tempaddr" 2));

     

       
973
       
973
       
 
       


     

       
974
       
974
       
 
       
    # Capabilities won't work unless we have at-least a 4.3 Linux

     
···

       
1051
       
1051
       
 
       
          ${cfg.localCommands}

     

       
1052
       
1052
       
 
       
        '';

     

       
1053
       
1053
       
 
       
      };

     

       
1054
       
1054
       
-
       
    } // (listToAttrs (flip map interfaces (i:

     

       
1054
       
1054
       
+
       
    } // (listToAttrs (forEach interfaces (i:

     

       
1055
       
1055
       
 
       
      let

     

       
1056
       
1056
       
 
       
        deviceDependency = if (config.boot.isContainer || i.name == "lo")

     

       
1057
       
1057
       
 
       
          then []

     

···

       
21
       
21
       
 
       
        useNetworkd = networkd;

     

       
22
       
22
       
 
       
        firewall.checkReversePath = true;

     

       
23
       
23
       
 
       
        firewall.allowedUDPPorts = [ 547 ];

     

       
24
       
24
       
-
       
        interfaces = mkOverride 0 (listToAttrs (flip map vlanIfs (n:

     

       
24
       
24
       
+
       
        interfaces = mkOverride 0 (listToAttrs (forEach vlanIfs (n:

     

       
25
       
25
       
 
       
          nameValuePair "eth${toString n}" {

     

       
26
       
26
       
 
       
            ipv4.addresses = [ { address = "192.168.${toString n}.1"; prefixLength = 24; } ];

     

       
27
       
27
       
 
       
            ipv6.addresses = [ { address = "fd00:1234:5678:${toString n}::1"; prefixLength = 64; } ];

     

···

       
54
       
54
       
 
       
    init = let

     

       
55
       
55
       
 
       
      init = builtins.replaceStrings [ "\n" ] [ ";" ] (config.init or "");

     

       
56
       
56
       
 
       


     

       
57
       
57
       
-
       
      mkScript = drv: lib.flip map drv.scripts (script: "/script load ${drv}/share/${script}");

     

       
57
       
57
       
+
       
      mkScript = drv: lib.forEach drv.scripts (script: "/script load ${drv}/share/${script}");

     

       
58
       
58
       
 
       


     

       
59
       
59
       
 
       
      scripts = builtins.concatStringsSep ";" (lib.foldl (scripts: drv: scripts ++ mkScript drv)

     

       
60
       
60
       
 
       
        [ ] (config.scripts or []));

     

···

       
58
       
58
       
 
       
      versions = [ "13.8.0" "13.9.0" "13.9.1" ];

     

       
59
       
59
       
 
       
    in

     

       
60
       
60
       
 
       
      lib.listToAttrs

     

       
61
       
61
       
-
       
        (lib.flip map versions

     

       
61
       
61
       
+
       
        (lib.forEach versions

     

       
62
       
62
       
 
       
          (v: lib.nameValuePair v (throw "Unsupported citrix_receiver version: ${v}")));

     

       
63
       
63
       
 
       
  in

     

       
64
       
64
       
 
       
    deprecatedVersions // supportedVersions;

     

···

       
59
       
59
       
 
       
      versions = [ ];

     

       
60
       
60
       
 
       
    in

     

       
61
       
61
       
 
       
      lib.listToAttrs

     

       
62
       
62
       
-
       
        (lib.flip map versions

     

       
62
       
62
       
+
       
        (lib.forEach versions

     

       
63
       
63
       
 
       
          (v: lib.nameValuePair v (throw "Unsupported citrix_workspace version: ${v}")));

     

       
64
       
64
       
 
       
  in

     

       
65
       
65
       
 
       
    deprecatedVersions // supportedVersions;

     

···

       
4
       
4
       
 
       


     

       
5
       
5
       
 
       
let

     

       
6
       
6
       
 
       


     

       
7
       
7
       
-
       
  hunspellDirs = with lib; makeSearchPath ":" (flatten (flip map langs (lang: [

     

       
7
       
7
       
+
       
  hunspellDirs = with lib; makeSearchPath ":" (flatten (forEach langs (lang: [

     

       
8
       
8
       
 
       
    "${hunspellDicts.${lang}}/share/hunspell"

     

       
9
       
9
       
 
       
    "${hunspellDicts.${lang}}/share/myspell"

     

       
10
       
10
       
 
       
    "${hunspellDicts.${lang}}/share/myspell/dicts"