treewide: remove redundant quotes

doc/doc-support/lib-function-locations.nix

···
     builtins.map
       (subsetname: {
         subsetname = subsetname;
-        functions = libDefPos toplib."${subsetname}";
+        functions = libDefPos toplib.${subsetname};
       })
       (builtins.filter
-        (name: builtins.isAttrs toplib."${name}")
+        (name: builtins.isAttrs toplib.${name})
         (builtins.attrNames toplib));
 
   nixpkgsLib = pkgs.lib;

lib/lists.nix

···
       if length list < 2
       then # finish
            { result =  list; }
-      else if dfsthis ? "cycle"
+      else if dfsthis ? cycle
            then # there's a cycle, starting from the current vertex, return it
                 { cycle = reverseList ([ dfsthis.cycle ] ++ dfsthis.visited);
                   inherit (dfsthis) loops; }
-           else if toporest ? "cycle"
+           else if toporest ? cycle
                 then # there's a cycle somewhere else in the graph, return it
                      toporest
                 # Slow, but short. Can be made a bit faster with an explicit stack.

lib/systems/default.nix

···
       uname = {
         # uname -s
         system = {
-          "linux" = "Linux";
-          "windows" = "Windows";
-          "darwin" = "Darwin";
-          "netbsd" = "NetBSD";
-          "freebsd" = "FreeBSD";
-          "openbsd" = "OpenBSD";
-          "wasi" = "Wasi";
+          linux = "Linux";
+          windows = "Windows";
+          darwin = "Darwin";
+          netbsd = "NetBSD";
+          freebsd = "FreeBSD";
+          openbsd = "OpenBSD";
+          wasi = "Wasi";
         }.${final.parsed.kernel.name} or null;
 
          # uname -p
···
         else if final.isx86_64 then "x86_64"
         else if final.isx86 then "i386"
         else {
-          "powerpc" = "ppc";
-          "powerpcle" = "ppc";
-          "powerpc64" = "ppc64";
-          "powerpc64le" = "ppc64le";
+          powerpc = "ppc";
+          powerpcle = "ppc";
+          powerpc64 = "ppc64";
+          powerpc64le = "ppc64le";
         }.${final.parsed.cpu.name} or final.parsed.cpu.name;
 
       emulator = pkgs: let

lib/systems/platforms.nix

···
   };
 
   selectBySystem = system: {
-      "i486-linux" = pc32;
-      "i586-linux" = pc32;
-      "i686-linux" = pc32;
-      "x86_64-linux" = pc64;
-      "armv5tel-linux" = sheevaplug;
-      "armv6l-linux" = raspberrypi;
-      "armv7a-linux" = armv7l-hf-multiplatform;
-      "armv7l-linux" = armv7l-hf-multiplatform;
-      "aarch64-linux" = aarch64-multiplatform;
-      "mipsel-linux" = fuloong2f_n32;
-      "powerpc64le-linux" = powernv;
+      i486-linux = pc32;
+      i586-linux = pc32;
+      i686-linux = pc32;
+      x86_64-linux = pc64;
+      armv5tel-linux = sheevaplug;
+      armv6l-linux = raspberrypi;
+      armv7a-linux = armv7l-hf-multiplatform;
+      armv7l-linux = armv7l-hf-multiplatform;
+      aarch64-linux = aarch64-multiplatform;
+      mipsel-linux = fuloong2f_n32;
+      powerpc64le-linux = powernv;
     }.${system} or pcBase;
 }

lib/types.nix

···
   # Default type functor
   defaultFunctor = name: {
     inherit name;
-    type    = types."${name}" or null;
+    type    = types.${name} or null;
     wrapped = null;
     payload = null;
     binOp   = a: b: null;

nixos/lib/qemu-flags.nix

···
         else throw "Unknown QEMU serial device for system '${pkgs.stdenv.hostPlatform.system}'";
 
   qemuBinary = qemuPkg: {
-    "x86_64-linux" = "${qemuPkg}/bin/qemu-kvm -cpu kvm64";
-    "armv7l-linux" = "${qemuPkg}/bin/qemu-system-arm -enable-kvm -machine virt -cpu host";
-    "aarch64-linux" = "${qemuPkg}/bin/qemu-system-aarch64 -enable-kvm -machine virt,gic-version=host -cpu host";
-    "x86_64-darwin" = "${qemuPkg}/bin/qemu-kvm -cpu kvm64";
+    x86_64-linux = "${qemuPkg}/bin/qemu-kvm -cpu kvm64";
+    armv7l-linux = "${qemuPkg}/bin/qemu-system-arm -enable-kvm -machine virt -cpu host";
+    aarch64-linux = "${qemuPkg}/bin/qemu-system-aarch64 -enable-kvm -machine virt,gic-version=host -cpu host";
+    x86_64-darwin = "${qemuPkg}/bin/qemu-kvm -cpu kvm64";
   }.${pkgs.stdenv.hostPlatform.system} or "${qemuPkg}/bin/qemu-kvm";
 }

nixos/modules/config/fonts/fontconfig-penultimate.nix

···
                   then "fontconfig"
                   else "fontconfig_${version}";
       makeCache = fontconfig: pkgs.makeFontsCache { inherit fontconfig; fontDirectories = config.fonts.fonts; };
-      cache     = makeCache pkgs."${fcPackage}";
-      cache32   = makeCache pkgs.pkgsi686Linux."${fcPackage}";
+      cache     = makeCache pkgs.${fcPackage};
+      cache32   = makeCache pkgs.pkgsi686Linux.${fcPackage};
     in
     pkgs.writeText "fc-00-nixos-cache.conf" ''
       <?xml version='1.0'?>

nixos/modules/config/fonts/fontconfig-ultimate.nix

···
   config = mkIf (config.fonts.fontconfig.enable && cfg.enable) {
 
     fonts.fontconfig.confPackages = [ confPkg ];
-    environment.variables."INFINALITY_FT" = cfg.preset;
+    environment.variables.INFINALITY_FT = cfg.preset;
 
   };
 

nixos/modules/config/fonts/fontconfig.nix

···
                     then "fontconfig"
                     else "fontconfig_${version}";
         makeCache = fontconfig: pkgs.makeFontsCache { inherit fontconfig; fontDirectories = config.fonts.fonts; };
-        cache     = makeCache pkgs."${fcPackage}";
-        cache32   = makeCache pkgs.pkgsi686Linux."${fcPackage}";
+        cache     = makeCache pkgs.${fcPackage};
+        cache32   = makeCache pkgs.pkgsi686Linux.${fcPackage};
       in
       pkgs.writeText "fc-00-nixos-cache.conf" ''
         <?xml version='1.0'?>

nixos/modules/config/krb5/default.nix

···
     realms = optionalAttrs (lib.all (value: value != null) [
       cfg.defaultRealm cfg.kdc cfg.kerberosAdminServer
     ]) {
-      "${cfg.defaultRealm}" = {
+      ${cfg.defaultRealm} = {
         kdc = cfg.kdc;
         admin_server = cfg.kerberosAdminServer;
       };
···
       cfg.domainRealm cfg.defaultRealm
     ]) {
       ".${cfg.domainRealm}" = cfg.defaultRealm;
-      "${cfg.domainRealm}" = cfg.defaultRealm;
+      ${cfg.domainRealm} = cfg.defaultRealm;
     };
   };
 

nixos/modules/config/malloc.nix

···
 
   # The set of alternative malloc(3) providers.
   providers = {
-    "graphene-hardened" = rec {
+    graphene-hardened = rec {
       libPath = "${pkgs.graphene-hardened-malloc}/lib/libhardened_malloc.so";
       description = ''
         An allocator designed to mitigate memory corruption attacks, such as
···
       '';
     };
 
-    "jemalloc" = {
+    jemalloc = {
       libPath = "${pkgs.jemalloc}/lib/libjemalloc.so";
       description = ''
         A general purpose allocator that emphasizes fragmentation avoidance
···
       '';
     };
 
-    "scudo" = {
+    scudo = {
       libPath = "${pkgs.llvmPackages.compiler-rt}/lib/linux/libclang_rt.scudo-x86_64.so";
       description = ''
         A user-mode allocator based on LLVM Sanitizer’s CombinedAllocator,
···
     };
   };
 
-  providerConf = providers."${cfg.provider}";
+  providerConf = providers.${cfg.provider};
 
   # An output that contains only the shared library, to avoid
   # needlessly bloating the system closure

nixos/modules/config/networking.nix

···
 
     environment.etc =
       { # /etc/services: TCP/UDP port assignments.
-        "services".source = pkgs.iana-etc + "/etc/services";
+        services.source = pkgs.iana-etc + "/etc/services";
 
         # /etc/protocols: IP protocol numbers.
-        "protocols".source  = pkgs.iana-etc + "/etc/protocols";
+        protocols.source  = pkgs.iana-etc + "/etc/protocols";
 
         # /etc/hosts: Hostname-to-IP mappings.
-        "hosts".text = let
+        hosts.text = let
           oneToString = set: ip: ip + " " + concatStringsSep " " set.${ip};
           allToString = set: concatMapStringsSep "\n" (oneToString set) (attrNames set);
         in ''
···
 
       } // optionalAttrs (pkgs.stdenv.hostPlatform.libc == "glibc") {
         # /etc/rpc: RPC program numbers.
-        "rpc".source = pkgs.glibc.out + "/etc/rpc";
+        rpc.source = pkgs.glibc.out + "/etc/rpc";
       };
 
       networking.proxy.envVars =

nixos/modules/config/power-management.nix

···
     };
 
     # Service executed before suspending/hibernating.
-    systemd.services."pre-sleep" =
+    systemd.services.pre-sleep =
       { description = "Pre-Sleep Actions";
         wantedBy = [ "sleep.target" ];
         before = [ "sleep.target" ];
···
         serviceConfig.Type = "oneshot";
       };
 
-    systemd.services."post-resume" =
+    systemd.services.post-resume =
       { description = "Post-Resume Actions";
         after = [ "suspend.target" "hibernate.target" "hybrid-sleep.target" ];
         script =

nixos/modules/config/shells-environment.nix

···
       l  = "ls -alh";
     };
 
-    environment.etc."shells".text =
+    environment.etc.shells.text =
       ''
         ${concatStringsSep "\n" (map utils.toShellPath cfg.shells)}
         /bin/sh
···
 
     # For resetting environment with `. /etc/set-environment` when needed
     # and discoverability (see motivation of #30418).
-    environment.etc."set-environment".source = config.system.build.setEnvironment;
+    environment.etc.set-environment.source = config.system.build.setEnvironment;
 
     system.build.setEnvironment = pkgs.writeText "set-environment"
       ''

nixos/modules/config/terminfo.nix

···
       "/share/terminfo"
     ];
 
-    environment.etc."terminfo" = {
+    environment.etc.terminfo = {
       source = "${config.system.path}/share/terminfo";
     };
 

nixos/modules/config/users-groups.nix

···
     environment.systemPackages = systemShells;
 
     environment.etc = {
-      "subuid" = {
+      subuid = {
         text = subuidFile;
         mode = "0644";
       };
-      "subgid" = {
+      subgid = {
         text = subgidFile;
         mode = "0644";
       };

nixos/modules/hardware/nitrokey.nix

···
         { inherit (cfg) group; }
       ))
     ];
-    users.groups."${cfg.group}" = {};
+    users.groups.${cfg.group} = {};
   };
 }

nixos/modules/hardware/video/ati.nix

···
 
     boot.blacklistedKernelModules = [ "radeon" ];
 
-    environment.etc."ati".source = "${ati_x11}/etc/ati";
+    environment.etc.ati.source = "${ati_x11}/etc/ati";
 
   };
 

nixos/modules/misc/version.nix

···
     # Generate /etc/os-release.  See
     # https://www.freedesktop.org/software/systemd/man/os-release.html for the
     # format.
-    environment.etc."os-release".text =
+    environment.etc.os-release.text =
       ''
         NAME=NixOS
         ID=nixos

nixos/modules/programs/atop.nix

···
   };
 
   config = mkIf (cfg.settings != {}) {
-    environment.etc."atoprc".text =
+    environment.etc.atoprc.text =
       concatStrings (mapAttrsToList (n: v: "${n} ${toString v}\n") cfg.settings);
   };
 }

nixos/modules/programs/bash/bash.nix

···
 
     };
 
-    environment.etc."profile".text =
+    environment.etc.profile.text =
       ''
         # /etc/profile: DO NOT EDIT -- this file has been generated automatically.
         # This file is read for login shells.
···
         fi
       '';
 
-    environment.etc."bashrc".text =
+    environment.etc.bashrc.text =
       ''
         # /etc/bashrc: DO NOT EDIT -- this file has been generated automatically.
 
···
 
     # Configuration for readline in bash. We use "option default"
     # priority to allow user override using both .text and .source.
-    environment.etc."inputrc".source = mkOptionDefault ./inputrc;
+    environment.etc.inputrc.source = mkOptionDefault ./inputrc;
 
     users.defaultUserShell = mkDefault pkgs.bashInteractive;
 

nixos/modules/programs/less.nix

···
         type = types.attrsOf types.str;
         default = {};
         example = {
-          "h" = "noaction 5\e(";
-          "l" = "noaction 5\e)";
+          h = "noaction 5\e(";
+          l = "noaction 5\e)";
         };
         description = "Defines new command keys.";
       };
···
         type = types.attrsOf types.str;
         default = {};
         example = {
-          "\e" = "abort";
+          e = "abort";
         };
         description = "Defines new line-editing keys.";
       };
···
     environment.systemPackages = [ pkgs.less ];
 
     environment.variables = {
-      "LESSKEY_SYSTEM" = toString lessKey;
+      LESSKEY_SYSTEM = toString lessKey;
     } // optionalAttrs (cfg.lessopen != null) {
-      "LESSOPEN" = cfg.lessopen;
+      LESSOPEN = cfg.lessopen;
     } // optionalAttrs (cfg.lessclose != null) {
-      "LESSCLOSE" = cfg.lessclose;
+      LESSCLOSE = cfg.lessclose;
     };
 
     warnings = optional (

nixos/modules/programs/nano.nix

···
   ###### implementation
 
   config = lib.mkIf (cfg.nanorc != "" || cfg.syntaxHighlight) {
-    environment.etc."nanorc".text = lib.concatStrings [ cfg.nanorc
+    environment.etc.nanorc.text = lib.concatStrings [ cfg.nanorc
       (lib.optionalString cfg.syntaxHighlight ''${LF}include "${pkgs.nano}/share/nano/*.nanorc"'') ];
   };
 

nixos/modules/programs/npm.nix

···
   ###### implementation
 
   config = lib.mkIf cfg.enable {
-    environment.etc."npmrc".text = cfg.npmrc;
+    environment.etc.npmrc.text = cfg.npmrc;
 
     environment.variables.NPM_CONFIG_GLOBALCONFIG = "/etc/npmrc";
 

nixos/modules/programs/screen.nix

···
   ###### implementation
 
   config = mkIf (cfg.screenrc != "") {
-    environment.etc."screenrc".text = cfg.screenrc;
+    environment.etc.screenrc.text = cfg.screenrc;
 
     environment.systemPackages = [ pkgs.screen ];
   };

nixos/modules/programs/xfs_quota.nix

···
         description = "Setup of xfs_quota projects. Make sure the filesystem is mounted with the pquota option.";
 
         example = {
-          "projname" = {
+          projname = {
             id = 50;
             path = "/xfsprojects/projname";
             sizeHardLimit = "50g";

nixos/modules/programs/xonsh.nix

···
 
   config = mkIf cfg.enable {
 
-    environment.etc."xonshrc".text = cfg.config;
+    environment.etc.xonshrc.text = cfg.config;
 
     environment.systemPackages = [ cfg.package ];
 

nixos/modules/programs/zsh/zsh.nix

···
 
     programs.zsh.shellAliases = mapAttrs (name: mkDefault) cfge.shellAliases;
 
-    environment.etc."zshenv".text =
+    environment.etc.zshenv.text =
       ''
         # /etc/zshenv: DO NOT EDIT -- this file has been generated automatically.
         # This file is read for all shells.
···
         fi
       '';
 
-    environment.etc."zprofile".text =
+    environment.etc.zprofile.text =
       ''
         # /etc/zprofile: DO NOT EDIT -- this file has been generated automatically.
         # This file is read for login shells.
···
         fi
       '';
 
-    environment.etc."zshrc".text =
+    environment.etc.zshrc.text =
       ''
         # /etc/zshrc: DO NOT EDIT -- this file has been generated automatically.
         # This file is read for interactive shells.
···
         fi
       '';
 
-    environment.etc."zinputrc".source = ./zinputrc;
+    environment.etc.zinputrc.source = ./zinputrc;
 
     environment.systemPackages = [ pkgs.zsh ]
       ++ optional cfg.enableCompletion pkgs.nix-zsh-completions;

nixos/modules/security/acme.nix

···
         })
       );
 
-      systemd.targets."acme-selfsigned-certificates" = mkIf cfg.preliminarySelfsigned {};
-      systemd.targets."acme-certificates" = {};
+      systemd.targets.acme-selfsigned-certificates = mkIf cfg.preliminarySelfsigned {};
+      systemd.targets.acme-certificates = {};
     })
 
   ];

nixos/modules/security/chromium-suid-sandbox.nix

···
 
   config = mkIf cfg.enable {
     environment.systemPackages = [ sandbox ];
-    security.wrappers."${sandbox.passthru.sandboxExecutableName}".source = "${sandbox}/bin/${sandbox.passthru.sandboxExecutableName}";
+    security.wrappers.${sandbox.passthru.sandboxExecutableName}.source = "${sandbox}/bin/${sandbox.passthru.sandboxExecutableName}";
   };
 }

nixos/modules/security/polkit.nix

···
 
     security.wrappers = {
       pkexec.source = "${pkgs.polkit.bin}/bin/pkexec";
-      "polkit-agent-helper-1".source = "${pkgs.polkit.out}/lib/polkit-1/polkit-agent-helper-1";
+      polkit-agent-helper-1.source = "${pkgs.polkit.out}/lib/polkit-1/polkit-agent-helper-1";
     };
 
     systemd.tmpfiles.rules = [

nixos/modules/security/prey.nix

···
 
 let
   cfg = config.services.prey;
-  myPrey = pkgs."prey-bash-client".override {
+  myPrey = pkgs.prey-bash-client.override {
     apiKey = cfg.apiKey;
     deviceKey = cfg.deviceKey;
   };

nixos/modules/security/wrappers/default.nix

···
 
   programs =
     (lib.mapAttrsToList
-      (n: v: (if v ? "program" then v else v // {program=n;}))
+      (n: v: (if v ? program then v else v // {program=n;}))
       wrappers);
 
   securityWrapper = pkgs.stdenv.mkDerivation {
···
 
   mkWrappedPrograms =
     builtins.map
-      (s: if (s ? "capabilities")
+      (s: if (s ? capabilities)
           then mkSetcapProgram
                  ({ owner = "root";
                     group = "root";
                   } // s)
           else if
-             (s ? "setuid" && s.setuid) ||
-             (s ? "setgid" && s.setgid) ||
-             (s ? "permissions")
+             (s ? setuid && s.setuid) ||
+             (s ? setgid && s.setgid) ||
+             (s ? permissions)
           then mkSetuidProgram s
           else mkSetuidProgram
                  ({ owner  = "root";

nixos/modules/services/audio/alsa.nix

···
 
     boot.kernelModules = optional config.sound.enableOSSEmulation "snd_pcm_oss";
 
-    systemd.services."alsa-store" =
+    systemd.services.alsa-store =
       { description = "Store Sound Card State";
         wantedBy = [ "multi-user.target" ];
         unitConfig.RequiresMountsFor = "/var/lib/alsa";

nixos/modules/services/backup/mysql-backup.nix

···
     }];
 
     systemd = {
-      timers."mysql-backup" = {
+      timers.mysql-backup = {
         description = "Mysql backup timer";
         wantedBy = [ "timers.target" ];
         timerConfig = {
···
           Unit = "mysql-backup.service";
         };
       };
-      services."mysql-backup" = {
+      services.mysql-backup = {
         description = "Mysql backup service";
         enable = true;
         serviceConfig = {

nixos/modules/services/backup/tsm.nix

···
   config = mkIf cfg.enable {
     inherit assertions;
     programs.tsmClient.enable = true;
-    programs.tsmClient.servers."${cfg.servername}".passwdDir =
+    programs.tsmClient.servers.${cfg.servername}.passwdDir =
       mkDefault "/var/lib/tsm-backup/password";
     systemd.services.tsm-backup = {
       description = "IBM Spectrum Protect (Tivoli Storage Manager) Backup";

nixos/modules/services/backup/zfs-replication.nix

···
       pkgs.lz4
     ];
 
-    systemd.services."zfs-replication" = {
+    systemd.services.zfs-replication = {
       after = [
         "zfs-snapshot-daily.service"
         "zfs-snapshot-frequent.service"

nixos/modules/services/backup/znapzend.nix

···
     environment.systemPackages = [ pkgs.znapzend ];
 
     systemd.services = {
-      "znapzend" = {
+      znapzend = {
         description = "ZnapZend - ZFS Backup System";
         wantedBy    = [ "zfs.target" ];
         after       = [ "zfs.target" ];

nixos/modules/services/cluster/hadoop/hdfs.nix

···
 
   config = mkMerge [
     (mkIf cfg.hdfs.namenode.enabled {
-      systemd.services."hdfs-namenode" = {
+      systemd.services.hdfs-namenode = {
         description = "Hadoop HDFS NameNode";
         wantedBy = [ "multi-user.target" ];
 
···
       };
     })
     (mkIf cfg.hdfs.datanode.enabled {
-      systemd.services."hdfs-datanode" = {
+      systemd.services.hdfs-datanode = {
         description = "Hadoop HDFS DataNode";
         wantedBy = [ "multi-user.target" ];
 

nixos/modules/services/cluster/hadoop/yarn.nix

···
     })
 
     (mkIf cfg.yarn.resourcemanager.enabled {
-      systemd.services."yarn-resourcemanager" = {
+      systemd.services.yarn-resourcemanager = {
         description = "Hadoop YARN ResourceManager";
         wantedBy = [ "multi-user.target" ];
 
···
     })
 
     (mkIf cfg.yarn.nodemanager.enabled {
-      systemd.services."yarn-nodemanager" = {
+      systemd.services.yarn-nodemanager = {
         description = "Hadoop YARN NodeManager";
         wantedBy = [ "multi-user.target" ];
 

nixos/modules/services/cluster/kubernetes/addons/dashboard.nix

···
         spec = {
           replicas = 1;
           revisionHistoryLimit = 10;
-          selector.matchLabels."k8s-app" = "kubernetes-dashboard";
+          selector.matchLabels.k8s-app = "kubernetes-dashboard";
           template = {
             metadata = {
               labels = {

nixos/modules/services/cluster/kubernetes/addons/dns.nix

···
         metadata = {
           labels = {
             "addonmanager.kubernetes.io/mode" = "Reconcile";
-            "k8s-app" = "kube-dns";
+            k8s-app = "kube-dns";
             "kubernetes.io/cluster-service" = "true";
             "kubernetes.io/bootstrapping" = "rbac-defaults";
           };
···
           };
           labels = {
             "addonmanager.kubernetes.io/mode" = "Reconcile";
-            "k8s-app" = "kube-dns";
+            k8s-app = "kube-dns";
             "kubernetes.io/cluster-service" = "true";
             "kubernetes.io/bootstrapping" = "rbac-defaults";
           };
···
         metadata = {
           labels = {
             "addonmanager.kubernetes.io/mode" = "Reconcile";
-            "k8s-app" = "kube-dns";
+            k8s-app = "kube-dns";
             "kubernetes.io/cluster-service" = "true";
           };
           name = "coredns";
···
         metadata = {
           labels = {
             "addonmanager.kubernetes.io/mode" = cfg.reconcileMode;
-            "k8s-app" = "kube-dns";
+            k8s-app = "kube-dns";
             "kubernetes.io/cluster-service" = "true";
           };
           name = "coredns";
···
         metadata = {
           labels = {
             "addonmanager.kubernetes.io/mode" = cfg.reconcileMode;
-            "k8s-app" = "kube-dns";
+            k8s-app = "kube-dns";
             "kubernetes.io/cluster-service" = "true";
             "kubernetes.io/name" = "CoreDNS";
           };
···
           };
           labels = {
             "addonmanager.kubernetes.io/mode" = "Reconcile";
-            "k8s-app" = "kube-dns";
+            k8s-app = "kube-dns";
             "kubernetes.io/cluster-service" = "true";
             "kubernetes.io/name" = "CoreDNS";
           };

nixos/modules/services/databases/cassandra.nix

···
         }
       ];
     users = mkIf (cfg.user == defaultUser) {
-      extraUsers."${defaultUser}" =
+      extraUsers.${defaultUser} =
         {  group = cfg.group;
            home = cfg.homeDir;
            createHome = true;
            uid = config.ids.uids.cassandra;
            description = "Cassandra service user";
         };
-      extraGroups."${defaultUser}".gid = config.ids.gids.cassandra;
+      extraGroups.${defaultUser}.gid = config.ids.gids.cassandra;
     };
 
     systemd.services.cassandra =

nixos/modules/services/databases/pgmanage.nix

···
       type = types.attrsOf types.str;
       default = {};
       example = {
-        "nuc-server"  = "hostaddr=192.168.0.100 port=5432 dbname=postgres";
-        "mini-server" = "hostaddr=127.0.0.1 port=5432 dbname=postgres sslmode=require";
+        nuc-server  = "hostaddr=192.168.0.100 port=5432 dbname=postgres";
+        mini-server = "hostaddr=127.0.0.1 port=5432 dbname=postgres sslmode=require";
       };
       description = ''
         pgmanage requires at least one PostgreSQL server be defined.
···
       };
     };
     users = {
-      users."${pgmanage}" = {
+      users.${pgmanage} = {
         name  = pgmanage;
         group = pgmanage;
         home  = cfg.sqlRoot;
         createHome = true;
       };
-      groups."${pgmanage}" = {
+      groups.${pgmanage} = {
         name = pgmanage;
       };
     };

nixos/modules/services/desktops/geoclue2.nix

···
     ];
 
     # restart geoclue service when the configuration changes
-    systemd.services."geoclue".restartTriggers = [
+    systemd.services.geoclue.restartTriggers = [
       config.environment.etc."geoclue/geoclue.conf".source
     ];
 
     # this needs to run as a user service, since it's associated with the
     # user who is making the requests
     systemd.user.services = mkIf cfg.enableDemoAgent {
-      "geoclue-agent" = {
+      geoclue-agent = {
         description = "Geoclue agent";
         script = "${package}/libexec/geoclue-2.0/demos/agent";
         # this should really be `partOf = [ "geoclue.service" ]`, but
···
       };
     };
 
-    services.geoclue2.appConfig."epiphany" = {
+    services.geoclue2.appConfig.epiphany = {
       isAllowed = true;
       isSystem = false;
     };
 
-    services.geoclue2.appConfig."firefox" = {
+    services.geoclue2.appConfig.firefox = {
       isAllowed = true;
       isSystem = false;
     };

nixos/modules/services/games/terraria.nix

···
 
 let
   cfg   = config.services.terraria;
-  worldSizeMap = { "small" = 1; "medium" = 2; "large" = 3; };
+  worldSizeMap = { small = 1; medium = 2; large = 3; };
   valFlag = name: val: optionalString (val != null) "-${name} \"${escape ["\\" "\""] (toString val)}\"";
   boolFlag = name: val: optionalString val "-${name}";
   flags = [ 

nixos/modules/services/hardware/sane.nix

···
       environment.sessionVariables = env;
       services.udev.packages = backends;
 
-      users.groups."scanner".gid = config.ids.gids.scanner;
+      users.groups.scanner.gid = config.ids.gids.scanner;
     })
 
     (mkIf config.services.saned.enable {
···
         };
       };
 
-      users.users."scanner" = {
+      users.users.scanner = {
         uid = config.ids.uids.scanner;
         group = "scanner";
       };

nixos/modules/services/hardware/throttled.nix

···
   config = mkIf cfg.enable {
     systemd.packages = [ pkgs.throttled ];
     # The upstream package has this in Install, but that's not enough, see the NixOS manual
-    systemd.services."lenovo_fix".wantedBy = [ "multi-user.target" ];
+    systemd.services.lenovo_fix.wantedBy = [ "multi-user.target" ];
 
     environment.etc."lenovo_fix.conf".source =
       if cfg.extraConfig != ""

nixos/modules/services/hardware/tlp.nix

···
     powerManagement.cpufreq.max = null;
     powerManagement.cpufreq.min = null;
 
-    systemd.sockets."systemd-rfkill".enable = false;
+    systemd.sockets.systemd-rfkill.enable = false;
 
     systemd.services = {
       "systemd-rfkill@".enable = false;
-      "systemd-rfkill".enable = false;
+      systemd-rfkill.enable = false;
 
       tlp = {
         description = "TLP system startup/shutdown";

nixos/modules/services/logging/logcheck.nix

···
   flags = "-r ${rulesDir} -c ${configFile} -L ${logFiles} -${levelFlag} -m ${cfg.mailTo}";
 
   levelFlag = getAttrFromPath [cfg.level]
-    { "paranoid"    = "p";
-      "server"      = "s";
-      "workstation" = "w";
+    { paranoid    = "p";
+      server      = "s";
+      workstation = "w";
     };
 
   cronJob = ''

nixos/modules/services/mail/mlmmj.nix

···
           ${pkgs.postfix}/bin/postmap ${stateDir}/transports
       '';
 
-    systemd.services."mlmmj-maintd" = {
+    systemd.services.mlmmj-maintd = {
       description = "mlmmj maintenance daemon";
       serviceConfig = {
         User = cfg.user;
···
       };
     };
 
-    systemd.timers."mlmmj-maintd" = {
+    systemd.timers.mlmmj-maintd = {
       description = "mlmmj maintenance timer";
       timerConfig.OnUnitActiveSec = cfg.maintInterval;
       wantedBy = [ "timers.target" ];

nixos/modules/services/mail/pfix-srsd.nix

···
       systemPackages = [ pkgs.pfixtools ];
     };
 
-    systemd.services."pfix-srsd" = {
+    systemd.services.pfix-srsd = {
       description = "Postfix sender rewriting scheme daemon";
       before = [ "postfix.service" ];
       #note that we use requires rather than wants because postfix

nixos/modules/services/mail/postfix.nix

···
     }
 
     (mkIf haveAliases {
-      services.postfix.aliasFiles."aliases" = aliasesFile;
+      services.postfix.aliasFiles.aliases = aliasesFile;
     })
     (mkIf haveTransport {
-      services.postfix.mapFiles."transport" = transportFile;
+      services.postfix.mapFiles.transport = transportFile;
     })
     (mkIf haveVirtual {
-      services.postfix.mapFiles."virtual" = virtualFile;
+      services.postfix.mapFiles.virtual = virtualFile;
     })
     (mkIf haveLocalRecipients {
-      services.postfix.mapFiles."local_recipients" = localRecipientMapFile;
+      services.postfix.mapFiles.local_recipients = localRecipientMapFile;
     })
     (mkIf cfg.enableHeaderChecks {
-      services.postfix.mapFiles."header_checks" = headerChecksFile;
+      services.postfix.mapFiles.header_checks = headerChecksFile;
     })
     (mkIf (cfg.dnsBlacklists != []) {
-      services.postfix.mapFiles."client_access" = checkClientAccessFile;
+      services.postfix.mapFiles.client_access = checkClientAccessFile;
     })
   ]);
 }

nixos/modules/services/mail/postgrey.nix

···
   natural = with types; addCheck int (x: x >= 0);
   natural' = with types; addCheck int (x: x > 0);
 
-  socket = with types; addCheck (either (submodule unixSocket) (submodule inetSocket)) (x: x ? "path" || x ? "port");
+  socket = with types; addCheck (either (submodule unixSocket) (submodule inetSocket)) (x: x ? path || x ? port);
 
   inetSocket = with types; {
     options = {
···
     };
 
     systemd.services.postgrey = let
-      bind-flag = if cfg.socket ? "path" then
+      bind-flag = if cfg.socket ? path then
         ''--unix=${cfg.socket.path} --socketmode=${cfg.socket.mode}''
       else
         ''--inet=${optionalString (cfg.socket.addr != null) (cfg.socket.addr + ":")}${toString cfg.socket.port}'';

nixos/modules/services/mail/rspamd.nix

···
       gid = config.ids.gids.rspamd;
     };
 
-    environment.etc."rspamd".source = rspamdDir;
+    environment.etc.rspamd.source = rspamdDir;
 
     systemd.services.rspamd = {
       description = "Rspamd Service";

nixos/modules/services/misc/airsonic.nix

···
 
     services.nginx = mkIf (cfg.virtualHost != null) {
       enable = true;
-      virtualHosts."${cfg.virtualHost}" = {
-        locations."${cfg.contextPath}".proxyPass = "http://${cfg.listenAddress}:${toString cfg.port}";
+      virtualHosts.${cfg.virtualHost} = {
+        locations.${cfg.contextPath}.proxyPass = "http://${cfg.listenAddress}:${toString cfg.port}";
       };
     };
 

nixos/modules/services/misc/dysnomia.nix

···
   printProperties = properties:
     concatMapStrings (propertyName:
       let
-        property = properties."${propertyName}";
+        property = properties.${propertyName};
       in
-      if isList property then "${propertyName}=(${lib.concatMapStrings (elem: "\"${toString elem}\" ") (properties."${propertyName}")})\n"
+      if isList property then "${propertyName}=(${lib.concatMapStrings (elem: "\"${toString elem}\" ") (properties.${propertyName})})\n"
       else "${propertyName}=\"${toString property}\"\n"
     ) (builtins.attrNames properties);
 
···
 
       ${concatMapStrings (containerName:
         let
-          containerProperties = cfg.containers."${containerName}";
+          containerProperties = cfg.containers.${containerName};
         in
         ''
           cat > ${containerName} <<EOF
···
 
       ${concatMapStrings (componentName:
         let
-          component = cfg.components."${containerName}"."${componentName}";
+          component = cfg.components.${containerName}.${componentName};
         in
         "ln -s ${component} ${containerName}/${componentName}\n"
-      ) (builtins.attrNames (cfg.components."${containerName}" or {}))}
+      ) (builtins.attrNames (cfg.components.${containerName} or {}))}
     '';
 
   componentsDir = pkgs.stdenv.mkDerivation {

nixos/modules/services/misc/exhibitor.nix

···
     };
   };
   cliOptions = concatStringsSep " " (mapAttrsToList (k: v: "--${k} ${v}") (filterAttrs (k: v: v != null && v != "") (cliOptionsCommon //
-               cliOptionsPerConfig."${cfg.configType}" //
+               cliOptionsPerConfig.${cfg.configType} //
                s3CommonOptions //
                optionalAttrs cfg.s3Backup { s3backup = "true"; } //
                optionalAttrs cfg.fileSystemBackup { filesystembackup = "true"; }

nixos/modules/services/misc/gitolite.nix

···
       group           = cfg.group;
       useDefaultShell = true;
     };
-    users.groups."${cfg.group}".gid = config.ids.gids.gitolite;
+    users.groups.${cfg.group}.gid = config.ids.gids.gitolite;
 
     systemd.tmpfiles.rules = [
       "d '${cfg.dataDir}' 0750 ${cfg.user} ${cfg.group} - -"
···
       "Z ${cfg.dataDir} 0750 ${cfg.user} ${cfg.group} - -"
     ];
 
-    systemd.services."gitolite-init" = {
+    systemd.services.gitolite-init = {
       description = "Gitolite initialization";
       wantedBy    = [ "multi-user.target" ];
       unitConfig.RequiresMountsFor = cfg.dataDir;

nixos/modules/services/misc/matrix-synapse.nix

···
             user = cfg.database_user;
             database = cfg.database_name;
           };
-        }."${cfg.database_type}";
+        }.${cfg.database_type};
         description = ''
           Arguments to pass to the engine.
         '';

nixos/modules/services/misc/nix-daemon.nix

···
       optionals (pkgs.stdenv.isx86_64 && pkgs.hostPlatform.platform ? gcc.arch) (
         # a x86_64 builder can run code for `platform.gcc.arch` and minor architectures:
         [ "gccarch-${pkgs.hostPlatform.platform.gcc.arch}" ] ++ {
-          "sandybridge"    = [ "gccarch-westmere" ];
-          "ivybridge"      = [ "gccarch-westmere" "gccarch-sandybridge" ];
-          "haswell"        = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" ];
-          "broadwell"      = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" ];
-          "skylake"        = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" "gccarch-broadwell" ];
-          "skylake-avx512" = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" "gccarch-broadwell" "gccarch-skylake" ];
+          sandybridge    = [ "gccarch-westmere" ];
+          ivybridge      = [ "gccarch-westmere" "gccarch-sandybridge" ];
+          haswell        = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" ];
+          broadwell      = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" ];
+          skylake        = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" "gccarch-broadwell" ];
+          skylake-avx512 = [ "gccarch-westmere" "gccarch-sandybridge" "gccarch-ivybridge" "gccarch-haswell" "gccarch-broadwell" "gccarch-skylake" ];
         }.${pkgs.hostPlatform.platform.gcc.arch} or []
       )
     );

nixos/modules/services/misc/nixos-manual.nix

···
     (mkIf (cfg.showManual && cfgd.enable && cfgd.nixos.enable) {
       boot.extraTTYs = [ "tty${toString cfg.ttyNumber}" ];
 
-      systemd.services."nixos-manual" = {
+      systemd.services.nixos-manual = {
         description = "NixOS Manual";
         wantedBy = [ "multi-user.target" ];
         serviceConfig = {

nixos/modules/services/misc/snapper.nix

···
     configs = mkOption {
       default = { };
       example = literalExample {
-        "home" = {
+        home = {
           subvolume = "/home";
           extraConfig = ''
             ALLOW_USERS="alice"

nixos/modules/services/misc/synergy.nix

···
 
   config = mkMerge [
     (mkIf cfgC.enable {
-      systemd.user.services."synergy-client" = {
+      systemd.user.services.synergy-client = {
         after = [ "network.target" "graphical-session.target" ];
         description = "Synergy client";
         wantedBy = optional cfgC.autoStart "graphical-session.target";
···
       };
     })
     (mkIf cfgS.enable {
-      systemd.user.services."synergy-server" = {
+      systemd.user.services.synergy-server = {
         after = [ "network.target" "graphical-session.target" ];
         description = "Synergy server";
         wantedBy = optional cfgS.autoStart "graphical-session.target";

nixos/modules/services/misc/zoneminder.nix

···
   group = {
     nginx = config.services.nginx.group;
     none  = user;
-  }."${cfg.webserver}";
+  }.${cfg.webserver};
 
   useNginx = cfg.webserver == "nginx";
 
···
       nginx = lib.mkIf useNginx {
         enable = true;
         virtualHosts = {
-          "${cfg.hostname}" = {
+          ${cfg.hostname} = {
             default = true;
             root = "${pkg}/share/zoneminder/www";
             listen = [ { addr = "0.0.0.0"; inherit (cfg) port; } ];
···
       };
     };
 
-    users.groups."${user}" = {
+    users.groups.${user} = {
       gid = config.ids.gids.zoneminder;
     };
 
-    users.users."${user}" = {
+    users.users.${user} = {
       uid = config.ids.uids.zoneminder;
       group = user;
       inherit home;

nixos/modules/services/monitoring/dd-agent/dd-agent.nix

···
   };
 
   config = mkIf cfg.enable {
-    environment.systemPackages = [ pkgs."dd-agent" pkgs.sysstat pkgs.procps ];
+    environment.systemPackages = [ pkgs.dd-agent pkgs.sysstat pkgs.procps ];
 
     users.users.datadog = {
       description = "Datadog Agent User";

nixos/modules/services/monitoring/fusion-inventory.nix

···
       description = "FusionInventory user";
     };
 
-    systemd.services."fusion-inventory" = {
+    systemd.services.fusion-inventory = {
       description = "Fusion Inventory Agent";
       wantedBy = [ "multi-user.target" ];
 

nixos/modules/services/monitoring/monit.nix

···
 
     environment.systemPackages = [ pkgs.monit ];
 
-    environment.etc."monitrc" = {
+    environment.etc.monitrc = {
       text = cfg.config;
       mode = "0400";
     };
···
         KillMode = "process";
         Restart = "always";
       };
-      restartTriggers = [ config.environment.etc."monitrc".source ];
+      restartTriggers = [ config.environment.etc.monitrc.source ];
     };
 
   };

nixos/modules/services/monitoring/thanos.nix

···
   } ''json2yaml -i $json -o $out'';
 
   thanos = cmd: "${cfg.package}/bin/thanos ${cmd}" +
-    (let args = cfg."${cmd}".arguments;
+    (let args = cfg.${cmd}.arguments;
      in optionalString (length args != 0) (" \\\n  " +
          concatStringsSep " \\\n  " args));
 
   argumentsOf = cmd: concatLists (collect isList
-    (flip mapParamsRecursive params."${cmd}" (path: param:
+    (flip mapParamsRecursive params.${cmd} (path: param:
       let opt = concatStringsSep "." path;
-          v = getAttrFromPath path cfg."${cmd}";
+          v = getAttrFromPath path cfg.${cmd};
       in param.toArgs opt v)));
 
   mkArgumentsOption = cmd: mkOption {
···
   };
 
   mapParamsRecursive =
-    let noParam = attr: !(attr ? "toArgs" && attr ? "option");
+    let noParam = attr: !(attr ? toArgs && attr ? option);
     in mapAttrsRecursiveCond noParam;
 
   paramsToOptions = mapParamsRecursive (_path: param: param.option);
···
   assertRelativeStateDir = cmd: {
     assertions = [
       {
-        assertion = !hasPrefix "/" cfg."${cmd}".stateDir;
+        assertion = !hasPrefix "/" cfg.${cmd}.stateDir;
         message =
           "The option services.thanos.${cmd}.stateDir should not be an absolute directory." +
           " It should be a directory relative to /var/lib.";

nixos/modules/services/monitoring/zabbix-agent.nix

···
 
     users.groups.${group} = { };
 
-    systemd.services."zabbix-agent" = {
+    systemd.services.zabbix-agent = {
       description = "Zabbix Agent";
 
       wantedBy = [ "multi-user.target" ];

nixos/modules/services/monitoring/zabbix-proxy.nix

···
       fping.source = "${pkgs.fping}/bin/fping";
     };
 
-    systemd.services."zabbix-proxy" = {
+    systemd.services.zabbix-proxy = {
       description = "Zabbix Proxy";
 
       wantedBy = [ "multi-user.target" ];

nixos/modules/services/monitoring/zabbix-server.nix

···
       fping.source = "${pkgs.fping}/bin/fping";
     };
 
-    systemd.services."zabbix-server" = {
+    systemd.services.zabbix-server = {
       description = "Zabbix Server";
 
       wantedBy = [ "multi-user.target" ];

nixos/modules/services/network-filesystems/beegfs.nix

···
   # functions to generate systemd.service entries
 
   systemdEntry = service: cfgFile: (mapAttrs' ( name: cfg:
-    (nameValuePair "beegfs-${service}-${name}" (mkIf cfg."${service}".enable {
+    (nameValuePair "beegfs-${service}-${name}" (mkIf cfg.${service}.enable {
     wantedBy = [ "multi-user.target" ];
     requires = [ "network-online.target" ];
     after = [ "network-online.target" ];

nixos/modules/services/network-filesystems/ceph.nix

···
       # Remove all name-value pairs with null values from the attribute set to avoid making empty sections in the ceph.conf
       globalConfig = mapAttrs' (name: value: nameValuePair (translateOption name) value) (filterAttrs (name: value: value != null) globalAndMgrConfig);
       totalConfig = {
-          "global" = globalConfig;
-        } // optionalAttrs (cfg.mon.enable && cfg.mon.extraConfig != {}) { "mon" = cfg.mon.extraConfig; }
-          // optionalAttrs (cfg.mds.enable && cfg.mds.extraConfig != {}) { "mds" = cfg.mds.extraConfig; }
-          // optionalAttrs (cfg.osd.enable && cfg.osd.extraConfig != {}) { "osd" = cfg.osd.extraConfig; }
+          global = globalConfig;
+        } // optionalAttrs (cfg.mon.enable && cfg.mon.extraConfig != {}) { mon = cfg.mon.extraConfig; }
+          // optionalAttrs (cfg.mds.enable && cfg.mds.extraConfig != {}) { mds = cfg.mds.extraConfig; }
+          // optionalAttrs (cfg.osd.enable && cfg.osd.extraConfig != {}) { osd = cfg.osd.extraConfig; }
           // optionalAttrs (cfg.client.enable && cfg.client.extraConfig != {})  cfg.client.extraConfig;
       in
         generators.toINI {} totalConfig;
···
 
     systemd.targets = let
       targets = [
-        { "ceph" = { description = "Ceph target allowing to start/stop all ceph service instances at once"; }; }
+        { ceph = { description = "Ceph target allowing to start/stop all ceph service instances at once"; }; }
       ] ++ optional cfg.mon.enable (generateTargetFile "mon")
         ++ optional cfg.mds.enable (generateTargetFile "mds")
         ++ optional cfg.osd.enable (generateTargetFile "osd")

nixos/modules/services/network-filesystems/samba.nix

···
           # Refer to https://github.com/samba-team/samba/tree/master/packaging/systemd
           # for correct use with systemd
           services = {
-            "samba-smbd" = daemonService "smbd" "";
-            "samba-nmbd" = mkIf cfg.enableNmbd (daemonService "nmbd" "");
-            "samba-winbindd" = mkIf cfg.enableWinbindd (daemonService "winbindd" "");
-            "samba-setup" = {
+            samba-smbd = daemonService "smbd" "";
+            samba-nmbd = mkIf cfg.enableNmbd (daemonService "nmbd" "");
+            samba-winbindd = mkIf cfg.enableWinbindd (daemonService "winbindd" "");
+            samba-setup = {
               description = "Samba Setup Task";
               script = setupScript;
               unitConfig.RequiresMountsFor = "/var/lib/samba";

nixos/modules/services/networking/babeld.nix

···
         example =
           {
             type = "tunnel";
-            "split-horizon" = true;
+            split-horizon = true;
           };
       };
 
···
         example =
           { enp0s2 =
             { type = "wired";
-              "hello-interval" = 5;
-              "split-horizon" = "auto";
+              hello-interval = 5;
+              split-horizon = "auto";
             };
           };
       };

nixos/modules/services/networking/connman.nix

···
 
     environment.systemPackages = [ connman ];
 
-    systemd.services."connman" = {
+    systemd.services.connman = {
       description = "Connection service";
       wantedBy = [ "multi-user.target" ];
       after = [ "syslog.target" ];
···
       };
     };
 
-    systemd.services."connman-vpn" = mkIf cfg.enableVPN {
+    systemd.services.connman-vpn = mkIf cfg.enableVPN {
       description = "ConnMan VPN service";
       wantedBy = [ "multi-user.target" ];
       after = [ "syslog.target" ];
···
       };
     };
 
-    systemd.services."net-connman-vpn" = mkIf cfg.enableVPN {
+    systemd.services.net-connman-vpn = mkIf cfg.enableVPN {
       description = "D-BUS Service";
       serviceConfig = {
         Name = "net.connman.vpn";

nixos/modules/services/networking/consul.nix

···
   config = mkIf cfg.enable (
     mkMerge [{
 
-      users.users."consul" = {
+      users.users.consul = {
         description = "Consul agent daemon user";
         uid = config.ids.uids.consul;
         # The shell is needed for health checks

nixos/modules/services/networking/firewall.nix

···
     ${text}
   ''; in "${dir}/bin/${name}";
 
-  defaultInterface = { default = mapAttrs (name: value: cfg."${name}") commonOptions; };
+  defaultInterface = { default = mapAttrs (name: value: cfg.${name}) commonOptions; };
   allInterfaces = defaultInterface // cfg.interfaces;
 
   startScript = writeShScript "firewall-start" ''

nixos/modules/services/networking/git-daemon.nix

···
         gid = config.ids.gids.git;
       };
 
-    systemd.services."git-daemon" = {
+    systemd.services.git-daemon = {
       after = [ "network.target" ];
       wantedBy = [ "multi-user.target" ];
       script = "${pkgs.git}/bin/git daemon --reuseaddr "

nixos/modules/services/networking/hylafax/systemd.nix

···
     inherit (cfg) spoolAreaPath;
   };
 
-  sockets."hylafax-hfaxd" = {
+  sockets.hylafax-hfaxd = {
     description = "HylaFAX server socket";
     documentation = [ "man:hfaxd(8)" ];
     wantedBy = [ "multi-user.target" ];
···
     socketConfig.Accept = true;
   };
 
-  paths."hylafax-faxq" = {
+  paths.hylafax-faxq = {
     description = "HylaFAX queue manager sendq watch";
     documentation = [ "man:faxq(8)" "man:sendq(5)" ];
     wantedBy = [ "multi-user.target" ];
···
   timers = mkMerge [
     (
       mkIf (cfg.faxcron.enable.frequency!=null)
-      { "hylafax-faxcron".timerConfig.Persistent = true; }
+      { hylafax-faxcron.timerConfig.Persistent = true; }
     )
     (
       mkIf (cfg.faxqclean.enable.frequency!=null)
-      { "hylafax-faxqclean".timerConfig.Persistent = true; }
+      { hylafax-faxqclean.timerConfig.Persistent = true; }
     )
   ];
 
···
     in
       service: service // { serviceConfig = apply service; };
 
-  services."hylafax-spool" = {
+  services.hylafax-spool = {
     description = "HylaFAX spool area preparation";
     documentation = [ "man:hylafax-server(4)" ];
     script = ''
···
     unitConfig.RequiresMountsFor = [ cfg.spoolAreaPath ];
   };
 
-  services."hylafax-faxq" = {
+  services.hylafax-faxq = {
     description = "HylaFAX queue manager";
     documentation = [ "man:faxq(8)" ];
     requires = [ "hylafax-spool.service" ];
···
     serviceConfig.PrivateNetwork = null;
   };
 
-  services."hylafax-faxcron" = rec {
+  services.hylafax-faxcron = rec {
     description = "HylaFAX spool area maintenance";
     documentation = [ "man:faxcron(8)" ];
     after = [ "hylafax-spool.service" ];
···
     ];
   };
 
-  services."hylafax-faxqclean" = rec {
+  services.hylafax-faxqclean = rec {
     description = "HylaFAX spool area queue cleaner";
     documentation = [ "man:faxqclean(8)" ];
     after = [ "hylafax-spool.service" ];

nixos/modules/services/networking/ircd-hybrid/default.nix

···
 
     users.groups.ircd.gid = config.ids.gids.ircd;
 
-    systemd.services."ircd-hybrid" = {
+    systemd.services.ircd-hybrid = {
       description = "IRCD Hybrid server";
       after = [ "started networking" ];
       wantedBy = [ "multi-user.target" ];

nixos/modules/services/networking/mtprotoproxy.nix

···
       users = mkOption {
         type = types.attrsOf types.str;
         example = {
-          "tg" = "00000000000000000000000000000000";
-          "tg2" = "0123456789abcdef0123456789abcdef";
+          tg = "00000000000000000000000000000000";
+          tg2 = "0123456789abcdef0123456789abcdef";
         };
         description = ''
           Allowed users and their secrets. A secret is a 32 characters long hex string.
···
         type = types.attrs;
         default = {};
         example = {
-          "STATS_PRINT_PERIOD" = 600;
+          STATS_PRINT_PERIOD = 600;
         };
         description = ''
           Extra configuration options for mtprotoproxy.

nixos/modules/services/networking/ndppd.nix

···
         messages, and respond to them according to a set of rules.
       '';
       default = {};
-      example = { "eth0".rules."1111::/64" = {}; };
+      example = { eth0.rules."1111::/64" = {}; };
     };
   };
 
···
     '' ];
 
     services.ndppd.proxies = mkIf (cfg.interface != null && cfg.network != null) {
-      "${cfg.interface}".rules."${cfg.network}" = {};
+      ${cfg.interface}.rules.${cfg.network} = {};
     };
 
     systemd.services.ndppd = {

nixos/modules/services/networking/networkmanager.nix

···
   '';
 
   dispatcherTypesSubdirMap = {
-    "basic" = "";
-    "pre-up" = "pre-up.d/";
-    "pre-down" = "pre-down.d/";
+    basic = "";
+    pre-up = "pre-up.d/";
+    pre-down = "pre-down.d/";
   };
 
   macAddressOpt = mkOption {
···
 
     systemd.packages = cfg.packages;
 
-    systemd.services."NetworkManager" = {
+    systemd.services.NetworkManager = {
       wantedBy = [ "network.target" ];
       restartTriggers = [ configFile ];
 
···
       };
     };
 
-    systemd.services."NetworkManager-dispatcher" = {
+    systemd.services.NetworkManager-dispatcher = {
       wantedBy = [ "network.target" ];
       restartTriggers = [ configFile ];
 

nixos/modules/services/networking/nsd.nix

···
       '';
     };
 
-    systemd.timers."nsd-dnssec" = mkIf dnssec {
+    systemd.timers.nsd-dnssec = mkIf dnssec {
       description = "Automatic DNSSEC key rollover";
 
       wantedBy = [ "nsd.service" ];
···
       };
     };
 
-    systemd.services."nsd-dnssec" = mkIf dnssec {
+    systemd.services.nsd-dnssec = mkIf dnssec {
       description = "DNSSEC key rollover";
 
       wantedBy = [ "nsd.service" ];

nixos/modules/services/networking/pdns-recursor.nix

···
 
   config = mkIf cfg.enable {
 
-    users.users."${username}" = {
+    users.users.${username} = {
       home = dataDir;
       createHome = true;
       uid = config.ids.uids.pdns-recursor;

nixos/modules/services/networking/quicktun.nix

···
           wantedBy = [ "multi-user.target" ];
           after = [ "network.target" ];
           environment = {
-            "INTERFACE" = name;
-            "TUN_MODE" = toString qtcfg.tunMode;
-            "REMOTE_ADDRESS" = qtcfg.remoteAddress;
-            "LOCAL_ADDRESS" = qtcfg.localAddress;
-            "LOCAL_PORT" = toString qtcfg.localPort;
-            "REMOTE_PORT" = toString qtcfg.remotePort;
-            "REMOTE_FLOAT" = toString qtcfg.remoteFloat;
-            "PRIVATE_KEY" = qtcfg.privateKey;
-            "PUBLIC_KEY" = qtcfg.publicKey;
-            "TIME_WINDOW" = toString qtcfg.timeWindow;
-            "TUN_UP_SCRIPT" = pkgs.writeScript "quicktun-${name}-up.sh" qtcfg.upScript;
-            "SUID" = "nobody";
+            INTERFACE = name;
+            TUN_MODE = toString qtcfg.tunMode;
+            REMOTE_ADDRESS = qtcfg.remoteAddress;
+            LOCAL_ADDRESS = qtcfg.localAddress;
+            LOCAL_PORT = toString qtcfg.localPort;
+            REMOTE_PORT = toString qtcfg.remotePort;
+            REMOTE_FLOAT = toString qtcfg.remoteFloat;
+            PRIVATE_KEY = qtcfg.privateKey;
+            PUBLIC_KEY = qtcfg.publicKey;
+            TIME_WINDOW = toString qtcfg.timeWindow;
+            TUN_UP_SCRIPT = pkgs.writeScript "quicktun-${name}-up.sh" qtcfg.upScript;
+            SUID = "nobody";
           };
           serviceConfig = {
             Type = "simple";

nixos/modules/services/networking/smokeping.nix

···
     ];
     security.wrappers = {
       fping.source = "${pkgs.fping}/bin/fping";
-      "fping6".source = "${pkgs.fping}/bin/fping6";
+      fping6.source = "${pkgs.fping}/bin/fping6";
     };
     environment.systemPackages = [ pkgs.fping ];
     users.users = singleton {

nixos/modules/services/networking/softether.nix

···
     mkMerge [{
       environment.systemPackages = [ package ];
 
-      systemd.services."softether-init" = {
+      systemd.services.softether-init = {
         description = "SoftEther VPN services initial task";
         after = [ "keys.target" ];
         wants = [ "keys.target" ];

nixos/modules/services/networking/strongswan-swanctl/param-constructors.nix

···
       StrongSwan default: <literal><![CDATA[${builtins.toJSON strongswanDefault}]]></literal>
     '';
 
-  single = f: name: value: { "${name}" = f value; };
+  single = f: name: value: { ${name} = f value; };
 
   mkStrParam         = mkParamOfType types.str;
   mkOptionalStrParam = mkStrParam null;

nixos/modules/services/networking/strongswan-swanctl/param-lib.nix

···
   mkConf = indent : ps :
     concatMapStringsSep "\n"
       (name:
-        let value = ps."${name}";
+        let value = ps.${name};
             indentation = replicate indent " ";
         in
         indentation + (
···
   ) set);
 
   # Recursively map over every parameter in the given attribute set.
-  mapParamsRecursive = mapAttrsRecursiveCond' (as: (!(as ? "_type" && as._type == "param")));
+  mapParamsRecursive = mapAttrsRecursiveCond' (as: (!(as ? _type && as._type == "param")));
 
   mapAttrsRecursiveCond' = cond: f: set:
     let
···
           g =
             name: value:
             if isAttrs value && cond value
-              then { "${name}" = recurse (path ++ [name]) value; }
+              then { ${name} = recurse (path ++ [name]) value; }
               else f (path ++ [name]) name value;
         in mapAttrs'' g set;
     in recurse [] set;
···
 
   # Extract the options from the given set of parameters.
   paramsToOptions = ps :
-    mapParamsRecursive (_path: name: param: { "${name}" = param.option; }) ps;
+    mapParamsRecursive (_path: name: param: { ${name} = param.option; }) ps;
 
 }

nixos/modules/services/networking/syncthing.nix

···
     systemd.packages = [ pkgs.syncthing ];
 
     users.users = mkIf (cfg.systemService && cfg.user == defaultUser) {
-      "${defaultUser}" =
+      ${defaultUser} =
         { group = cfg.group;
           home  = cfg.dataDir;
           createHome = true;
···
     };
 
     users.groups = mkIf (cfg.systemService && cfg.group == defaultUser) {
-      "${defaultUser}".gid =
+      ${defaultUser}.gid =
         config.ids.gids.syncthing;
     };
 

nixos/modules/services/networking/websockify.nix

···
       scriptArgs = "%i";
     };
 
-    systemd.targets."default-websockify" = {
+    systemd.targets.default-websockify = {
       description = "Target to start all default websockify@ services";
-      unitConfig."X-StopOnReconfiguration" = true;
+      unitConfig.X-StopOnReconfiguration = true;
       wants = mapAttrsToList (name: value: "websockify@${name}:${toString value}.service") cfg.portMap;
       wantedBy = [ "multi-user.target" ];
     };

nixos/modules/services/networking/zerobin.nix

···
     };
 
     config = mkIf (cfg.enable) {
-      users.users."${cfg.user}" =
+      users.users.${cfg.user} =
       if cfg.user == "zerobin" then {
         isSystemUser = true;
         group = cfg.group;
···
         createHome = true;
       }
       else {};
-      users.groups."${cfg.group}" = {};
+      users.groups.${cfg.group} = {};
 
       systemd.services.zerobin = {
         enable = true;

nixos/modules/services/printing/cupsd.nix

···
       };
 
     environment.systemPackages = [ cups.out ] ++ optional polkitEnabled cups-pk-helper;
-    environment.etc."cups".source = "/var/lib/cups";
+    environment.etc.cups.source = "/var/lib/cups";
 
     services.dbus.packages = [ cups.out ] ++ optional polkitEnabled cups-pk-helper;
 

nixos/modules/services/security/fprot.nix

···
 
     services.cron.systemCronJobs = [ "*/${toString cfg.updater.frequency} * * * * root start fprot-updater" ];
 
-    systemd.services."fprot-updater" = {
+    systemd.services.fprot-updater = {
       serviceConfig = {
         Type = "oneshot";
         RemainAfterExit = false;

nixos/modules/services/security/physlock.nix

···
       # for physlock -l and physlock -L
       environment.systemPackages = [ pkgs.physlock ];
 
-      systemd.services."physlock" = {
+      systemd.services.physlock = {
         enable = true;
         description = "Physlock";
         wantedBy = optional cfg.lockOn.suspend   "suspend.target"

nixos/modules/services/security/sks.nix

···
       hkpAddress = "'" + (builtins.concatStringsSep " " cfg.hkpAddress) + "'" ;
       hkpPort = builtins.toString cfg.hkpPort;
     in {
-      "sks-db" = {
+      sks-db = {
         description = "SKS database server";
         after = [ "network.target" ];
         wantedBy = [ "multi-user.target" ];

nixos/modules/services/system/localtime.nix

···
   config = mkIf cfg.enable {
     services.geoclue2 = {
       enable = true;
-      appConfig."localtime" = {
+      appConfig.localtime = {
         isAllowed = true;
         isSystem = true;
       };

nixos/modules/services/torrent/deluge.nix

···
     services.deluge.extraPackages = with pkgs; [ unzip gnutar xz p7zip bzip2 ];
 
     systemd.tmpfiles.rules = [ "d '${configDir}' 0770 ${cfg.user} ${cfg.group}" ]
-    ++ optional (cfg.config ? "download_location")
+    ++ optional (cfg.config ? download_location)
       "d '${cfg.config.download_location}' 0770 ${cfg.user} ${cfg.group}"
-    ++ optional (cfg.config ? "torrentfiles_location")
+    ++ optional (cfg.config ? torrentfiles_location)
       "d '${cfg.config.torrentfiles_location}' 0770 ${cfg.user} ${cfg.group}"
-    ++ optional (cfg.config ? "move_completed_path")
+    ++ optional (cfg.config ? move_completed_path)
       "d '${cfg.config.move_completed_path}' 0770 ${cfg.user} ${cfg.group}";
 
     systemd.services.deluged = {

nixos/modules/services/ttys/agetty.nix

···
         restartIfChanged = false;
       };
 
-    systemd.services."console-getty" =
+    systemd.services.console-getty =
       { serviceConfig.ExecStart = [
           "" # override upstream default with an empty ExecStart
           (gettyCmd "--noclear --keep-baud console 115200,38400,9600 $TERM")

nixos/modules/services/web-apps/atlassian/confluence.nix

···
   };
 
   config = mkIf cfg.enable {
-    users.users."${cfg.user}" = {
+    users.users.${cfg.user} = {
       isSystemUser = true;
       group = cfg.group;
     };
 
-    users.groups."${cfg.group}" = {};
+    users.groups.${cfg.group} = {};
 
     systemd.tmpfiles.rules = [
       "d '${cfg.home}' - ${cfg.user} - - -"

nixos/modules/services/web-apps/atlassian/crowd.nix

···
   };
 
   config = mkIf cfg.enable {
-    users.users."${cfg.user}" = {
+    users.users.${cfg.user} = {
       isSystemUser = true;
       group = cfg.group;
     };
 
-    users.groups."${cfg.group}" = {};
+    users.groups.${cfg.group} = {};
 
     systemd.tmpfiles.rules = [
       "d '${cfg.home}' - ${cfg.user} ${cfg.group} - -"

nixos/modules/services/web-apps/atlassian/jira.nix

···
   };
 
   config = mkIf cfg.enable {
-    users.users."${cfg.user}" = {
+    users.users.${cfg.user} = {
       isSystemUser = true;
       group = cfg.group;
     };
 
-    users.groups."${cfg.group}" = {};
+    users.groups.${cfg.group} = {};
 
     systemd.tmpfiles.rules = [
       "d '${cfg.home}' - ${cfg.user} - - -"

nixos/modules/services/web-apps/icingaweb2/icingaweb2.nix

···
 
   config = mkIf cfg.enable {
     services.phpfpm.poolConfigs = mkIf (cfg.pool == "${poolName}") {
-      "${poolName}" = ''
+      ${poolName} = ''
         listen = "${phpfpmSocketName}"
         listen.owner = nginx
         listen.group = nginx
···
     services.nginx = {
       enable = true;
       virtualHosts = mkIf (cfg.virtualHost != null) {
-        "${cfg.virtualHost}" = {
+        ${cfg.virtualHost} = {
           root = "${pkgs.icingaweb2}/public";
 
           extraConfig = ''
···
 
     # /etc/icingaweb2
     environment.etc = let
-      doModule = name: optionalAttrs (cfg.modules."${name}".enable) { "icingaweb2/enabledModules/${name}".source = "${pkgs.icingaweb2}/modules/${name}"; };
+      doModule = name: optionalAttrs (cfg.modules.${name}.enable) { "icingaweb2/enabledModules/${name}".source = "${pkgs.icingaweb2}/modules/${name}"; };
     in {}
       # Module packages
       // (mapAttrs' (k: v: nameValuePair "icingaweb2/enabledModules/${k}" { source = v; }) cfg.modulePackages)

nixos/modules/services/web-apps/icingaweb2/module-monitoring.nix

···
     };
 
     backends = mkOption {
-      default = { "icinga" = { resource = "icinga_ido"; }; };
+      default = { icinga = { resource = "icinga_ido"; }; };
       description = "Monitoring backends to define";
       type = attrsOf (submodule ({ name, ... }: {
         options = {

nixos/modules/services/web-apps/limesurvey.nix

···
 
     systemd.services.httpd.after = optional mysqlLocal "mysql.service" ++ optional pgsqlLocal "postgresql.service";
 
-    users.users."${user}".group = group;
+    users.users.${user}.group = group;
 
   };
 }

nixos/modules/services/web-apps/nextcloud.nix

···
     phpOptions = mkOption {
       type = types.attrsOf types.str;
       default = {
-        "short_open_tag" = "Off";
-        "expose_php" = "Off";
-        "error_reporting" = "E_ALL & ~E_DEPRECATED & ~E_STRICT";
-        "display_errors" = "stderr";
+        short_open_tag = "Off";
+        expose_php = "Off";
+        error_reporting = "E_ALL & ~E_DEPRECATED & ~E_STRICT";
+        display_errors = "stderr";
         "opcache.enable_cli" = "1";
         "opcache.interned_strings_buffer" = "8";
         "opcache.max_accelerated_files" = "10000";
···
         "opcache.revalidate_freq" = "1";
         "opcache.fast_shutdown" = "1";
         "openssl.cafile" = "/etc/ssl/certs/ca-certificates.crt";
-        "catch_workers_output" = "yes";
+        catch_workers_output = "yes";
       };
       description = ''
         Options for PHP's php.ini file for nextcloud.
···
       ];
     }
 
-    { systemd.timers."nextcloud-cron" = {
+    { systemd.timers.nextcloud-cron = {
         wantedBy = [ "timers.target" ];
         timerConfig.OnBootSec = "5m";
         timerConfig.OnUnitActiveSec = "15m";
···
       };
 
       systemd.services = {
-        "nextcloud-setup" = let
+        nextcloud-setup = let
           c = cfg.config;
           writePhpArrary = a: "[${concatMapStringsSep "," (val: ''"${toString val}"'') a}]";
           overrideConfig = pkgs.writeText "nextcloud-config.php" ''
···
           '';
           serviceConfig.Type = "oneshot";
         };
-        "nextcloud-cron" = {
+        nextcloud-cron = {
           environment.NEXTCLOUD_CONFIG_DIR = "${cfg.home}/config";
           serviceConfig.Type = "oneshot";
           serviceConfig.User = "nextcloud";
           serviceConfig.ExecStart = "${phpPackage}/bin/php -f ${pkgs.nextcloud}/cron.php";
         };
-        "nextcloud-update-plugins" = mkIf cfg.autoUpdateApps.enable {
+        nextcloud-update-plugins = mkIf cfg.autoUpdateApps.enable {
           serviceConfig.Type = "oneshot";
           serviceConfig.ExecStart = "${occ}/bin/nextcloud-occ app:update --all";
           startAt = cfg.autoUpdateApps.startAt;
···
       services.nginx = {
         enable = true;
         virtualHosts = {
-          "${cfg.hostName}" = {
+          ${cfg.hostName} = {
             root = pkgs.nextcloud;
             locations = {
               "= /robots.txt" = {

nixos/modules/services/web-apps/nexus.nix

···
   };
 
   config = mkIf cfg.enable {
-    users.users."${cfg.user}" = {
+    users.users.${cfg.user} = {
       isSystemUser = true;
       group = cfg.group;
       home = cfg.home;
       createHome = true;
     };
 
-    users.groups."${cfg.group}" = {};
+    users.groups.${cfg.group} = {};
 
     systemd.services.nexus = {
       description = "Sonatype Nexus3";

nixos/modules/services/web-apps/pgpkeyserver-lite.nix

···
     services.nginx.virtualHosts = let
       hkpPort = builtins.toString cfg.hkpPort;
     in {
-      "${cfg.hostname}" = {
+      ${cfg.hostname} = {
         root = webPkg;
         locations = {
           "/pks".extraConfig = ''

nixos/modules/services/web-apps/restya-board.nix

···
   config = mkIf cfg.enable {
 
     services.phpfpm.pools = {
-      "${poolName}" = {
+      ${poolName} = {
         listen = phpfpmSocketName;
         phpOptions = ''
           date.timezone = "CET"
···
     };
 
     services.nginx.enable = true;
-    services.nginx.virtualHosts."${cfg.virtualHost.serverName}" = {
+    services.nginx.virtualHosts.${cfg.virtualHost.serverName} = {
       listen = [ { addr = cfg.virtualHost.listenHost; port = cfg.virtualHost.listenPort; } ];
       serverName = cfg.virtualHost.serverName;
       root = runDir;

nixos/modules/services/web-apps/selfoss.nix

···
   config = mkIf cfg.enable {
 
     services.phpfpm.poolConfigs = mkIf (cfg.pool == "${poolName}") {
-      "${poolName}" = ''
+      ${poolName} = ''
         listen = "${phpfpmSocketName}";
         listen.owner = nginx
         listen.group = nginx

nixos/modules/services/web-apps/tt-rss.nix

···
     ];
 
     services.phpfpm.pools = mkIf (cfg.pool == "${poolName}") {
-      "${poolName}" = {
+      ${poolName} = {
         listen = "/var/run/phpfpm/${poolName}.sock";
         extraConfig = ''
           listen.owner = nginx
···
     services.nginx = mkIf (cfg.virtualHost != null) {
       enable = true;
       virtualHosts = {
-        "${cfg.virtualHost}" = {
+        ${cfg.virtualHost} = {
           root = "${cfg.root}";
 
           locations."/" = {

nixos/modules/services/web-apps/zabbix.nix

···
     <?php
     // Zabbix GUI configuration file.
     global $DB;
-    $DB['TYPE'] = '${ { "mysql" = "MYSQL"; "pgsql" = "POSTGRESQL"; "oracle" = "ORACLE"; }.${cfg.database.type} }';
+    $DB['TYPE'] = '${ { mysql = "MYSQL"; pgsql = "POSTGRESQL"; oracle = "ORACLE"; }.${cfg.database.type} }';
     $DB['SERVER'] = '${cfg.database.host}';
     $DB['PORT'] = '${toString cfg.database.port}';
     $DB['DATABASE'] = '${cfg.database.name}';

nixos/modules/services/x11/clight.nix

···
       longitude = mkDefault config.location.longitude;
     });
 
-    services.geoclue2.appConfig."clightc" = {
+    services.geoclue2.appConfig.clightc = {
       isAllowed = true;
       isSystem = true;
     };

nixos/modules/services/x11/desktop-managers/gnome3.nix

···
     # GNOME should have its own geoclue agent
     services.geoclue2.enableDemoAgent = false;
 
-    services.geoclue2.appConfig."gnome-datetime-panel" = {
+    services.geoclue2.appConfig.gnome-datetime-panel = {
       isAllowed = true;
       isSystem = true;
     };
-    services.geoclue2.appConfig."gnome-color-panel" = {
+    services.geoclue2.appConfig.gnome-color-panel = {
       isAllowed = true;
       isSystem = true;
     };

nixos/modules/services/x11/desktop-managers/mate.nix

···
     services.gnome3.gvfs.enable = true;
     services.upower.enable = config.powerManagement.enable;
 
-    security.pam.services."mate-screensaver".unixAuth = true;
+    security.pam.services.mate-screensaver.unixAuth = true;
 
     environment.variables.GIO_EXTRA_MODULES = [ "${pkgs.gnome3.gvfs}/lib/gio/modules" ];
 

nixos/modules/services/x11/desktop-managers/plasma5.nix

···
 
       security.wrappers = {
         kcheckpass.source = "${lib.getBin plasma5.kscreenlocker}/libexec/kcheckpass";
-        "start_kdeinit".source = "${lib.getBin pkgs.kinit}/libexec/kf5/start_kdeinit";
+        start_kdeinit.source = "${lib.getBin pkgs.kinit}/libexec/kf5/start_kdeinit";
         kwin_wayland = {
           source = "${lib.getBin plasma5.kwin}/bin/kwin_wayland";
           capabilities = "cap_sys_nice+ep";

nixos/modules/services/x11/display-managers/lightdm.nix

···
 
   xcfg = config.services.xserver;
   dmcfg = xcfg.displayManager;
-  xEnv = config.systemd.services."display-manager".environment;
+  xEnv = config.systemd.services.display-manager.environment;
   cfg = dmcfg.lightdm;
 
   dmDefault = xcfg.desktopManager.default;

nixos/modules/services/x11/display-managers/sddm.nix

···
   xcfg = config.services.xserver;
   dmcfg = xcfg.displayManager;
   cfg = dmcfg.sddm;
-  xEnv = config.systemd.services."display-manager".environment;
+  xEnv = config.systemd.services.display-manager.environment;
 
   inherit (pkgs) sddm;
 

nixos/modules/services/x11/hardware/synaptics.nix

···
 
     services.xserver.modules = [ pkg.out ];
 
-    environment.etc."${etcFile}".source =
+    environment.etc.${etcFile}.source =
       "${pkg.out}/share/X11/xorg.conf.d/70-synaptics.conf";
 
     environment.systemPackages = [ pkg ];

nixos/modules/services/x11/redshift.nix

···
     # needed so that .desktop files are installed, which geoclue cares about
     environment.systemPackages = [ cfg.package ];
 
-    services.geoclue2.appConfig."redshift" = {
+    services.geoclue2.appConfig.redshift = {
       isAllowed = true;
       isSystem = true;
     };

nixos/modules/services/x11/xautolock.nix

···
       ] ++ (lib.flip map [ "locker" "notifier" "nowlocker" "killer" ]
         (option:
         {
-          assertion = cfg."${option}" != null -> builtins.substring 0 1 cfg."${option}" == "/";
+          assertion = cfg.${option} != null -> builtins.substring 0 1 cfg.${option} == "/";
           message = "Please specify a canonical path for `services.xserver.xautolock.${option}`";
         })
       );

nixos/modules/system/boot/kernel.nix

···
         source = kernelModulesConf;
       };
 
-    systemd.services."systemd-modules-load" =
+    systemd.services.systemd-modules-load =
       { wantedBy = [ "multi-user.target" ];
         restartTriggers = [ kernelModulesConf ];
         serviceConfig =

nixos/modules/system/boot/kexec.nix

···
   config = lib.mkIf (lib.any (lib.meta.platformMatch pkgs.stdenv.hostPlatform) pkgs.kexectools.meta.platforms) {
     environment.systemPackages = [ pkgs.kexectools ];
 
-    systemd.services."prepare-kexec" =
+    systemd.services.prepare-kexec =
       { description = "Preparation for kexec";
         wantedBy = [ "kexec.target" ];
         before = [ "systemd-kexec.service" ];

nixos/modules/system/boot/loader/grub/grub.nix

···
              else "${convertedFont}");
     });
 
-  bootDeviceCounters = fold (device: attr: attr // { "${device}" = (attr."${device}" or 0) + 1; }) {}
+  bootDeviceCounters = fold (device: attr: attr // { ${device} = (attr.${device} or 0) + 1; }) {}
     (concatMap (args: args.devices) cfg.mirroredBoots);
 
   convertedFont = (pkgs.runCommand "grub-font-converted.pf2" {}

nixos/modules/system/boot/luksroot.nix

···
 
     boot.initrd.luks.devices = mkOption {
       default = { };
-      example = { "luksroot".device = "/dev/disk/by-uuid/430e9eff-d852-4f68-aa3b-2fa3599ebe08"; };
+      example = { luksroot.device = "/dev/disk/by-uuid/430e9eff-d852-4f68-aa3b-2fa3599ebe08"; };
       description = ''
         The encrypted disk that should be opened before the root
         filesystem is mounted. Both LVM-over-LUKS and LUKS-over-LVM

nixos/modules/system/boot/systemd-nspawn.nix

···
 
       environment.etc."systemd/nspawn".source = generateUnits "nspawn" units [] [];
 
-      systemd.targets."multi-user".wants = [ "machines.target" ];
+      systemd.targets.multi-user.wants = [ "machines.target" ];
   };
 
 }

nixos/modules/system/boot/systemd.nix

···
           [Service]
           ${let env = cfg.globalEnvironment // def.environment;
             in concatMapStrings (n:
-              let s = optionalString (env."${n}" != null)
+              let s = optionalString (env.${n} != null)
                 "Environment=${builtins.toJSON "${n}=${env.${n}}"}\n";
               # systemd max line length is now 1MiB
               # https://github.com/systemd/systemd/commit/e6dde451a51dc5aaa7f4d98d39b8fe735f73d2af
···
     systemd.generators = mkOption {
       type = types.attrsOf types.path;
       default = {};
-      example = { "systemd-gpt-auto-generator" = "/dev/null"; };
+      example = { systemd-gpt-auto-generator = "/dev/null"; };
       description = ''
         Definition of systemd generators.
         For each <literal>NAME = VALUE</literal> pair of the attrSet, a link is generated from

nixos/modules/tasks/filesystems.nix

···
 
   fileSystems' = toposort fsBefore (attrValues config.fileSystems);
 
-  fileSystems = if fileSystems' ? "result"
+  fileSystems = if fileSystems' ? result
                 then # use topologically sorted fileSystems everywhere
                      fileSystems'.result
                 else # the assertion below will catch this,
···
       ls = sep: concatMapStringsSep sep (x: x.mountPoint);
       notAutoResizable = fs: fs.autoResize && !(hasPrefix "ext" fs.fsType || fs.fsType == "f2fs");
     in [
-      { assertion = ! (fileSystems' ? "cycle");
+      { assertion = ! (fileSystems' ? cycle);
         message = "The ‘fileSystems’ option can't be topologically sorted: mountpoint dependency path ${ls " -> " fileSystems'.cycle} loops to ${ls ", " fileSystems'.loops}";
       }
       { assertion = ! (any notAutoResizable fileSystems);

nixos/modules/tasks/filesystems/zfs.nix

···
                       map createSyncService allPools ++
                       map createZfsService [ "zfs-mount" "zfs-share" "zfs-zed" ]);
 
-      systemd.targets."zfs-import" =
+      systemd.targets.zfs-import =
         let
           services = map (pool: "zfs-import-${pool}.service") dataPools;
         in
···
             wantedBy = [ "zfs.target" ];
           };
 
-      systemd.targets."zfs".wantedBy = [ "multi-user.target" ];
+      systemd.targets.zfs.wantedBy = [ "multi-user.target" ];
     })
 
     (mkIf enableAutoSnapshots {

nixos/modules/tasks/kbd.nix

···
 
   config = mkMerge [
     (mkIf (!setVconsole) {
-      systemd.services."systemd-vconsole-setup".enable = false;
+      systemd.services.systemd-vconsole-setup.enable = false;
     })
 
     (mkIf setVconsole (mkMerge [
···
         # virtual consoles.
         environment.etc."vconsole.conf".source = vconsoleConf;
         # Provide kbd with additional packages.
-        environment.etc."kbd".source = "${kbdEnv}/share";
+        environment.etc.kbd.source = "${kbdEnv}/share";
 
         boot.initrd.preLVMCommands = mkBefore ''
           kbd_mode ${if isUnicode then "-u" else "-a"} -C /dev/console
···
           '') config.i18n.consoleColors}
         '';
 
-        systemd.services."systemd-vconsole-setup" =
+        systemd.services.systemd-vconsole-setup =
           { before = [ "display-manager.service" ];
             after = [ "systemd-udev-settle.service" ];
             restartTriggers = [ vconsoleConf kbdEnv ];

nixos/modules/tasks/network-interfaces-scripted.nix

···
          // mapAttrs' createSitDevice cfg.sits
          // mapAttrs' createVlanDevice cfg.vlans
          // {
-           "network-setup" = networkSetup;
-           "network-local-commands" = networkLocalCommands;
+           network-setup = networkSetup;
+           network-local-commands = networkLocalCommands;
          };
 
     services.udev.extraRules =

nixos/modules/tasks/network-interfaces-systemd.nix

···
                             (mapAttrsToList (k: _: k) do); "";
             # get those driverOptions that have been set
             filterSystemdOptions = filterAttrs (sysDOpt: kOpts:
-                                     any (kOpt: do ? "${kOpt}") kOpts.optNames);
+                                     any (kOpt: do ? ${kOpt}) kOpts.optNames);
             # build final set of systemd options to bond values
             buildOptionSet = mapAttrs (_: kOpts: with kOpts;
                                # we simply take the first set kernel bond option
                                # (one option has multiple names, which is silly)
-                               head (map (optN: valTransform (do."${optN}"))
+                               head (map (optN: valTransform (do.${optN}))
                                  # only map those that exist
-                                 (filter (o: do ? "${o}") optNames)));
+                                 (filter (o: do ? ${o}) optNames)));
             in seq assertNoUnknownOption
                    (buildOptionSet (filterSystemdOptions driverOptionMapping));
 

nixos/modules/tasks/network-interfaces.nix

···
     networking.wlanInterfaces = mkOption {
       default = { };
       example = literalExample {
-        "wlan-station0" = {
+        wlan-station0 = {
             device = "wlp6s0";
         };
-        "wlan-adhoc0" = {
+        wlan-adhoc0 = {
             type = "ibss";
             device = "wlp6s0";
             mac = "02:00:00:00:00:01";
         };
-        "wlan-p2p0" = {
+        wlan-p2p0 = {
             device = "wlp6s0";
             mac = "02:00:00:00:00:02";
         };
-        "wlan-ap0" = {
+        wlan-ap0 = {
             device = "wlp6s0";
             mac = "02:00:00:00:00:03";
         };
···
         domainname "${cfg.domain}"
       '';
 
-    environment.etc."hostid" = mkIf (cfg.hostId != null)
+    environment.etc.hostid = mkIf (cfg.hostId != null)
       { source = pkgs.runCommand "gen-hostid" { preferLocalBuild = true; } ''
           hi="${cfg.hostId}"
           ${if pkgs.stdenv.isBigEndian then ''
···
 
     # static hostname configuration needed for hostnamectl and the
     # org.freedesktop.hostname1 dbus service (both provided by systemd)
-    environment.etc."hostname" = mkIf (cfg.hostName != "")
+    environment.etc.hostname = mkIf (cfg.hostName != "")
       {
         text = cfg.hostName + "\n";
       };
···
 
     # The network-interfaces target is kept for backwards compatibility.
     # New modules must NOT use it.
-    systemd.targets."network-interfaces" =
+    systemd.targets.network-interfaces =
       { description = "All Network Interfaces (deprecated)";
         wantedBy = [ "network.target" ];
         before = [ "network.target" ];
···
           in
           flip (concatMapStringsSep "\n") (attrNames wlanDeviceInterfaces) (device:
             let
-              interfaces = wlanListDeviceFirst device wlanDeviceInterfaces."${device}";
+              interfaces = wlanListDeviceFirst device wlanDeviceInterfaces.${device};
               curInterface = elemAt interfaces 0;
               newInterfaces = drop 1 interfaces;
             in ''
             # It is important to have that rule first as overwriting the NAME attribute also prevents the
             # next rules from matching.
-            ${flip (concatMapStringsSep "\n") (wlanListDeviceFirst device wlanDeviceInterfaces."${device}") (interface:
+            ${flip (concatMapStringsSep "\n") (wlanListDeviceFirst device wlanDeviceInterfaces.${device}) (interface:
             ''ACTION=="add", SUBSYSTEM=="net", ENV{DEVTYPE}=="wlan", ENV{INTERFACE}=="${interface._iName}", ${systemdAttrs interface._iName}, RUN+="${newInterfaceScript device interface}"'')}
 
             # Add the required, new WLAN interfaces to the default WLAN interface with the

nixos/modules/virtualisation/brightbox-image.nix

···
   # Always include cryptsetup so that NixOps can use it.
   environment.systemPackages = [ pkgs.cryptsetup ];
 
-  systemd.services."fetch-ec2-data" =
+  systemd.services.fetch-ec2-data =
     { description = "Fetch EC2 Data";
 
       wantedBy = [ "multi-user.target" "sshd.service" ];

nixos/modules/virtualisation/containers.nix

···
       serviceConfig = serviceDirectives dummyConfig;
     };
   in {
-    systemd.targets."multi-user".wants = [ "machines.target" ];
+    systemd.targets.multi-user.wants = [ "machines.target" ];
 
     systemd.services = listToAttrs (filter (x: x.value != null) (
       # The generic container template used by imperative containers

nixos/modules/virtualisation/ec2-data.nix

···
         serviceConfig.RemainAfterExit = true;
       };
 
-    systemd.services."print-host-key" =
+    systemd.services.print-host-key =
       { description = "Print SSH Host Key";
         wantedBy = [ "multi-user.target" ];
         after = [ "sshd.service" ];

nixos/modules/virtualisation/kvmgt.nix

···
           and find info about device via <command>cat /sys/bus/pci/devices/*/mdev_supported_types/i915-GVTg_V5_4/description</command>
         '';
         example = {
-          "i915-GVTg_V5_8" = {
+          i915-GVTg_V5_8 = {
             uuid = "a297db4a-f4c2-11e6-90f6-d3b88d6c9525";
           };
         };

nixos/modules/virtualisation/virtualbox-host.nix

···
 
     # Since we lack the right setuid/setcap binaries, set up a host-only network by default.
   } (mkIf cfg.addNetworkInterface {
-    systemd.services."vboxnet0" =
+    systemd.services.vboxnet0 =
       { description = "VirtualBox vboxnet0 Interface";
         requires = [ "dev-vboxnetctl.device" ];
         after = [ "dev-vboxnetctl.device" ];

nixos/modules/virtualisation/vmware-guest.nix

···
         serviceConfig.ExecStart = "${open-vm-tools}/bin/vmtoolsd";
       };
 
-    environment.etc."vmware-tools".source = "${open-vm-tools}/etc/vmware-tools/*";
+    environment.etc.vmware-tools.source = "${open-vm-tools}/etc/vmware-tools/*";
 
     services.xserver = mkIf (!cfg.headless) {
       videoDrivers = mkOverride 50 [ "vmware" ];

nixos/tests/beegfs.nix

···
         }
       ];
 
-    environment.etc."${connAuthFile}" = {
+    environment.etc.${connAuthFile} = {
       enable = true;
       text = "ThisIsALousySecret";
       mode = "0600";
···
       ];
 
     environment.systemPackages = with pkgs; [ beegfs ];
-    environment.etc."${connAuthFile}" = {
+    environment.etc.${connAuthFile} = {
       enable = true;
       text = "ThisIsALousySecret";
       mode = "0600";
···
     services.beegfs.default = {
       mgmtdHost = "mgmt";
       connAuthFile = "/etc/${connAuthFile}";
-      "${service}" = {
+      ${service} = {
         enable = true;
         storeDir = "/data";
       };

nixos/tests/containers-reloadable.nix

···
     containers.test1 = {
       autoStart = true;
       config = {
-        environment.etc."check".text = "client_base";
+        environment.etc.check.text = "client_base";
       };
     };
 
···
       imports = [ client_base ];
 
       containers.test1.config = {
-        environment.etc."check".text = lib.mkForce "client_c1";
+        environment.etc.check.text = lib.mkForce "client_c1";
         services.httpd.enable = true;
         services.httpd.adminAddr = "[e-mail]";
       };
···
       imports = [ client_base ];
 
       containers.test1.config = {
-        environment.etc."check".text = lib.mkForce "client_c2";
+        environment.etc.check.text = lib.mkForce "client_c2";
         services.nginx.enable = true;
       };
     };

nixos/tests/elk.nix

···
     '';
   };
 in mapAttrs mkElkTest {
-  "ELK-5" = {
+  ELK-5 = {
     elasticsearch = pkgs.elasticsearch5;
     logstash      = pkgs.logstash5;
     kibana        = pkgs.kibana5;
     journalbeat   = pkgs.journalbeat5;
   };
-  "ELK-6" =
+  ELK-6 =
     if enableUnfree
     then {
       elasticsearch = pkgs.elasticsearch6;
···
       kibana        = pkgs.kibana6-oss;
       journalbeat   = pkgs.journalbeat6;
     };
-  "ELK-7" =
+  ELK-7 =
     if enableUnfree
     then {
       elasticsearch = pkgs.elasticsearch7;

nixos/tests/env.nix

···
   machine = { pkgs, ... }:
     {
       boot.kernelPackages = pkgs.linuxPackages;
-      environment.etc."plainFile".text = ''
+      environment.etc.plainFile.text = ''
         Hello World
       '';
       environment.etc."folder/with/file".text = ''

nixos/tests/gitlab.nix

···
         enable = true;
         recommendedProxySettings = true;
         virtualHosts = {
-          "localhost" = {
+          localhost = {
             locations."/".proxyPass = "http://unix:/run/gitlab/gitlab-workhorse.socket";
           };
         };

nixos/tests/kubernetes/base.nix

···
                 443 # kubernetes apiserver
               ];
             })
-            (optionalAttrs (machine ? "extraConfiguration") (machine.extraConfiguration { inherit config pkgs lib nodes; }))
+            (optionalAttrs (machine ? extraConfiguration) (machine.extraConfiguration { inherit config pkgs lib nodes; }))
             (optionalAttrs (extraConfiguration != null) (extraConfiguration { inherit config pkgs lib nodes; }))
           ]
       ) machines;

nixos/tests/ldap.nix

···
           );
 
         slapdDatabases = {
-          "${dbSuffix}" = {
+          ${dbSuffix} = {
             conf = ''
               dn: olcBackend={1}mdb,cn=config
               objectClass: olcBackendConfig

nixos/tests/mosquitto.nix

···
         enable = true;
         host = "0.0.0.0";
         checkPasswords = true;
-        users."${username}" = {
+        users.${username} = {
           inherit password;
           acl = [
             "topic readwrite ${topic}"

nixos/tests/ndppd.nix

···
       };
       services.ndppd = {
         enable = true;
-        proxies."eth1".rules."fd42::/112" = {};
+        proxies.eth1.rules."fd42::/112" = {};
       };
       containers.client = {
         autoStart = true;

nixos/tests/networking.nix

···
     virtual = {
       name = "Virtual";
       machine = {
-        networking.interfaces."tap0" = {
+        networking.interfaces.tap0 = {
           ipv4.addresses = [ { address = "192.168.1.1"; prefixLength = 24; } ];
           ipv6.addresses = [ { address = "2001:1470:fffd:2096::"; prefixLength = 64; } ];
           virtual = true;
         };
-        networking.interfaces."tun0" = {
+        networking.interfaces.tun0 = {
           ipv4.addresses = [ { address = "192.168.1.2"; prefixLength = 24; } ];
           ipv6.addresses = [ { address = "2001:1470:fffd:2097::"; prefixLength = 64; } ];
           virtual = true;
···
       name = "routes";
       machine = {
         networking.useDHCP = false;
-        networking.interfaces."eth0" = {
+        networking.interfaces.eth0 = {
           ipv4.addresses = [ { address = "192.168.1.2"; prefixLength = 24; } ];
           ipv6.addresses = [ { address = "2001:1470:fffd:2097::"; prefixLength = 64; } ];
           ipv6.routes = [

nixos/tests/nextcloud/with-mysql-and-memcached.nix

···
         '';
       };
 
-      systemd.services."nextcloud-setup"= {
+      systemd.services.nextcloud-setup= {
         requires = ["mysql.service"];
         after = ["mysql.service"];
       };

nixos/tests/nextcloud/with-postgresql-and-redis.nix

···
         serviceConfig.PermissionsStartOnly = true;
       };
 
-      systemd.services."nextcloud-setup"= {
+      systemd.services.nextcloud-setup= {
         requires = ["postgresql.service"];
         after = [
           "postgresql.service"
···
       # At the time of writing, redis creates its socket with the "nobody"
       # group.  I figure this is slightly less bad than making the socket world
       # readable.
-      systemd.services."chown-redis-socket" = {
+      systemd.services.chown-redis-socket = {
         enable = true;
         script = ''
           until ${pkgs.redis}/bin/redis-cli ping; do

nixos/tests/nghttpx.nix

···
 
         services.nginx = {
           enable = true;
-          virtualHosts."server" = {
+          virtualHosts.server = {
             locations."/".root = nginxRoot;
           };
         };

nixos/tests/pgmanage.nix

···
         pgmanage = {
           enable = true;
           connections = {
-            "${conn}" = "hostaddr=127.0.0.1 port=${toString config.services.postgresql.port} dbname=postgres";
+            ${conn} = "hostaddr=127.0.0.1 port=${toString config.services.postgresql.port} dbname=postgres";
           };
         };
       };

nixos/tests/quake3.nix

···
     { server =
         { pkgs, ... }:
 
-        { systemd.services."quake3-server" =
+        { systemd.services.quake3-server =
             { wantedBy = [ "multi-user.target" ];
               script =
                 "${pkgs.quake3demo}/bin/quake3-server +set g_gametype 0 " +

nixos/tests/strongswan-swanctl.nix

···
           enable = true;
           swanctl = {
             connections = {
-              "rw" = {
+              rw = {
                 local_addrs = [ moonIp ];
-                local."main" = {
+                local.main = {
                   auth = "psk";
                 };
-                remote."main" = {
+                remote.main = {
                   auth = "psk";
                 };
                 children = {
-                  "net" = {
+                  net = {
                     local_ts = [ vlan0 ];
                     updown = "${strongswan}/libexec/ipsec/_updown iptables";
                     inherit esp_proposals;
···
               };
             };
             secrets = {
-              ike."carol" = {
-                id."main" = carolIp;
+              ike.carol = {
+                id.main = carolIp;
                 inherit secret;
               };
             };
···
           enable = true;
           swanctl = {
             connections = {
-              "home" = {
+              home = {
                 local_addrs = [ carolIp ];
                 remote_addrs = [ moonIp ];
-                local."main" = {
+                local.main = {
                   auth = "psk";
                   id = carolIp;
                 };
-                remote."main" = {
+                remote.main = {
                   auth = "psk";
                   id = moonIp;
                 };
                 children = {
-                  "home" = {
+                  home = {
                     remote_ts = [ vlan0 ];
                     start_action = "trap";
                     updown = "${strongswan}/libexec/ipsec/_updown iptables";
···
               };
             };
             secrets = {
-              ike."moon" = {
-                id."main" = moonIp;
+              ike.moon = {
+                id.main = moonIp;
                 inherit secret;
               };
             };

pkgs/applications/editors/emacs-modes/libgenerated.nix

···
                       , sha256 ? null
                       , ... }@args:
       let
-        sourceArgs = args."${variant}";
+        sourceArgs = args.${variant};
         version = sourceArgs.version or null;
         deps = sourceArgs.deps or null;
         error = sourceArgs.error or args.error or null;
···
                 inherit sha256;
               };
             packageRequires = lib.optional (! isNull deps)
-              (map (dep: pkgargs."${dep}" or self."${dep}" or null)
+              (map (dep: pkgargs.${dep} or self.${dep} or null)
                    deps);
             meta = (sourceArgs.meta or {}) // {
               inherit broken;

pkgs/applications/editors/emacs-modes/melpa-packages.nix

···
       };
     };
 
-  in super // overrides."${variant}");
+  in super // overrides.${variant});
 
 in generateMelpa { }

pkgs/applications/editors/standardnotes/default.nix

···
   version = "3.0.15";
 
   plat = {
-    "i386-linux" = "i386";
-    "x86_64-linux" = "x86_64";
+    i386-linux = "i386";
+    x86_64-linux = "x86_64";
   }.${stdenv.hostPlatform.system};
 
   sha256 = {
-    "i386-linux" = "0v2nsis6vb1lnhmjd28vrfxqwwpycv02j0nvjlfzcgj4b3400j7a";
-    "x86_64-linux" = "130n586cw0836zsbwqcz3pp3h0d4ny74ngqs4k4cvfb92556r7xh";
+    i386-linux = "0v2nsis6vb1lnhmjd28vrfxqwwpycv02j0nvjlfzcgj4b3400j7a";
+    x86_64-linux = "130n586cw0836zsbwqcz3pp3h0d4ny74ngqs4k4cvfb92556r7xh";
   }.${stdenv.hostPlatform.system};
 in
 

pkgs/applications/editors/vim/configurable.nix

···
   inherit (common) version postPatch hardeningDisable enableParallelBuilding meta;
 
   src = builtins.getAttr source {
-    "default" = common.src; # latest release
+    default = common.src; # latest release
   };
 
   patches = [ ./cflags-prune.diff ] ++ stdenv.lib.optional ftNixSupport ./ft-nix-support.patch;

pkgs/applications/editors/vscode/vscode.nix

···
   inherit (stdenv.hostPlatform) system;
 
   plat = {
-    "x86_64-linux" = "linux-x64";
-    "x86_64-darwin" = "darwin";
+    x86_64-linux = "linux-x64";
+    x86_64-darwin = "darwin";
   }.${system};
 
   archive_fmt = if system == "x86_64-darwin" then "zip" else "tar.gz";
 
   sha256 = {
-    "x86_64-linux" = "17g7mra9a52qlrrj77cw16vqvc7fsvbhc03wrl4iq1afzxsyqi22";
-    "x86_64-darwin" = "1is04anvhl2b354h5w7i5qi7ixhzna277f7xdy4qj9gjby6zydc6";
+    x86_64-linux = "17g7mra9a52qlrrj77cw16vqvc7fsvbhc03wrl4iq1afzxsyqi22";
+    x86_64-darwin = "1is04anvhl2b354h5w7i5qi7ixhzna277f7xdy4qj9gjby6zydc6";
   }.${system};
 in
   callPackage ./generic.nix rec {

pkgs/applications/editors/vscode/vscodium.nix

···
   inherit (stdenv.hostPlatform) system;
 
   plat = {
-    "x86_64-linux" = "linux-x64";
-    "x86_64-darwin" = "darwin";
+    x86_64-linux = "linux-x64";
+    x86_64-darwin = "darwin";
   }.${system};
 
   archive_fmt = if system == "x86_64-darwin" then "zip" else "tar.gz";
 
   sha256 = {
-    "x86_64-linux" = "1ay4zvkbln2wf2j1d71mn13b6p2fqvzgz45mzrgaqwsszhbg4xzp";
-    "x86_64-darwin" = "17r9krb1qd92ybx078hkw9zlyym6kbnmbl91vjdilsq77bkf9jmw";
+    x86_64-linux = "1ay4zvkbln2wf2j1d71mn13b6p2fqvzgz45mzrgaqwsszhbg4xzp";
+    x86_64-darwin = "17r9krb1qd92ybx078hkw9zlyym6kbnmbl91vjdilsq77bkf9jmw";
   }.${system};
 in
   callPackage ./generic.nix rec {

pkgs/applications/kde/default.nix

···
     let
       inherit (args) name;
       sname = args.sname or name;
-      inherit (srcs."${sname}") src version;
+      inherit (srcs.${sname}) src version;
       mkDerivation =
         libsForQt5.callPackage ({ mkDerivation }: mkDerivation) {};
     in

pkgs/applications/misc/taskjuggler/3.x/gemset.nix

···
 {
-  "mail" = {
+  mail = {
     version = "2.6.3";
     source = {
       type = "gem";
···
       "mime-types"
     ];
   };
-  "mime-types" = {
+  mime-types = {
     version = "2.6.1";
     source = {
       type = "gem";
       sha256 = "1vnrvf245ijfyxzjbj9dr6i1hkjbyrh4yj88865wv9bs75axc5jv";
     };
   };
-  "taskjuggler" = {
+  taskjuggler = {
     version = "3.5.0";
     source = {
       type = "gem";
···
       "term-ansicolor"
     ];
   };
-  "term-ansicolor" = {
+  term-ansicolor = {
     version = "1.3.2";
     source = {
       type = "gem";
···
       "tins"
     ];
   };
-  "tins" = {
+  tins = {
     version = "1.6.0";
     source = {
       type = "gem";

pkgs/applications/networking/browsers/firefox-bin/default.nix

···
   inherit (generated) version sources;
 
   mozillaPlatforms = {
-    "i686-linux" = "linux-i686";
-    "x86_64-linux" = "linux-x86_64";
+    i686-linux = "linux-i686";
+    x86_64-linux = "linux-x86_64";
   };
 
   arch = mozillaPlatforms.${stdenv.hostPlatform.system};

pkgs/applications/networking/browsers/tor-browser-bundle-bin/default.nix

···
   lang = "en-US";
 
   srcs = {
-    "x86_64-linux" = fetchurl {
+    x86_64-linux = fetchurl {
       urls = [
         "https://github.com/TheTorProject/gettorbrowser/releases/download/v${version}/tor-browser-linux64-${version}_${lang}.tar.xz"
         "https://dist.torproject.org/torbrowser/${version}/tor-browser-linux64-${version}_${lang}.tar.xz"
···
       sha256 = "0nnzynk3nlnd847c8jjghs9anmr5a2hv7nk1qxigigxqa5vqy96z";
     };
 
-    "i686-linux" = fetchurl {
+    i686-linux = fetchurl {
       urls = [
         "https://dist.torproject.org/torbrowser/${version}/tor-browser-linux32-${version}_${lang}.tar.xz"
         "https://github.com/TheTorProject/gettorbrowser/releases/download/v${version}/tor-browser-linux32-${version}_${lang}.tar.xz"
···
   pname = "tor-browser-bundle-bin";
   inherit version;
 
-  src = srcs."${stdenv.hostPlatform.system}" or (throw "unsupported system: ${stdenv.hostPlatform.system}");
+  src = srcs.${stdenv.hostPlatform.system} or (throw "unsupported system: ${stdenv.hostPlatform.system}");
 
   preferLocalBuild = true;
   allowSubstitutes = false;

pkgs/applications/networking/dropbox/default.nix

···
   version = "73.4.118";
 
   arch = {
-    "x86_64-linux" = "x86_64";
-    "i686-linux"   = "x86";
+    x86_64-linux = "x86_64";
+    i686-linux   = "x86";
   }.${stdenv.hostPlatform.system};
 
   installer = "https://clientupdates.dropboxstatic.com/dbx-releng/client/dropbox-lnx.${arch}-${version}.tar.gz";

pkgs/applications/networking/instant-messengers/wire-desktop/default.nix

···
   pname = "wire-desktop";
 
   version = {
-    "x86_64-linux" = "3.9.2895";
-    "x86_64-darwin" = "3.9.2943";
+    x86_64-linux = "3.9.2895";
+    x86_64-darwin = "3.9.2943";
   }.${system} or throwSystem;
 
   sha256 = {
-    "x86_64-linux" = "0wrn95m64j4b7ym44h9zawq13kg4m12aixlyyzp56bfyczmjq4a5";
-    "x86_64-darwin" = "1y1bzsjmjrj518q29xfx6gg1nhdbaz7y5hzaqrp241az6plp090k";
+    x86_64-linux = "0wrn95m64j4b7ym44h9zawq13kg4m12aixlyyzp56bfyczmjq4a5";
+    x86_64-darwin = "1y1bzsjmjrj518q29xfx6gg1nhdbaz7y5hzaqrp241az6plp090k";
   }.${system} or throwSystem;
 
   meta = with stdenv.lib; {

pkgs/applications/networking/p2p/soulseekqt/default.nix

···
 
   mainbin = "SoulseekQt-" + (version) +"-"+ (if stdenv.is64bit then "64bit" else "32bit");
   srcs = {
-    "x86_64-linux" = fetchurl {
+    x86_64-linux = fetchurl {
       url = "https://www.dropbox.com/s/0vi87eef3ooh7iy/${mainbin}.tgz";
       sha256 = "0d1cayxr1a4j19bc5a3qp9pg22ggzmd55b6f5av3lc6lvwqqg4w6";
     };
···
 
   pname = "soulseekqt";
   inherit version;
-  src = srcs."${stdenv.hostPlatform.system}" or (throw "unsupported system: ${stdenv.hostPlatform.system}");
+  src = srcs.${stdenv.hostPlatform.system} or (throw "unsupported system: ${stdenv.hostPlatform.system}");
 
   dontBuild = true;
 

pkgs/applications/networking/remote/anydesk/default.nix

···
 
 let
   sha256 = {
-    "x86_64-linux" = "08kdxsg9npb1nmlr2jyq7p238735kqkp7c5xckxn6rc4cp12n2y2";
-    "i686-linux"   = "11r5d4234zbkkgyrd7q9x3w7s7lailnq7z4x8cnhpr8vipzrg7h2";
-  }."${stdenv.hostPlatform.system}" or (throw "system ${stdenv.hostPlatform.system} not supported");
+    x86_64-linux = "08kdxsg9npb1nmlr2jyq7p238735kqkp7c5xckxn6rc4cp12n2y2";
+    i686-linux   = "11r5d4234zbkkgyrd7q9x3w7s7lailnq7z4x8cnhpr8vipzrg7h2";
+  }.${stdenv.hostPlatform.system} or (throw "system ${stdenv.hostPlatform.system} not supported");
 
   arch = {
-    "x86_64-linux" = "amd64";
-    "i686-linux"   = "i686";
-  }."${stdenv.hostPlatform.system}" or (throw "system ${stdenv.hostPlatform.system} not supported");
+    x86_64-linux = "amd64";
+    i686-linux   = "i686";
+  }.${stdenv.hostPlatform.system} or (throw "system ${stdenv.hostPlatform.system} not supported");
 
   description = "Desktop sharing application, providing remote support and online meetings";
 

pkgs/applications/networking/resilio-sync/default.nix

···
 
 let
   arch = {
-    "x86_64-linux" = "x64";
-    "i686-linux" = "i386";
+    x86_64-linux = "x64";
+    i686-linux = "i386";
   }.${stdenv.hostPlatform.system} or (throw "Unsupported system: ${stdenv.hostPlatform.system}");
   libPath = stdenv.lib.makeLibraryPath [ stdenv.cc.libc ];
 
···
   src = fetchurl {
     url = "https://download-cdn.resilio.com/${version}/linux-${arch}/resilio-sync_${arch}.tar.gz";
     sha256 = {
-      "x86_64-linux" = "114k7dsxn7lzv6mjq9alsqxypvkah4lmjn5w6brbvgd6m6pdwslz";
-      "i686-linux"   = "1dh0hxbd33bs51xib3qwxw58h9j30v0dc10b4x4rwkbgsj11nc83";
+      x86_64-linux = "114k7dsxn7lzv6mjq9alsqxypvkah4lmjn5w6brbvgd6m6pdwslz";
+      i686-linux   = "1dh0hxbd33bs51xib3qwxw58h9j30v0dc10b4x4rwkbgsj11nc83";
     }.${stdenv.hostPlatform.system};
   };
 

pkgs/applications/radio/gnuradio/ais.nix

···
     owner = "bistromath";
     repo = "gr-ais";
     # Upstream PR: https://github.com/bistromath/gr-ais/commit/8502d0252a2a1a9b8d1a71795eaeb5d820684054
-    "rev" = "8502d0252a2a1a9b8d1a71795eaeb5d820684054";
-    "sha256" = "1b9j0kc74cw12a7jv4lii77dgzqzg2s8ndzp4xmisxksgva1qfvh";
+    rev = "8502d0252a2a1a9b8d1a71795eaeb5d820684054";
+    sha256 = "1b9j0kc74cw12a7jv4lii77dgzqzg2s8ndzp4xmisxksgva1qfvh";
   };
 
   nativeBuildInputs = [ pkgconfig ];

pkgs/applications/science/logic/coq/default.nix

···
    "8.9.0" = "1dkgdjc4n1m15m1p724hhi5cyxpqbjw6rxc5na6fl3v4qjjfnizh";
    "8.9.1" = "1xrq6mkhpq994bncmnijf8jwmwn961kkpl4mwwlv7j3dgnysrcv2";
    "8.10+beta2" = "0jk7pwydhd17ab7ii69zvi4sgrr630q2lsxhckaj3sz55cpjlhal";
-  }."${version}";
+  }.${version};
   coq-version = stdenv.lib.versions.majorMinor version;
   versionAtLeast = stdenv.lib.versionAtLeast coq-version;
   ideFlags = stdenv.lib.optionalString (buildIde && !versionAtLeast "8.10")

pkgs/applications/science/math/nauty/default.nix

···
     # Prevent nauty from sniffing some cpu features. While those are very
     # widely available, it can lead to nasty bugs when they are not available:
     # https://groups.google.com/forum/#!topic/sage-packaging/Pe4SRDNYlhA
-    "default"        = [ "--disable-clz" "--disable-popcnt" ];
-    "westmere"       = [ "--disable-clz" ];
-    "sandybridge"    = [ "--disable-clz" ];
-    "ivybridge"      = [ "--disable-clz" ];
+    default        = [ "--disable-clz" "--disable-popcnt" ];
+    westmere       = [ "--disable-clz" ];
+    sandybridge    = [ "--disable-clz" ];
+    ivybridge      = [ "--disable-clz" ];
   }.${stdenv.hostPlatform.platform.gcc.arch or "default"} or [];
   buildInputs = [];
   installPhase = ''

pkgs/applications/video/kodi/plugins.nix

···
     };
 
     mkController = controller: {
-        "${controller}" = mkKodiPlugin rec {
+        ${controller} = mkKodiPlugin rec {
           plugin = pname + "-" + controller;
           namespace = "game.controller." + controller;
           sourceDir = "addons/" + namespace;

pkgs/applications/virtualization/xen/4.10.nix

···
 
   # Sources needed to build tools and firmwares.
   xenfiles = optionalAttrs withInternalQemu {
-    "qemu-xen" = {
+    qemu-xen = {
       src = fetchgit {
         url = https://xenbits.xen.org/git-http/qemu-xen.git;
         # rev = "refs/tags/qemu-xen-${version}";
···
       meta.description = "Xen's fork of upstream Qemu";
     };
   } // optionalAttrs withInternalTraditionalQemu {
-    "qemu-xen-traditional" = {
+    qemu-xen-traditional = {
       src = fetchgit {
         url = https://xenbits.xen.org/git-http/qemu-xen-traditional.git;
         # rev = "refs/tags/xen-${version}";
···
       meta.description = "Xen's fork of iPXE";
     };
   } // optionalAttrs withLibHVM {
-    "xen-libhvm-dir-remote" = {
+    xen-libhvm-dir-remote = {
       src = fetchgit {
         name = "xen-libhvm";
         url = https://github.com/michalpalka/xen-libhvm;

pkgs/applications/virtualization/xen/4.5.nix

···
 
   # Sources needed to build tools and firmwares.
   xenfiles = optionalAttrs withInternalQemu {
-    "qemu-xen" = {
+    qemu-xen = {
       src = fetchgit {
         url = https://xenbits.xen.org/git-http/qemu-xen.git;
         rev = "refs/tags/qemu-xen-${version}";
···
       meta.description = "Xen's fork of upstream Qemu";
     };
   } // optionalAttrs withInternalTraditionalQemu {
-    "qemu-xen-traditional" = {
+    qemu-xen-traditional = {
       src = fetchgit {
         url = https://xenbits.xen.org/git-http/qemu-xen-traditional.git;
         rev = "refs/tags/xen-${version}";
···
       meta.description = "Xen's fork of iPXE";
     };
   } // optionalAttrs withLibHVM {
-    "xen-libhvm-dir-remote" = {
+    xen-libhvm-dir-remote = {
       src = fetchgit {
         name = "xen-libhvm";
         url = https://github.com/ts468/xen-libhvm;

pkgs/applications/virtualization/xen/4.8.nix

···
 
   # Sources needed to build tools and firmwares.
   xenfiles = optionalAttrs withInternalQemu {
-    "qemu-xen" = {
+    qemu-xen = {
       src = fetchgit {
         url = https://xenbits.xen.org/git-http/qemu-xen.git;
         rev = "refs/tags/qemu-xen-${version}";
···
       meta.description = "Xen's fork of upstream Qemu";
     };
   } // optionalAttrs withInternalTraditionalQemu {
-    "qemu-xen-traditional" = {
+    qemu-xen-traditional = {
       src = fetchgit {
         url = https://xenbits.xen.org/git-http/qemu-xen-traditional.git;
         rev = "refs/tags/xen-${version}";
···
       meta.description = "Xen's fork of iPXE";
     };
   } // optionalAttrs withLibHVM {
-    "xen-libhvm-dir-remote" = {
+    xen-libhvm-dir-remote = {
       src = fetchgit {
         name = "xen-libhvm";
         url = https://github.com/michalpalka/xen-libhvm;

pkgs/applications/window-managers/stumpwm/default.nix

···
     sha256 = "1ml6mjk2fsfv4sf65fdbji3q5x0qiq99g1k8w7a99gsl2i8h60gc";
   });
   versionSpec = {
-    "latest" = {
+    latest = {
       name = "1.0.0";
       rev = "refs/tags/1.0.0";
       sha256 = "16r0lwhxl8g71masmfbjr7s7m7fah4ii4smi1g8zpbpiqjz48ryb";
···
       sha256 = "0hmvbdk2yr5wrkiwn9dfzf65s4xc2qifj0sn6w2mghzp96cph79k";
       patches = [ ./fix-module-path.patch ];
     };
-    "git" = {
+    git = {
         name = "git-20170203";
         rev = "d20f24e58ab62afceae2afb6262ffef3cc318b97";
         sha256 = "1gi29ds1x6dq7lz8lamnhcvcrr3cvvrg5yappfkggyhyvib1ii70";

pkgs/applications/window-managers/way-cooler/default.nix

···
   # https://nest.pijul.com/pmeunier/carnix/discussions/22
   version = "0.8.1";
   deps = (callPackage ./way-cooler.nix {}).deps;
-  way_cooler_ = f: cratesIO.crates.way_cooler."${version}" deps {
-    features = cratesIO.features_.way_cooler."${version}" deps {
-      "way_cooler"."${version}" = f;
+  way_cooler_ = f: cratesIO.crates.way_cooler.${version} deps {
+    features = cratesIO.features_.way_cooler.${version} deps {
+      way_cooler.${version} = f;
     };
   };
   way-cooler = ((way_cooler_ { builtin-lua = true; }).override {

pkgs/build-support/bintools-wrapper/default.nix

···
       else if targetPlatform.isx86_64  then "x86-64"
       else if targetPlatform.isx86_32  then "i386"
       else if targetPlatform.isMips    then {
-          "mips"     = "btsmipn32"; # n32 variant
-          "mipsel"   = "ltsmipn32"; # n32 variant
-          "mips64"   = "btsmip";
-          "mips64el" = "ltsmip";
+          mips     = "btsmipn32"; # n32 variant
+          mipsel   = "ltsmipn32"; # n32 variant
+          mips64   = "btsmip";
+          mips64el = "ltsmip";
         }.${targetPlatform.parsed.cpu.name}
       else if targetPlatform.isPower then if targetPlatform.isBigEndian then "ppc" else "lppc"
       else if targetPlatform.isSparc then "sparc"

pkgs/build-support/fetchdocker/default.nix

···
 
   repositories =
     writeText "repositories" (builtins.toJSON {
-      "${repoTag1}" = {
-        "${tag}" = lib.last layers;
+      ${repoTag1} = {
+        ${tag} = lib.last layers;
       };
     });
 

pkgs/build-support/rust/build-rust-crate/test/brotli-crates.nix

···
     features = mkFeatures (features.brotli_2_5_0 or {});
   };
   brotli_2_5_0_features = f: updateFeatures f (rec {
-    alloc_no_stdlib_1_3_0."no-stdlib" =
-      (f.alloc_no_stdlib_1_3_0."no-stdlib" or false) ||
-      (brotli_2_5_0."no-stdlib" or false) ||
-      (f.brotli_2_5_0."no-stdlib" or false);
+    alloc_no_stdlib_1_3_0.no-stdlib =
+      (f.alloc_no_stdlib_1_3_0.no-stdlib or false) ||
+      (brotli_2_5_0.no-stdlib or false) ||
+      (f.brotli_2_5_0.no-stdlib or false);
     alloc_no_stdlib_1_3_0.default = true;
     brotli_2_5_0.default = (f.brotli_2_5_0.default or true);
-    brotli_decompressor_1_3_1."disable-timer" =
-      (f.brotli_decompressor_1_3_1."disable-timer" or false) ||
-      (brotli_2_5_0."disable-timer" or false) ||
-      (f.brotli_2_5_0."disable-timer" or false);
-    brotli_decompressor_1_3_1."no-stdlib" =
-      (f.brotli_decompressor_1_3_1."no-stdlib" or false) ||
-      (brotli_2_5_0."no-stdlib" or false) ||
-      (f.brotli_2_5_0."no-stdlib" or false);
+    brotli_decompressor_1_3_1.disable-timer =
+      (f.brotli_decompressor_1_3_1.disable-timer or false) ||
+      (brotli_2_5_0.disable-timer or false) ||
+      (f.brotli_2_5_0.disable-timer or false);
+    brotli_decompressor_1_3_1.no-stdlib =
+      (f.brotli_decompressor_1_3_1.no-stdlib or false) ||
+      (brotli_2_5_0.no-stdlib or false) ||
+      (f.brotli_2_5_0.no-stdlib or false);
     brotli_decompressor_1_3_1.benchmark =
       (f.brotli_decompressor_1_3_1.benchmark or false) ||
       (brotli_2_5_0.benchmark or false) ||
···
     features = mkFeatures (features.brotli_decompressor_1_3_1 or {});
   };
   brotli_decompressor_1_3_1_features = f: updateFeatures f (rec {
-    alloc_no_stdlib_1_3_0."no-stdlib" =
-      (f.alloc_no_stdlib_1_3_0."no-stdlib" or false) ||
-      (brotli_decompressor_1_3_1."no-stdlib" or false) ||
-      (f.brotli_decompressor_1_3_1."no-stdlib" or false);
+    alloc_no_stdlib_1_3_0.no-stdlib =
+      (f.alloc_no_stdlib_1_3_0.no-stdlib or false) ||
+      (brotli_decompressor_1_3_1.no-stdlib or false) ||
+      (f.brotli_decompressor_1_3_1.no-stdlib or false);
     alloc_no_stdlib_1_3_0.default = true;
     alloc_no_stdlib_1_3_0.unsafe =
       (f.alloc_no_stdlib_1_3_0.unsafe or false) ||

pkgs/build-support/rust/default.nix

···
   hostConfig = stdenv.hostPlatform.config;
 
   rustHostConfig = {
-    "x86_64-pc-mingw32" = "x86_64-pc-windows-gnu";
-  }."${hostConfig}" or hostConfig;
+    x86_64-pc-mingw32 = "x86_64-pc-windows-gnu";
+  }.${hostConfig} or hostConfig;
 
   ccForBuild="${buildPackages.stdenv.cc}/bin/${buildPackages.stdenv.cc.targetPrefix}cc";
   cxxForBuild="${buildPackages.stdenv.cc}/bin/${buildPackages.stdenv.cc.targetPrefix}c++";

pkgs/data/fonts/iosevka/package-lock.nix

···
         0;
       chars = stringToCharacters (substring 0 (len - padding) str);
       table = {
-        "A" = [0 0 0];
-        "B" = [0 0 1];
-        "C" = [0 0 2];
-        "D" = [0 0 3];
-        "E" = [0 1 0];
-        "F" = [0 1 1];
-        "G" = [0 1 2];
-        "H" = [0 1 3];
-        "I" = [0 2 0];
-        "J" = [0 2 1];
-        "K" = [0 2 2];
-        "L" = [0 2 3];
-        "M" = [0 3 0];
-        "N" = [0 3 1];
-        "O" = [0 3 2];
-        "P" = [0 3 3];
-        "Q" = [1 0 0];
-        "R" = [1 0 1];
-        "S" = [1 0 2];
-        "T" = [1 0 3];
-        "U" = [1 1 0];
-        "V" = [1 1 1];
-        "W" = [1 1 2];
-        "X" = [1 1 3];
-        "Y" = [1 2 0];
-        "Z" = [1 2 1];
-        "a" = [1 2 2];
-        "b" = [1 2 3];
-        "c" = [1 3 0];
-        "d" = [1 3 1];
-        "e" = [1 3 2];
-        "f" = [1 3 3];
-        "g" = [2 0 0];
-        "h" = [2 0 1];
-        "i" = [2 0 2];
-        "j" = [2 0 3];
-        "k" = [2 1 0];
-        "l" = [2 1 1];
-        "m" = [2 1 2];
-        "n" = [2 1 3];
-        "o" = [2 2 0];
-        "p" = [2 2 1];
-        "q" = [2 2 2];
-        "r" = [2 2 3];
-        "s" = [2 3 0];
-        "t" = [2 3 1];
-        "u" = [2 3 2];
-        "v" = [2 3 3];
-        "w" = [3 0 0];
-        "x" = [3 0 1];
-        "y" = [3 0 2];
-        "z" = [3 0 3];
+        A = [0 0 0];
+        B = [0 0 1];
+        C = [0 0 2];
+        D = [0 0 3];
+        E = [0 1 0];
+        F = [0 1 1];
+        G = [0 1 2];
+        H = [0 1 3];
+        I = [0 2 0];
+        J = [0 2 1];
+        K = [0 2 2];
+        L = [0 2 3];
+        M = [0 3 0];
+        N = [0 3 1];
+        O = [0 3 2];
+        P = [0 3 3];
+        Q = [1 0 0];
+        R = [1 0 1];
+        S = [1 0 2];
+        T = [1 0 3];
+        U = [1 1 0];
+        V = [1 1 1];
+        W = [1 1 2];
+        X = [1 1 3];
+        Y = [1 2 0];
+        Z = [1 2 1];
+        a = [1 2 2];
+        b = [1 2 3];
+        c = [1 3 0];
+        d = [1 3 1];
+        e = [1 3 2];
+        f = [1 3 3];
+        g = [2 0 0];
+        h = [2 0 1];
+        i = [2 0 2];
+        j = [2 0 3];
+        k = [2 1 0];
+        l = [2 1 1];
+        m = [2 1 2];
+        n = [2 1 3];
+        o = [2 2 0];
+        p = [2 2 1];
+        q = [2 2 2];
+        r = [2 2 3];
+        s = [2 3 0];
+        t = [2 3 1];
+        u = [2 3 2];
+        v = [2 3 3];
+        w = [3 0 0];
+        x = [3 0 1];
+        y = [3 0 2];
+        z = [3 0 3];
         "0" = [3 1 0];
         "1" = [3 1 1];
         "2" = [3 1 2];

pkgs/desktops/pantheon/update.nix

···
 
   throwFlag = throw "${versionPolicy} is not a valid versionPolicy - Options are either 'release' or 'master' (defaults to release).";
 
-  versionFlag = { "release" = "-r"; "master" = "-m"; }.${versionPolicy} or throwFlag;
+  versionFlag = { release = "-r"; master = "-m"; }.${versionPolicy} or throwFlag;
 
 in [ updateScript versionFlag repoName attrPath ]

pkgs/desktops/plasma-5/default.nix

···
           let
             inherit (args) name;
             sname = args.sname or name;
-            inherit (srcs."${sname}") src version;
+            inherit (srcs.${sname}) src version;
 
             outputs = args.outputs or [ "out" ];
             hasBin = lib.elem "bin" outputs;

pkgs/development/androidndk-pkgs/androidndk-pkgs.nix

···
   # than we do. We don't just use theirs because ours are less ambiguous and
   # some builds need that clarity.
   ndkInfoFun = { config, ... }: {
-    "x86_64-apple-darwin" = {
+    x86_64-apple-darwin = {
       double = "darwin-x86_64";
     };
-    "x86_64-unknown-linux-gnu" = {
+    x86_64-unknown-linux-gnu = {
       double = "linux-x86_64";
     };
-    "i686-unknown-linux-android" = {
+    i686-unknown-linux-android = {
       triple = "i686-linux-android";
       arch = "x86";
       toolchain = "x86";
       gccVer = "4.9";
     };
-    "x86_64-unknown-linux-android" = {
+    x86_64-unknown-linux-android = {
       triple = "x86_64-linux-android";
       arch = "x86_64";
       toolchain = "x86_64";
       gccVer = "4.9";
     };
-    "armv7a-unknown-linux-androideabi" = {
+    armv7a-unknown-linux-androideabi = {
       arch = "arm";
       triple = "arm-linux-androideabi";
       toolchain = "arm-linux-androideabi";
       gccVer = "4.9";
     };
-    "aarch64-unknown-linux-android" = {
+    aarch64-unknown-linux-android = {
       arch = "arm64";
       triple = "aarch64-linux-android";
       toolchain = "aarch64-linux-android";

pkgs/development/compilers/binaryen/default.nix

···
 
   # Map from git revs to SHA256 hashes
   sha256s = {
-    "version_89" = "0rh1dq33ilq54szfgi1ajaiaj7rbylai02rhp9zm9vpwp0rw8mij";
+    version_89 = "0rh1dq33ilq54szfgi1ajaiaj7rbylai02rhp9zm9vpwp0rw8mij";
     "1.38.28" = "172s7y5f38736ic8ri3mnbdqcrkadd40a26cxcfwbscc53phl11v";
   };
 in

pkgs/development/compilers/ccl/default.nix

···
     };
     armv6l-linux = armv7l-linux;
   };
-  cfg = options."${stdenv.hostPlatform.system}" or (throw "missing source url for platform ${stdenv.hostPlatform.system}");
+  cfg = options.${stdenv.hostPlatform.system} or (throw "missing source url for platform ${stdenv.hostPlatform.system}");
 in
 
 stdenv.mkDerivation rec {

pkgs/development/compilers/crystal/default.nix

···
 
 let
   archs = {
-    "x86_64-linux"  = "linux-x86_64";
-    "i686-linux"    = "linux-i686";
-    "x86_64-darwin" = "darwin-x86_64";
+    x86_64-linux  = "linux-x86_64";
+    i686-linux    = "linux-i686";
+    x86_64-darwin = "darwin-x86_64";
   };
 
-  arch = archs."${stdenv.system}" or (throw "system ${stdenv.system} not supported");
+  arch = archs.${stdenv.system} or (throw "system ${stdenv.system} not supported");
 
   checkInputs = [ git gmp openssl readline libxml2 libyaml ];
 
···
 
     src = fetchurl {
       url = "https://github.com/crystal-lang/crystal/releases/download/${version}/crystal-${version}-${toString rel}-${arch}.tar.gz";
-      sha256 = sha256s."${stdenv.system}";
+      sha256 = sha256s.${stdenv.system};
     };
 
     buildCommand = ''
···
   binaryCrystal_0_26 = genericBinary {
     version = "0.26.1";
     sha256s = {
-      "x86_64-linux"  = "1xban102yiiwmlklxvn3xp3q546bp8hlxxpakayajkhhnpl6yv45";
-      "i686-linux"    = "1igspf1lrv7wpmz0pfrkbx8m1ykvnv4zhic53cav4nicppm2v0ic";
-      "x86_64-darwin" = "1mri8bfrcldl69gczxpihxpv1shn4bijx28m3qby8vnk0ii63n9s";
+      x86_64-linux  = "1xban102yiiwmlklxvn3xp3q546bp8hlxxpakayajkhhnpl6yv45";
+      i686-linux    = "1igspf1lrv7wpmz0pfrkbx8m1ykvnv4zhic53cav4nicppm2v0ic";
+      x86_64-darwin = "1mri8bfrcldl69gczxpihxpv1shn4bijx28m3qby8vnk0ii63n9s";
     };
   };
 
   binaryCrystal_0_27 = genericBinary {
     version = "0.27.2";
     sha256s = {
-      "x86_64-linux"  = "05l5x7kx2acgnv42fj3rr17z73ix06zvi05h7d7vf3kw0izxrasm";
-      "i686-linux"    = "1iwizkvn6pglc0azkyfhlmk9ap793krdgcnbihd1kvrvs4cz0mm9";
-      "x86_64-darwin" = "14c69ac2dmfwmb5q56ps3xyxxb0mrbc91ahk9h07c8fiqfii3k9g";
+      x86_64-linux  = "05l5x7kx2acgnv42fj3rr17z73ix06zvi05h7d7vf3kw0izxrasm";
+      i686-linux    = "1iwizkvn6pglc0azkyfhlmk9ap793krdgcnbihd1kvrvs4cz0mm9";
+      x86_64-darwin = "14c69ac2dmfwmb5q56ps3xyxxb0mrbc91ahk9h07c8fiqfii3k9g";
     };
   };
 
   binaryCrystal_0_29 = genericBinary {
     version = "0.29.0";
     sha256s = {
-      "x86_64-linux"  = "1wrk29sfx35akg7hxwpdiikvl18wd40gq1kwirw7x522hnq7vlna";
-      "i686-linux"    = "1nx0piis2k3nn7kqiijqazzbvlaavhgvsln0l3dxmpfa4i4dz5h2";
-      "x86_64-darwin" = "1fd0fbyf05abivnp3igjlrm2axf65n2wdmg4aq6nqj60ipc01rvd";
+      x86_64-linux  = "1wrk29sfx35akg7hxwpdiikvl18wd40gq1kwirw7x522hnq7vlna";
+      i686-linux    = "1nx0piis2k3nn7kqiijqazzbvlaavhgvsln0l3dxmpfa4i4dz5h2";
+      x86_64-darwin = "1fd0fbyf05abivnp3igjlrm2axf65n2wdmg4aq6nqj60ipc01rvd";
     };
   };
 

pkgs/development/compilers/dmd/default.nix

···
   dmdConfFile = writeTextFile {
       name = "dmd.conf";
       text = (lib.generators.toINI {} {
-        "Environment" = {
+        Environment = {
           DFLAGS = ''-I@out@/include/dmd -L-L@out@/lib -fPIC ${stdenv.lib.optionalString (!targetPackages.stdenv.cc.isClang) "-L--export-dynamic"}'';
         };
       });

pkgs/development/compilers/elm/packages/node-composition.nix

···
 
 {pkgs ? import <nixpkgs> {
     inherit system;
-  }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-10_x"}:
+  }, system ? builtins.currentSystem, nodejs ? pkgs.nodejs-10_x}:
 
 let
   nodeEnv = import ./node-env.nix {

pkgs/development/compilers/ghc/8.2.2-binary.nix

···
   name = "ghc-${version}-binary";
 
   src = fetchurl ({
-    "i686-linux" = {
+    i686-linux = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-i386-deb8-linux.tar.xz";
       sha256 = "08w2ik55dp3n95qikmrflc91lsiq01xp53ki3jlhnbj8fqnxfrwy";
     };
-    "x86_64-linux" = {
+    x86_64-linux = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-x86_64-deb8-linux.tar.xz";
       sha256 = "0ahv26304pqi3dm7i78si4pxwvg5f5dc2jwsfgvcrhcx5g30bqj8";
     };
-    "armv7l-linux" = {
+    armv7l-linux = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-armv7-deb8-linux.tar.xz";
       sha256 = "1jmv8qmnh5bn324fivbwdcaj55kvw7cb2zq9pafmlmv3qwwx7s46";
     };
-    "aarch64-linux" = {
+    aarch64-linux = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-aarch64-deb8-linux.tar.xz";
       sha256 = "1k2amylcp1ad67c75h1pqf7czf9m0zj1i7hdc45ghjklnfq9hrk7";
     };
-    "x86_64-darwin" = {
+    x86_64-darwin = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";
       sha256 = "09swx71gh5habzbx55shz2xykgr96xkcy09nzinnm4z0yxicy3zr";
     };

pkgs/development/compilers/ghc/8.6.3-binary.nix

···
   name = "ghc-${version}-binary";
 
   src = fetchurl ({
-    "i686-linux" = {
+    i686-linux = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-i386-deb8-linux.tar.xz";
       sha256 = "0bw8a7fxcbskf93rb4m542ff66vrmx5i5kj77qx37cbhijx70w5m";
     };
-    "x86_64-linux" = {
+    x86_64-linux = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-x86_64-deb8-linux.tar.xz";
       sha256 = "1m9gaga2pzi2cx5gvasg0rx1dlvr68gmi20l67652kag6xjsa719";
     };
-    "x86_64-darwin" = {
+    x86_64-darwin = {
       url = "http://haskell.org/ghc/dist/${version}/ghc-${version}-x86_64-apple-darwin.tar.xz";
       sha256 = "1hbzk57v45176kxcx848p5jn5p1xbp2129ramkbzsk6plyhnkl3r";
     };

pkgs/development/compilers/go/1.11.nix

···
   '';
 
   goarch = platform: {
-    "i686" = "386";
-    "x86_64" = "amd64";
-    "aarch64" = "arm64";
-    "arm" = "arm";
-    "armv5tel" = "arm";
-    "armv6l" = "arm";
-    "armv7l" = "arm";
+    i686 = "386";
+    x86_64 = "amd64";
+    aarch64 = "arm64";
+    arm = "arm";
+    armv5tel = "arm";
+    armv6l = "arm";
+    armv7l = "arm";
   }.${platform.parsed.cpu.name} or (throw "Unsupported system");
 
 in

pkgs/development/compilers/go/1.12.nix

···
   '';
 
   goarch = platform: {
-    "i686" = "386";
-    "x86_64" = "amd64";
-    "aarch64" = "arm64";
-    "arm" = "arm";
-    "armv5tel" = "arm";
-    "armv6l" = "arm";
-    "armv7l" = "arm";
+    i686 = "386";
+    x86_64 = "amd64";
+    aarch64 = "arm64";
+    arm = "arm";
+    armv5tel = "arm";
+    armv6l = "arm";
+    armv7l = "arm";
   }.${platform.parsed.cpu.name} or (throw "Unsupported system");
 
 in

pkgs/development/compilers/go/1.4.nix

···
 , Security }:
 
 let
-  libc = if stdenv ? "cross" then libcCross else stdenv.cc.libc;
+  libc = if stdenv ? cross then libcCross else stdenv.cc.libc;
 in
 
 stdenv.mkDerivation rec {

pkgs/development/compilers/julia/shared.nix

···
   makeFlags =
     let
       arch = head (splitString "-" stdenv.system);
-      march = { "x86_64" = stdenv.hostPlatform.platform.gcc.arch or "x86-64"; "i686" = "pentium4"; }."${arch}"
+      march = { x86_64 = stdenv.hostPlatform.platform.gcc.arch or "x86-64"; i686 = "pentium4"; }.${arch}
               or (throw "unsupported architecture: ${arch}");
       # Julia requires Pentium 4 (SSE2) or better
-      cpuTarget = { "x86_64" = "x86-64"; "i686" = "pentium4"; }."${arch}"
+      cpuTarget = { x86_64 = "x86-64"; i686 = "pentium4"; }.${arch}
                   or (throw "unsupported architecture: ${arch}");
     in [
       "ARCH=${arch}"

pkgs/development/compilers/mozart/binary.nix

···
   version = "2.0.0";
 
   binaries = {
-    "x86_64-linux" = fetchurl {
+    x86_64-linux = fetchurl {
       url = "mirror://sourceforge/project/mozart-oz/v${version}-alpha.0/mozart2-${version}-alpha.0+build.4105.5c06ced-x86_64-linux.tar.gz";
       sha256 = "0rsfrjimjxqbwprpzzlmydl3z3aiwg5qkb052jixdxjyad7gyh5z";
     };
···
 
   preferLocalBuild = true;
 
-  src = binaries."${stdenv.hostPlatform.system}" or (throw "unsupported system: ${stdenv.hostPlatform.system}");
+  src = binaries.${stdenv.hostPlatform.system} or (throw "unsupported system: ${stdenv.hostPlatform.system}");
 
   libPath = stdenv.lib.makeLibraryPath
     [ stdenv.cc.cc

pkgs/development/compilers/openjdk/8.nix

···
    * The JRE libraries are in directories that depend on the CPU.
    */
   architecture = {
-    "i686-linux" = "i386";
-    "x86_64-linux" = "amd64";
-    "aarch64-linux" = "aarch64";
+    i686-linux = "i386";
+    x86_64-linux = "amd64";
+    aarch64-linux = "aarch64";
   }.${stdenv.system} or (throw "Unsupported platform");
 
   update = "222";

pkgs/development/compilers/openjdk/openjfx/11.nix

···
     outputHashMode = "recursive";
     # Downloaded AWT jars differ by platform.
     outputHash = {
-      "i686-linux" = "0mjlyf6jvbis7nrm5d394sjv4hjw6k3753hr1nwdxk8skwc3ry08";
-      "x86_64-linux" = "0d4msxswdav1xsfkpr0qd3xgqkcbxzf47v1zdy5jmg5w4bs6a78a";
+      i686-linux = "0mjlyf6jvbis7nrm5d394sjv4hjw6k3753hr1nwdxk8skwc3ry08";
+      x86_64-linux = "0d4msxswdav1xsfkpr0qd3xgqkcbxzf47v1zdy5jmg5w4bs6a78a";
     }.${stdenv.system} or (throw "Unsupported platform");
   };
 

pkgs/development/compilers/openjdk/openjfx/12.nix

···
     outputHashMode = "recursive";
     # Downloaded AWT jars differ by platform.
     outputHash = {
-      "x86_64-linux" = "1z5qar5l28ja4pkf5l5m48xbv3x1yrnilsv9lpf2j3vkdk9h1nci";
-      "i686-linux" = "0rbygvjc7w197fi5nxldqdrm6mpiyd3n45042g3gd4s5qk08spjd";
+      x86_64-linux = "1z5qar5l28ja4pkf5l5m48xbv3x1yrnilsv9lpf2j3vkdk9h1nci";
+      i686-linux = "0rbygvjc7w197fi5nxldqdrm6mpiyd3n45042g3gd4s5qk08spjd";
     }.${stdenv.system} or (throw "Unsupported platform");
   };
 

pkgs/development/compilers/rust/bootstrap.nix

···
 
   src = fetchurl {
      url = "https://static.rust-lang.org/dist/rust-${version}-${platform}.tar.gz";
-     sha256 = hashes."${platform}";
+     sha256 = hashes.${platform};
   };
 
 in callPackage ./binary.nix

pkgs/development/coq-modules/QuickChick/default.nix

···
       sha256 = "1c34v1k37rk7v0xk2czv5n79mbjxjrm6nh3llg2mpfmdsqi68wf3";
     };
   };
-  param = params."${coq.coq-version}";
+  param = params.${coq.coq-version};
 in
 
 let recent = stdenv.lib.versionAtLeast coq.coq-version "8.8"; in

pkgs/development/coq-modules/Velisarios/default.nix

···
       sha256 = "0l9885nxy0n955fj1gnijlxl55lyxiv9yjfmz8hmfrn9hl8vv1m2";
     };
   };
-  param = params."${coq.coq-version}";
+  param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/coq-modules/bignums/default.nix

···
         sha256 = "1slw227idwjw9a21vj3s6kal22mrmvvlpg8r7xk590ml99bn6404";
       };
     };
-    param = params."${coq.coq-version}";
+    param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/coq-modules/category-theory/default.nix

···
     "8.8" = v20190414;
     "8.9" = v20190414;
   };
-  param = params."${coq.coq-version}";
+  param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/coq-modules/contribs/default.nix

···
       rev = "86ac28259030649ef51460e4de2441c8a1017751";
       sha256 = "09bbk2a7pn0j76mmapl583f8a20zqd3a1m9lkml8rpwml692bzi9";
     };
-  }."${coq.coq-version}";
+  }.${coq.coq-version};
 
   abp = mkContrib "abp" [ "8.5" "8.6" "8.7" ] {
     version = "v8.6.0";
···
       rev = "aa33052c1edfc5a65885942a67c2773b5d96f8cc";
       sha256 = "0mjgfdr9bzsch0dlk4vq1frkaig14dqh46r54cv0l15flxapg0iw";
     };
-  }."${coq.coq-version}";
+  }.${coq.coq-version};
 
   continuations = mkContrib "continuations" [ ] {
     version = "v8.5.0-13-g6885310";

pkgs/development/coq-modules/coq-elpi/default.nix

···
     sha256 = "188avk9irwjsbs5ya4ka01mpk3vw4397kv2rmsncqrrrsa1pdddk";
   };
 };
-  param = params."${coq.coq-version}";
+  param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/coq-modules/coq-ext-lib/default.nix

···
     "8.8" = { version = "0.9.8"; sha256 = "0z1ix855kdjl7zw5ca664h5njd1x8mmvf5wi37fck4dj9dgamwlz"; };
     "8.9" = { version = "0.10.1"; sha256 = "0r1vspad8fb8bry3zliiz4hfj4w1iib1l2gm115a94m6zbiksd95"; };
   };
-  param = params."${coq.coq-version}";
+  param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/coq-modules/coq-haskell/default.nix

···
       sha256 = "09dq1vvshhlhgjccrhqgbhnq2hrys15xryfszqq11rzpgvl2zgdv";
     };
   };
-  param = params."${coq.coq-version}";
+  param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/coq-modules/coqhammer/default.nix

···
       sha256 = "0hmqwsry8ldg4g4hhwg4b84dgzibpdrg1wwsajhlyqfx3fb3n3b5";
     };
   };
-  param = params."${coq.coq-version}";
+  param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/coq-modules/coqprime/default.nix

···
     "8.9" = v_8_8;
     "8.10" = v_8_8;
     };
-  param = params."${coq.coq-version}"
+  param = params.${coq.coq-version}
 ; in
 
 stdenv.mkDerivation rec {

pkgs/development/coq-modules/dpdgraph/default.nix

···
     sha256 = "0qvar8gfbrcs9fmvkph5asqz4l5fi63caykx3bsn8zf0xllkwv0n";
   };
 };
-param = params."${coq.coq-version}";
+param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation {

pkgs/development/coq-modules/equations/default.nix

···
       sha256 = "1v5kx0xzxzsbs5r4w08rm1lrmjjggnd3ap0sd1my88ds17jzyasd";
     };
   };
-  param = params."${coq.coq-version}";
+  param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/coq-modules/ltac2/default.nix

···
     sha256 = "0xby1kb26r9gcvk5511wqj05fqm9paynwfxlfqkmwkgnfmzk0x73";
   };
 };
-  param = params."${coq.coq-version}";
+  param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation rec {

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

···
   # COMPUTED using the configuration above (edit with caution) #
   ##############################################################
   default-mathcomp-version = let v = head (
-    filter (mc: mathcomp-coq-versions."${mc}" coq.coq-version)
+    filter (mc: mathcomp-coq-versions.${mc} coq.coq-version)
             mathcomp-version-preference ++ ["0.0.0"]);
      in if v == "0.0.0" then max-mathcomp-version else v;
 
···
         };
       };
     in
-    {"${mathcomp-pkg}" = stdenv.mkDerivation (attrs // overrides attrs);};
+    {${mathcomp-pkg} = stdenv.mkDerivation (attrs // overrides attrs);};
 
-getAttrOr = a: n: a."${n}" or (throw a.error);
+getAttrOr = a: n: a.${n} or (throw a.error);
 
 mathcompCorePkgs_1_7 = mathcompGen "1.7.0";
 mathcompCorePkgs_1_8 = mathcompGen "1.8.0";

pkgs/development/coq-modules/mathcomp/extra.nix

···
                                else compatibleCoqVersions;
     mc-core-deps = if builtins.isNull core-deps then [ssreflect] else core-deps;
   in
-  { "${package}" = let from = src; in
+  { ${package} = let from = src; in
 
   stdenv.mkDerivation rec {
     inherit version;
···
       owner = owner;
       repo = package;
       rev = version;
-      sha256 = version-sha256."${version}";
+      sha256 = version-sha256.${version};
     } else from;
 
     propagatedBuildInputs = [ coq ] ++ mc-core-deps ++ extra-deps;
···
   };
   };
 
-current-versions = versions."${current-ssreflect.version}" or {};
+current-versions = versions.${current-ssreflect.version} or {};
 
 select = x: mapAttrs (n: pkg: {package = n;} // pkg) (recursiveUpdate param x);
 
···
         {name = "mathcomp_${suffix}-${n}";
          value = (packageGen ({
              ssreflect = coqPackages."mathcomp-ssreflect_${suffix}";
-           } // pkg))."${n}";})
-        (select versions."${v}"));
+           } // pkg)).${n};})
+        (select versions.${v}));
 
 all = (for-version "1.7.0" "1_7") //
       (for-version "1.8.0" "1_8") //
       (for-version "1.9.0" "1_9") //
      (recurseIntoAttrs (mapDerivationAttrset dontDistribute (
-        mapAttrs' (n: pkg: {name = "mathcomp-${n}"; value = (packageGen pkg)."${n}";})
+        mapAttrs' (n: pkg: {name = "mathcomp-${n}"; value = (packageGen pkg).${n};})
               (select current-versions))));
 in
 {

pkgs/development/coq-modules/paramcoq/default.nix

···
       sha256 = "002xabhjlph394vydw3dx8ipv5ry2nq3py4440bk9a18ljx0w6ll";
     };
   };
-  param = params."${coq.coq-version}";
+  param = params.${coq.coq-version};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/interpreters/acl2/default.nix

···
   src = fetchFromGitHub {
     owner = "acl2-devel";
     repo = "acl2-devel";
-    rev = revs."${version}";
-    sha256 = hashes."${version}";
+    rev = revs.${version};
+    sha256 = hashes.${version};
   };
 
   buildInputs = [ sbcl

pkgs/development/interpreters/ruby/default.nix

···
           (import ./patchsets.nix {
             inherit patchSet useRailsExpress ops;
             patchLevel = ver.patchLevel;
-          })."${ver.majMinTiny}";
+          }).${ver.majMinTiny};
 
         postUnpack = ''
           cp -r ${rubygems} $sourceRoot/rubygems

pkgs/development/libraries/fflas-ffpack/default.nix

···
     "--with-lapack-libs=-l${blas.linkName}"
   ] ++ stdenv.lib.optionals stdenv.isx86_64 {
     # disable SIMD instructions (which are enabled *when available* by default)
-    "default"        = [ "--disable-sse3" "--disable-ssse3" "--disable-sse41" "--disable-sse42" "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "westmere"       = [                                                                        "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "sandybridge"    = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "ivybridge"      = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "haswell"        = [                                                                                                                         "--disable-fma4" ];
-    "broadwell"      = [                                                                                                                         "--disable-fma4" ];
-    "skylake"        = [                                                                                                                         "--disable-fma4" ];
-    "skylake-avx512" = [                                                                                                                         "--disable-fma4" ];
+    default        = [ "--disable-sse3" "--disable-ssse3" "--disable-sse41" "--disable-sse42" "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    westmere       = [                                                                        "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    sandybridge    = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    ivybridge      = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    haswell        = [                                                                                                                         "--disable-fma4" ];
+    broadwell      = [                                                                                                                         "--disable-fma4" ];
+    skylake        = [                                                                                                                         "--disable-fma4" ];
+    skylake-avx512 = [                                                                                                                         "--disable-fma4" ];
   }.${stdenv.hostPlatform.platform.gcc.arch or "default"};
 
   doCheck = true;

pkgs/development/libraries/g2o/default.nix

···
     "-DQGLVIEWER_INCLUDE_DIR=${libsForQt5.libqglviewer}/include/QGLViewer"
     "-DG2O_BUILD_EXAMPLES=OFF"
   ] ++ lib.optionals stdenv.isx86_64 ([ "-DDO_SSE_AUTODETECT=OFF" ] ++ {
-    "default"        = [ "-DDISABLE_SSE3=ON" "-DDISABLE_SSE4_1=ON" "-DDISABLE_SSE4_2=ON" "-DDISABLE_SSE4_A=ON" ];
-    "westmere"       = [                                                                 "-DDISABLE_SSE4_A=ON" ];
-    "sandybridge"    = [                                                                 "-DDISABLE_SSE4_A=ON" ];
-    "ivybridge"      = [                                                                 "-DDISABLE_SSE4_A=ON" ];
-    "haswell"        = [                                                                 "-DDISABLE_SSE4_A=ON" ];
-    "broadwell"      = [                                                                 "-DDISABLE_SSE4_A=ON" ];
-    "skylake"        = [                                                                 "-DDISABLE_SSE4_A=ON" ];
-    "skylake-avx512" = [                                                                 "-DDISABLE_SSE4_A=ON" ];
+    default        = [ "-DDISABLE_SSE3=ON" "-DDISABLE_SSE4_1=ON" "-DDISABLE_SSE4_2=ON" "-DDISABLE_SSE4_A=ON" ];
+    westmere       = [                                                                 "-DDISABLE_SSE4_A=ON" ];
+    sandybridge    = [                                                                 "-DDISABLE_SSE4_A=ON" ];
+    ivybridge      = [                                                                 "-DDISABLE_SSE4_A=ON" ];
+    haswell        = [                                                                 "-DDISABLE_SSE4_A=ON" ];
+    broadwell      = [                                                                 "-DDISABLE_SSE4_A=ON" ];
+    skylake        = [                                                                 "-DDISABLE_SSE4_A=ON" ];
+    skylake-avx512 = [                                                                 "-DDISABLE_SSE4_A=ON" ];
   }.${stdenv.hostPlatform.platform.gcc.arch or "default"});
 
   postInstall = ''

pkgs/development/libraries/givaro/default.nix

···
     "--disable-optimization"
   ] ++ stdenv.lib.optionals stdenv.isx86_64 {
     # disable SIMD instructions (which are enabled *when available* by default)
-    "default"        = [ "--disable-sse3" "--disable-ssse3" "--disable-sse41" "--disable-sse42" "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "westmere"       = [                                                                        "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "sandybridge"    = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "ivybridge"      = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "haswell"        = [                                                                                                                         "--disable-fma4" ];
-    "broadwell"      = [                                                                                                                         "--disable-fma4" ];
-    "skylake"        = [                                                                                                                         "--disable-fma4" ];
-    "skylake-avx512" = [                                                                                                                         "--disable-fma4" ];
+    default        = [ "--disable-sse3" "--disable-ssse3" "--disable-sse41" "--disable-sse42" "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    westmere       = [                                                                        "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    sandybridge    = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    ivybridge      = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    haswell        = [                                                                                                                         "--disable-fma4" ];
+    broadwell      = [                                                                                                                         "--disable-fma4" ];
+    skylake        = [                                                                                                                         "--disable-fma4" ];
+    skylake-avx512 = [                                                                                                                         "--disable-fma4" ];
   }.${stdenv.hostPlatform.platform.gcc.arch or "default"};
 
   # On darwin, tests are linked to dylib in the nix store, so we need to make

pkgs/development/libraries/java/swt/default.nix

···
 
 let
   platformMap = {
-    "x86_64-linux" =
+    x86_64-linux =
       { platform = "gtk-linux-x86_64";
         sha256 = "1qq0pjll6030v4ml0hifcaaik7sx3fl7ghybfdw95vsvxafwp2ff"; };
-    "i686-linux" =
+    i686-linux =
       { platform = "gtk-linux-x86";
         sha256 = "03mhzraikcs4fsz7d3h5af9pw1bbcfd6dglsvbk2ciwimy9zj30q"; };
-    "x86_64-darwin" =
+    x86_64-darwin =
       { platform = "cocoa-macosx-x86_64";
         sha256 = "00k1mfbncvyh8klgmk0891w8jwnd5niqb16j1j8yacrm2smmlb05"; };
   };

pkgs/development/libraries/kde-frameworks/default.nix

···
           let
 
             inherit (args) name;
-            inherit (srcs."${name}") src version;
+            inherit (srcs.${name}) src version;
 
             outputs = args.outputs or [ "bin" "dev" "out" ];
             hasSeparateDev = lib.elem "dev" outputs;

pkgs/development/libraries/linbox/default.nix

···
     "--disable-optimization"
   ] ++ stdenv.lib.optionals stdenv.isx86_64 {
     # disable SIMD instructions (which are enabled *when available* by default)
-    "default"        = [ "--disable-sse3" "--disable-ssse3" "--disable-sse41" "--disable-sse42" "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "westmere"       = [                                                                        "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "sandybridge"    = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "ivybridge"      = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
-    "haswell"        = [                                                                                                                         "--disable-fma4" ];
-    "broadwell"      = [                                                                                                                         "--disable-fma4" ];
-    "skylake"        = [                                                                                                                         "--disable-fma4" ];
-    "skylake-avx512" = [                                                                                                                         "--disable-fma4" ];
+    default        = [ "--disable-sse3" "--disable-ssse3" "--disable-sse41" "--disable-sse42" "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    westmere       = [                                                                        "--disable-avx" "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    sandybridge    = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    ivybridge      = [                                                                                        "--disable-avx2" "--disable-fma" "--disable-fma4" ];
+    haswell        = [                                                                                                                         "--disable-fma4" ];
+    broadwell      = [                                                                                                                         "--disable-fma4" ];
+    skylake        = [                                                                                                                         "--disable-fma4" ];
+    skylake-avx512 = [                                                                                                                         "--disable-fma4" ];
   }.${stdenv.hostPlatform.platform.gcc.arch or "default"}
   ++ stdenv.lib.optionals withSage [
     "--enable-sage"

pkgs/development/libraries/openssl/default.nix

···
     # TODO(@Ericson2314): Improve with mass rebuild
     configurePlatforms = [];
     configureScript = {
-        "x86_64-darwin"  = "./Configure darwin64-x86_64-cc";
-        "x86_64-solaris" = "./Configure solaris64-x86_64-gcc";
-        "armv6l-linux" = "./Configure linux-armv4 -march=armv6";
-        "armv7l-linux" = "./Configure linux-armv4 -march=armv7-a";
+        x86_64-darwin  = "./Configure darwin64-x86_64-cc";
+        x86_64-solaris = "./Configure solaris64-x86_64-gcc";
+        armv6l-linux = "./Configure linux-armv4 -march=armv6";
+        armv7l-linux = "./Configure linux-armv4 -march=armv7-a";
       }.${stdenv.hostPlatform.system} or (
         if stdenv.hostPlatform == stdenv.buildPlatform
           then "./config"

pkgs/development/libraries/oracle-instantclient/default.nix

···
   throwSystem = throw "Unsupported system: ${stdenv.hostPlatform.system}";
 
   arch = {
-    "x86_64-linux" = "linux.x64";
-    "x86_64-darwin" = "macos.x64";
-  }."${stdenv.hostPlatform.system}" or throwSystem;
+    x86_64-linux = "linux.x64";
+    x86_64-darwin = "macos.x64";
+  }.${stdenv.hostPlatform.system} or throwSystem;
 
   srcs = {
-    "x86_64-linux" = [
+    x86_64-linux = [
       (requireSource "basic" arch version "" "5015e3c9fba84e009f7519893f798a1622c37d1ae2c55104ff502c52a0fe5194")
       (requireSource "sdk" arch version "" "7f404c3573c062ce487a51ac4cfe650c878d7edf8e73b364ec852645ed1098cb")
       (requireSource "sqlplus" arch version "" "d49b2bd97376591ca07e7a836278933c3f251875c215044feac73ba9f451dfc2") ]
       ++ optional odbcSupport (requireSource "odbc" arch version "2" "365a4ae32c7062d9fbc3fb41add748e7881f774484a175a4b41a2c294ce9095d");
-    "x86_64-darwin" = [
+    x86_64-darwin = [
       (requireSource "basic" arch version "2" "3ed3102e5a24f0da638694191edb34933309fb472eb1df21ad5c86eedac3ebb9")
       (requireSource "sdk" arch version "2" "e0befca9c4e71ebc9f444957ffa70f01aeeec5976ea27c40406471b04c34848b")
       (requireSource "sqlplus" arch version "2" "d147cbb5b2a954fdcb4b642df4f0bd1153fd56e0f56e7fa301601b4f7e2abe0e") ]
       ++ optional odbcSupport (requireSource "odbc" arch version "2" "1805c1ab6c8c5e8df7bdcc35d7f2b94c329ecf4dff9bde55d5f9b159ecd8b64e");
-  }."${stdenv.hostPlatform.system}" or throwSystem;
+  }.${stdenv.hostPlatform.system} or throwSystem;
 
   extLib = stdenv.hostPlatform.extensions.sharedLibrary;
 in stdenv.mkDerivation rec {

pkgs/development/libraries/qt-5/modules/qtbase.nix

···
       if (!stdenv.hostPlatform.isx86_64)
       then [ "-no-sse2" ]
       else lib.optionals (compareVersion "5.9.0" >= 0) {
-        "default"        = [ "-sse2" "-no-sse3" "-no-ssse3" "-no-sse4.1" "-no-sse4.2" "-no-avx" "-no-avx2" ];
-        "westmere"       = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2" "-no-avx" "-no-avx2" ];
-        "sandybridge"    = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx" "-no-avx2" ];
-        "ivybridge"      = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx" "-no-avx2" ];
-        "haswell"        = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx"    "-avx2" ];
-        "broadwell"      = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx"    "-avx2" ];
-        "skylake"        = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx"    "-avx2" ];
-        "skylake-avx512" = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx"    "-avx2" ];
+        default        = [ "-sse2" "-no-sse3" "-no-ssse3" "-no-sse4.1" "-no-sse4.2" "-no-avx" "-no-avx2" ];
+        westmere       = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2" "-no-avx" "-no-avx2" ];
+        sandybridge    = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx" "-no-avx2" ];
+        ivybridge      = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx" "-no-avx2" ];
+        haswell        = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx"    "-avx2" ];
+        broadwell      = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx"    "-avx2" ];
+        skylake        = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx"    "-avx2" ];
+        skylake-avx512 = [ "-sse2"    "-sse3"    "-ssse3"    "-sse4.1"    "-sse4.2"    "-avx"    "-avx2" ];
       }.${stdenv.hostPlatform.platform.gcc.arch or "default"}
     )
     ++ [

pkgs/development/libraries/qt-5/qtModule.nix

···
 
 let
   inherit (args) name;
-  version = args.version or srcs."${name}".version;
-  src = args.src or srcs."${name}".src;
+  version = args.version or srcs.${name}.version;
+  src = args.src or srcs.${name}.src;
 in
 
 mkDerivation (args // {
   name = "${name}-${version}";
   inherit src;
-  patches = args.patches or patches."${name}" or [];
+  patches = args.patches or patches.${name} or [];
 
   nativeBuildInputs = (args.nativeBuildInputs or []) ++ [ perl self.qmake ];
   propagatedBuildInputs = args.qtInputs ++ (args.propagatedBuildInputs or []);

pkgs/development/libraries/science/math/tensorflow/binary-hashes.nix

···
 {
 version = "1.14.0";
-"cpu-linux-x86_64" = {
+cpu-linux-x86_64 = {
   url = "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-cpu-linux-x86_64-1.14.0.tar.gz";
   sha256 = "04bi3ijq4sbb8c5vk964zlv0j9mrjnzzxd9q9knq3h273nc1a36k";
 };
-"gpu-linux-x86_64" = {
+gpu-linux-x86_64 = {
   url = "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-gpu-linux-x86_64-1.14.0.tar.gz";
   sha256 = "1ffnpyj9jjgwxpjfiyjvq4dm3n6nwiksim5jld9zw7fdswh215x6";
 };
-"cpu-darwin-x86_64" = {
+cpu-darwin-x86_64 = {
   url = "https://storage.googleapis.com/tensorflow/libtensorflow/libtensorflow-cpu-darwin-x86_64-1.14.0.tar.gz";
   sha256 = "0zsd5ils1a17j6jzh0c7q1z56fw46gkzybbnms7h2rgg8al0rh92";
 };

pkgs/development/libraries/v8/5_x.nix

···
   sharedFlag = if static then "static_library" else "shared_library";
 
   deps = {
-    "build" = fetchgit {
+    build = fetchgit {
       url = "${git_url}/chromium/src/build.git";
       rev = "2c67d4d74b6b3673228fab191918500a582ef3b0";
       sha256 = "0jc7hci5yh792pw0ahjfxrk5xzllnlrv9llmwlgcgn2x8x6bn34q";
···
       rev = "b5ecbb29a26532f72ef482569b223d5a51fd50bf";
       sha256 = "0ld47wdnk8grcba221z67l3pnphv9zwifk4y44f5b946w3iwmpns";
     };
-    "buildtools" = fetchgit {
+    buildtools = fetchgit {
       url = "${git_url}/chromium/buildtools.git";
       rev = "60f7f9a8b421ebf9a46041dfa2ff11c0fe59c582";
       sha256 = "0i10bw7yhslklqwcx5krs3k05sicb73cpwd0mkaz96yxsvmkvjq0";

pkgs/development/libraries/v8/default.nix

···
       rev    = "936ba8a963284a6b3737cf2f0474a7131073abee";
       sha256 = "14nr22fqdpxma1kzjflj6a865vr3hfnnm2gs4vcixyq4kmfzfcy2";
     };
-    "build" = fetchgit {
+    build = fetchgit {
       url    = "${git_url}/chromium/src/build.git";
       rev    = "325e95d6dae64f35b160b3dc7d73218cee5ec079";
       sha256 = "0dddyxa76p2xpjhmxif05v63i5ar6h5v684fdl667sg84f5bhhxf";

pkgs/development/libraries/v8/plv8_6_x.nix

···
       rev    = "0e9a47d74970bee1bbfc063c47215406f8918699";
       sha256 = "07rbzrlscp8adh4z86yl5jxdnvgkc3xs950xldpk318wf9i3bh6c";
     };
-    "build" = fetchgit {
+    build = fetchgit {
       url    = "${git_url}/chromium/src/build.git";
       rev    = "9338ce52d0b9bcef34c38285fbd5023b62739fac";
       sha256 = "1s2sa8dy3waidsirjylc82ggb18l1108bczjc8z0v4ywyj4k0cvh";
     };
-    "buildtools" = fetchgit {
+    buildtools = fetchgit {
       url    = "${git_url}/chromium/buildtools.git";
       rev    = "505de88083136eefd056e5ee4ca0f01fe9b33de8";
       sha256 = "0vj216nhb803bggsl0hnyagj8njrm96pn8sim6xcnqb7nhz1vabw";

pkgs/development/mobile/androidenv/compose-android-packages.nix

···
   platform-tools = import ./platform-tools.nix {
     inherit deployAndroidPackage os autoPatchelfHook pkgs;
     inherit (stdenv) lib;
-    package = packages.platform-tools."${platformToolsVersion}";
+    package = packages.platform-tools.${platformToolsVersion};
   };
 
   build-tools = map (version:
     import ./build-tools.nix {
       inherit deployAndroidPackage os autoPatchelfHook makeWrapper pkgs pkgs_i686;
       inherit (stdenv) lib;
-      package = packages.build-tools."${version}";
+      package = packages.build-tools.${version};
     }
   ) buildToolsVersions;
 
···
   emulator = import ./emulator.nix {
     inherit deployAndroidPackage os autoPatchelfHook makeWrapper pkgs pkgs_i686;
     inherit (stdenv) lib;
-    package = packages.emulator."${emulatorVersion}"."${os}";
+    package = packages.emulator.${emulatorVersion}.${os};
   };
 
   platforms = map (version:
     deployAndroidPackage {
       inherit os;
-      package = packages.platforms."${version}";
+      package = packages.platforms.${version};
     }
   ) platformVersions;
 
   sources = map (version:
     deployAndroidPackage {
       inherit os;
-      package = packages.sources."${version}";
+      package = packages.sources.${version};
     }
   ) platformVersions;
 
···
     import ./lldb.nix {
       inherit deployAndroidPackage os autoPatchelfHook pkgs;
       inherit (stdenv) lib;
-      package = packages.lldb."${version}";
+      package = packages.lldb.${version};
     }
   ) lldbVersions;
 
···
     import ./cmake.nix {
       inherit deployAndroidPackage os autoPatchelfHook pkgs;
       inherit (stdenv) lib;
-      package = packages.cmake."${version}";
+      package = packages.cmake.${version};
     }
   ) cmakeVersions;
 
   ndk-bundle = import ./ndk-bundle {
     inherit deployAndroidPackage os autoPatchelfHook makeWrapper pkgs platform-tools;
     inherit (stdenv) lib;
-    package = packages.ndk-bundle."${ndkVersion}";
+    package = packages.ndk-bundle.${ndkVersion};
   };
 
   google-apis = map (version:
     deployAndroidPackage {
       inherit os;
-      package = addons.addons."${version}".google_apis;
+      package = addons.addons.${version}.google_apis;
     }
   ) (builtins.filter (platformVersion: platformVersion < "26") platformVersions); # API level 26 and higher include Google APIs by default
 
   google-tv-addons = map (version:
     deployAndroidPackage {
       inherit os;
-      package = addons.addons."${version}".google_tv_addon;
+      package = addons.addons.${version}.google_tv_addon;
     }
   ) platformVersions;
 
···
       # Link extras
       ${stdenv.lib.concatMapStrings (identifier:
         let
-          path = addons.extras."${identifier}".path;
+          path = addons.extras.${identifier}.path;
           addon = deployAndroidPackage {
             inherit os;
-            package = addons.extras."${identifier}";
+            package = addons.extras.${identifier};
           };
         in
         ''

pkgs/development/mobile/androidenv/tools.nix

···
   };
 } else if toolsVersion == "26.1.1" then import ./tools/26.nix {
   inherit deployAndroidPackage lib autoPatchelfHook makeWrapper os pkgs pkgs_i686 postInstall;
-  package = packages.tools."${toolsVersion}";
+  package = packages.tools.${toolsVersion};
 } else import ./tools/25.nix {
   inherit deployAndroidPackage lib autoPatchelfHook makeWrapper os pkgs pkgs_i686 postInstall;
-  package = packages.tools."${toolsVersion}";
+  package = packages.tools.${toolsVersion};
 }

pkgs/development/node-packages/composition-v10.nix

···
 
 {pkgs ? import <nixpkgs> {
     inherit system;
-  }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-10_x"}:
+  }, system ? builtins.currentSystem, nodejs ? pkgs.nodejs-10_x}:
 
 let
   nodeEnv = import ./node-env.nix {

pkgs/development/node-packages/composition-v12.nix

···
 
 {pkgs ? import <nixpkgs> {
     inherit system;
-  }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-6_x"}:
+  }, system ? builtins.currentSystem, nodejs ? pkgs.nodejs-6_x}:
 
 let
   nodeEnv = import ./node-env.nix {

pkgs/development/ocaml-modules/labltk/default.nix

···
     key = "1764";
     sha256 = "0wgx65y1wkgf22ihpqmspqfp95fqbj3pldhp1p3b1mi8rmc37zwj";
   };
-}."${builtins.substring 0 4 ocaml.version}";
+}.${builtins.substring 0 4 ocaml.version};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/ocaml-modules/lwt/legacy.nix

···
   "3.0.0" = "0wwhnl9hppixcsdisinj1wmffx0nv6hkpm01z9qvkngkrazi3i88";
   "2.7.1" = "0w7f59havrl2fsnvs84lm7wlqpsrldg80gy5afpnpr21zkw22g8w";
   "2.6.0" = "0f1h83zh60rspm4fxd96z9h5bkhq1n1q968hgq92sq4a6bfi1c2w";
-}."${version}"; in
+}.${version}; in
 
 let optionals = stdenv.lib.optionals (!stdenv.lib.versionAtLeast version "3"); in
 

pkgs/development/ocaml-modules/ppx_tools/default.nix

···
   "4.07" = {
     version = "5.1+4.06.0";
     sha256 = "1ww4cspdpgjjsgiv71s0im5yjkr3544x96wsq1vpdacq7dr7zwiw"; };
-}."${ocaml.meta.branch}";
+}.${ocaml.meta.branch};
 in
   stdenv.mkDerivation {
     name = "ocaml${ocaml.version}-ppx_tools-${param.version}";

pkgs/development/python-modules/numpy/default.nix

···
   cfg = writeTextFile {
     name = "site.cfg";
     text = (lib.generators.toINI {} {
-      "${blasImplementation}" = {
+      ${blasImplementation} = {
         include_dirs = "${blas}/include";
         library_dirs = "${blas}/lib";
       } // lib.optionalAttrs (blasImplementation == "mkl") {

pkgs/development/python-modules/spacy/models.nix

···
     meta = with stdenv.lib; {
       description = "Models for the spaCy NLP library";
       homepage    = "https://github.com/explosion/spacy-models";
-      license     = licenses."${license}";
+      license     = licenses.${license};
       maintainers = with maintainers; [ rvl ];
     };
   };

pkgs/development/ruby-modules/bundled-common/default.nix

···
     name
   else
     let
-      gem = gems."${pname}";
+      gem = gems.${pname};
       version = gem.version;
     in
       "${pname}-${version}";
···
 
   maybeCopyAll = pkgname: if pkgname == null then "" else
   let
-    mainGem = gems."${pkgname}" or (throw "bundlerEnv: gem ${pkgname} not found");
+    mainGem = gems.${pkgname} or (throw "bundlerEnv: gem ${pkgname} not found");
   in
     copyIfBundledByPath mainGem;
 

pkgs/development/ruby-modules/bundled-common/functions.nix

···
       converge expandDependencies directlyMatchingGems;
 
   platformMatches = {rubyEngine, version, ...}: attrs: (
-  !(attrs ? "platforms") ||
+  !(attrs ? platforms) ||
   builtins.length attrs.platforms == 0 ||
     builtins.any (platform:
       platform.engine == rubyEngine &&
-        (!(platform ? "version") || platform.version == version.majMin)
+        (!(platform ? version) || platform.version == version.majMin)
     ) attrs.platforms
   );
 
   groupMatches = groups: attrs:
-    groups == null || !(attrs ? "groups") ||
+    groups == null || !(attrs ? groups) ||
       (intersectLists (groups ++ [ "default" ]) attrs.groups) != [];
 
   applyGemConfigs = attrs:
-    (if gemConfig ? "${attrs.gemName}"
-    then attrs // gemConfig."${attrs.gemName}" attrs
+    (if gemConfig ? ${attrs.gemName}
+    then attrs // gemConfig.${attrs.gemName} attrs
     else attrs);
 
   genStubsScript = { lib, ruby, confFiles, bundler, groups, binPaths, ... }: ''
···
     inherit (attrs.source) type;
     source = removeAttrs attrs.source ["type"];
     gemName = name;
-    gemPath = map (gemName: gems."${gemName}") (attrs.dependencies or []);
+    gemPath = map (gemName: gems.${gemName}) (attrs.dependencies or []);
   });
 }

pkgs/development/ruby-modules/bundler-env/default.nix

···
       postBuild = genStubsScript {
         inherit lib ruby bundler groups;
         confFiles = basicEnv.confFiles;
-        binPaths = [ basicEnv.gems."${pname}" ];
+        binPaths = [ basicEnv.gems.${pname} ];
       } + lib.optionalString (postBuild != null) postBuild;
 
       meta = { platforms = ruby.meta.platforms; } // meta;

pkgs/development/tools/build-managers/bazel/default.nix

···
       srcs.io_bazel_rules_sass
       srcs.platforms
       (if stdenv.hostPlatform.isDarwin
-       then srcs.${"java_tools_javac11_darwin-v2.0.zip"}
-       else srcs.${"java_tools_javac11_linux-v2.0.zip"})
-      srcs.${"coverage_output_generator-v1.0.zip"}
+       then srcs."java_tools_javac11_darwin-v2.0.zip"
+       else srcs."java_tools_javac11_linux-v2.0.zip")
+      srcs."coverage_output_generator-v1.0.zip"
       srcs.build_bazel_rules_nodejs
-      srcs.${"android_tools_pkg-0.7.tar.gz"}
+      srcs."android_tools_pkg-0.7.tar.gz"
       ]);
 
   distDir = runCommand "bazel-deps" {} ''

pkgs/development/tools/build-managers/meson/default.nix

···
 let
   # See https://mesonbuild.com/Reference-tables.html#cpu-families
   cpuFamilies = {
-    "aarch64" = "aarch64";
-    "armv6l"  = "arm";
-    "armv7l"  = "arm";
-    "i686"    = "x86";
-    "x86_64"  = "x86_64";
+    aarch64 = "aarch64";
+    armv6l  = "arm";
+    armv7l  = "arm";
+    i686    = "x86";
+    x86_64  = "x86_64";
   };
 in
 python3Packages.buildPythonApplication rec {

pkgs/development/tools/misc/kibana/5.x.nix

···
 let
   inherit (builtins) elemAt;
   archOverrides = {
-    "i686" = "x86";
+    i686 = "x86";
   };
   info = splitString "-" stdenv.hostPlatform.system;
   arch = (elemAt info 0);
-  elasticArch = archOverrides."${arch}" or arch;
+  elasticArch = archOverrides.${arch} or arch;
   plat = elemAt info 1;
   shas = {
-    "x86_64-linux"  = "0hzr47hyw54b9j4c33n6f6n3pala6kjhyvinfszgikbghyhb7fsa";
-    "i686-linux"    = "0bka4h31cw10ii4pfygc81pwc3wr32pzw3v4k4bi8rnqbk280fmn";
-    "x86_64-darwin" = "0jqc2g89rqkla0alqxr14sh4pccfn514jrwr7mkjivxdapygh1ll";
+    x86_64-linux  = "0hzr47hyw54b9j4c33n6f6n3pala6kjhyvinfszgikbghyhb7fsa";
+    i686-linux    = "0bka4h31cw10ii4pfygc81pwc3wr32pzw3v4k4bi8rnqbk280fmn";
+    x86_64-darwin = "0jqc2g89rqkla0alqxr14sh4pccfn514jrwr7mkjivxdapygh1ll";
   };
 in stdenv.mkDerivation rec {
   pname = "kibana";
···
 
   src = fetchurl {
     url = "https://artifacts.elastic.co/downloads/kibana/${pname}-${version}-${plat}-${elasticArch}.tar.gz";
-    sha256 = shas."${stdenv.hostPlatform.system}" or (throw "Unknown architecture");
+    sha256 = shas.${stdenv.hostPlatform.system} or (throw "Unknown architecture");
   };
 
   buildInputs = [ makeWrapper ];

pkgs/development/tools/misc/kibana/6.x.nix

···
   shas =
     if enableUnfree
     then {
-      "x86_64-linux"  = "1i3zmzxihplwd8n994lfxhhgygdg3qxjqgrj1difa8w3vss0zbfn";
-      "x86_64-darwin" = "09a96ms9id77infxd9xxfs6r7j01mn0rz5yw3g9sl92j9ri7r52c";
+      x86_64-linux  = "1i3zmzxihplwd8n994lfxhhgygdg3qxjqgrj1difa8w3vss0zbfn";
+      x86_64-darwin = "09a96ms9id77infxd9xxfs6r7j01mn0rz5yw3g9sl92j9ri7r52c";
     }
     else {
-      "x86_64-linux"  = "166rhxr0qlv1yarj2mg1c3b8mxvhl70jhz53azq7ic6laj55q7fk";
-      "x86_64-darwin" = "0ngngkbl036p2mzwhp8qafi3aqzk398a218w12srfqny5n630vdk";
+      x86_64-linux  = "166rhxr0qlv1yarj2mg1c3b8mxvhl70jhz53azq7ic6laj55q7fk";
+      x86_64-darwin = "0ngngkbl036p2mzwhp8qafi3aqzk398a218w12srfqny5n630vdk";
     };
 
 in stdenv.mkDerivation rec {
···
 
   src = fetchurl {
     url = "https://artifacts.elastic.co/downloads/kibana/${name}-${plat}-${arch}.tar.gz";
-    sha256 = shas."${stdenv.hostPlatform.system}" or (throw "Unknown architecture");
+    sha256 = shas.${stdenv.hostPlatform.system} or (throw "Unknown architecture");
   };
 
   patches = [

pkgs/development/tools/misc/kibana/7.x.nix

···
   shas =
     if enableUnfree
     then {
-      "x86_64-linux"  = "1mzycd0ljnkslz9p9jhq279bkpk35r7svhngxjnmsh11ampsvxb8";
-      "x86_64-darwin" = "1bz409njdpmsagh5dg062114wpa96w7pmxwfjsizwksqyyjdwdv7";
+      x86_64-linux  = "1mzycd0ljnkslz9p9jhq279bkpk35r7svhngxjnmsh11ampsvxb8";
+      x86_64-darwin = "1bz409njdpmsagh5dg062114wpa96w7pmxwfjsizwksqyyjdwdv7";
     }
     else {
-      "x86_64-linux"  = "1x3gjc9xa03m4jfnl5vjxigzcnb8ysnhxgd8618v85x4l0010v38";
-      "x86_64-darwin" = "1nsbmrswv2jv2z7686i2sf6rrmxysbqi5ih6jjrbrqnk64xi18j2";
+      x86_64-linux  = "1x3gjc9xa03m4jfnl5vjxigzcnb8ysnhxgd8618v85x4l0010v38";
+      x86_64-darwin = "1nsbmrswv2jv2z7686i2sf6rrmxysbqi5ih6jjrbrqnk64xi18j2";
     };
 
 in stdenv.mkDerivation rec {
···
 
   src = fetchurl {
     url = "https://artifacts.elastic.co/downloads/kibana/${name}-${plat}-${arch}.tar.gz";
-    sha256 = shas."${stdenv.hostPlatform.system}" or (throw "Unknown architecture");
+    sha256 = shas.${stdenv.hostPlatform.system} or (throw "Unknown architecture");
   };
 
   patches = [

pkgs/development/tools/ocaml/camlp4/default.nix

···
   "4.08" = {
      version = "4.08+1";
      sha256 = "0qplawvxwai25bi27niw2cgz2al01kcnkj8wxwhxslpi21z6pyx1"; };
-  }."${ocaml.meta.branch}";
+  }.${ocaml.meta.branch};
 in
 
 stdenv.mkDerivation rec {

pkgs/development/tools/ocaml/js_of_ocaml/default.nix

···
     sha256 = {
       "2.7" = "1dali1akyd4zmkwav0d957ynxq2jj6cc94r4xiaql7ca89ajz4jj";
       "2.8.4" = "098ph50s9kqw6rc3qjn39zv9b5swdf4qr44afwqfkkjgjs5d7vbl";
-    }."${version}";
+    }.${version};
   };
 
   buildInputs = [ ocaml findlib menhir ocsigen_deriving ocamlbuild

pkgs/development/tools/selenium/chromedriver/default.nix

···
 }:
 let
   allSpecs = {
-    "x86_64-linux" = {
+    x86_64-linux = {
       system = "linux64";
       sha256 = "04wb6h57daxmnv3a3xrcsznawbx7r8wyi1vk1g26z2l2ppcnsbzv";
     };
 
-    "x86_64-darwin" = {
+    x86_64-darwin = {
       system = "mac64";
       sha256 = "0f8j7m8ardaaw8pv02vxhwkqbcm34366bln0np0j0ig21d4fag09";
     };
   };
 
-  spec = allSpecs."${stdenv.hostPlatform.system}"
+  spec = allSpecs.${stdenv.hostPlatform.system}
     or (throw "missing chromedriver binary for ${stdenv.hostPlatform.system}");
 
   libs = stdenv.lib.makeLibraryPath [

pkgs/development/web/remarkjs/nodepkgs.nix

···
 
 {pkgs ? import <nixpkgs> {
     inherit system;
-  }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-10_x"}:
+  }, system ? builtins.currentSystem, nodejs ? pkgs.nodejs-10_x}:
 
 let
   nodeEnv = import ../../node-packages/node-env.nix {

pkgs/games/dwarf-fortress/game.nix

···
   # Other srcs are avilable like 32-bit mac & win, but I have only
   # included the ones most likely to be needed by Nixpkgs users.
   platforms = {
-    "x86_64-linux" = "linux";
-    "i686-linux" = "linux32";
-    "x86_64-darwin" = "osx";
-    "i686-darwin" = "osx32";
-    "x86_64-cygwin" = "win";
-    "i686-cygwin" = "win32";
+    x86_64-linux = "linux";
+    i686-linux = "linux32";
+    x86_64-darwin = "osx";
+    i686-darwin = "osx32";
+    x86_64-cygwin = "win";
+    i686-cygwin = "win32";
   };
 
   dfVersionTriple = splitString "." dfVersion;

pkgs/misc/base16-builder/node-packages.nix

···
 
 {pkgs ? import <nixpkgs> {
     inherit system;
-  }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-10_x"}:
+  }, system ? builtins.currentSystem, nodejs ? pkgs.nodejs-10_x}:
 
 let
   nodeEnv = import ../../development/node-packages/node-env.nix {

pkgs/misc/drivers/hplip/3.16.11.nix

···
   };
 
   hplipPlatforms = {
-    "i686-linux"    = "x86_32";
-    "x86_64-linux"  = "x86_64";
-    "armv6l-linux"  = "arm32";
-    "armv7l-linux"  = "arm32";
-    "aarch64-linux" = "arm64";
+    i686-linux    = "x86_32";
+    x86_64-linux  = "x86_64";
+    armv6l-linux  = "arm32";
+    armv7l-linux  = "arm32";
+    aarch64-linux = "arm64";
   };
 
-  hplipArch = hplipPlatforms."${stdenv.hostPlatform.system}"
+  hplipArch = hplipPlatforms.${stdenv.hostPlatform.system}
     or (throw "HPLIP not supported on ${stdenv.hostPlatform.system}");
 
   pluginArches = [ "x86_32" "x86_64" "arm32" "arm64" ];

pkgs/misc/drivers/hplip/3.18.5.nix

···
   };
 
   hplipPlatforms = {
-    "i686-linux"    = "x86_32";
-    "x86_64-linux"  = "x86_64";
-    "armv6l-linux"  = "arm32";
-    "armv7l-linux"  = "arm32";
-    "aarch64-linux" = "arm64";
+    i686-linux    = "x86_32";
+    x86_64-linux  = "x86_64";
+    armv6l-linux  = "arm32";
+    armv7l-linux  = "arm32";
+    aarch64-linux = "arm64";
   };
 
-  hplipArch = hplipPlatforms."${stdenv.hostPlatform.system}"
+  hplipArch = hplipPlatforms.${stdenv.hostPlatform.system}
     or (throw "HPLIP not supported on ${stdenv.hostPlatform.system}");
 
   pluginArches = [ "x86_32" "x86_64" "arm32" "arm64" ];

pkgs/misc/drivers/hplip/default.nix

···
   };
 
   hplipPlatforms = {
-    "i686-linux"   = "x86_32";
-    "x86_64-linux" = "x86_64";
-    "armv6l-linux" = "arm32";
-    "armv7l-linux" = "arm32";
+    i686-linux   = "x86_32";
+    x86_64-linux = "x86_64";
+    armv6l-linux = "arm32";
+    armv7l-linux = "arm32";
   };
 
-  hplipArch = hplipPlatforms."${stdenv.hostPlatform.system}"
+  hplipArch = hplipPlatforms.${stdenv.hostPlatform.system}
     or (throw "HPLIP not supported on ${stdenv.hostPlatform.system}");
 
   pluginArches = [ "x86_32" "x86_64" "arm32" ];

pkgs/misc/vim-plugins/vim-utils.nix

···
         ${lib.concatMapStrings (plugin: ''
           let g:nix_plugin_locations['${plugin.pname}'] = "${plugin.rtp}"
         '') plugins}
-        let g:nix_plugin_locations['vim-addon-manager'] = "${knownPlugins."vim-addon-manager".rtp}"
+        let g:nix_plugin_locations['vim-addon-manager'] = "${knownPlugins.vim-addon-manager.rtp}"
 
         let g:vim_addon_manager = {}
 
···
     name = "vim_with_custom_plugin";
     vimrcConfig.vam.knownPlugins =
       vimPlugins // ({
-        "vim-trailing-whitespace" = buildVimPluginFrom2Nix {
+        vim-trailing-whitespace = buildVimPluginFrom2Nix {
           name = "vim-trailing-whitespace";
           src = fetchFromGitHub {
             owner = "bronson";

pkgs/misc/vscode-extensions/python/default.nix

···
     else throw "Only x86_64 Linux and Darwin are supported.";
 
   languageServerSha256 = {
-    "linux-x64" = "0j9251f8dfccmg0x9gzg1cai4k5zd0alcfpb0443gs4jqakl0lr2";
-    "osx-x64" = "070qwwl08fa24rsnln4i5x9mfriqaw920l6v2j8d1r0zylxnyjsa";
-  }."${arch}";
+    linux-x64 = "0j9251f8dfccmg0x9gzg1cai4k5zd0alcfpb0443gs4jqakl0lr2";
+    osx-x64 = "070qwwl08fa24rsnln4i5x9mfriqaw920l6v2j8d1r0zylxnyjsa";
+  }.${arch};
 
   # version is languageServerVersion in the package.json
   languageServer = extractNuGet rec {

pkgs/os-specific/bsd/netbsd/default.nix

···
     HOST_SH = "${buildPackages.bash}/bin/sh";
 
     MACHINE_ARCH = {
-      "i686" = "i386";
+      i686 = "i386";
     }.${stdenv'.hostPlatform.parsed.cpu.name}
       or stdenv'.hostPlatform.parsed.cpu.name;
 
     MACHINE = {
-      "x86_64" = "amd64";
-      "aarch64" = "evbarm64";
-      "i686" = "i386";
+      x86_64 = "amd64";
+      aarch64 = "evbarm64";
+      i686 = "i386";
     }.${stdenv'.hostPlatform.parsed.cpu.name}
       or stdenv'.hostPlatform.parsed.cpu.name;
 

pkgs/os-specific/darwin/xcode/sdk-pkgs.nix

···
 minSdkVersion = "9.0";
 
 iosPlatformArch = { parsed, ... }: {
-  "armv7a"  = "armv7";
-  "aarch64" = "arm64";
-  "x86_64"  = "x86_64";
+  armv7a  = "armv7";
+  aarch64 = "arm64";
+  x86_64  = "x86_64";
 }.${parsed.cpu.name};
 
 in

pkgs/os-specific/linux/kernel/linux-rpi.nix

···
   };
 
   defconfig = {
-    "armv6l-linux" = "bcmrpi_defconfig";
-    "armv7l-linux" = "bcm2709_defconfig";
-    "aarch64-linux" = "bcmrpi3_defconfig";
+    armv6l-linux = "bcmrpi_defconfig";
+    armv7l-linux = "bcm2709_defconfig";
+    aarch64-linux = "bcmrpi3_defconfig";
   }.${stdenv.hostPlatform.system} or (throw "linux_rpi not supported on '${stdenv.hostPlatform.system}'");
 
   features = {

pkgs/servers/nosql/arangodb/default.nix

···
       "-DUSE_OPTIMIZE_FOR_ARCHITECTURE=OFF"
       # also avoid using builder's /proc/cpuinfo
     ] ++
-    { "westmere"       = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
-      "sandybridge"    = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
-      "ivybridge"      = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
-      "haswell"        = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
-      "broadwell"      = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
-      "skylake"        = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
-      "skylake-avx512" = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
+    { westmere       = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
+      sandybridge    = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
+      ivybridge      = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
+      haswell        = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
+      broadwell      = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
+      skylake        = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
+      skylake-avx512 = [ "-DHAVE_SSE42=ON" "-DASM_OPTIMIZATIONS=ON" ];
     }.${stdenv.hostPlatform.platform.gcc.arch or ""} or [ "-DHAVE_SSE42=OFF" "-DASM_OPTIMIZATIONS=OFF" ];
 
     enableParallelBuilding = true;

pkgs/servers/search/elasticsearch/7.x.nix

···
   shas =
     if enableUnfree
     then {
-      "x86_64-linux"  = "1jkfllafcjqhfydsy90jx2ghpv5cmm6gabv206niwg9qc6y6r1ik";
-      "x86_64-darwin" = "1lgyxq3yahdww0wpqmpc1mz57kmk5hy2drb1dha69k9l0ibmjf18";
+      x86_64-linux  = "1jkfllafcjqhfydsy90jx2ghpv5cmm6gabv206niwg9qc6y6r1ik";
+      x86_64-darwin = "1lgyxq3yahdww0wpqmpc1mz57kmk5hy2drb1dha69k9l0ibmjf18";
     }
     else {
-      "x86_64-linux"  = "0pg22wi2xcjla44azfvn9c58r4xq3x9jiwh7qb0d8f3nv30vfd10";
-      "x86_64-darwin" = "0d9xg3bf06mr7mw2bd16gb2xrfjncrhj19846rrj4j5gb2qjz0x2";
+      x86_64-linux  = "0pg22wi2xcjla44azfvn9c58r4xq3x9jiwh7qb0d8f3nv30vfd10";
+      x86_64-darwin = "0d9xg3bf06mr7mw2bd16gb2xrfjncrhj19846rrj4j5gb2qjz0x2";
     };
 in
 stdenv.mkDerivation (rec {
···
 
   src = fetchurl {
     url = "https://artifacts.elastic.co/downloads/elasticsearch/${name}-${plat}-${arch}.tar.gz";
-    sha256 = shas."${stdenv.hostPlatform.system}" or (throw "Unknown architecture");
+    sha256 = shas.${stdenv.hostPlatform.system} or (throw "Unknown architecture");
   };
 
   patches = [ ./es-home-6.x.patch ];

pkgs/servers/web-apps/cryptpad/node-packages.nix

···
 
 {pkgs ? import <nixpkgs> {
     inherit system;
-  }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-10_x"}:
+  }, system ? builtins.currentSystem, nodejs ? pkgs.nodejs-10_x}:
 
 let
   nodeEnv = import ../../../development/node-packages/node-env.nix {

pkgs/stdenv/default.nix

···
   if crossSystem != localSystem || crossOverlays != [] then stagesCross
   else if config ? replaceStdenv then stagesCustom
   else { # switch
-    "i686-linux" = stagesLinux;
-    "x86_64-linux" = stagesLinux;
-    "armv5tel-linux" = stagesLinux;
-    "armv6l-linux" = stagesLinux;
-    "armv6m-linux" = stagesLinux;
-    "armv7a-linux" = stagesLinux;
-    "armv7l-linux" = stagesLinux;
-    "armv7r-linux" = stagesLinux;
-    "armv7m-linux" = stagesLinux;
-    "armv8a-linux" = stagesLinux;
-    "armv8r-linux" = stagesLinux;
-    "armv8m-linux" = stagesLinux;
-    "aarch64-linux" = stagesLinux;
-    "mipsel-linux" = stagesLinux;
-    "powerpc-linux" = /* stagesLinux */ stagesNative;
-    "powerpc64le-linux" = stagesLinux;
-    "x86_64-darwin" = stagesDarwin;
-    "x86_64-solaris" = stagesNix;
-    "i686-cygwin" = stagesNative;
-    "x86_64-cygwin" = stagesNative;
-    "x86_64-freebsd" = stagesFreeBSD;
+    i686-linux = stagesLinux;
+    x86_64-linux = stagesLinux;
+    armv5tel-linux = stagesLinux;
+    armv6l-linux = stagesLinux;
+    armv6m-linux = stagesLinux;
+    armv7a-linux = stagesLinux;
+    armv7l-linux = stagesLinux;
+    armv7r-linux = stagesLinux;
+    armv7m-linux = stagesLinux;
+    armv8a-linux = stagesLinux;
+    armv8r-linux = stagesLinux;
+    armv8m-linux = stagesLinux;
+    aarch64-linux = stagesLinux;
+    mipsel-linux = stagesLinux;
+    powerpc-linux = /* stagesLinux */ stagesNative;
+    powerpc64le-linux = stagesLinux;
+    x86_64-darwin = stagesDarwin;
+    x86_64-solaris = stagesNix;
+    i686-cygwin = stagesNative;
+    x86_64-cygwin = stagesNative;
+    x86_64-freebsd = stagesFreeBSD;
   }.${localSystem.system} or stagesNative

pkgs/stdenv/generic/check-meta.nix

···
 
         '' + (builtins.getAttr reason remediation) attrs;
 
-      handler = if config ? "handleEvalIssue"
+      handler = if config ? handleEvalIssue
         then config.handleEvalIssue reason
         else throw;
     in handler msg;

pkgs/stdenv/linux/default.nix

···
 
 , bootstrapFiles ?
   let table = {
-    "glibc" = {
-      "i686-linux" = import ./bootstrap-files/i686.nix;
-      "x86_64-linux" = import ./bootstrap-files/x86_64.nix;
-      "armv5tel-linux" = import ./bootstrap-files/armv5tel.nix;
-      "armv6l-linux" = import ./bootstrap-files/armv6l.nix;
-      "armv7l-linux" = import ./bootstrap-files/armv7l.nix;
-      "aarch64-linux" = import ./bootstrap-files/aarch64.nix;
-      "mipsel-linux" = import ./bootstrap-files/loongson2f.nix;
-      "powerpc64le-linux" = import ./bootstrap-files/ppc64le.nix;
+    glibc = {
+      i686-linux = import ./bootstrap-files/i686.nix;
+      x86_64-linux = import ./bootstrap-files/x86_64.nix;
+      armv5tel-linux = import ./bootstrap-files/armv5tel.nix;
+      armv6l-linux = import ./bootstrap-files/armv6l.nix;
+      armv7l-linux = import ./bootstrap-files/armv7l.nix;
+      aarch64-linux = import ./bootstrap-files/aarch64.nix;
+      mipsel-linux = import ./bootstrap-files/loongson2f.nix;
+      powerpc64le-linux = import ./bootstrap-files/ppc64le.nix;
     };
-    "musl" = {
-      "aarch64-linux" = import ./bootstrap-files/aarch64-musl.nix;
-      "armv6l-linux"  = import ./bootstrap-files/armv6l-musl.nix;
-      "x86_64-linux"  = import ./bootstrap-files/x86_64-musl.nix;
-      "powerpc64le-linux" = import ./bootstrap-files/ppc64le-musl.nix;
+    musl = {
+      aarch64-linux = import ./bootstrap-files/aarch64-musl.nix;
+      armv6l-linux  = import ./bootstrap-files/armv6l-musl.nix;
+      x86_64-linux  = import ./bootstrap-files/x86_64-musl.nix;
+      powerpc64le-linux = import ./bootstrap-files/ppc64le-musl.nix;
     };
   };
 

pkgs/stdenv/native/default.nix

···
 
     cc = let
       nativePrefix = { # switch
-        "i686-solaris" = "/usr/gnu";
-        "x86_64-solaris" = "/opt/local/gcc47";
+        i686-solaris = "/usr/gnu";
+        x86_64-solaris = "/opt/local/gcc47";
       }.${system} or "/usr";
     in
     import ../../build-support/cc-wrapper {

pkgs/tools/admin/pulumi/default.nix

···
 
   # switch the dropdown to “manual” on https://pulumi.io/quickstart/install.html # TODO: update script
   pulumiArchPackage = {
-    "x86_64-linux" = {
+    x86_64-linux = {
       url = "https://get.pulumi.com/releases/sdk/pulumi-v${version}-linux-x64.tar.gz";
       sha256 = "13ajgc8x5l3s93hmz6jg88if10bvd319jmkljy4n26zdp30vfqmw";
     };
-    "x86_64-darwin" = {
+    x86_64-darwin = {
       url = "https://get.pulumi.com/releases/sdk/pulumi-v${version}-darwin-x64.tar.gz";
       sha256 = "0chpbnz2s4icwgmfq6kl8blz5mg4lpdqg061w3nh0p04adpgrn48";
     };

pkgs/tools/backup/lvmsync/default.nix

···
 let
 
   pname = "lvmsync";
-  version = (import ./gemset.nix)."${pname}".version;
+  version = (import ./gemset.nix).${pname}.version;
 
 in stdenv.mkDerivation rec {
 

pkgs/tools/bootloaders/refind/default.nix

···
 
 let
   archids = {
-    "x86_64-linux" = { hostarch = "x86_64"; efiPlatform = "x64"; };
-    "i686-linux" = rec { hostarch = "ia32"; efiPlatform = hostarch; };
-    "aarch64-linux" = rec { hostarch = "aarch64"; efiPlatform = "aa64"; };
+    x86_64-linux = { hostarch = "x86_64"; efiPlatform = "x64"; };
+    i686-linux = rec { hostarch = "ia32"; efiPlatform = hostarch; };
+    aarch64-linux = rec { hostarch = "aarch64"; efiPlatform = "aa64"; };
   };
 
   inherit

pkgs/tools/misc/grub/2.0x.nix

···
 with stdenv.lib;
 let
   pcSystems = {
-    "i686-linux".target = "i386";
-    "x86_64-linux".target = "i386";
+    i686-linux.target = "i386";
+    x86_64-linux.target = "i386";
   };
 
   efiSystemsBuild = {
-    "i686-linux".target = "i386";
-    "x86_64-linux".target = "x86_64";
-    "aarch64-linux".target = "aarch64";
+    i686-linux.target = "i386";
+    x86_64-linux.target = "x86_64";
+    aarch64-linux.target = "aarch64";
   };
 
   # For aarch64, we need to use '--target=aarch64-efi' when building,
   # but '--target=arm64-efi' when installing. Insanity!
   efiSystemsInstall = {
-    "i686-linux".target = "i386";
-    "x86_64-linux".target = "x86_64";
-    "aarch64-linux".target = "arm64";
+    i686-linux.target = "i386";
+    x86_64-linux.target = "x86_64";
+    aarch64-linux.target = "arm64";
   };
 
   canEfi = any (system: stdenv.hostPlatform.system == system) (mapAttrsToList (name: _: name) efiSystemsBuild);

pkgs/tools/misc/grub/pvgrub_image/default.nix

···
 with stdenv.lib;
 let
   efiSystemsBuild = {
-    "i686-linux".target = "i386";
-    "x86_64-linux".target = "x86_64";
-    "aarch64-linux".target = "aarch64";
+    i686-linux.target = "i386";
+    x86_64-linux.target = "x86_64";
+    aarch64-linux.target = "aarch64";
   };
 
 in (

pkgs/tools/misc/grub/trusted.nix

···
 with stdenv.lib;
 let
   pcSystems = {
-    "i686-linux".target = "i386";
-    "x86_64-linux".target = "i386";
+    i686-linux.target = "i386";
+    x86_64-linux.target = "i386";
   };
 
   inPCSystems = any (system: stdenv.hostPlatform.system == system) (mapAttrsToList (name: _: name) pcSystems);

pkgs/tools/networking/airfield/node.nix

···
 
 {pkgs ? import <nixpkgs> {
     inherit system;
-  }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-10_x"}:
+  }, system ? builtins.currentSystem, nodejs ? pkgs.nodejs-10_x}:
 
 let
   nodeEnv = import ../../../development/node-packages/node-env.nix {

pkgs/tools/networking/envoy/default.nix

···
   # Generate the BUILD file.
   buildFile =
     let field = name: attrs:
-      if attrs ? "${name}" then "    ${name} = ${attrs.${name}},\n" else "";
+      if attrs ? ${name} then "    ${name} = ${attrs.${name}},\n" else "";
     in
     ''
     licenses(["notice"])  # Apache 2

pkgs/tools/networking/s6-networking/default.nix

···
   inherit (stdenv) lib;
   sslSupportEnabled = sslSupport != false;
   sslLibs = {
-    "libressl" = libressl;
+    libressl = libressl;
   };
 
 in

pkgs/tools/package-management/nixui/nixui.nix

···
 
 {pkgs ? import <nixpkgs> {
     inherit system;
-  }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-10_x"}:
+  }, system ? builtins.currentSystem, nodejs ? pkgs.nodejs-10_x}:
 
 let
   nodeEnv = import ../../../development/node-packages/node-env.nix {

pkgs/tools/security/bitwarden-cli/node-packages.nix

···
 
 {pkgs ? import <nixpkgs> {
     inherit system;
-  }, system ? builtins.currentSystem, nodejs ? pkgs."nodejs-10_x"}:
+  }, system ? builtins.currentSystem, nodejs ? pkgs.nodejs-10_x}:
 
 let
   nodeEnv = import ../../../development/node-packages/node-env.nix {

pkgs/tools/security/bitwarden/default.nix

···
   pname = "bitwarden";
 
   version = {
-    "x86_64-linux" = "1.15.2";
+    x86_64-linux = "1.15.2";
   }.${system} or "";
 
   sha256 = {
-    "x86_64-linux" = "0yz4hkqqwq2zrdjfxk5kybhs90n80k6bkn0625m47b09lwl2di4f";
+    x86_64-linux = "0yz4hkqqwq2zrdjfxk5kybhs90n80k6bkn0625m47b09lwl2di4f";
   }.${system} or "";
 
   meta = with stdenv.lib; {

pkgs/tools/security/vault/vault-bin.nix

···
   sources = let
     base = "https://releases.hashicorp.com/vault/${version}";
   in {
-    "x86_64-linux" = fetchurl {
+    x86_64-linux = fetchurl {
       url = "${base}/vault_${version}_linux_amd64.zip";
       sha256 = "293b88f4d31f6bcdcc8b508eccb7b856a0423270adebfa0f52f04144c5a22ae0";
     };
-    "i686-linux" = fetchurl {
+    i686-linux = fetchurl {
       url = "${base}/vault_${version}_linux_386.zip";
       sha256 = "9f2fb99e08fa3d25af1497516d08b5d2d8a73bcacd5354ddec024e9628795867";
     };
-    "x86_64-darwin" = fetchurl {
+    x86_64-darwin = fetchurl {
       url = "${base}/vault_${version}_darwin_amd64.zip";
       sha256 = "a0a7a242f8299ac4a00af8aa10ccedaf63013c8a068f56eadfb9d730b87155ea";
     };
-    "i686-darwin" = fetchurl {
+    i686-darwin = fetchurl {
       url = "${base}/vault_${version}_darwin_386.zip";
       sha256 = "50542cfb37abb06e8bb6b8ba41f5ca7d72a4d6a4396d4e3f4a8391bed14f63be";
     };
-    "aarch64-linux" = fetchurl {
+    aarch64-linux = fetchurl {
       url = "${base}/vault_${version}_linux_arm64.zip";
       sha256 = "c243dce14b2e48e3667c2aa5b7fb37009dd7043b56032d6ebe50dd456715fd3f";
     };
···
   pname = "vault-bin";
   inherit version;
 
-  src = sources."${stdenv.hostPlatform.system}" or (throw "unsupported system: ${stdenv.hostPlatform.system}");
+  src = sources.${stdenv.hostPlatform.system} or (throw "unsupported system: ${stdenv.hostPlatform.system}");
 
   nativeBuildInputs = [ unzip ];
 

pkgs/tools/typesetting/kindlegen/default.nix

···
   fileVersion = builtins.replaceStrings [ "." ] [ "_" ] version;
 
   sha256 = {
-    "x86_64-linux"  = "15i20kzhdcmi94w7wfhqbl6j20v47cdakjm2mn3x8w495iddna4q";
-    "i686-linux"    = "15i20kzhdcmi94w7wfhqbl6j20v47cdakjm2mn3x8w495iddna4q";
-    "x86_64-darwin" = "0zniyn0s41fxqrajbgwxbcsj5vzf9m7a6yvdz2b11mphr00kpbbs";
-    "i686-darwin"   = "0zniyn0s41fxqrajbgwxbcsj5vzf9m7a6yvdz2b11mphr00kpbbs";
-    "x86_64-cygwin" = "02slfh1bbpijay4skj85cjiv7z43ha8vm5aa1lwiqjk86qbl1f3h";
-    "i686-cygwin"   = "02slfh1bbpijay4skj85cjiv7z43ha8vm5aa1lwiqjk86qbl1f3h";
-  }."${stdenv.hostPlatform.system}" or (throw "system #{stdenv.hostPlatform.system.} is not supported");
+    x86_64-linux  = "15i20kzhdcmi94w7wfhqbl6j20v47cdakjm2mn3x8w495iddna4q";
+    i686-linux    = "15i20kzhdcmi94w7wfhqbl6j20v47cdakjm2mn3x8w495iddna4q";
+    x86_64-darwin = "0zniyn0s41fxqrajbgwxbcsj5vzf9m7a6yvdz2b11mphr00kpbbs";
+    i686-darwin   = "0zniyn0s41fxqrajbgwxbcsj5vzf9m7a6yvdz2b11mphr00kpbbs";
+    x86_64-cygwin = "02slfh1bbpijay4skj85cjiv7z43ha8vm5aa1lwiqjk86qbl1f3h";
+    i686-cygwin   = "02slfh1bbpijay4skj85cjiv7z43ha8vm5aa1lwiqjk86qbl1f3h";
+  }.${stdenv.hostPlatform.system} or (throw "system #{stdenv.hostPlatform.system.} is not supported");
 
   url = {
-    "x86_64-linux"  = "http://kindlegen.s3.amazonaws.com/kindlegen_linux_2.6_i386_v${fileVersion}.tar.gz";
-    "i686-linux"    = "http://kindlegen.s3.amazonaws.com/kindlegen_linux_2.6_i386_v${fileVersion}.tar.gz";
-    "x86_64-darwin" = "http://kindlegen.s3.amazonaws.com/KindleGen_Mac_i386_v${fileVersion}.zip";
-    "i686-darwin"   = "http://kindlegen.s3.amazonaws.com/KindleGen_Mac_i386_v${fileVersion}.zip";
-    "x86_64-cygwin" = "http://kindlegen.s3.amazonaws.com/kindlegen_win32_v${fileVersion}.zip";
-    "i686-cygwin"   = "http://kindlegen.s3.amazonaws.com/kindlegen_win32_v${fileVersion}.zip";
-  }."${stdenv.hostPlatform.system}" or (throw "system #{stdenv.hostPlatform.system.} is not supported");
+    x86_64-linux  = "http://kindlegen.s3.amazonaws.com/kindlegen_linux_2.6_i386_v${fileVersion}.tar.gz";
+    i686-linux    = "http://kindlegen.s3.amazonaws.com/kindlegen_linux_2.6_i386_v${fileVersion}.tar.gz";
+    x86_64-darwin = "http://kindlegen.s3.amazonaws.com/KindleGen_Mac_i386_v${fileVersion}.zip";
+    i686-darwin   = "http://kindlegen.s3.amazonaws.com/KindleGen_Mac_i386_v${fileVersion}.zip";
+    x86_64-cygwin = "http://kindlegen.s3.amazonaws.com/kindlegen_win32_v${fileVersion}.zip";
+    i686-cygwin   = "http://kindlegen.s3.amazonaws.com/kindlegen_win32_v${fileVersion}.zip";
+  }.${stdenv.hostPlatform.system} or (throw "system #{stdenv.hostPlatform.system.} is not supported");
 
 in stdenv.mkDerivation rec {
   pname = "kindlegen";

pkgs/tools/typesetting/tex/texlive/default.nix

···
             # the fake derivations are used for filtering of hyphenation patterns
           else { inherit pname version; tlType = "run"; }
         )]
-        ++ lib.optional (attrs.sha512 ? "doc") (mkPkgV "doc")
-        ++ lib.optional (attrs.sha512 ? "source") (mkPkgV "source")
+        ++ lib.optional (attrs.sha512 ? doc) (mkPkgV "doc")
+        ++ lib.optional (attrs.sha512 ? source) (mkPkgV "source")
         ++ lib.optional (bin ? ${pname})
             ( bin.${pname} // { inherit pname; tlType = "bin"; } )
         ++ combinePkgs (attrs.deps or {});

pkgs/top-level/haskell-packages.nix

···
         (pkgs.lib.attrNames compiler);
     in pkgs.recurseIntoAttrs (pkgs.lib.genAttrs
       integerSimpleGhcNames
-      (name: compiler."${name}".override { enableIntegerSimple = true; }));
+      (name: compiler.${name}.override { enableIntegerSimple = true; }));
   };
 
   # Default overrides that are applied to all package sets.
···
       integerSimpleGhcNames = pkgs.lib.filter
         (name: ! builtins.elem name integerSimpleExcludes)
         (pkgs.lib.attrNames packages);
-    in pkgs.lib.genAttrs integerSimpleGhcNames (name: packages."${name}".override {
-      ghc = bh.compiler.integer-simple."${name}";
-      buildHaskellPackages = bh.packages.integer-simple."${name}";
+    in pkgs.lib.genAttrs integerSimpleGhcNames (name: packages.${name}.override {
+      ghc = bh.compiler.integer-simple.${name};
+      buildHaskellPackages = bh.packages.integer-simple.${name};
       overrides = _self : _super : {
         integer-simple = null;
         integer-gmp = null;

pkgs/top-level/stage.nix

···
         then "localSystem" else "crossSystem"} = {
         parsed = stdenv.hostPlatform.parsed // {
           abi = {
-            "gnu" = lib.systems.parse.abis.musl;
-            "gnueabi" = lib.systems.parse.abis.musleabi;
-            "gnueabihf" = lib.systems.parse.abis.musleabihf;
+            gnu = lib.systems.parse.abis.musl;
+            gnueabi = lib.systems.parse.abis.musleabi;
+            gnueabihf = lib.systems.parse.abis.musleabihf;
           }.${stdenv.hostPlatform.parsed.abi.name}
             or lib.systems.parse.abis.musl;
         };
···
       crossSystem = {
         parsed = stdenv.hostPlatform.parsed // {
           abi = {
-            "gnu" = lib.systems.parse.abis.musl;
-            "gnueabi" = lib.systems.parse.abis.musleabi;
-            "gnueabihf" = lib.systems.parse.abis.musleabihf;
+            gnu = lib.systems.parse.abis.musl;
+            gnueabi = lib.systems.parse.abis.musleabi;
+            gnueabihf = lib.systems.parse.abis.musleabihf;
           }.${stdenv.hostPlatform.parsed.abi.name}
             or lib.systems.parse.abis.musl;
         };