Merge pull request #110670 from siraben/double-quotes-fix

treewide: fix double quoted strings in one-liners

lib/licenses.nix

···
 
   beerware = spdx {
     spdxId = "Beerware";
-    fullName = ''Beerware License'';
+    fullName = "Beerware License";
   };
 
   blueOak100 = spdx {
···
 
   bsd2Patent = spdx {
     spdxId = "BSD-2-Clause-Patent";
-    fullName = ''BSD-2-Clause Plus Patent License'';
+    fullName = "BSD-2-Clause Plus Patent License";
   };
 
   bsd3 = spdx {

nixos/modules/config/console.nix

···
     packages = mkOption {
       type = types.listOf types.package;
       default = with pkgs.kbdKeymaps; [ dvp neo ];
-      defaultText = ''with pkgs.kbdKeymaps; [ dvp neo ]'';
+      defaultText = "with pkgs.kbdKeymaps; [ dvp neo ]";
       description = ''
         List of additional packages that provide console fonts, keymaps and
         other resources for virtual consoles use.

nixos/modules/config/fonts/fontconfig.nix

···
         useEmbeddedBitmaps = mkOption {
           type = types.bool;
           default = false;
-          description = ''Use embedded bitmaps in fonts like Calibri.'';
+          description = "Use embedded bitmaps in fonts like Calibri.";
         };
 
       };

nixos/modules/config/i18n.nix

···
     environment.etc."locale.conf".source = pkgs.writeText "locale.conf"
       ''
         LANG=${config.i18n.defaultLocale}
-        ${concatStringsSep "\n" (mapAttrsToList (n: v: ''${n}=${v}'') config.i18n.extraLocaleSettings)}
+        ${concatStringsSep "\n" (mapAttrsToList (n: v: "${n}=${v}") config.i18n.extraLocaleSettings)}
       '';
 
   };

nixos/modules/config/networking.nix

···
         '';
 
         # /etc/netgroup: Network-wide groups.
-        netgroup.text = mkDefault ''
-        '';
+        netgroup.text = mkDefault "";
 
         # /etc/host.conf: resolver configuration file
         "host.conf".text = ''

nixos/modules/config/pulseaudio.nix

···
         config = mkOption {
           type = types.attrsOf types.unspecified;
           default = {};
-          description = ''Config of the pulse daemon. See <literal>man pulse-daemon.conf</literal>.'';
+          description = "Config of the pulse daemon. See <literal>man pulse-daemon.conf</literal>.";
           example = literalExample ''{ realtime-scheduling = "yes"; }'';
         };
       };

nixos/modules/config/users-groups.nix

···
       count = mkOption {
         type = types.int;
         default = 1;
-        description = ''Count of subordinate user ids'';
+        description = "Count of subordinate user ids";
       };
     };
   };
···
       count = mkOption {
         type = types.int;
         default = 1;
-        description = ''Count of subordinate group ids'';
+        description = "Count of subordinate group ids";
       };
     };
   };

nixos/modules/hardware/video/bumblebee.nix

···
         default = "wheel";
         example = "video";
         type = types.str;
-        description = ''Group for bumblebee socket'';
+        description = "Group for bumblebee socket";
       };
 
       connectDisplay = mkOption {

nixos/modules/misc/locate.nix

···
           ''
           else ''
             exec ${cfg.locate}/bin/updatedb \
-              ${optionalString (cfg.localuser != null && ! isMLocate) ''--localuser=${cfg.localuser}''} \
+              ${optionalString (cfg.localuser != null && ! isMLocate) "--localuser=${cfg.localuser}"} \
               --output=${toString cfg.output} ${concatStringsSep " " cfg.extraFlags}
           '';
         environment = optionalAttrs (!isMLocate) {

nixos/modules/misc/nixpkgs.nix

···
           }
         '';
       type = pkgsType;
-      example = literalExample ''import <nixpkgs> {}'';
+      example = literalExample "import <nixpkgs> {}";
       description = ''
         If set, the pkgs argument to all NixOS modules is the value of
         this option, extended with <code>nixpkgs.overlays</code>, if

nixos/modules/programs/captive-browser.nix

···
       # the options below are the same as in "captive-browser.toml"
       browser = mkOption {
         type = types.str;
-        default = concatStringsSep " " [ ''${pkgs.chromium}/bin/chromium''
-                                         ''--user-data-dir=''${XDG_DATA_HOME:-$HOME/.local/share}/chromium-captive''
+        default = concatStringsSep " " [ "${pkgs.chromium}/bin/chromium"
+                                         "--user-data-dir=\${XDG_DATA_HOME:-$HOME/.local/share}/chromium-captive"
                                          ''--proxy-server="socks5://$PROXY"''
                                          ''--host-resolver-rules="MAP * ~NOTFOUND , EXCLUDE localhost"''
-                                         ''--no-first-run''
-                                         ''--new-window''
-                                         ''--incognito''
-                                         ''http://cache.nixos.org/''
+                                         "--no-first-run"
+                                         "--new-window"
+                                         "--incognito"
+                                         "http://cache.nixos.org/"
                                        ];
         description = ''
           The shell (/bin/sh) command executed once the proxy starts.
···
       socks5-addr = mkOption {
         type = types.str;
         default = "localhost:1666";
-        description = ''the listen address for the SOCKS5 proxy server'';
+        description = "the listen address for the SOCKS5 proxy server";
       };
 
       bindInterface = mkOption {

nixos/modules/programs/ssh.nix

···
       askPassword = mkOption {
         type = types.str;
         default = "${pkgs.x11_ssh_askpass}/libexec/x11-ssh-askpass";
-        description = ''Program used by SSH to ask for passwords.'';
+        description = "Program used by SSH to ask for passwords.";
       };
 
       forwardX11 = mkOption {

nixos/modules/programs/xss-lock.nix

···
 
     lockerCommand = mkOption {
       default = "${pkgs.i3lock}/bin/i3lock";
-      example = literalExample ''''${pkgs.i3lock-fancy}/bin/i3lock-fancy'';
+      example = literalExample "\${pkgs.i3lock-fancy}/bin/i3lock-fancy";
       type = types.separatedString " ";
       description = "Locker to be used with xsslock";
     };

nixos/modules/services/audio/mpd.nix

···
       musicDirectory = mkOption {
         type = with types; either path (strMatching "(http|https|nfs|smb)://.+");
         default = "${cfg.dataDir}/music";
-        defaultText = ''''${dataDir}/music'';
+        defaultText = "\${dataDir}/music";
         description = ''
           The directory or NFS/SMB network share where MPD reads music from. If left
           as the default value this directory will automatically be created before
···
       playlistDirectory = mkOption {
         type = types.path;
         default = "${cfg.dataDir}/playlists";
-        defaultText = ''''${dataDir}/playlists'';
+        defaultText = "\${dataDir}/playlists";
         description = ''
           The directory where MPD stores playlists. If left as the default value
           this directory will automatically be created before the MPD server starts,
···
       dbFile = mkOption {
         type = types.nullOr types.str;
         default = "${cfg.dataDir}/tag_cache";
-        defaultText = ''''${dataDir}/tag_cache'';
+        defaultText = "\${dataDir}/tag_cache";
         description = ''
           The path to MPD's database. If set to <literal>null</literal> the
           parameter is omitted from the configuration.

nixos/modules/services/backup/bacula.nix

···
       };
 
       devices = mkOption {
-        description = ''
-        '';
+        description = "";
       };
 
       extraAutochangerConfig = mkOption {

nixos/modules/services/backup/tarsnap.nix

···
 
         script = let
           tarsnap = ''tarsnap --configfile "/etc/tarsnap/${name}.conf"'';
-          lastArchive = ''$(${tarsnap} --list-archives | sort | tail -1)'';
+          lastArchive = "$(${tarsnap} --list-archives | sort | tail -1)";
           run = ''${tarsnap} -x -f "${lastArchive}" ${optionalString cfg.verbose "-v"}'';
 
         in if (cfg.cachedir != null) then ''

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

···
       default = pkgs.hadoop;
       defaultText = "pkgs.hadoop";
       example = literalExample "pkgs.hadoop";
-      description = ''
-      '';
+      description = "";
     };
   };
 

nixos/modules/services/computing/slurm/slurm.nix

···
       ClusterName=${cfg.clusterName}
       StateSaveLocation=${cfg.stateSaveLocation}
       SlurmUser=${cfg.user}
-      ${optionalString (cfg.controlMachine != null) ''controlMachine=${cfg.controlMachine}''}
-      ${optionalString (cfg.controlAddr != null) ''controlAddr=${cfg.controlAddr}''}
+      ${optionalString (cfg.controlMachine != null) "controlMachine=${cfg.controlMachine}"}
+      ${optionalString (cfg.controlAddr != null) "controlAddr=${cfg.controlAddr}"}
       ${toString (map (x: "NodeName=${x}\n") cfg.nodeName)}
       ${toString (map (x: "PartitionName=${x}\n") cfg.partitionName)}
       PlugStackConfig=${plugStackConfig}/plugstack.conf
···
 
   plugStackConfig = pkgs.writeTextDir "plugstack.conf"
     ''
-      ${optionalString cfg.enableSrunX11 ''optional ${pkgs.slurm-spank-x11}/lib/x11.so''}
+      ${optionalString cfg.enableSrunX11 "optional ${pkgs.slurm-spank-x11}/lib/x11.so"}
       ${cfg.extraPlugstackConfig}
     '';
 

nixos/modules/services/databases/couchdb.nix

···
       [admins]
       ${cfg.adminUser} = ${cfg.adminPass}
     '' else
-    ''
-    '') + (if useVersion2 then
+    "") + (if useVersion2 then
     ''
       [chttpd]
     '' else

nixos/modules/services/databases/firebird.nix

···
         serviceConfig.User = cfg.user;
         serviceConfig.LogsDirectory = "firebird";
         serviceConfig.LogsDirectoryMode = "0700";
-        serviceConfig.ExecStart = ''${firebird}/bin/fbserver -d'';
+        serviceConfig.ExecStart = "${firebird}/bin/fbserver -d";
 
         # TODO think about shutdown
       };

nixos/modules/services/databases/neo4j.nix

···
       ''}
       dbms.ssl.policy.${name}.client_auth=${conf.clientAuth}
       ${if length (splitString "/" conf.privateKey) > 1 then
-        ''dbms.ssl.policy.${name}.private_key=${conf.privateKey}''
+        "dbms.ssl.policy.${name}.private_key=${conf.privateKey}"
       else
-        ''dbms.ssl.policy.${name}.private_key=${conf.baseDirectory}/${conf.privateKey}''
+        "dbms.ssl.policy.${name}.private_key=${conf.baseDirectory}/${conf.privateKey}"
       }
       ${if length (splitString "/" conf.privateKey) > 1 then
-        ''dbms.ssl.policy.${name}.public_certificate=${conf.publicCertificate}''
+        "dbms.ssl.policy.${name}.public_certificate=${conf.publicCertificate}"
       else
-        ''dbms.ssl.policy.${name}.public_certificate=${conf.baseDirectory}/${conf.publicCertificate}''
+        "dbms.ssl.policy.${name}.public_certificate=${conf.baseDirectory}/${conf.publicCertificate}"
       }
       dbms.ssl.policy.${name}.revoked_dir=${conf.revokedDir}
       dbms.ssl.policy.${name}.tls_versions=${concatStringsSep "," conf.tlsVersions}

nixos/modules/services/development/bloop.nix

···
       };
       serviceConfig = {
         Type        = "simple";
-        ExecStart   = ''${pkgs.bloop}/bin/bloop server'';
+        ExecStart   = "${pkgs.bloop}/bin/bloop server";
         Restart     = "always";
       };
     };

nixos/modules/services/editors/infinoted.nix

···
           install -o ${cfg.user} -g ${cfg.group} -m 0600 /dev/null /var/lib/infinoted/infinoted.conf
           cat >>/var/lib/infinoted/infinoted.conf <<EOF
           [infinoted]
-          ${optionalString (cfg.keyFile != null) ''key-file=${cfg.keyFile}''}
-          ${optionalString (cfg.certificateFile != null) ''certificate-file=${cfg.certificateFile}''}
-          ${optionalString (cfg.certificateChain != null) ''certificate-chain=${cfg.certificateChain}''}
+          ${optionalString (cfg.keyFile != null) "key-file=${cfg.keyFile}"}
+          ${optionalString (cfg.certificateFile != null) "certificate-file=${cfg.certificateFile}"}
+          ${optionalString (cfg.certificateChain != null) "certificate-chain=${cfg.certificateChain}"}
           port=${toString cfg.port}
           security-policy=${cfg.securityPolicy}
           root-directory=${cfg.rootDirectory}
           plugins=${concatStringsSep ";" cfg.plugins}
-          ${optionalString (cfg.passwordFile != null) ''password=$(head -n 1 ${cfg.passwordFile})''}
+          ${optionalString (cfg.passwordFile != null) "password=$(head -n 1 ${cfg.passwordFile})"}
 
           ${cfg.extraConfig}
           EOF

nixos/modules/services/games/openarena.nix

···
       extraFlags = mkOption {
         type = types.listOf types.str;
         default = [];
-        description = ''Extra flags to pass to <command>oa_ded</command>'';
+        description = "Extra flags to pass to <command>oa_ded</command>";
         example = [
           "+set dedicated 2"
           "+set sv_hostname 'My NixOS OpenArena Server'"

nixos/modules/services/logging/logstash.nix

···
 
       inputConfig = mkOption {
         type = types.lines;
-        default = ''generator { }'';
+        default = "generator { }";
         description = "Logstash input configuration.";
         example = ''
           # Read from journal
···
 
       outputConfig = mkOption {
         type = types.lines;
-        default = ''stdout { codec => rubydebug }'';
+        default = "stdout { codec => rubydebug }";
         description = "Logstash output configuration.";
         example = ''
           redis { host => ["localhost"] data_type => "list" key => "logstash" codec => json }

nixos/modules/services/mail/postgrey.nix

···
 
     systemd.services.postgrey = let
       bind-flag = if cfg.socket ? path then
-        ''--unix=${cfg.socket.path} --socketmode=${cfg.socket.mode}''
+        "--unix=${cfg.socket.path} --socketmode=${cfg.socket.mode}"
       else
         ''--inet=${optionalString (cfg.socket.addr != null) (cfg.socket.addr + ":")}${toString cfg.socket.port}'';
     in {

nixos/modules/services/misc/cgminer.nix

···
       wantedBy = [ "multi-user.target" ];
 
       environment = {
-        LD_LIBRARY_PATH = ''/run/opengl-driver/lib:/run/opengl-driver-32/lib'';
+        LD_LIBRARY_PATH = "/run/opengl-driver/lib:/run/opengl-driver-32/lib";
         DISPLAY = ":${toString config.services.xserver.display}";
         GPU_MAX_ALLOC_PERCENT = "100";
         GPU_USE_SYNC_OBJECTS = "1";

nixos/modules/services/misc/dictd.nix

···
         default = with pkgs.dictdDBs; [ wiktionary wordnet ];
         defaultText = "with pkgs.dictdDBs; [ wiktionary wordnet ]";
         example = literalExample "[ pkgs.dictdDBs.nld2eng ]";
-        description = ''List of databases to make available.'';
+        description = "List of databases to make available.";
       };
 
     };

nixos/modules/services/misc/exhibitor.nix

···
       };
       zkExtraCfg = mkOption {
         type = types.str;
-        default = ''initLimit=5&syncLimit=2&tickTime=2000'';
+        default = "initLimit=5&syncLimit=2&tickTime=2000";
         description = ''
           Extra options to pass into Zookeeper
         '';

nixos/modules/services/misc/gitea.nix

···
     users.groups.gitea = {};
 
     warnings =
-      optional (cfg.database.password != "") ''
-        config.services.gitea.database.password will be stored as plaintext in the Nix store. Use database.passwordFile instead.'' ++
+      optional (cfg.database.password != "") "config.services.gitea.database.password will be stored as plaintext in the Nix store. Use database.passwordFile instead." ++
       optional (cfg.extraConfig != null) ''
         services.gitea.`extraConfig` is deprecated, please use services.gitea.`settings`.
       '';

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

···
       report_stats = mkOption {
         type = types.bool;
         default = false;
-        description = ''
-        '';
+        description = "";
       };
       servers = mkOption {
         type = types.attrsOf (types.attrsOf types.str);

nixos/modules/services/monitoring/apcupsd.nix

···
       hooks = mkOption {
         default = {};
         example = {
-          doshutdown = ''# shell commands to notify that the computer is shutting down'';
+          doshutdown = "# shell commands to notify that the computer is shutting down";
         };
         type = types.attrsOf types.lines;
         description = ''

nixos/modules/services/monitoring/graphite.nix

···
 
   graphiteApiConfig = pkgs.writeText "graphite-api.yaml" ''
     search_index: ${dataDir}/index
-    ${optionalString (config.time.timeZone != null) ''time_zone: ${config.time.timeZone}''}
-    ${optionalString (cfg.api.finders != []) ''finders:''}
+    ${optionalString (config.time.timeZone != null) "time_zone: ${config.time.timeZone}"}
+    ${optionalString (cfg.api.finders != []) "finders:"}
     ${concatMapStringsSep "\n" (f: "  - " + f.moduleName) cfg.api.finders}
-    ${optionalString (cfg.api.functions != []) ''functions:''}
+    ${optionalString (cfg.api.functions != []) "functions:"}
     ${concatMapStringsSep "\n" (f: "  - " + f) cfg.api.functions}
     ${cfg.api.extraConfig}
   '';

nixos/modules/services/monitoring/incron.nix

···
   config = mkIf cfg.enable {
 
     warnings = optional (cfg.allow != null && cfg.deny != null)
-      ''If `services.incron.allow` is set then `services.incron.deny` will be ignored.'';
+      "If `services.incron.allow` is set then `services.incron.deny` will be ignored.";
 
     environment.systemPackages = [ pkgs.incron ];
 

nixos/modules/services/monitoring/prometheus/exporters/collectd.nix

···
       port = mkOption {
         type = types.int;
         default = 25826;
-        description = ''Network address on which to accept collectd binary network packets.'';
+        description = "Network address on which to accept collectd binary network packets.";
       };
 
       listenAddress = mkOption {

nixos/modules/services/monitoring/telegraf.nix

···
             umask 077
             ${pkgs.envsubst}/bin/envsubst -i "${configFile}" > /var/run/telegraf/config.toml
           '');
-        ExecStart=''${cfg.package}/bin/telegraf -config ${finalConfigFile}'';
+        ExecStart="${cfg.package}/bin/telegraf -config ${finalConfigFile}";
         ExecReload="${pkgs.coreutils}/bin/kill -HUP $MAINPID";
         RuntimeDirectory = "telegraf";
         User = "telegraf";

nixos/modules/services/monitoring/thanos.nix

···
   };
 
   optionToArgs = opt: v  : optional (v != null)  ''--${opt}="${toString v}"'';
-  flagToArgs   = opt: v  : optional v            ''--${opt}'';
+  flagToArgs   = opt: v  : optional v            "--${opt}";
   listToArgs   = opt: vs : map               (v: ''--${opt}="${v}"'') vs;
   attrsToArgs  = opt: kvs: mapAttrsToList (k: v: ''--${opt}=${k}=\"${v}\"'') kvs;
 
···
     preferLocalBuild = true;
     json = builtins.toFile "${name}.json" (builtins.toJSON attrs);
     nativeBuildInputs = [ pkgs.remarshal ];
-  } ''json2yaml -i $json -o $out'';
+  } "json2yaml -i $json -o $out";
 
   thanos = cmd: "${cfg.package}/bin/thanos ${cmd}" +
     (let args = cfg.${cmd}.arguments;

nixos/modules/services/monitoring/ups.nix

···
       after = [ "upsd.service" ];
       wantedBy = [ "multi-user.target" ];
       # TODO: replace 'root' by another username.
-      script = ''${pkgs.nut}/bin/upsdrvctl -u root start'';
+      script = "${pkgs.nut}/bin/upsdrvctl -u root start";
       serviceConfig = {
         Type = "oneshot";
         RemainAfterExit = true;

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

···
       ExecStart = ''${ceph.out}/bin/${if daemonType == "rgw" then "radosgw" else "ceph-${daemonType}"} \
                     -f --cluster ${clusterName} --id ${daemonId}'';
     } // optionalAttrs (daemonType == "osd") {
-      ExecStartPre = ''${ceph.lib}/libexec/ceph/ceph-osd-prestart.sh --id ${daemonId} --cluster ${clusterName}'';
+      ExecStartPre = "${ceph.lib}/libexec/ceph/ceph-osd-prestart.sh --id ${daemonId} --cluster ${clusterName}";
       RestartSec = "20s";
       PrivateDevices = "no"; # osd needs disk access
     } // optionalAttrs ( daemonType == "mon") {
···
     ];
 
     warnings = optional (cfg.global.monInitialMembers == null)
-      ''Not setting up a list of members in monInitialMembers requires that you set the host variable for each mon daemon or else the cluster won't function'';
+      "Not setting up a list of members in monInitialMembers requires that you set the host variable for each mon daemon or else the cluster won't function";
 
     environment.etc."ceph/ceph.conf".text = let
       # Merge the extraConfig set for mgr daemons, as mgr don't have their own section

nixos/modules/services/networking/amuled.nix

···
 
       dataDir = mkOption {
         type = types.str;
-        default = ''/home/${user}/'';
+        default = "/home/${user}/";
         description = ''
           The directory holding configuration, incoming and temporary files.
         '';

nixos/modules/services/networking/cntlm.nix

···
     };
 
     domain = mkOption {
-      description = ''Proxy account domain/workgroup name.'';
+      description = "Proxy account domain/workgroup name.";
     };
 
     password = mkOption {
       default = "/etc/cntlm.password";
       type = types.str;
-      description = ''Proxy account password. Note: use chmod 0600 on /etc/cntlm.password for security.'';
+      description = "Proxy account password. Note: use chmod 0600 on /etc/cntlm.password for security.";
     };
 
     netbios_hostname = mkOption {

nixos/modules/services/networking/connman.nix

···
 
       extraConfig = mkOption {
         type = types.lines;
-        default = ''
-        '';
+        default = "";
         description = ''
           Configuration lines appended to the generated connman configuration file.
         '';

nixos/modules/services/networking/dnsdist.nix

···
 
       extraConfig = mkOption {
         type = types.lines;
-        default = ''
-        '';
+        default = "";
         description = ''
           Extra lines to be added verbatim to dnsdist.conf.
         '';

nixos/modules/services/networking/gateone.nix

···
       pidDir = mkOption {
         default = "/run/gateone";
         type = types.path;
-        description = ''Path of pid files for GateOne.'';
+        description = "Path of pid files for GateOne.";
       };
       settingsDir = mkOption {
         default = "/var/lib/gateone";
         type = types.path;
-        description = ''Path of configuration files for GateOne.'';
+        description = "Path of configuration files for GateOne.";
       };
     };
 };

nixos/modules/services/networking/hostapd.nix

···
     ssid=${cfg.ssid}
     hw_mode=${cfg.hwMode}
     channel=${toString cfg.channel}
-    ${optionalString (cfg.countryCode != null) ''country_code=${cfg.countryCode}''}
-    ${optionalString (cfg.countryCode != null) ''ieee80211d=1''}
+    ${optionalString (cfg.countryCode != null) "country_code=${cfg.countryCode}"}
+    ${optionalString (cfg.countryCode != null) "ieee80211d=1"}
 
     # logging (debug level)
     logger_syslog=-1

nixos/modules/services/networking/hylafax/modem-default.nix

···
 {
 
   TagLineFont = "etc/LiberationSans-25.pcf";
-  TagLineLocale = ''en_US.UTF-8'';
+  TagLineLocale = "en_US.UTF-8";
 
   AdminGroup = "root";  # groups that can change server config
   AnswerRotary = "fax";  # don't accept anything else but faxes
···
   SessionTracing = "0x78701";
   UUCPLockDir = "/var/lock";
 
-  SendPageCmd = ''${pkgs.coreutils}/bin/false'';  # prevent pager transmit
-  SendUUCPCmd = ''${pkgs.coreutils}/bin/false'';  # prevent UUCP transmit
+  SendPageCmd = "${pkgs.coreutils}/bin/false";  # prevent pager transmit
+  SendUUCPCmd = "${pkgs.coreutils}/bin/false";  # prevent UUCP transmit
 
 }

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

···
       # Otherwise, we use `false` to provoke
       # an error if hylafax tries to use it.
       c.sendmailPath = mkMerge [
-        (mkIfDefault noWrapper ''${pkgs.coreutils}/bin/false'')
-        (mkIfDefault (!noWrapper) ''${wrapperDir}/${program}'')
+        (mkIfDefault noWrapper "${pkgs.coreutils}/bin/false")
+        (mkIfDefault (!noWrapper) "${wrapperDir}/${program}")
       ];
       importDefaultConfig = file:
         lib.attrsets.mapAttrs
···
 
   options.services.hylafax = {
 
-    enable = mkEnableOption ''HylaFAX server'';
+    enable = mkEnableOption "HylaFAX server";
 
     autostart = mkOption {
       type = bool;
···
       type = nullOr str1;
       default = null;
       example = "49";
-      description = ''Country code for server and all modems.'';
+      description = "Country code for server and all modems.";
     };
 
     areaCode = mkOption {
       type = nullOr str1;
       default = null;
       example = "30";
-      description = ''Area code for server and all modems.'';
+      description = "Area code for server and all modems.";
     };
 
     longDistancePrefix = mkOption {
       type = nullOr str;
       default = null;
       example = "0";
-      description = ''Long distance prefix for server and all modems.'';
+      description = "Long distance prefix for server and all modems.";
     };
 
     internationalPrefix = mkOption {
       type = nullOr str;
       default = null;
       example = "00";
-      description = ''International prefix for server and all modems.'';
+      description = "International prefix for server and all modems.";
     };
 
     spoolAreaPath = mkOption {
···
     spoolExtraInit = mkOption {
       type = lines;
       default = "";
-      example = ''chmod 0755 .  # everyone may read my faxes'';
+      example = "chmod 0755 .  # everyone may read my faxes";
       description = ''
         Additional shell code that is executed within the
         spooling area directory right after its setup.
···
     faxqclean.doneqMinutes = mkOption {
       type = int1;
       default = 15;
-      example = literalExample ''24*60'';
+      example = literalExample "24*60";
       description = ''
         Set the job
         age threshold (in minutes) that controls how long
···
     faxqclean.docqMinutes = mkOption {
       type = int1;
       default = 60;
-      example = literalExample ''24*60'';
+      example = literalExample "24*60";
       description = ''
         Set the document
         age threshold (in minutes) that controls how long

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

···
       mkLines = conf:
         (lib.concatLists
         (lib.flip lib.mapAttrsToList conf
-        (k: map (v: ''${k}: ${v}'')
+        (k: map (v: "${k}: ${v}")
       )));
       include = mkLines { Include = conf.Include or []; };
       other = mkLines ( conf // { Include = []; } );
     in
-      pkgs.writeText ''hylafax-config${name}''
+      pkgs.writeText "hylafax-config${name}"
       (concatStringsSep "\n" (include ++ other));
 
   globalConfigPath = mkConfigFile "" cfg.faxqConfig;
···
   modemConfigPath =
     let
       mkModemConfigFile = { config, name, ... }:
-        mkConfigFile ''.${name}''
+        mkConfigFile ".${name}"
         (cfg.commonModemConfig // config);
       mkLine = { name, type, ... }@modem: ''
         # check if modem config file exists:
···
     description = "HylaFAX queue manager sendq watch";
     documentation = [ "man:faxq(8)" "man:sendq(5)" ];
     wantedBy = [ "multi-user.target" ];
-    pathConfig.PathExistsGlob = [ ''${cfg.spoolAreaPath}/sendq/q*'' ];
+    pathConfig.PathExistsGlob = [ "${cfg.spoolAreaPath}/sendq/q*" ];
   };
 
   timers = mkMerge [
···
         exit 1
       fi
     '';
-    serviceConfig.ExecStop = ''${setupSpoolScript}'';
+    serviceConfig.ExecStop = "${setupSpoolScript}";
     serviceConfig.RemainAfterExit = true;
     serviceConfig.Type = "oneshot";
     unitConfig.RequiresMountsFor = [ cfg.spoolAreaPath ];
···
     documentation = [ "man:faxq(8)" ];
     requires = [ "hylafax-spool.service" ];
     after = [ "hylafax-spool.service" ];
-    wants = mapModems ( { name, ... }: ''hylafax-faxgetty@${name}.service'' );
+    wants = mapModems ( { name, ... }: "hylafax-faxgetty@${name}.service" );
     wantedBy = mkIf cfg.autostart [ "multi-user.target" ];
     serviceConfig.Type = "forking";
     serviceConfig.ExecStart = ''${pkgs.hylafaxplus}/spool/bin/faxq -q "${cfg.spoolAreaPath}"'';
···
     # stopped will always yield a failed send attempt:
     # The fax service is started when the job is created with
     # `sendfax`, but modems need some time to initialize.
-    serviceConfig.ExecStartPost = [ ''${waitFaxqScript}'' ];
+    serviceConfig.ExecStartPost = [ "${waitFaxqScript}" ];
     # faxquit fails if the pipe is already gone
     # (e.g. the service is already stopping)
     serviceConfig.ExecStop = ''-${pkgs.hylafaxplus}/spool/bin/faxquit -q "${cfg.spoolAreaPath}"'';
···
     wantedBy = mkIf cfg.faxcron.enable.spoolInit requires;
     startAt = mkIf (cfg.faxcron.enable.frequency!=null) cfg.faxcron.enable.frequency;
     serviceConfig.ExecStart = concatStringsSep " " [
-      ''${pkgs.hylafaxplus}/spool/bin/faxcron''
+      "${pkgs.hylafaxplus}/spool/bin/faxcron"
       ''-q "${cfg.spoolAreaPath}"''
       ''-info ${toString cfg.faxcron.infoDays}''
       ''-log  ${toString cfg.faxcron.logDays}''
···
     wantedBy = mkIf cfg.faxqclean.enable.spoolInit requires;
     startAt = mkIf (cfg.faxqclean.enable.frequency!=null) cfg.faxqclean.enable.frequency;
     serviceConfig.ExecStart = concatStringsSep " " [
-      ''${pkgs.hylafaxplus}/spool/bin/faxqclean''
+      "${pkgs.hylafaxplus}/spool/bin/faxqclean"
       ''-q "${cfg.spoolAreaPath}"''
-      ''-v''
-      (optionalString (cfg.faxqclean.archiving!="never") ''-a'')
-      (optionalString (cfg.faxqclean.archiving=="always")  ''-A'')
+      "-v"
+      (optionalString (cfg.faxqclean.archiving!="never") "-a")
+      (optionalString (cfg.faxqclean.archiving=="always")  "-A")
       ''-j ${toString (cfg.faxqclean.doneqMinutes*60)}''
       ''-d ${toString (cfg.faxqclean.docqMinutes*60)}''
     ];
   };
 
   mkFaxgettyService = { name, ... }:
-    lib.nameValuePair ''hylafax-faxgetty@${name}'' rec {
+    lib.nameValuePair "hylafax-faxgetty@${name}" rec {
       description = "HylaFAX faxgetty for %I";
       documentation = [ "man:faxgetty(8)" ];
       bindsTo = [ "dev-%i.device" ];
···
       after = bindsTo ++ requires;
       before = [ "hylafax-faxq.service" "getty.target" ];
       unitConfig.StopWhenUnneeded = true;
-      unitConfig.AssertFileNotEmpty = ''${cfg.spoolAreaPath}/etc/config.%I'';
+      unitConfig.AssertFileNotEmpty = "${cfg.spoolAreaPath}/etc/config.%I";
       serviceConfig.UtmpIdentifier = "%I";
       serviceConfig.TTYPath = "/dev/%I";
       serviceConfig.Restart = "always";

nixos/modules/services/networking/kippo.nix

···
       enable = mkOption {
         default = false;
         type = types.bool;
-        description = ''Enable the kippo honeypot ssh server.'';
+        description = "Enable the kippo honeypot ssh server.";
       };
       port = mkOption {
         default = 2222;
         type = types.int;
-        description = ''TCP port number for kippo to bind to.'';
+        description = "TCP port number for kippo to bind to.";
       };
       hostname = mkOption {
         default = "nas3";
         type = types.str;
-        description = ''Hostname for kippo to present to SSH login'';
+        description = "Hostname for kippo to present to SSH login";
       };
       varPath = mkOption {
         default = "/var/lib/kippo";
         type = types.path;
-        description = ''Path of read/write files needed for operation and configuration.'';
+        description = "Path of read/write files needed for operation and configuration.";
       };
       logPath = mkOption {
         default = "/var/log/kippo";
         type = types.path;
-        description = ''Path of log files needed for operation and configuration.'';
+        description = "Path of log files needed for operation and configuration.";
       };
       pidPath = mkOption {
         default = "/run/kippo";
         type = types.path;
-        description = ''Path of pid files needed for operation.'';
+        description = "Path of pid files needed for operation.";
       };
       extraConfig = mkOption {
         default = "";
         type = types.lines;
-        description = ''Extra verbatim configuration added to the end of kippo.cfg.'';
+        description = "Extra verbatim configuration added to the end of kippo.cfg.";
       };
     };
 

nixos/modules/services/networking/owamp.nix

···
   ###### interface
 
   options = {
-    services.owamp.enable = mkEnableOption ''Enable OWAMP server'';
+    services.owamp.enable = mkEnableOption "Enable OWAMP server";
   };
 
 

nixos/modules/services/networking/quassel.nix

···
       };
 
       dataDir = mkOption {
-        default = ''/home/${user}/.config/quassel-irc.org'';
+        default = "/home/${user}/.config/quassel-irc.org";
         description = ''
           The directory holding configuration files, the SQlite database and the SSL Cert.
         '';

nixos/modules/services/networking/smokeping.nix

···
         ${cfg.package}/bin/smokeping --check --config=${configPath}
         ${cfg.package}/bin/smokeping --static --config=${configPath}
       '';
-      script = ''${cfg.package}/bin/smokeping --config=${configPath} --nodaemon'';
+      script = "${cfg.package}/bin/smokeping --config=${configPath} --nodaemon";
     };
     systemd.services.thttpd = mkIf cfg.webService {
       wantedBy = [ "multi-user.target"];

nixos/modules/services/networking/ssh/lshd.nix

···
       syslog = mkOption {
         type = types.bool;
         default = true;
-        description = ''Whether to enable syslog output.'';
+        description = "Whether to enable syslog output.";
       };
 
       passwordAuthentication = mkOption {
         type = types.bool;
         default = true;
-        description = ''Whether to enable password authentication.'';
+        description = "Whether to enable password authentication.";
       };
 
       publicKeyAuthentication = mkOption {
         type = types.bool;
         default = true;
-        description = ''Whether to enable public key authentication.'';
+        description = "Whether to enable public key authentication.";
       };
 
       rootLogin = mkOption {
         type = types.bool;
         default = false;
-        description = ''Whether to enable remote root login.'';
+        description = "Whether to enable remote root login.";
       };
 
       loginShell = mkOption {
···
       tcpForwarding = mkOption {
         type = types.bool;
         default = true;
-        description = ''Whether to enable TCP/IP forwarding.'';
+        description = "Whether to enable TCP/IP forwarding.";
       };
 
       x11Forwarding = mkOption {
         type = types.bool;
         default = true;
-        description = ''Whether to enable X11 forwarding.'';
+        description = "Whether to enable X11 forwarding.";
       };
 
       subsystems = mkOption {

nixos/modules/services/networking/strongswan-swanctl/swanctl-params.nix

···
         provided the user is prompted during an interactive
         <literal>--load-creds</literal> call.
       '';
-    } ''Definition for a private key that's stored on a token/smartcard/TPM.'';
+    } "Definition for a private key that's stored on a token/smartcard/TPM.";
 
   };
 

nixos/modules/services/networking/supybot.nix

···
           value must be a function which receives the attrset defined
           in <varname>python3Packages</varname> as the sole argument.
         '';
-        example = literalExample ''p: [ p.lxml p.requests ]'';
+        example = literalExample "p: [ p.lxml p.requests ]";
       };
 
     };

nixos/modules/services/networking/wpa_supplicant.nix

···
         then ''"${psk}"''
         else pskRaw;
       baseAuth = if key != null
-        then ''psk=${key}''
-        else ''key_mgmt=NONE'';
+        then "psk=${key}"
+        else "key_mgmt=NONE";
     in ''
       network={
         ssid="${ssid}"

nixos/modules/services/security/usbguard.nix

···
 
       serviceConfig = {
         Type = "simple";
-        ExecStart = ''${cfg.package}/bin/usbguard-daemon -P -k -c ${daemonConfFile}'';
+        ExecStart = "${cfg.package}/bin/usbguard-daemon -P -k -c ${daemonConfFile}";
         Restart = "on-failure";
 
         StateDirectory = [

nixos/modules/services/system/cloud-init.nix

···
            - final-message
            - power-state-change
           '';
-        description = ''cloud-init configuration.'';
+        description = "cloud-init configuration.";
       };
 
     };

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

···
         locations."/" = {
           priority = 1;
           index = "doku.php";
-          extraConfig = ''try_files $uri $uri/ @dokuwiki;'';
+          extraConfig = "try_files $uri $uri/ @dokuwiki;";
         };
 
         locations."@dokuwiki" = {

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

···
         assertions = [
           {
             assertion = (cfg.databaseUseSSL && cfg.databaseType == "postgresql") -> (cfg.databaseCaCert != null);
-            message = ''A CA certificate must be specified (in 'services.keycloak.databaseCaCert') when PostgreSQL is used with SSL'';
+            message = "A CA certificate must be specified (in 'services.keycloak.databaseCaCert') when PostgreSQL is used with SSL";
           }
         ];
 

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

···
       type = mkOption {
         type = types.enum [ "mysql" "pgsql" ];
         default = "mysql";
-        description = ''Database engine to use.'';
+        description = "Database engine to use.";
       };
 
       host = mkOption {

nixos/modules/services/web-servers/lighttpd/default.nix

···
       configText = mkOption {
         default = "";
         type = types.lines;
-        example = ''...verbatim config file contents...'';
+        example = "...verbatim config file contents...";
         description = ''
           Overridable config file contents to use for lighttpd. By default, use
           the contents automatically generated by NixOS.

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

···
       version = mkOption {
         default = 2;
         type = types.enum [ 0 1 2 3 4 ];
-        description = ''
-        '';
+        description = "";
       };
 
       uboot = {

nixos/modules/tasks/filesystems/zfs.nix

···
         # - HDDs are mixed with SSDs
         # - There is a SSDs in a pool that is currently trimmed.
         # - There are only HDDs and we would set the system in a degraded state
-        serviceConfig.ExecStart = ''${pkgs.runtimeShell} -c 'for pool in $(zpool list -H -o name); do zpool trim $pool;  done || true' '';
+        serviceConfig.ExecStart = "${pkgs.runtimeShell} -c 'for pool in $(zpool list -H -o name); do zpool trim $pool;  done || true' ";
       };
 
       systemd.timers.zpool-trim.timerConfig.Persistent = "yes";

nixos/modules/virtualisation/nixos-containers.nix

···
 
       ${concatStringsSep "\n" (
         mapAttrsToList (name: cfg:
-          ''ip link del dev ${name} 2> /dev/null || true ''
+          "ip link del dev ${name} 2> /dev/null || true "
         ) cfg.extraVeths
       )}
    '';
···
             fi
           ''
         else
-          ''${ipcmd} add ${cfg.${attribute}} dev $ifaceHost'';
+          "${ipcmd} add ${cfg.${attribute}} dev $ifaceHost";
       renderExtraVeth = name: cfg:
         if cfg.hostBridge != null then
           ''

nixos/modules/virtualisation/qemu-vm.nix

···
             cp ${bootDisk}/efi-vars.fd "$NIX_EFI_VARS" || exit 1
             chmod 0644 "$NIX_EFI_VARS" || exit 1
           fi
-        '' else ''
-        ''}
-      '' else ''
-      ''}
+        '' else ""}
+      '' else ""}
 
       cd $TMPDIR
       idx=0
···
                 efiVars=$out/efi-vars.fd
                 cp ${efiVarsDefault} $efiVars
                 chmod 0644 $efiVars
-              '' else ''
-              ''}
+              '' else ""}
             '';
           buildInputs = [ pkgs.util-linux ];
           QEMU_OPTS = "-nographic -serial stdio -monitor none"

nixos/modules/virtualisation/railcar.nix

···
 
     stateDir = mkOption {
       type = types.path;
-      default = ''/var/railcar'';
+      default = "/var/railcar";
       description = "Railcar persistent state directory";
     };
 

pkgs/applications/audio/lsp-plugins/default.nix

···
   buildInputs = [ jack2Full libsndfile libGLU libGL lv2 cairo ladspaH ];
 
   makeFlags = [
-    "PREFIX=${placeholder ''out''}"
+    "PREFIX=${placeholder "out"}"
     "ETC_PATH=$(out)/etc"
   ];
 

pkgs/applications/audio/zam-plugins/default.nix

···
   '';
 
   makeFlags = [
-    "PREFIX=${placeholder ''out''}"
+    "PREFIX=${placeholder "out"}"
   ];
 
   enableParallelBuilding = true;

pkgs/applications/editors/manuskript/default.nix

···
       --replace sample-projects $out/share/${pname}/sample-projects
    '';
 
-  buildPhase = '''';
+  buildPhase = "";
 
   installPhase = ''
     mkdir -p $out/share/${pname}

pkgs/applications/editors/rstudio/default.nix

···
     mimeType = "text/x-r-source;text/x-r;text/x-R;text/x-r-doc;text/x-r-sweave;text/x-r-markdown;text/x-r-html;text/x-r-presentation;application/x-r-data;application/x-r-project;text/x-r-history;text/x-r-profile;text/x-tex;text/x-markdown;text/html;text/css;text/javascript;text/x-chdr;text/x-csrc;text/x-c++hdr;text/x-c++src;";
   };
 
-  qtWrapperArgs = [ ''--suffix PATH : ${gnumake}/bin'' ];
+  qtWrapperArgs = [ "--suffix PATH : ${gnumake}/bin" ];
 
   postInstall = ''
       mkdir $out/share

pkgs/applications/editors/vim/configurable.nix

···
     ++ lib.optional tclSupport tcl
     ++ lib.optional rubySupport ruby;
 
-  preConfigure = ''
-    '' + lib.optionalString ftNixSupport ''
+  preConfigure = "" + lib.optionalString ftNixSupport ''
       cp ${vimPlugins.vim-nix.src}/ftplugin/nix.vim runtime/ftplugin/nix.vim
       cp ${vimPlugins.vim-nix.src}/indent/nix.vim runtime/indent/nix.vim
       cp ${vimPlugins.vim-nix.src}/syntax/nix.vim runtime/syntax/nix.vim

pkgs/applications/graphics/ahoviewer/default.nix

···
 
   NIX_LDFLAGS = "-lpthread";
 
-  postPatch = ''patchShebangs version.sh'';
+  postPatch = "patchShebangs version.sh";
 
   postInstall = ''
     wrapProgram $out/bin/ahoviewer \

pkgs/applications/graphics/ipe/default.nix

···
 
   nativeBuildInputs = [ pkg-config ];
 
-  qtWrapperArgs = [ ''--prefix PATH : ${texlive}/bin''  ];
+  qtWrapperArgs = [ "--prefix PATH : ${texlive}/bin"  ];
 
   enableParallelBuilding = true;
 

pkgs/applications/graphics/mandelbulber/default.nix

···
   sourceRoot = "${src.name}/mandelbulber2";
 
   qmakeFlags = [
-    "SHARED_PATH=${placeholder ''out''}"
+    "SHARED_PATH=${placeholder "out"}"
     (if withOpenCL
       then "qmake/mandelbulber-opencl.pro"
       else "qmake/mandelbulber.pro")

pkgs/applications/graphics/pinta/default.nix

···
     '';
 
   makeWrapperArgs = [
-    ''--prefix MONO_GAC_PREFIX : ${gtksharp}''
-    ''--prefix LD_LIBRARY_PATH : ${gtksharp}/lib''
-    ''--prefix LD_LIBRARY_PATH : ${gtksharp.gtk.out}/lib''
+    "--prefix MONO_GAC_PREFIX : ${gtksharp}"
+    "--prefix LD_LIBRARY_PATH : ${gtksharp}/lib"
+    "--prefix LD_LIBRARY_PATH : ${gtksharp.gtk.out}/lib"
   ];
 
   postInstall = ''

pkgs/applications/misc/bleachbit/default.nix

···
   # prevent double wrapping from wrapGApps and wrapPythonProgram
   dontWrapGApps = true;
   makeWrapperArgs = [
-    ''''${gappsWrapperArgs[@]}''
+    "\${gappsWrapperArgs[@]}"
   ];
 
   strictDeps = false;

pkgs/applications/misc/digitalbitbox/default.nix

···
     "format"
   ];
 
-  qtWrapperArgs = [ ''--prefix LD_LIBRARY_PATH : $out/lib'' ];
+  qtWrapperArgs = [ "--prefix LD_LIBRARY_PATH : $out/lib" ];
 
   postInstall = ''
     mkdir -p "$out/lib"

pkgs/applications/misc/dupeguru/default.nix

···
   ];
 
   makeFlags = [
-    "PREFIX=${placeholder ''out''}"
+    "PREFIX=${placeholder "out"}"
     "NO_VENV=1"
   ];
 

pkgs/applications/misc/ikiwiki/default.nix

···
   postInstall = ''
     for a in "$out/bin/"*; do
       wrapProgram $a --suffix PERL5LIB : $PERL5LIB --prefix PATH : ${perlPackages.perl}/bin:$out/bin \
-      ${lib.optionalString gitSupport ''--prefix PATH : ${git}/bin ''} \
-      ${lib.optionalString monotoneSupport ''--prefix PATH : ${monotone}/bin ''} \
-      ${lib.optionalString bazaarSupport ''--prefix PATH : ${breezy}/bin ''} \
-      ${lib.optionalString cvsSupport ''--prefix PATH : ${cvs}/bin ''} \
-      ${lib.optionalString cvsSupport ''--prefix PATH : ${cvsps}/bin ''} \
-      ${lib.optionalString subversionSupport ''--prefix PATH : ${subversion.out}/bin ''} \
-      ${lib.optionalString mercurialSupport ''--prefix PATH : ${mercurial}/bin ''} \
+      ${lib.optionalString gitSupport "--prefix PATH : ${git}/bin "} \
+      ${lib.optionalString monotoneSupport "--prefix PATH : ${monotone}/bin "} \
+      ${lib.optionalString bazaarSupport "--prefix PATH : ${breezy}/bin "} \
+      ${lib.optionalString cvsSupport "--prefix PATH : ${cvs}/bin "} \
+      ${lib.optionalString cvsSupport "--prefix PATH : ${cvsps}/bin "} \
+      ${lib.optionalString subversionSupport "--prefix PATH : ${subversion.out}/bin "} \
+      ${lib.optionalString mercurialSupport "--prefix PATH : ${mercurial}/bin "} \
       ${lib.optionalString docutilsSupport ''--prefix PYTHONPATH : "$(toPythonPath ${docutils})" ''} \
       ${lib.concatMapStrings (x: "--prefix PATH : ${x}/bin ") extraUtils}
     done

pkgs/applications/misc/lutris/default.nix

···
   dontWrapGApps = true;
   makeWrapperArgs = [
     "--prefix PATH : ${binPath}"
-    ''''${gappsWrapperArgs[@]}''
+    "\${gappsWrapperArgs[@]}"
   ];
   # needed for glib-schemas to work correctly (will crash on dialogues otherwise)
   # see https://github.com/NixOS/nixpkgs/issues/56943

pkgs/applications/misc/osm2xmap/default.nix

···
   makeFlags = [
     "GIT_VERSION=${version}"
     "GIT_TIMESTAMP="
-    "SHAREDIR=${placeholder ''out''}/share/osm2xmap"
-    "INSTALL_BINDIR=${placeholder ''out''}/bin"
-    "INSTALL_MANDIR=${placeholder ''out''}/share/man/man1"
+    "SHAREDIR=${placeholder "out"}/share/osm2xmap"
+    "INSTALL_BINDIR=${placeholder "out"}/bin"
+    "INSTALL_MANDIR=${placeholder "out"}/share/man/man1"
   ];
 
   NIX_CFLAGS_COMPILE = "-DACCEPT_USE_OF_DEPRECATED_PROJ_API_H";

pkgs/applications/misc/plasma-applet-volumewin7mixer/default.nix

···
   };
 
   patches = [ ./cmake.patch ];
-  postPatch = '' rm build '';
+  postPatch = "rm build ";
   nativeBuildInputs = [ cmake extra-cmake-modules ];
   buildInputs = [ plasma-framework kwindowsystem plasma-pa ];
 

pkgs/applications/networking/instant-messengers/baresip/default.nix

···
     "LIBRE_INC=${libre}/include/re"
     "LIBRE_SO=${libre}/lib"
     "LIBREM_PATH=${librem}"
-    ''PREFIX=$(out)''
+    "PREFIX=$(out)"
     "USE_VIDEO=1"
     "CCACHE_DISABLE=1"
 

pkgs/applications/networking/instant-messengers/jitsi/default.nix

···
   nativeBuildInputs = [ unzip ];
   buildInputs = [ ant jdk ];
 
-  buildPhase = ''ant make'';
+  buildPhase = "ant make";
 
   installPhase = ''
     mkdir -p $out

pkgs/applications/networking/owamp/default.nix

···
 
   meta = with lib; {
     homepage = "http://software.internet2.edu/owamp/";
-    description = ''A tool for performing one-way active measurements'';
+    description = "A tool for performing one-way active measurements";
     platforms = platforms.linux;
     maintainers = [maintainers.teto];
     license = licenses.asl20;

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

···
 
   installTargets = [ "install_client" "install_man" ];
 
-  qtWrapperArgs = [ ''--suffix PATH : ${nx-libs}/bin:${openssh}/libexec'' ];
+  qtWrapperArgs = [ "--suffix PATH : ${nx-libs}/bin:${openssh}/libexec" ];
 
   meta = with lib; {
     description = "Graphical NoMachine NX3 remote desktop client";

pkgs/applications/office/docear/default.nix

···
 
     # The wrapper ensures oraclejre is used
     makeWrapper ${runtimeShell} $out/bin/docear \
-      --set _JAVA_OPTIONS "${lib.optionalString antialiasFont ''-Dswing.aatext=TRUE -Dawt.useSystemAAFontSettings=on''}" \
+      --set _JAVA_OPTIONS "${lib.optionalString antialiasFont "-Dswing.aatext=TRUE -Dawt.useSystemAAFontSettings=on"}" \
       --set JAVA_HOME ${oraclejre.home} \
       --add-flags "$out/share/docear.sh"
 

pkgs/applications/office/planner/default.nix

···
   # glib-2.62 deprecations
   NIX_CFLAGS_COMPILE = "-DGLIB_DISABLE_DEPRECATION_WARNINGS";
 
-  preConfigure = ''./autogen.sh'';
+  preConfigure = "./autogen.sh";
   configureFlags = [
     "--enable-python"
     "--enable-python-plugin"

pkgs/applications/radio/gnuradio/3.7.nix

···
     # gr-fcd feature was dropped in 3.8
     ++ lib.optionals (hasFeature "gr-fcd" features) [ "share/gnuradio/examples/fcd" ]
   ;
-  preConfigure = ''
-  ''
+  preConfigure = ""
     # wxgui and pygtk are not looked up properly, so we force them to be
     # detected as found, if they are requested by the `features` attrset.
     + lib.optionalString (hasFeature "gr-wxgui" features) ''

pkgs/applications/radio/gnuradio/default.nix

···
       ${removeReferencesTo}/bin/remove-references-to -t ${python} $out/lib/cmake/gnuradio/GnuradioConfig.cmake
     ''
   ;
-  preConfigure = ''
-  ''
+  preConfigure = ""
     # If python-support is disabled, don't install volk's (git submodule)
     # volk_modtool - it references python.
     #

pkgs/applications/radio/gnuradio/shared.nix

···
     ++ lib.optionals (hasFeature "gr-uhd" features) [ "share/gnuradio/examples/uhd" ]
     ++ lib.optionals (hasFeature "gr-qtgui" features) [ "share/gnuradio/examples/qt-gui" ]
   ;
-  postInstall = ''
-  ''
+  postInstall = ""
     # Gcc references
     + lib.optionalString (hasFeature "volk" features) ''
       ${removeReferencesTo}/bin/remove-references-to -t ${stdenv.cc} $(readlink -f $out/lib/libvolk.so)

pkgs/applications/science/biology/migrate/default.nix

···
   };
 
   buildInputs = [ zlib mpi ];
-  setSourceRoot = ''sourceRoot=$(echo */src)'';
+  setSourceRoot = "sourceRoot=$(echo */src)";
   buildFlags = [ "thread" "mpis" ];
   preInstall = "mkdir -p $out/man/man1";
 

pkgs/applications/science/biology/ncbi-tools/default.nix

···
   buildInputs = [ cpio ];
 
   meta = {
-    description = ''NCBI Bioinformatics toolbox (incl. BLAST)'';
-    longDescription = ''The NCBI Bioinformatics toolsbox, including command-line utilties, libraries and include files. No X11 support'';
+    description = "NCBI Bioinformatics toolbox (incl. BLAST)";
+    longDescription = "The NCBI Bioinformatics toolsbox, including command-line utilties, libraries and include files. No X11 support";
     homepage = "http://www.ncbi.nlm.nih.gov/IEB/ToolBox/";
     license = "GPL";
     priority = 5;   # zlib.so gives a conflict with zlib

pkgs/applications/science/biology/paml/default.nix

···
 
   meta = {
     description     = "Phylogenetic Analysis by Maximum Likelihood (PAML)";
-    longDescription = ''PAML is a package of programs for phylogenetic analyses of DNA or protein sequences using maximum likelihood. It is maintained and distributed for academic use free of charge by Ziheng Yang. ANSI C source codes are distributed for UNIX/Linux/Mac OSX, and executables are provided for MS Windows. PAML is not good for tree making. It may be used to estimate parameters and test hypotheses to study the evolutionary process, when you have reconstructed trees using other programs such as PAUP*, PHYLIP, MOLPHY, PhyML, RaxML, etc.'';
+    longDescription = "PAML is a package of programs for phylogenetic analyses of DNA or protein sequences using maximum likelihood. It is maintained and distributed for academic use free of charge by Ziheng Yang. ANSI C source codes are distributed for UNIX/Linux/Mac OSX, and executables are provided for MS Windows. PAML is not good for tree making. It may be used to estimate parameters and test hypotheses to study the evolutionary process, when you have reconstructed trees using other programs such as PAUP*, PHYLIP, MOLPHY, PhyML, RaxML, etc.";
     license     = "non-commercial";
     homepage    = "http://abacus.gene.ucl.ac.uk/software/paml.html";
   };

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

···
 
   buildInputs = [ ocaml eprover zlib ];
 
-  preConfigure = ''patchShebangs .'';
+  preConfigure = "patchShebangs .";
 
   installPhase = ''
     mkdir -p "$out/bin"

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

···
   };
   buildInputs = [readline];
   meta = {
-    description = ''Lambda calculus interpreter'';
+    description = "Lambda calculus interpreter";
     maintainers = with lib.maintainers; [raskin];
     platforms = with lib.platforms; linux;
     license = lib.licenses.gpl3;

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

···
 
   meta = {
     inherit version;
-    description = ''Automated theorem prover for higher-order logic'';
+    description = "Automated theorem prover for higher-order logic";
     license = lib.licenses.mit ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

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

···
   doCheck = true;
 
   # Usual shenanigans
-  patchPhase = ''patchShebangs tests/regress/check.sh'';
+  patchPhase = "patchShebangs tests/regress/check.sh";
 
   # Includes a fix for the embedded soname being libyices.so.2.5, but
   # only installing the libyices.so.2.5.x file.

pkgs/applications/science/logic/z3/tptp.nix

···
   meta = {
     inherit version;
     inherit (z3.meta) license homepage platforms;
-    description = ''TPTP wrapper for Z3 prover'';
+    description = "TPTP wrapper for Z3 prover";
     maintainers = [lib.maintainers.raskin];
   };
 }

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

···
   '';
 
   buildFlags = [ "CC=cc" "CXX=c++" ];
-  installFlags = [ ''PREFIX=$(out)'' ];
+  installFlags = [ "PREFIX=$(out)" ];
   buildInputs = [ gmp mpir cddlib ];
 
   meta = {
     inherit version;
-    description = ''A software package for computing Gröbner fans and tropical varieties'';
+    description = "A software package for computing Gröbner fans and tropical varieties";
     license = lib.licenses.gpl2 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

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

···
   checkTarget = "checks";
   meta = with lib; {
     inherit version;
-    description = ''Programs for computing automorphism groups of graphs and digraphs'';
+    description = "Programs for computing automorphism groups of graphs and digraphs";
     license = licenses.asl20;
     maintainers = teams.sage.members;
     platforms = platforms.unix;

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

···
 
   meta = {
     inherit version;
-    description = ''A program to find rational points on hyperelliptic curves'';
+    description = "A program to find rational points on hyperelliptic curves";
     license = lib.licenses.gpl2Plus;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

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

···
   enableParallelBuilding = true;
 
   meta = with lib; {
-    description = ''A collection of routines for representation theory and combinatorics'';
+    description = "A collection of routines for representation theory and combinatorics";
     license = licenses.isc;
     maintainers = teams.sage.members;
     platforms = platforms.unix;

pkgs/applications/terminal-emulators/guake/default.nix

···
   PBR_VERSION = version; # pbr needs either .git directory, sdist, or env var
 
   makeFlags = [
-    "prefix=${placeholder ''out''}"
+    "prefix=${placeholder "out"}"
   ];
 
   preFixup = ''

pkgs/applications/terminal-emulators/wezterm/default.nix

···
 
   buildInputs = runtimeDeps;
 
-  installPhase = ''
-  '' + lib.optionalString stdenv.isLinux ''
+  installPhase = "" + lib.optionalString stdenv.isLinux ''
     for artifact in wezterm wezterm-gui wezterm-mux-server strip-ansi-escapes; do
       patchelf --set-rpath "${lib.makeLibraryPath runtimeDeps}" $releaseDir/$artifact
       install -D $releaseDir/$artifact -t $out/bin

pkgs/applications/version-management/cvsps/default.nix

···
   installFlags = [ "prefix=$(out)" ];
 
   meta = {
-    description = ''A tool to generate CVS patch set information'';
+    description = "A tool to generate CVS patch set information";
     longDescription = ''
       CVSps is a program for generating `patchset' information from a
       CVS repository.  A patchset in this case is defined as a set of

pkgs/applications/version-management/cvsq/default.nix

···
   '';
 
   meta = {
-    description = ''A collection of tools to work locally with CVS'';
+    description = "A collection of tools to work locally with CVS";
     longDescription = ''
       cvsq is a collection of tools to work locally with CVS.
 

pkgs/applications/version-management/monotone-viz/default.nix

···
 
   meta = {
     inherit version;
-    description = ''Monotone ancestry visualiser'';
+    description = "Monotone ancestry visualiser";
     license = lib.licenses.gpl2Plus ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/applications/video/makemkv/default.nix

···
     let
       binPath = lib.makeBinPath [ jre_headless ];
     in lib.optionals withJava [
-      ''--prefix PATH : ${binPath}''
+      "--prefix PATH : ${binPath}"
     ];
 
   installPhase = ''

pkgs/applications/video/mythtv/default.nix

···
     ./disable-os-detection.patch
   ];
 
-  setSourceRoot = ''sourceRoot=$(echo */mythtv)'';
+  setSourceRoot = "sourceRoot=$(echo */mythtv)";
 
   buildInputs = [
     freetype qtbase qtwebkit qtscript lame zlib xlibsWrapper libGLU libGL

pkgs/applications/video/xawtv/default.nix

···
 
   makeFlags = [
     "SUID_ROOT=" # do not try to setuid
-    "resdir=${placeholder ''out''}/share/X11"
+    "resdir=${placeholder "out"}/share/X11"
   ];
 
   meta = {

pkgs/applications/virtualization/docker/default.nix

···
       };
 
       # Do not remove static from make files as we want a static binary
-      patchPhase = ''
-      '';
+      patchPhase = "";
 
       NIX_CFLAGS_COMPILE = "-DMINIMAL=ON";
     });

pkgs/applications/virtualization/xen/generic.nix

···
                                  " (${args.meta.description})";
     longDescription = (args.meta.longDescription or "")
                     + "\nIncludes:\n"
-                    + withXenfiles (name: x: ''* ${name}: ${x.meta.description or "(No description)"}.'');
+                    + withXenfiles (name: x: "* ${name}: ${x.meta.description or "(No description)"}.");
     platforms = [ "x86_64-linux" ];
     maintainers = with lib.maintainers; [ eelco tstrobel oxij ];
     license = lib.licenses.gpl2;

pkgs/build-support/skaware/clean-packaging.nix

···
 let
   globWith = lib.concatMapStringsSep "\n";
   rmNoise = noiseGlobs: globWith (f:
-    ''rm -rf ${f}'') noiseGlobs;
+    "rm -rf ${f}") noiseGlobs;
   mvDoc = docGlobs: globWith
     (f: ''mv ${f} "$DOCDIR" 2>/dev/null || true'')
     docGlobs;

pkgs/data/fonts/orbitron/default.nix

···
   meta = with lib; {
     homepage = "https://www.theleagueofmoveabletype.com/orbitron";
     downloadPage = "https://www.theleagueofmoveabletype.com/orbitron/download";
-    description = ''
-     Geometric sans-serif for display purposes by Matt McInerney'';
+    description = "Geometric sans-serif for display purposes by Matt McInerney";
     longDescription = ''
      Orbitron is a geometric sans-serif typeface intended for display
      purposes. It features four weights (light, medium, bold, and

pkgs/data/fonts/twitter-color-emoji/default.nix

···
 
   postPatch = let
     templateSubstitutions = lib.concatStringsSep "; " [
-      ''s#Noto Color Emoji#Twitter Color Emoji#''
-      ''s#NotoColorEmoji#TwitterColorEmoji#''
+      "s#Noto Color Emoji#Twitter Color Emoji#"
+      "s#NotoColorEmoji#TwitterColorEmoji#"
       ''s#Copyright .* Google Inc\.#Twitter, Inc and other contributors.#''
-      ''s# Version .*# ${version}#''
-      ''s#.*is a trademark.*##''
+      "s# Version .*# ${version}#"
+      "s#.*is a trademark.*##"
       ''s#Google, Inc\.#Twitter, Inc and other contributors#''
-      ''s#http://www.google.com/get/noto/#https://twemoji.twitter.com/#''
-      ''s#.*is licensed under.*#      Creative Commons Attribution 4.0 International#''
-      ''s#http://scripts.sil.org/OFL#http://creativecommons.org/licenses/by/4.0/#''
+      "s#http://www.google.com/get/noto/#https://twemoji.twitter.com/#"
+      "s#.*is licensed under.*#      Creative Commons Attribution 4.0 International#"
+      "s#http://scripts.sil.org/OFL#http://creativecommons.org/licenses/by/4.0/#"
     ];
   in ''
     ${noto-fonts-emoji.postPatch}

pkgs/desktops/gnome-3/extensions/gsconnect/default.nix

···
     "-Dsshkeygen_path=${openssh}/bin/ssh-keygen"
     "-Dsession_bus_services_dir=${placeholder "out"}/share/dbus-1/services"
     "-Dpost_install=true"
-    "-Dinstalled_test_prefix=${placeholder ''installedTests''}"
+    "-Dinstalled_test_prefix=${placeholder "installedTests"}"
   ];
 
   postPatch = ''

pkgs/development/beam-modules/build-rebar3.nix

···
       HOME=. rebar3 compile
       ${if compilePorts then ''
         HOME=. rebar3 pc compile
-      '' else ''''}
+      '' else ""}
       runHook postBuild
     '';
 

pkgs/development/beam-modules/rebar3-release.nix

···
     configurePhase = ''
       runHook preConfigure
       ${if checkouts != null then
-          ''cp --no-preserve=all -R ${checkouts}/_checkouts .''
+          "cp --no-preserve=all -R ${checkouts}/_checkouts ."
         else
-          ''''}
+          ""}
       runHook postConfigure
     '';
 
     buildPhase = ''
       runHook preBuild
       HOME=. DEBUG=1 rebar3 as ${profile} ${if releaseType == "escript"
-                                            then '' escriptize''
-                                            else '' release''}
+                                            then "escriptize"
+                                            else "release"}
       runHook postBuild
     '';
 
     installPhase = ''
       runHook preInstall
       dir=${if releaseType == "escript"
-            then ''bin''
-            else ''rel''}
+            then "bin"
+            else "rel"}
       mkdir -p "$out/$dir"
       cp -R --preserve=mode "_build/${profile}/$dir" "$out"
       runHook postInstall

pkgs/development/compilers/crystal/build-package.nix

···
   buildPhase = args.buildPhase or (lib.concatStringsSep "\n" ([
     "runHook preBuild"
   ] ++ lib.optional (format == "make")
-    ''make ''${buildTargets:-build} $makeFlags''
+    "make \${buildTargets:-build} $makeFlags"
   ++ lib.optionals (format == "crystal") (lib.mapAttrsToList
     (bin: attrs: ''
       crystal ${lib.escapeShellArgs ([
···
   installPhase = args.installPhase or (lib.concatStringsSep "\n" ([
     "runHook preInstall"
   ] ++ lib.optional (format == "make")
-    ''make ''${installTargets:-install} $installFlags''
+    "make \${installTargets:-install} $installFlags"
   ++ lib.optionals (format == "crystal") (map
     (bin: ''
       install -Dm555 ${lib.escapeShellArgs [ bin "${placeholder "out"}/bin/${bin}" ]}
     '')
     (lib.attrNames crystalBinaries))
   ++ lib.optional (format == "shards")
-    ''install -Dm555 bin/* -t $out/bin''
+    "install -Dm555 bin/* -t $out/bin"
   ++ [
     ''
       for f in README* *.md LICENSE; do
···
   checkPhase = args.checkPhase or (lib.concatStringsSep "\n" ([
     "runHook preCheck"
   ] ++ lib.optional (format == "make")
-    ''make ''${checkTarget:-test} $checkFlags''
+    "make \${checkTarget:-test} $checkFlags"
   ++ lib.optional (format != "make")
-    ''crystal ''${checkTarget:-spec} $checkFlags''
+    "crystal \${checkTarget:-spec} $checkFlags"
   ++ [ "runHook postCheck" ]));
 
   doInstallCheck = args.doInstallCheck or true;

pkgs/development/compilers/osl/default.nix

···
 
   cmakeFlags = [ "-DUSE_BOOST_WAVE=ON" "-DENABLERTTI=ON" ];
 
-  preConfigure = '' patchShebangs src/liboslexec/serialize-bc.bash '';
+  preConfigure = "patchShebangs src/liboslexec/serialize-bc.bash ";
 
   nativeBuildInputs = [ cmake boost_static flex bison];
   buildInputs = [

pkgs/development/compilers/ponyc/default.nix

···
 
   NIX_CFLAGS_COMPILE = [ "-Wno-error=redundant-move" "-Wno-error=implicit-fallthrough" ];
 
-  installPhase = ''
-    make config=release prefix=$out ''
-    + lib.optionalString stdenv.isDarwin '' bits=64 ''
-    + lib.optionalString (stdenv.isDarwin && (!lto)) '' lto=no ''
+  installPhase = "make config=release prefix=$out "
+    + lib.optionalString stdenv.isDarwin "bits=64 "
+    + lib.optionalString (stdenv.isDarwin && (!lto)) "lto=no "
     + '' install
 
     wrapProgram $out/bin/ponyc \

pkgs/development/compilers/rust/rustc.nix

···
   postPatch = ''
     patchShebangs src/etc
 
-    ${optionalString (!withBundledLLVM) ''rm -rf src/llvm''}
+    ${optionalString (!withBundledLLVM) "rm -rf src/llvm"}
 
     # Fix the configure script to not require curl as we won't use it
     sed -i configure \

pkgs/development/compilers/stalin/default.nix

···
 
   buildInputs = [ ncompress libX11 ];
 
-  buildPhase = '' ./build '';
+  buildPhase = "./build ";
 
   installPhase = ''
     mkdir -p "$out/bin"

pkgs/development/compilers/swift/default.nix

···
   '';
 
   # Hack to avoid build and install directories in RPATHs.
-  preFixup = ''rm -rf $SWIFT_BUILD_ROOT $SWIFT_INSTALL_DIR'';
+  preFixup = "rm -rf $SWIFT_BUILD_ROOT $SWIFT_INSTALL_DIR";
 
   meta = with lib; {
     description = "The Swift Programming Language";

pkgs/development/haskell-modules/hackage-packages.nix

···
          sed -i "s|\"-s\"|\"\"|" ./Setup.hs
          sed -i "s|numJobs (bf bi)++||" ./Setup.hs
        '';
-       preBuild = ''export LD_LIBRARY_PATH=`pwd`/dist/build''${LD_LIBRARY_PATH:+:}$LD_LIBRARY_PATH'';
+       preBuild = "export LD_LIBRARY_PATH=`pwd`/dist/build\${LD_LIBRARY_PATH:+:}$LD_LIBRARY_PATH";
        description = "Grammatical Framework";
        license = "unknown";
        hydraPlatforms = lib.platforms.none;

pkgs/development/haskell-modules/hoogle.nix

···
     else "haddock-ghcjs";
   ghcDocLibDir =
     if !isGhcjs
-    then ghc.doc + ''/share/doc/ghc*/html/libraries''
-    else ghc     + ''/doc/lib'';
+    then ghc.doc + "/share/doc/ghc*/html/libraries"
+    else ghc     + "/doc/lib";
   # On GHCJS, use a stripped down version of GHC's prologue.txt
   prologue =
     if !isGhcjs

pkgs/development/interpreters/lua-5/build-lua-package.nix

···
 
   postFixup = lib.optionalString (!dontWrapLuaPrograms) ''
     wrapLuaPrograms
-  '' + attrs.postFixup or '''';
+  '' + attrs.postFixup or "";
 
   installPhase = attrs.installPhase or ''
     runHook preInstall

pkgs/development/interpreters/python/mk-python-derivation.nix

···
 
     postFixup = lib.optionalString (!dontWrapPythonPrograms) ''
       wrapPythonPrograms
-    '' + attrs.postFixup or '''';
+    '' + attrs.postFixup or "";
 
     # Python packages built through cross-compilation are always for the host platform.
     disallowedReferences = lib.optionals (python.stdenv.hostPlatform != python.stdenv.buildPlatform) [ python.pythonForBuild ];

pkgs/development/interpreters/quickjs/default.nix

···
     sha256 = "13hlx6qwrrxmlvvqcr3irxba6zmf05cf54l32vj50wc66s1qd41p";
   };
 
-  makeFlags = [ "prefix=${placeholder ''out''}" ];
+  makeFlags = [ "prefix=${placeholder "out"}" ];
   enableParallelBuilding = true;
 
   doInstallCheck = true;

pkgs/development/libraries/aravis/default.nix

···
       ++ lib.optionals (enableViewer || enableGstPlugin) [ gstreamer gst-plugins-base gst-plugins-good gst-plugins-bad ]
       ++ lib.optionals (enableViewer) [ libnotify gtk3 gnome3.adwaita-icon-theme ];
 
-    preAutoreconf = ''./autogen.sh'';
+    preAutoreconf = "./autogen.sh";
 
     configureFlags =
       lib.optional enableUsb "--enable-usb"

pkgs/development/libraries/aws-sdk-cpp/default.nix

···
   postFixupHooks = [
     # This bodge is necessary so that the file that the generated -config.cmake file
     # points to an existing directory.
-    ''mkdir -p $out/include''
+    "mkdir -p $out/include"
   ];
 
   __darwinAllowLocalNetworking = true;

pkgs/development/libraries/capstone/default.nix

···
     sed -i 's/^IS_APPLE := .*$/IS_APPLE := 1/' Makefile
   '';
 
-  configurePhase = '' patchShebangs make.sh '';
+  configurePhase = "patchShebangs make.sh ";
   buildPhase = "PREFIX=$out ./make.sh";
 
   doCheck = true;

pkgs/development/libraries/dbus/default.nix

···
   configureFlags = [
     "--enable-user-session"
     "--enable-xml-docs"
-    "--libexecdir=${placeholder ''out''}/libexec"
+    "--libexecdir=${placeholder "out"}/libexec"
     "--datadir=/etc"
     "--localstatedir=/var"
     "--runstatedir=/run"
···
     "--with-session-socket-dir=/tmp"
     "--with-system-pid-file=/run/dbus/pid"
     "--with-system-socket=/run/dbus/system_bus_socket"
-    "--with-systemdsystemunitdir=${placeholder ''out''}/etc/systemd/system"
-    "--with-systemduserunitdir=${placeholder ''out''}/etc/systemd/user"
+    "--with-systemdsystemunitdir=${placeholder "out"}/etc/systemd/system"
+    "--with-systemduserunitdir=${placeholder "out"}/etc/systemd/user"
   ] ++ lib.optional (!x11Support) "--without-x"
   ++ lib.optionals (!stdenv.isDarwin) [ "--enable-apparmor" "--enable-libaudit" ];
 
···
   doCheck = true;
 
   installFlags = [
-    "sysconfdir=${placeholder ''out''}/etc"
-    "datadir=${placeholder ''out''}/share"
+    "sysconfdir=${placeholder "out"}/etc"
+    "datadir=${placeholder "out"}/share"
   ];
 
   # it's executed from $lib by absolute path

pkgs/development/libraries/ffmpeg/generic.nix

···
     inherit sha256;
   };
 
-  postPatch = ''patchShebangs .'';
+  postPatch = "patchShebangs .";
   inherit patches;
 
   outputs = [ "bin" "dev" "out" "man" ]

pkgs/development/libraries/gaia/default.nix

···
   };
 
   # Fix installation error when waf tries to put files in /etc/
-  prePatch = ''
-  '' + lib.optionalString cyclopsSupport ''
+  prePatch = "" + lib.optionalString cyclopsSupport ''
     substituteInPlace src/wscript \
       --replace "/etc/cyclops" "$out/etc/cyclops" \
       --replace "/etc/init.d" "$out/etc/init.d"
···
     ++ lib.optionals (cyclopsSupport) [ "--with-cyclops" ]
   ;
 
-  postFixup = ''
-  ''
+  postFixup = ""
     + lib.optionalString pythonSupport ''
       wrapPythonPrograms
     ''

pkgs/development/libraries/gcab/default.nix

···
 
   mesonFlags = [
     "-Dinstalled_tests=true"
-    "-Dinstalled_test_prefix=${placeholder ''installedTests''}"
+    "-Dinstalled_test_prefix=${placeholder "installedTests"}"
   ];
 
   doCheck = true;

pkgs/development/libraries/glib/default.nix

···
     # Instead we just copy them over from the native output.
     "-Dgtk_doc=${boolToString (stdenv.hostPlatform == stdenv.buildPlatform)}"
     "-Dnls=enabled"
-    "-Ddevbindir=${placeholder ''dev''}/bin"
+    "-Ddevbindir=${placeholder "dev"}/bin"
   ];
 
   NIX_CFLAGS_COMPILE = toString [

pkgs/development/libraries/glui/default.nix

···
   '';
 
   meta = with lib; {
-    description = ''A user interface library using OpenGL'';
+    description = "A user interface library using OpenGL";
     license = licenses.zlib ;
     maintainers = [ maintainers.raskin ];
     platforms = platforms.linux;

pkgs/development/libraries/gtdialog/default.nix

···
   makeFlags = ["PREFIX=$(out)"];
   meta = {
     inherit (s) version;
-    description = ''Cross-platform helper for creating interactive dialogs'';
+    description = "Cross-platform helper for creating interactive dialogs";
     license = lib.licenses.mit ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/development/libraries/hspell/default.nix

···
     sha256 = "08x7rigq5pa1pfpl30qp353hbdkpadr1zc49slpczhsn0sg36pd6";
   };
 
-  patchPhase = ''patchShebangs .'';
+  patchPhase = "patchShebangs .";
   buildInputs = [ perl zlib ];
 
   meta = with lib; {

pkgs/development/libraries/iml/default.nix

···
   ];
   meta = {
     inherit version;
-    description = ''Algorithms for computing exact solutions to dense systems of linear equations over the integers'';
+    description = "Algorithms for computing exact solutions to dense systems of linear equations over the integers";
     license = lib.licenses.gpl2Plus;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

pkgs/development/libraries/java/dbus-java/default.nix

···
   };
   JAVA_HOME=jdk;
   JAVA="${jdk}/bin/java";
-  PREFIX=''''${out}'';
+  PREFIX="\${out}";
   JAVAUNIXLIBDIR="${libmatthew_java}/lib/jni";
   JAVAUNIXJARDIR="${libmatthew_java}/share/java";
   buildInputs = [ gettext jdk ];

pkgs/development/libraries/java/libmatthew-java/default.nix

···
     sha256 = "1yldkhsdzm0a41a0i881bin2jklhp85y3ah245jd6fz3npcx7l85";
   };
   JAVA_HOME=jdk;
-  PREFIX=''''${out}'';
+  PREFIX="\${out}";
   buildInputs = [ jdk ];
 
   meta = with lib; {

pkgs/development/libraries/libatomic_ops/default.nix

···
   '';
 
   meta = {
-    description = ''A library for semi-portable access to hardware-provided atomic memory update operations'';
+    description = "A library for semi-portable access to hardware-provided atomic memory update operations";
     license = lib.licenses.gpl2Plus ;
     maintainers = [lib.maintainers.raskin];
     platforms = with lib.platforms; unix ++ windows;

pkgs/development/libraries/libe-book/default.nix

···
   NIX_CFLAGS_COMPILE = "-Wno-error=unused-function";
   meta = {
     inherit (s) version;
-    description = ''Library for import of reflowable e-book formats'';
+    description = "Library for import of reflowable e-book formats";
     license = lib.licenses.lgpl21Plus ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

pkgs/development/libraries/liblangtag/default.nix

···
   '';
 
   configureFlags = [
-    ''--with-locale-alias=${stdenv.cc.libc}/share/locale/locale.alias''
+    "--with-locale-alias=${stdenv.cc.libc}/share/locale/locale.alias"
   ];
 
   buildInputs = [ gettext glib libxml2 gobject-introspection gnome-common

pkgs/development/libraries/libmwaw/default.nix

···
   };
   meta = {
     inherit (s) version;
-    description = ''Import library for some old mac text documents'';
+    description = "Import library for some old mac text documents";
     license = lib.licenses.mpl20 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

pkgs/development/libraries/libodfgen/default.nix

···
   };
   meta = {
     inherit (s) version;
-    description = ''A base library for generating ODF documents'';
+    description = "A base library for generating ODF documents";
     license = lib.licenses.mpl20 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

pkgs/development/libraries/librem/default.nix

···
   makeFlags = [
     "LIBRE_MK=${libre}/share/re/re.mk"
     "LIBRE_INC=${libre}/include/re"
-    ''PREFIX=$(out)''
+    "PREFIX=$(out)"
   ]
   ++ lib.optional (stdenv.cc.cc != null) "SYSROOT_ALT=${lib.getDev stdenv.cc.cc}"
   ++ lib.optional (stdenv.cc.libc != null) "SYSROOT=${lib.getDev stdenv.cc.libc}"

pkgs/development/libraries/librevenge/default.nix

···
 
   meta = {
     inherit (s) version;
-    description = ''A base library for writing document import filters'';
+    description = "A base library for writing document import filters";
     license = lib.licenses.mpl20 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

pkgs/development/libraries/libvpx/1_8.nix

···
 #    ./CVE-2019-9232.CVE-2019-9325.CVE-2019-9371.CVE-2019-9433.patch
   ];
 
-  postPatch = ''patchShebangs .'';
+  postPatch = "patchShebangs .";
 
   outputs = [ "bin" "dev" "out" ];
   setOutputFlags = false;

pkgs/development/libraries/libxml2/default.nix

···
   preInstall = lib.optionalString pythonSupport
     ''substituteInPlace python/libxml2mod.la --replace "${python}" "$py"'';
   installFlags = lib.optional pythonSupport
-    "pythondir=\"${placeholder ''py''}/lib/${python.libPrefix}/site-packages\"";
+    "pythondir=\"${placeholder "py"}/lib/${python.libPrefix}/site-packages\"";
 
   postFixup = ''
     moveToOutput bin/xml2-config "$dev"

pkgs/development/libraries/libzmf/default.nix

···
 
   meta = {
     inherit version;
-    description = ''A library that parses the file format of Zoner Callisto/Draw documents'';
+    description = "A library that parses the file format of Zoner Callisto/Draw documents";
     license = lib.licenses.mpl20;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

pkgs/development/libraries/mpfi/default.nix

···
   buildInputs = [mpfr];
   meta = {
     inherit version;
-    description = ''A multiple precision interval arithmetic library based on MPFR'';
+    description = "A multiple precision interval arithmetic library based on MPFR";
     homepage = "https://gforge.inria.fr/projects/mpfi/";
     license = lib.licenses.lgpl21Plus;
     maintainers = [lib.maintainers.raskin];

pkgs/development/libraries/mpir/default.nix

···
 
   meta = {
     inherit version;
-    description = ''A highly optimised library for bignum arithmetic forked from GMP'';
+    description = "A highly optimised library for bignum arithmetic forked from GMP";
     license = lib.licenses.lgpl3Plus;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

pkgs/development/libraries/msgpuck/default.nix

···
   nativeBuildInputs = [ cmake pkg-config ];
 
   meta = with lib; {
-     description = ''A simple and efficient MsgPack binary serialization library in a self-contained header file'';
+     description = "A simple and efficient MsgPack binary serialization library in a self-contained header file";
      homepage = "https://github.com/rtsisyk/msgpuck";
      license = licenses.bsd2;
      platforms = platforms.linux;

pkgs/development/libraries/openpa/default.nix

···
     sha256 = "0flyi596hm6fv7xyw2iykx3s65p748s62bf15624xcnwpfrh8ncy";
   };
 
-  prePatch = ''substituteInPlace configure --replace /usr/bin/file ${file}/bin/file'';
+  prePatch = "substituteInPlace configure --replace /usr/bin/file ${file}/bin/file";
 
   doCheck = true;
 

pkgs/development/libraries/qca-qt5/default.nix

···
   patches = lib.optional stdenv.isDarwin ./move-project.patch ;
 
   # tells CMake to use this CA bundle file if it is accessible
-  preConfigure = ''export QC_CERTSTORE_PATH=/etc/ssl/certs/ca-certificates.crt'';
+  preConfigure = "export QC_CERTSTORE_PATH=/etc/ssl/certs/ca-certificates.crt";
 
   # tricks CMake into using this CA bundle file if it is not accessible (in a sandbox)
   cmakeFlags = [ "-Dqca_CERTSTORE=/etc/ssl/certs/ca-certificates.crt" ];

pkgs/development/libraries/science/math/caffe2/default.nix

···
     ./fix_compilation_on_gcc7.patch
   ] ++ lib.optional stdenv.cc.isClang [ ./update_clang_cvtsh_bugfix.patch ];
 
-  cmakeFlags = [ ''-DBUILD_TEST=OFF''
-                 ''-DBUILD_PYTHON=ON''
-                 ''-DUSE_CUDA=${if useCuda then ''ON''else ''OFF''}''
-                 ''-DUSE_OPENMP=${if useOpenmp then ''ON''else ''OFF''}''
-                 ''-DUSE_OPENCV=${if useOpencv3 then ''ON''else ''OFF''}''
-                 ''-DUSE_MPI=${if useMpi then ''ON''else ''OFF''}''
-                 ''-DUSE_LEVELDB=${if useLeveldb then ''ON''else ''OFF''}''
-                 ''-DUSE_LMDB=${if useLmdb then ''ON''else ''OFF''}''
-                 ''-DUSE_ROCKSDB=${if useRocksdb then ''ON''else ''OFF''}''
-                 ''-DUSE_ZMQ=${if useZeromq  then ''ON''else ''OFF''}''
-                 ''-DUSE_GLOO=OFF''
-                 ''-DUSE_NNPACK=OFF''
-                 ''-DUSE_NCCL=OFF''
-                 ''-DUSE_REDIS=OFF''
-                 ''-DUSE_FFMPEG=OFF''
+  cmakeFlags = [ "-DBUILD_TEST=OFF"
+                 "-DBUILD_PYTHON=ON"
+                 ''-DUSE_CUDA=${if useCuda then "ON"else "OFF"}''
+                 ''-DUSE_OPENMP=${if useOpenmp then "ON"else "OFF"}''
+                 ''-DUSE_OPENCV=${if useOpencv3 then "ON"else "OFF"}''
+                 ''-DUSE_MPI=${if useMpi then "ON"else "OFF"}''
+                 ''-DUSE_LEVELDB=${if useLeveldb then "ON"else "OFF"}''
+                 ''-DUSE_LMDB=${if useLmdb then "ON"else "OFF"}''
+                 ''-DUSE_ROCKSDB=${if useRocksdb then "ON"else "OFF"}''
+                 ''-DUSE_ZMQ=${if useZeromq  then "ON"else "OFF"}''
+                 "-DUSE_GLOO=OFF"
+                 "-DUSE_NNPACK=OFF"
+                 "-DUSE_NCCL=OFF"
+                 "-DUSE_REDIS=OFF"
+                 "-DUSE_FFMPEG=OFF"
                ]
                ++ lib.optional useCuda [
-                 ''-DCUDA_TOOLKIT_ROOT_DIR=${cudatoolkit}''
-                 ''-DCUDA_FAST_MATH=ON''
-                 ''-DCUDA_HOST_COMPILER=${cudatoolkit.cc}/bin/gcc''
+                 "-DCUDA_TOOLKIT_ROOT_DIR=${cudatoolkit}"
+                 "-DCUDA_FAST_MATH=ON"
+                 "-DCUDA_HOST_COMPILER=${cudatoolkit.cc}/bin/gcc"
                ];
 
   preConfigure = ''

pkgs/development/libraries/speechd/default.nix

···
   configureFlags = [
     # Audio method falls back from left to right.
     "--with-default-audio-method=\"libao,pulse,alsa,oss\""
-    "--with-systemdsystemunitdir=${placeholder ''out''}/lib/systemd/system"
+    "--with-systemdsystemunitdir=${placeholder "out"}/lib/systemd/system"
   ] ++ optional withPulse "--with-pulse"
     ++ optional withAlsa "--with-alsa"
     ++ optional withLibao "--with-libao"

pkgs/development/lisp-modules/lisp-packages.nix

···
         url = "https://beta.quicklisp.org/dist/quicklisp/2020-10-16/distinfo.txt";
         sha256 = "sha256:090xjcnyqcv8az9n1a7m0f6vzz2nwcncy95ha7ixb7fnd2rj1n65";
       };
-      buildPhase = '' true; '';
+      buildPhase = "true; ";
       postInstall = ''
         substituteAll ${./quicklisp.sh} "$out"/bin/quicklisp
         chmod a+x "$out"/bin/quicklisp
···
 
   clx-truetype = buildLispPackage rec {
           baseName = "clx-truetype";
-          version = ''20160825-git'';
+          version = "20160825-git";
 
           buildSystems = [ "clx-truetype" ];
           parasites = [ "clx-truetype-test" ];
···
                           cl-vectors clx trivial-features zpb-ttf
           ];
           src = pkgs.fetchurl {
-                  url = ''http://beta.quicklisp.org/archive/clx-truetype/2016-08-25/clx-truetype-20160825-git.tgz'';
-                  sha256 = ''0ndy067rg9w6636gxwlpnw7f3ck9nrnjb03444pprik9r3c9in67'';
+                  url = "http://beta.quicklisp.org/archive/clx-truetype/2016-08-25/clx-truetype-20160825-git.tgz";
+                  sha256 = "0ndy067rg9w6636gxwlpnw7f3ck9nrnjb03444pprik9r3c9in67";
           };
 
           packageName = "clx-truetype";

pkgs/development/lisp-modules/quicklisp-to-nix-output/_3bmd-ext-code-blocks.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''_3bmd-ext-code-blocks'';
-  version = ''3bmd-20200925-git'';
+  baseName = "_3bmd-ext-code-blocks";
+  version = "3bmd-20200925-git";
 
-  description = ''extension to 3bmd implementing github style ``` delimited code blocks, with support for syntax highlighting using colorize, pygments, or chroma'';
+  description = "extension to 3bmd implementing github style ``` delimited code blocks, with support for syntax highlighting using colorize, pygments, or chroma";
 
   deps = [ args."_3bmd" args."alexandria" args."colorize" args."esrap" args."html-encode" args."split-sequence" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/3bmd/2020-09-25/3bmd-20200925-git.tgz'';
-    sha256 = ''0sk4b0xma4vv6ssiskbz7h5bw8v8glm34mbv3llqywb50b9ks4fw'';
+    url = "http://beta.quicklisp.org/archive/3bmd/2020-09-25/3bmd-20200925-git.tgz";
+    sha256 = "0sk4b0xma4vv6ssiskbz7h5bw8v8glm34mbv3llqywb50b9ks4fw";
   };
 
   packageName = "3bmd-ext-code-blocks";

pkgs/development/lisp-modules/quicklisp-to-nix-output/_3bmd.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''_3bmd'';
-  version = ''20200925-git'';
+  baseName = "_3bmd";
+  version = "20200925-git";
 
-  description = ''markdown processor in CL using esrap parser.'';
+  description = "markdown processor in CL using esrap parser.";
 
   deps = [ args."alexandria" args."esrap" args."split-sequence" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/3bmd/2020-09-25/3bmd-20200925-git.tgz'';
-    sha256 = ''0sk4b0xma4vv6ssiskbz7h5bw8v8glm34mbv3llqywb50b9ks4fw'';
+    url = "http://beta.quicklisp.org/archive/3bmd/2020-09-25/3bmd-20200925-git.tgz";
+    sha256 = "0sk4b0xma4vv6ssiskbz7h5bw8v8glm34mbv3llqywb50b9ks4fw";
   };
 
   packageName = "3bmd";

pkgs/development/lisp-modules/quicklisp-to-nix-output/access.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''access'';
-  version = ''20151218-git'';
+  baseName = "access";
+  version = "20151218-git";
 
   parasites = [ "access-test" ];
 
···
   deps = [ args."alexandria" args."anaphora" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."flexi-streams" args."iterate" args."lisp-unit2" args."named-readtables" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/access/2015-12-18/access-20151218-git.tgz'';
-    sha256 = ''0f4257cxd1rpp46wm2qbnk0ynlc3dli9ib4qbn45hglh8zy7snfl'';
+    url = "http://beta.quicklisp.org/archive/access/2015-12-18/access-20151218-git.tgz";
+    sha256 = "0f4257cxd1rpp46wm2qbnk0ynlc3dli9ib4qbn45hglh8zy7snfl";
   };
 
   packageName = "access";

pkgs/development/lisp-modules/quicklisp-to-nix-output/acclimation.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''acclimation'';
-  version = ''20200925-git'';
+  baseName = "acclimation";
+  version = "20200925-git";
 
-  description = ''Library supporting internationalization'';
+  description = "Library supporting internationalization";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/acclimation/2020-09-25/acclimation-20200925-git.tgz'';
-    sha256 = ''11vw1h5zxicj5qxb1smiyjxafw8xk0isnzcf5g0lqis3y9ssqxbw'';
+    url = "http://beta.quicklisp.org/archive/acclimation/2020-09-25/acclimation-20200925-git.tgz";
+    sha256 = "11vw1h5zxicj5qxb1smiyjxafw8xk0isnzcf5g0lqis3y9ssqxbw";
   };
 
   packageName = "acclimation";

pkgs/development/lisp-modules/quicklisp-to-nix-output/alexandria.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''alexandria'';
-  version = ''20200925-git'';
+  baseName = "alexandria";
+  version = "20200925-git";
 
-  description = ''Alexandria is a collection of portable public domain utilities.'';
+  description = "Alexandria is a collection of portable public domain utilities.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/alexandria/2020-09-25/alexandria-20200925-git.tgz'';
-    sha256 = ''1cpvnzfs807ah07hrk8kplim6ryzqs4r35ym03cpky5xdl8c89fl'';
+    url = "http://beta.quicklisp.org/archive/alexandria/2020-09-25/alexandria-20200925-git.tgz";
+    sha256 = "1cpvnzfs807ah07hrk8kplim6ryzqs4r35ym03cpky5xdl8c89fl";
   };
 
   packageName = "alexandria";

pkgs/development/lisp-modules/quicklisp-to-nix-output/anaphora.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''anaphora'';
-  version = ''20191007-git'';
+  baseName = "anaphora";
+  version = "20191007-git";
 
   parasites = [ "anaphora/test" ];
 
-  description = ''The Anaphoric Macro Package from Hell'';
+  description = "The Anaphoric Macro Package from Hell";
 
   deps = [ args."rt" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/anaphora/2019-10-07/anaphora-20191007-git.tgz'';
-    sha256 = ''0iwfddh3cycjr9vhjnr1ldd5xc3qwqhrp41904s1dvysf99277kv'';
+    url = "http://beta.quicklisp.org/archive/anaphora/2019-10-07/anaphora-20191007-git.tgz";
+    sha256 = "0iwfddh3cycjr9vhjnr1ldd5xc3qwqhrp41904s1dvysf99277kv";
   };
 
   packageName = "anaphora";

pkgs/development/lisp-modules/quicklisp-to-nix-output/arnesi.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''arnesi'';
-  version = ''20170403-git'';
+  baseName = "arnesi";
+  version = "20170403-git";
 
   parasites = [ "arnesi/cl-ppcre-extras" "arnesi/slime-extras" ];
 
-  description = ''A bag-of-tools utilities library used to aid in implementing the bese.it toolkit'';
+  description = "A bag-of-tools utilities library used to aid in implementing the bese.it toolkit";
 
   deps = [ args."alexandria" args."cl-ppcre" args."closer-mop" args."collectors" args."iterate" args."swank" args."symbol-munger" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/arnesi/2017-04-03/arnesi-20170403-git.tgz'';
-    sha256 = ''01kirjpgv5pgbcdxjrnw3ld4jw7wrqm3rgqnxwac4gxaphr2s6q4'';
+    url = "http://beta.quicklisp.org/archive/arnesi/2017-04-03/arnesi-20170403-git.tgz";
+    sha256 = "01kirjpgv5pgbcdxjrnw3ld4jw7wrqm3rgqnxwac4gxaphr2s6q4";
   };
 
   packageName = "arnesi";

pkgs/development/lisp-modules/quicklisp-to-nix-output/array-utils.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''array-utils'';
-  version = ''20190710-git'';
+  baseName = "array-utils";
+  version = "20190710-git";
 
-  description = ''A few utilities for working with arrays.'';
+  description = "A few utilities for working with arrays.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/array-utils/2019-07-10/array-utils-20190710-git.tgz'';
-    sha256 = ''1fzsg3lqa79yrkad6fx924vai7i6m92i2rq8lyq37wrbwkhm7grh'';
+    url = "http://beta.quicklisp.org/archive/array-utils/2019-07-10/array-utils-20190710-git.tgz";
+    sha256 = "1fzsg3lqa79yrkad6fx924vai7i6m92i2rq8lyq37wrbwkhm7grh";
   };
 
   packageName = "array-utils";

pkgs/development/lisp-modules/quicklisp-to-nix-output/asdf-package-system.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''asdf-package-system'';
-  version = ''20150608-git'';
+  baseName = "asdf-package-system";
+  version = "20150608-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/asdf-package-system/2015-06-08/asdf-package-system-20150608-git.tgz'';
-    sha256 = ''17lfwfc15hcag8a2jsaxkx42wmz2mwkvxf6vb2h9cim7dwsnyy29'';
+    url = "http://beta.quicklisp.org/archive/asdf-package-system/2015-06-08/asdf-package-system-20150608-git.tgz";
+    sha256 = "17lfwfc15hcag8a2jsaxkx42wmz2mwkvxf6vb2h9cim7dwsnyy29";
   };
 
   packageName = "asdf-package-system";

pkgs/development/lisp-modules/quicklisp-to-nix-output/asdf-system-connections.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''asdf-system-connections'';
-  version = ''20170124-git'';
+  baseName = "asdf-system-connections";
+  version = "20170124-git";
 
-  description = ''Allows for ASDF system to be connected so that auto-loading may occur.'';
+  description = "Allows for ASDF system to be connected so that auto-loading may occur.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/asdf-system-connections/2017-01-24/asdf-system-connections-20170124-git.tgz'';
-    sha256 = ''0h8237bq3niw6glcsps77n1ykcmc5bjkcrbjyxjgkmcb1c5kwwpq'';
+    url = "http://beta.quicklisp.org/archive/asdf-system-connections/2017-01-24/asdf-system-connections-20170124-git.tgz";
+    sha256 = "0h8237bq3niw6glcsps77n1ykcmc5bjkcrbjyxjgkmcb1c5kwwpq";
   };
 
   packageName = "asdf-system-connections";

pkgs/development/lisp-modules/quicklisp-to-nix-output/babel.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''babel'';
-  version = ''20200925-git'';
+  baseName = "babel";
+  version = "20200925-git";
 
-  description = ''Babel, a charset conversion library.'';
+  description = "Babel, a charset conversion library.";
 
   deps = [ args."alexandria" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/babel/2020-09-25/babel-20200925-git.tgz'';
-    sha256 = ''1hpjm2whw7zla9igzj50y3nibii0mfg2a6y6nslaf5vpkni88jfi'';
+    url = "http://beta.quicklisp.org/archive/babel/2020-09-25/babel-20200925-git.tgz";
+    sha256 = "1hpjm2whw7zla9igzj50y3nibii0mfg2a6y6nslaf5vpkni88jfi";
   };
 
   packageName = "babel";

pkgs/development/lisp-modules/quicklisp-to-nix-output/blackbird.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''blackbird'';
-  version = ''20160531-git'';
+  baseName = "blackbird";
+  version = "20160531-git";
 
-  description = ''A promise implementation for Common Lisp.'';
+  description = "A promise implementation for Common Lisp.";
 
   deps = [ args."vom" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/blackbird/2016-05-31/blackbird-20160531-git.tgz'';
-    sha256 = ''0l053fb5fdz1q6dyfgys6nmbairc3aig4wjl5abpf8b1paf7gzq9'';
+    url = "http://beta.quicklisp.org/archive/blackbird/2016-05-31/blackbird-20160531-git.tgz";
+    sha256 = "0l053fb5fdz1q6dyfgys6nmbairc3aig4wjl5abpf8b1paf7gzq9";
   };
 
   packageName = "blackbird";

pkgs/development/lisp-modules/quicklisp-to-nix-output/bordeaux-threads.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''bordeaux-threads'';
-  version = ''v0.8.8'';
+  baseName = "bordeaux-threads";
+  version = "v0.8.8";
 
   parasites = [ "bordeaux-threads/test" ];
 
-  description = ''Bordeaux Threads makes writing portable multi-threaded apps simple.'';
+  description = "Bordeaux Threads makes writing portable multi-threaded apps simple.";
 
   deps = [ args."alexandria" args."fiveam" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/bordeaux-threads/2020-06-10/bordeaux-threads-v0.8.8.tgz'';
-    sha256 = ''1ppb7lvr796k1j4hi0jnp717v9zxy6vq4f5cyzgn7svg1ic6l0pp'';
+    url = "http://beta.quicklisp.org/archive/bordeaux-threads/2020-06-10/bordeaux-threads-v0.8.8.tgz";
+    sha256 = "1ppb7lvr796k1j4hi0jnp717v9zxy6vq4f5cyzgn7svg1ic6l0pp";
   };
 
   packageName = "bordeaux-threads";

pkgs/development/lisp-modules/quicklisp-to-nix-output/buildnode-xhtml.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''buildnode-xhtml'';
-  version = ''buildnode-20170403-git'';
+  baseName = "buildnode-xhtml";
+  version = "buildnode-20170403-git";
 
-  description = ''Tool for building up an xml dom of an excel spreadsheet nicely.'';
+  description = "Tool for building up an xml dom of an excel spreadsheet nicely.";
 
   deps = [ args."alexandria" args."babel" args."buildnode" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."closure-common" args."closure-html" args."collectors" args."cxml" args."flexi-streams" args."iterate" args."named-readtables" args."puri" args."split-sequence" args."swank" args."symbol-munger" args."trivial-features" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/buildnode/2017-04-03/buildnode-20170403-git.tgz'';
-    sha256 = ''1gb3zsp4g31iscvvhvb99z0i7lfn1g3493q6sgpr46fmn2vdwwb6'';
+    url = "http://beta.quicklisp.org/archive/buildnode/2017-04-03/buildnode-20170403-git.tgz";
+    sha256 = "1gb3zsp4g31iscvvhvb99z0i7lfn1g3493q6sgpr46fmn2vdwwb6";
   };
 
   packageName = "buildnode-xhtml";

pkgs/development/lisp-modules/quicklisp-to-nix-output/buildnode.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''buildnode'';
-  version = ''20170403-git'';
+  baseName = "buildnode";
+  version = "20170403-git";
 
   parasites = [ "buildnode-test" ];
 
-  description = ''Tool for building up an xml dom nicely.'';
+  description = "Tool for building up an xml dom nicely.";
 
   deps = [ args."alexandria" args."babel" args."buildnode-xhtml" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."closure-common" args."closure-html" args."collectors" args."cxml" args."flexi-streams" args."iterate" args."lisp-unit2" args."named-readtables" args."puri" args."split-sequence" args."swank" args."symbol-munger" args."trivial-features" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/buildnode/2017-04-03/buildnode-20170403-git.tgz'';
-    sha256 = ''1gb3zsp4g31iscvvhvb99z0i7lfn1g3493q6sgpr46fmn2vdwwb6'';
+    url = "http://beta.quicklisp.org/archive/buildnode/2017-04-03/buildnode-20170403-git.tgz";
+    sha256 = "1gb3zsp4g31iscvvhvb99z0i7lfn1g3493q6sgpr46fmn2vdwwb6";
   };
 
   packageName = "buildnode";

pkgs/development/lisp-modules/quicklisp-to-nix-output/caveman.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''caveman'';
-  version = ''20200325-git'';
+  baseName = "caveman";
+  version = "20200325-git";
 
-  description = ''Web Application Framework for Common Lisp'';
+  description = "Web Application Framework for Common Lisp";
 
   deps = [ args."alexandria" args."anaphora" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."chipz" args."chunga" args."circular-streams" args."cl_plus_ssl" args."cl-annot" args."cl-ansi-text" args."cl-base64" args."cl-colors" args."cl-colors2" args."cl-cookie" args."cl-emb" args."cl-fad" args."cl-ppcre" args."cl-project" args."cl-reexport" args."cl-syntax" args."cl-syntax-annot" args."cl-utilities" args."clack" args."clack-handler-hunchentoot" args."clack-socket" args."clack-test" args."clack-v1-compat" args."dexador" args."dissect" args."do-urlencode" args."fast-http" args."fast-io" args."flexi-streams" args."http-body" args."hunchentoot" args."ironclad" args."jonathan" args."lack" args."lack-component" args."lack-middleware-backtrace" args."lack-util" args."let-plus" args."local-time" args."map-set" args."marshal" args."md5" args."myway" args."named-readtables" args."proc-parse" args."prove" args."quri" args."rfc2388" args."rove" args."smart-buffer" args."split-sequence" args."static-vectors" args."trivial-backtrace" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."trivial-mimes" args."trivial-types" args."usocket" args."xsubseq" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/caveman/2020-03-25/caveman-20200325-git.tgz'';
-    sha256 = ''0s134lamlyll4ad0380rj0hkiy9gakly7cb6sjr1yg2yd6ydz1py'';
+    url = "http://beta.quicklisp.org/archive/caveman/2020-03-25/caveman-20200325-git.tgz";
+    sha256 = "0s134lamlyll4ad0380rj0hkiy9gakly7cb6sjr1yg2yd6ydz1py";
   };
 
   packageName = "caveman";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-grovel.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cffi-grovel'';
-  version = ''cffi_0.23.0'';
+  baseName = "cffi-grovel";
+  version = "cffi_0.23.0";
 
-  description = ''The CFFI Groveller'';
+  description = "The CFFI Groveller";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."cffi-toolchain" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz'';
-    sha256 = ''1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck'';
+    url = "http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz";
+    sha256 = "1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck";
   };
 
   packageName = "cffi-grovel";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi-toolchain.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cffi-toolchain'';
-  version = ''cffi_0.23.0'';
+  baseName = "cffi-toolchain";
+  version = "cffi_0.23.0";
 
-  description = ''The CFFI toolchain'';
+  description = "The CFFI toolchain";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz'';
-    sha256 = ''1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck'';
+    url = "http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz";
+    sha256 = "1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck";
   };
 
   packageName = "cffi-toolchain";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cffi.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cffi'';
-  version = ''cffi_0.23.0'';
+  baseName = "cffi";
+  version = "cffi_0.23.0";
 
   parasites = [ "cffi/c2ffi" "cffi/c2ffi-generator" ];
 
-  description = ''The Common Foreign Function Interface'';
+  description = "The Common Foreign Function Interface";
 
   deps = [ args."alexandria" args."babel" args."cl-json" args."cl-ppcre" args."trivial-features" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz'';
-    sha256 = ''1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck'';
+    url = "http://beta.quicklisp.org/archive/cffi/2020-07-15/cffi_0.23.0.tgz";
+    sha256 = "1szpbg5m5fjq7bpkblflpnwmgz3ncsvp1y43g3jzwlk7yfxrwxck";
   };
 
   packageName = "cffi";

pkgs/development/lisp-modules/quicklisp-to-nix-output/chanl.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''chanl'';
-  version = ''20201016-git'';
+  baseName = "chanl";
+  version = "20201016-git";
 
   parasites = [ "chanl/examples" "chanl/tests" ];
 
-  description = ''Communicating Sequential Process support for Common Lisp'';
+  description = "Communicating Sequential Process support for Common Lisp";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."fiveam" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/chanl/2020-10-16/chanl-20201016-git.tgz'';
-    sha256 = ''13kmk6q20kkwy8z3fy0sv57076xf5nls3qx31yp47vaxhn9p11a1'';
+    url = "http://beta.quicklisp.org/archive/chanl/2020-10-16/chanl-20201016-git.tgz";
+    sha256 = "13kmk6q20kkwy8z3fy0sv57076xf5nls3qx31yp47vaxhn9p11a1";
   };
 
   packageName = "chanl";

pkgs/development/lisp-modules/quicklisp-to-nix-output/chipz.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''chipz'';
-  version = ''20190202-git'';
+  baseName = "chipz";
+  version = "20190202-git";
 
-  description = ''A library for decompressing deflate, zlib, and gzip data'';
+  description = "A library for decompressing deflate, zlib, and gzip data";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/chipz/2019-02-02/chipz-20190202-git.tgz'';
-    sha256 = ''1vk8nml2kvkpwydcnm49gz2j9flvl8676kbvci5qa7qm286dhn5a'';
+    url = "http://beta.quicklisp.org/archive/chipz/2019-02-02/chipz-20190202-git.tgz";
+    sha256 = "1vk8nml2kvkpwydcnm49gz2j9flvl8676kbvci5qa7qm286dhn5a";
   };
 
   packageName = "chipz";

pkgs/development/lisp-modules/quicklisp-to-nix-output/chunga.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''chunga'';
-  version = ''20200427-git'';
+  baseName = "chunga";
+  version = "20200427-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/chunga/2020-04-27/chunga-20200427-git.tgz'';
-    sha256 = ''0p6dlnan6raincd682brcjbklyvmkfkhz0yzp2bkfw67s9615bkk'';
+    url = "http://beta.quicklisp.org/archive/chunga/2020-04-27/chunga-20200427-git.tgz";
+    sha256 = "0p6dlnan6raincd682brcjbklyvmkfkhz0yzp2bkfw67s9615bkk";
   };
 
   packageName = "chunga";

pkgs/development/lisp-modules/quicklisp-to-nix-output/circular-streams.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''circular-streams'';
-  version = ''20161204-git'';
+  baseName = "circular-streams";
+  version = "20161204-git";
 
-  description = ''Circularly readable streams for Common Lisp'';
+  description = "Circularly readable streams for Common Lisp";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."fast-io" args."static-vectors" args."trivial-features" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/circular-streams/2016-12-04/circular-streams-20161204-git.tgz'';
-    sha256 = ''1i29b9sciqs5x59hlkdj2r4siyqgrwj5hb4lnc80jgfqvzbq4128'';
+    url = "http://beta.quicklisp.org/archive/circular-streams/2016-12-04/circular-streams-20161204-git.tgz";
+    sha256 = "1i29b9sciqs5x59hlkdj2r4siyqgrwj5hb4lnc80jgfqvzbq4128";
   };
 
   packageName = "circular-streams";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-aa.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-aa'';
-  version = ''cl-vectors-20180228-git'';
+  baseName = "cl-aa";
+  version = "cl-vectors-20180228-git";
 
-  description = ''cl-aa: polygon rasterizer'';
+  description = "cl-aa: polygon rasterizer";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz'';
-    sha256 = ''0fcypjfzqra8ryb4nx1vx1fqy7fwvyz3f443qkjg2z81akhkscly'';
+    url = "http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz";
+    sha256 = "0fcypjfzqra8ryb4nx1vx1fqy7fwvyz3f443qkjg2z81akhkscly";
   };
 
   packageName = "cl-aa";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-annot.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-annot'';
-  version = ''20150608-git'';
+  baseName = "cl-annot";
+  version = "20150608-git";
 
-  description = ''Python-like Annotation Syntax for Common Lisp'';
+  description = "Python-like Annotation Syntax for Common Lisp";
 
   deps = [ args."alexandria" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-annot/2015-06-08/cl-annot-20150608-git.tgz'';
-    sha256 = ''0ixsp20rk498phv3iivipn3qbw7a7x260x63hc6kpv2s746lpdg3'';
+    url = "http://beta.quicklisp.org/archive/cl-annot/2015-06-08/cl-annot-20150608-git.tgz";
+    sha256 = "0ixsp20rk498phv3iivipn3qbw7a7x260x63hc6kpv2s746lpdg3";
   };
 
   packageName = "cl-annot";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-anonfun.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-anonfun'';
-  version = ''20111203-git'';
+  baseName = "cl-anonfun";
+  version = "20111203-git";
 
-  description = ''Anonymous function helpers for Common Lisp'';
+  description = "Anonymous function helpers for Common Lisp";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-anonfun/2011-12-03/cl-anonfun-20111203-git.tgz'';
-    sha256 = ''16r3v3yba41smkqpz0qvzabkxashl39klfb6vxhzbly696x87p1m'';
+    url = "http://beta.quicklisp.org/archive/cl-anonfun/2011-12-03/cl-anonfun-20111203-git.tgz";
+    sha256 = "16r3v3yba41smkqpz0qvzabkxashl39klfb6vxhzbly696x87p1m";
   };
 
   packageName = "cl-anonfun";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-ansi-text.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-ansi-text'';
-  version = ''20200218-git'';
+  baseName = "cl-ansi-text";
+  version = "20200218-git";
 
-  description = ''ANSI control string characters, focused on color'';
+  description = "ANSI control string characters, focused on color";
 
   deps = [ args."alexandria" args."cl-colors2" args."cl-ppcre" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-ansi-text/2020-02-18/cl-ansi-text-20200218-git.tgz'';
-    sha256 = ''1yn657rka3pcg3p5g9czbpk0f0rv81dbq1gknid1b24zg7krks5r'';
+    url = "http://beta.quicklisp.org/archive/cl-ansi-text/2020-02-18/cl-ansi-text-20200218-git.tgz";
+    sha256 = "1yn657rka3pcg3p5g9czbpk0f0rv81dbq1gknid1b24zg7krks5r";
   };
 
   packageName = "cl-ansi-text";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-async-repl.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-async-repl'';
-  version = ''cl-async-20200610-git'';
+  baseName = "cl-async-repl";
+  version = "cl-async-20200610-git";
 
-  description = ''REPL integration for CL-ASYNC.'';
+  description = "REPL integration for CL-ASYNC.";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-async" args."cl-async-base" args."cl-async-util" args."cl-libuv" args."cl-ppcre" args."fast-io" args."static-vectors" args."trivial-features" args."trivial-gray-streams" args."vom" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-async/2020-06-10/cl-async-20200610-git.tgz'';
-    sha256 = ''10fyd36i5zlnxh69y1l7098b3h94l4hqwl0zhv0nshcs4sa7l37h'';
+    url = "http://beta.quicklisp.org/archive/cl-async/2020-06-10/cl-async-20200610-git.tgz";
+    sha256 = "10fyd36i5zlnxh69y1l7098b3h94l4hqwl0zhv0nshcs4sa7l37h";
   };
 
   packageName = "cl-async-repl";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-async-ssl.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-async-ssl'';
-  version = ''cl-async-20200610-git'';
+  baseName = "cl-async-ssl";
+  version = "cl-async-20200610-git";
 
-  description = ''SSL Wrapper around cl-async socket implementation.'';
+  description = "SSL Wrapper around cl-async socket implementation.";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-async" args."cl-async-base" args."cl-async-util" args."cl-libuv" args."cl-ppcre" args."fast-io" args."static-vectors" args."trivial-features" args."trivial-gray-streams" args."vom" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-async/2020-06-10/cl-async-20200610-git.tgz'';
-    sha256 = ''10fyd36i5zlnxh69y1l7098b3h94l4hqwl0zhv0nshcs4sa7l37h'';
+    url = "http://beta.quicklisp.org/archive/cl-async/2020-06-10/cl-async-20200610-git.tgz";
+    sha256 = "10fyd36i5zlnxh69y1l7098b3h94l4hqwl0zhv0nshcs4sa7l37h";
   };
 
   packageName = "cl-async-ssl";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-async.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-async'';
-  version = ''20200610-git'';
+  baseName = "cl-async";
+  version = "20200610-git";
 
   parasites = [ "cl-async-base" "cl-async-util" ];
 
-  description = ''Asynchronous operations for Common Lisp.'';
+  description = "Asynchronous operations for Common Lisp.";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-libuv" args."cl-ppcre" args."fast-io" args."static-vectors" args."trivial-features" args."trivial-gray-streams" args."uiop" args."vom" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-async/2020-06-10/cl-async-20200610-git.tgz'';
-    sha256 = ''10fyd36i5zlnxh69y1l7098b3h94l4hqwl0zhv0nshcs4sa7l37h'';
+    url = "http://beta.quicklisp.org/archive/cl-async/2020-06-10/cl-async-20200610-git.tgz";
+    sha256 = "10fyd36i5zlnxh69y1l7098b3h94l4hqwl0zhv0nshcs4sa7l37h";
   };
 
   packageName = "cl-async";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-base64.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-base64'';
-  version = ''20201016-git'';
+  baseName = "cl-base64";
+  version = "20201016-git";
 
   parasites = [ "cl-base64/test" ];
 
-  description = ''Base64 encoding and decoding with URI support.'';
+  description = "Base64 encoding and decoding with URI support.";
 
   deps = [ args."kmrcl" args."ptester" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-base64/2020-10-16/cl-base64-20201016-git.tgz'';
-    sha256 = ''1wd2sgvfrivrbzlhs1vgj762jqz7sk171ssli6gl1kfwbnphzx9z'';
+    url = "http://beta.quicklisp.org/archive/cl-base64/2020-10-16/cl-base64-20201016-git.tgz";
+    sha256 = "1wd2sgvfrivrbzlhs1vgj762jqz7sk171ssli6gl1kfwbnphzx9z";
   };
 
   packageName = "cl-base64";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cffi-gtk-cairo.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-cffi-gtk-cairo'';
-  version = ''cl-cffi-gtk-20201016-git'';
+  baseName = "cl-cffi-gtk-cairo";
+  version = "cl-cffi-gtk-20201016-git";
 
-  description = ''A Lisp binding to Cairo'';
+  description = "A Lisp binding to Cairo";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-glib" args."iterate" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz'';
-    sha256 = ''1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55'';
+    url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz";
+    sha256 = "1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55";
   };
 
   packageName = "cl-cffi-gtk-cairo";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cffi-gtk-gdk-pixbuf.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-cffi-gtk-gdk-pixbuf'';
-  version = ''cl-cffi-gtk-20201016-git'';
+  baseName = "cl-cffi-gtk-gdk-pixbuf";
+  version = "cl-cffi-gtk-20201016-git";
 
-  description = ''A Lisp binding to GDK Pixbuf 2'';
+  description = "A Lisp binding to GDK Pixbuf 2";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-glib" args."cl-cffi-gtk-gobject" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz'';
-    sha256 = ''1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55'';
+    url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz";
+    sha256 = "1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55";
   };
 
   packageName = "cl-cffi-gtk-gdk-pixbuf";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cffi-gtk-gdk.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-cffi-gtk-gdk'';
-  version = ''cl-cffi-gtk-20201016-git'';
+  baseName = "cl-cffi-gtk-gdk";
+  version = "cl-cffi-gtk-20201016-git";
 
-  description = ''A Lisp binding to GDK 3'';
+  description = "A Lisp binding to GDK 3";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-cairo" args."cl-cffi-gtk-gdk-pixbuf" args."cl-cffi-gtk-gio" args."cl-cffi-gtk-glib" args."cl-cffi-gtk-gobject" args."cl-cffi-gtk-pango" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz'';
-    sha256 = ''1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55'';
+    url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz";
+    sha256 = "1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55";
   };
 
   packageName = "cl-cffi-gtk-gdk";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cffi-gtk-gio.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-cffi-gtk-gio'';
-  version = ''cl-cffi-gtk-20201016-git'';
+  baseName = "cl-cffi-gtk-gio";
+  version = "cl-cffi-gtk-20201016-git";
 
-  description = ''A Lisp binding to GIO 2'';
+  description = "A Lisp binding to GIO 2";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-glib" args."cl-cffi-gtk-gobject" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz'';
-    sha256 = ''1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55'';
+    url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz";
+    sha256 = "1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55";
   };
 
   packageName = "cl-cffi-gtk-gio";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cffi-gtk-glib.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-cffi-gtk-glib'';
-  version = ''cl-cffi-gtk-20201016-git'';
+  baseName = "cl-cffi-gtk-glib";
+  version = "cl-cffi-gtk-20201016-git";
 
-  description = ''A Lisp binding to GLib 2'';
+  description = "A Lisp binding to GLib 2";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."iterate" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz'';
-    sha256 = ''1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55'';
+    url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz";
+    sha256 = "1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55";
   };
 
   packageName = "cl-cffi-gtk-glib";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cffi-gtk-gobject.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-cffi-gtk-gobject'';
-  version = ''cl-cffi-gtk-20201016-git'';
+  baseName = "cl-cffi-gtk-gobject";
+  version = "cl-cffi-gtk-20201016-git";
 
-  description = ''A Lisp binding GObject 2'';
+  description = "A Lisp binding GObject 2";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-glib" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz'';
-    sha256 = ''1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55'';
+    url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz";
+    sha256 = "1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55";
   };
 
   packageName = "cl-cffi-gtk-gobject";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cffi-gtk-pango.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-cffi-gtk-pango'';
-  version = ''cl-cffi-gtk-20201016-git'';
+  baseName = "cl-cffi-gtk-pango";
+  version = "cl-cffi-gtk-20201016-git";
 
-  description = ''A Lisp binding to Pango'';
+  description = "A Lisp binding to Pango";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-cairo" args."cl-cffi-gtk-glib" args."cl-cffi-gtk-gobject" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz'';
-    sha256 = ''1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55'';
+    url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz";
+    sha256 = "1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55";
   };
 
   packageName = "cl-cffi-gtk-pango";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cffi-gtk.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-cffi-gtk'';
-  version = ''20201016-git'';
+  baseName = "cl-cffi-gtk";
+  version = "20201016-git";
 
-  description = ''A Lisp binding to GTK 3'';
+  description = "A Lisp binding to GTK 3";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk-cairo" args."cl-cffi-gtk-gdk" args."cl-cffi-gtk-gdk-pixbuf" args."cl-cffi-gtk-gio" args."cl-cffi-gtk-glib" args."cl-cffi-gtk-gobject" args."cl-cffi-gtk-pango" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz'';
-    sha256 = ''1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55'';
+    url = "http://beta.quicklisp.org/archive/cl-cffi-gtk/2020-10-16/cl-cffi-gtk-20201016-git.tgz";
+    sha256 = "1m91597nwwrps32awvk57k3h4jjq603ja0kf395n2jxvckfz0a55";
   };
 
   packageName = "cl-cffi-gtk";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-change-case.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-change-case'';
-  version = ''20191007-git'';
+  baseName = "cl-change-case";
+  version = "20191007-git";
 
-  description = ''Convert strings between camelCase, param-case, PascalCase and more'';
+  description = "Convert strings between camelCase, param-case, PascalCase and more";
 
   deps = [ args."cl-ppcre" args."cl-ppcre-unicode" args."cl-unicode" args."flexi-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-change-case/2019-10-07/cl-change-case-20191007-git.tgz'';
-    sha256 = ''097n7bzlsryqh6gbwn3nzi9qdw4jhck4vn3qw41zpc496xfgz9y1'';
+    url = "http://beta.quicklisp.org/archive/cl-change-case/2019-10-07/cl-change-case-20191007-git.tgz";
+    sha256 = "097n7bzlsryqh6gbwn3nzi9qdw4jhck4vn3qw41zpc496xfgz9y1";
   };
 
   packageName = "cl-change-case";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cli.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-cli'';
-  version = ''20151218-git'';
+  baseName = "cl-cli";
+  version = "20151218-git";
 
-  description = ''Command line parser'';
+  description = "Command line parser";
 
   deps = [ args."split-sequence" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-cli/2015-12-18/cl-cli-20151218-git.tgz'';
-    sha256 = ''0d097wjprljghkai1yacvjqmjm1mwpa46yxbacjnwps8pqwh18ay'';
+    url = "http://beta.quicklisp.org/archive/cl-cli/2015-12-18/cl-cli-20151218-git.tgz";
+    sha256 = "0d097wjprljghkai1yacvjqmjm1mwpa46yxbacjnwps8pqwh18ay";
   };
 
   packageName = "cl-cli";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-colors.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-colors'';
-  version = ''20180328-git'';
+  baseName = "cl-colors";
+  version = "20180328-git";
 
   parasites = [ "cl-colors-tests" ];
 
-  description = ''Simple color library for Common Lisp'';
+  description = "Simple color library for Common Lisp";
 
   deps = [ args."alexandria" args."anaphora" args."let-plus" args."lift" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-colors/2018-03-28/cl-colors-20180328-git.tgz'';
-    sha256 = ''0anrb3zsi03dixfsjz92y06w93kpn0d0c5142fhx72f5kafwvc4a'';
+    url = "http://beta.quicklisp.org/archive/cl-colors/2018-03-28/cl-colors-20180328-git.tgz";
+    sha256 = "0anrb3zsi03dixfsjz92y06w93kpn0d0c5142fhx72f5kafwvc4a";
   };
 
   packageName = "cl-colors";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-colors2.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-colors2'';
-  version = ''20200218-git'';
+  baseName = "cl-colors2";
+  version = "20200218-git";
 
   parasites = [ "cl-colors2/tests" ];
 
-  description = ''Simple color library for Common Lisp'';
+  description = "Simple color library for Common Lisp";
 
   deps = [ args."alexandria" args."cl-ppcre" args."clunit2" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-colors2/2020-02-18/cl-colors2-20200218-git.tgz'';
-    sha256 = ''0rpf8j232qv254zhkvkz3ja20al1kswvcqhvvv0r2ag6dks56j29'';
+    url = "http://beta.quicklisp.org/archive/cl-colors2/2020-02-18/cl-colors2-20200218-git.tgz";
+    sha256 = "0rpf8j232qv254zhkvkz3ja20al1kswvcqhvvv0r2ag6dks56j29";
   };
 
   packageName = "cl-colors2";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-containers.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-containers'';
-  version = ''20200427-git'';
+  baseName = "cl-containers";
+  version = "20200427-git";
 
   parasites = [ "cl-containers/with-moptilities" "cl-containers/with-utilities" ];
 
-  description = ''A generic container library for Common Lisp'';
+  description = "A generic container library for Common Lisp";
 
   deps = [ args."asdf-system-connections" args."metatilities-base" args."moptilities" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-containers/2020-04-27/cl-containers-20200427-git.tgz'';
-    sha256 = ''0llaymnlss0dhwyqgr2s38w1hjb2as1x1nn57qcvdphnm7qs50fy'';
+    url = "http://beta.quicklisp.org/archive/cl-containers/2020-04-27/cl-containers-20200427-git.tgz";
+    sha256 = "0llaymnlss0dhwyqgr2s38w1hjb2as1x1nn57qcvdphnm7qs50fy";
   };
 
   packageName = "cl-containers";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-cookie.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-cookie'';
-  version = ''20191007-git'';
+  baseName = "cl-cookie";
+  version = "20191007-git";
 
-  description = ''HTTP cookie manager'';
+  description = "HTTP cookie manager";
 
   deps = [ args."alexandria" args."babel" args."cl-ppcre" args."cl-utilities" args."local-time" args."proc-parse" args."quri" args."split-sequence" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-cookie/2019-10-07/cl-cookie-20191007-git.tgz'';
-    sha256 = ''1xcb69n3qfp37nwj0mj2whf3yj5xfsgh9sdw6c64gxqkiiq9nfhh'';
+    url = "http://beta.quicklisp.org/archive/cl-cookie/2019-10-07/cl-cookie-20191007-git.tgz";
+    sha256 = "1xcb69n3qfp37nwj0mj2whf3yj5xfsgh9sdw6c64gxqkiiq9nfhh";
   };
 
   packageName = "cl-cookie";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-css.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-css'';
-  version = ''20140914-git'';
+  baseName = "cl-css";
+  version = "20140914-git";
 
-  description = ''Simple inline CSS generator'';
+  description = "Simple inline CSS generator";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-css/2014-09-14/cl-css-20140914-git.tgz'';
-    sha256 = ''16zjm10qqyv5v0ysvicbiscplrwlfr0assbf01gp73j1m108rn7n'';
+    url = "http://beta.quicklisp.org/archive/cl-css/2014-09-14/cl-css-20140914-git.tgz";
+    sha256 = "16zjm10qqyv5v0ysvicbiscplrwlfr0assbf01gp73j1m108rn7n";
   };
 
   packageName = "cl-css";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-csv.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-csv'';
-  version = ''20201016-git'';
+  baseName = "cl-csv";
+  version = "20201016-git";
 
   parasites = [ "cl-csv/speed-test" "cl-csv/test" ];
 
-  description = ''Facilities for reading and writing CSV format files'';
+  description = "Facilities for reading and writing CSV format files";
 
   deps = [ args."alexandria" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."flexi-streams" args."iterate" args."lisp-unit2" args."named-readtables" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-csv/2020-10-16/cl-csv-20201016-git.tgz'';
-    sha256 = ''1w12ads26v5sgcmy6rjm6ys9lml7l6rz86w776s2an2maci9kzmf'';
+    url = "http://beta.quicklisp.org/archive/cl-csv/2020-10-16/cl-csv-20201016-git.tgz";
+    sha256 = "1w12ads26v5sgcmy6rjm6ys9lml7l6rz86w776s2an2maci9kzmf";
   };
 
   packageName = "cl-csv";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-dbi.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-dbi'';
-  version = ''20200610-git'';
+  baseName = "cl-dbi";
+  version = "20200610-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."closer-mop" args."dbi" args."split-sequence" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz'';
-    sha256 = ''1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas'';
+    url = "http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz";
+    sha256 = "1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas";
   };
 
   packageName = "cl-dbi";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-dot.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-dot'';
-  version = ''20200925-git'';
+  baseName = "cl-dot";
+  version = "20200925-git";
 
-  description = ''Generate Dot Output from Arbitrary Lisp Data'';
+  description = "Generate Dot Output from Arbitrary Lisp Data";
 
   deps = [ args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-dot/2020-09-25/cl-dot-20200925-git.tgz'';
-    sha256 = ''01vx4yzasmgswrlyagjr2cz76g906jsijdwikdf8wvxyyq77gkla'';
+    url = "http://beta.quicklisp.org/archive/cl-dot/2020-09-25/cl-dot-20200925-git.tgz";
+    sha256 = "01vx4yzasmgswrlyagjr2cz76g906jsijdwikdf8wvxyyq77gkla";
   };
 
   packageName = "cl-dot";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-emb.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-emb'';
-  version = ''20190521-git'';
+  baseName = "cl-emb";
+  version = "20190521-git";
 
-  description = ''A templating system for Common Lisp'';
+  description = "A templating system for Common Lisp";
 
   deps = [ args."cl-ppcre" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-emb/2019-05-21/cl-emb-20190521-git.tgz'';
-    sha256 = ''1d6bi2mx1kw7an3maxjp4ldrhkwfdb58va9whxblz2xjlbykdv8d'';
+    url = "http://beta.quicklisp.org/archive/cl-emb/2019-05-21/cl-emb-20190521-git.tgz";
+    sha256 = "1d6bi2mx1kw7an3maxjp4ldrhkwfdb58va9whxblz2xjlbykdv8d";
   };
 
   packageName = "cl-emb";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-fad.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-fad'';
-  version = ''20200610-git'';
+  baseName = "cl-fad";
+  version = "20200610-git";
 
   parasites = [ "cl-fad-test" ];
 
-  description = ''Portable pathname library'';
+  description = "Portable pathname library";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."cl-ppcre" args."unit-test" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-fad/2020-06-10/cl-fad-20200610-git.tgz'';
-    sha256 = ''08d0q2jpjz4djz20w8m86rfkili8g0vdbkkmvn8c88qmvcr79k5x'';
+    url = "http://beta.quicklisp.org/archive/cl-fad/2020-06-10/cl-fad-20200610-git.tgz";
+    sha256 = "08d0q2jpjz4djz20w8m86rfkili8g0vdbkkmvn8c88qmvcr79k5x";
   };
 
   packageName = "cl-fad";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-fuse-meta-fs.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-fuse-meta-fs'';
-  version = ''20190710-git'';
+  baseName = "cl-fuse-meta-fs";
+  version = "20190710-git";
 
-  description = ''CFFI bindings to FUSE (Filesystem in user space)'';
+  description = "CFFI bindings to FUSE (Filesystem in user space)";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-fuse" args."cl-utilities" args."iterate" args."pcall" args."pcall-queue" args."trivial-backtrace" args."trivial-features" args."trivial-utf-8" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-fuse-meta-fs/2019-07-10/cl-fuse-meta-fs-20190710-git.tgz'';
-    sha256 = ''1c2nyxj7q8njxydn4xiagvnb21zhb1l07q7nhfw0qs2qk6dkasq7'';
+    url = "http://beta.quicklisp.org/archive/cl-fuse-meta-fs/2019-07-10/cl-fuse-meta-fs-20190710-git.tgz";
+    sha256 = "1c2nyxj7q8njxydn4xiagvnb21zhb1l07q7nhfw0qs2qk6dkasq7";
   };
 
   packageName = "cl-fuse-meta-fs";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-fuse.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-fuse'';
-  version = ''20200925-git'';
+  baseName = "cl-fuse";
+  version = "20200925-git";
 
-  description = ''CFFI bindings to FUSE (Filesystem in user space)'';
+  description = "CFFI bindings to FUSE (Filesystem in user space)";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-utilities" args."iterate" args."trivial-backtrace" args."trivial-features" args."trivial-utf-8" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-fuse/2020-09-25/cl-fuse-20200925-git.tgz'';
-    sha256 = ''1c5cn0l0md77asw804qssylcbbphw81mfpbijydd0s25q6xga7dp'';
+    url = "http://beta.quicklisp.org/archive/cl-fuse/2020-09-25/cl-fuse-20200925-git.tgz";
+    sha256 = "1c5cn0l0md77asw804qssylcbbphw81mfpbijydd0s25q6xga7dp";
   };
 
   packageName = "cl-fuse";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-hooks.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-hooks'';
-  version = ''architecture.hooks-20181210-git'';
+  baseName = "cl-hooks";
+  version = "architecture.hooks-20181210-git";
 
   parasites = [ "cl-hooks/test" ];
 
···
   deps = [ args."alexandria" args."anaphora" args."closer-mop" args."fiveam" args."let-plus" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/architecture.hooks/2018-12-10/architecture.hooks-20181210-git.tgz'';
-    sha256 = ''04l8rjmgsd7i580rpm1wndz1jcvfqrmwllnkh3h7als3azi3q2ns'';
+    url = "http://beta.quicklisp.org/archive/architecture.hooks/2018-12-10/architecture.hooks-20181210-git.tgz";
+    sha256 = "04l8rjmgsd7i580rpm1wndz1jcvfqrmwllnkh3h7als3azi3q2ns";
   };
 
   packageName = "cl-hooks";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-html-parse.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-html-parse'';
-  version = ''20200925-git'';
+  baseName = "cl-html-parse";
+  version = "20200925-git";
 
-  description = ''HTML Parser'';
+  description = "HTML Parser";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-html-parse/2020-09-25/cl-html-parse-20200925-git.tgz'';
-    sha256 = ''14pfd4gwjb8ywr79dqrcznw6h8a1il3g5b6cm5x9aiyr49zdv15f'';
+    url = "http://beta.quicklisp.org/archive/cl-html-parse/2020-09-25/cl-html-parse-20200925-git.tgz";
+    sha256 = "14pfd4gwjb8ywr79dqrcznw6h8a1il3g5b6cm5x9aiyr49zdv15f";
   };
 
   packageName = "cl-html-parse";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-html5-parser.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-html5-parser'';
-  version = ''20190521-git'';
+  baseName = "cl-html5-parser";
+  version = "20190521-git";
 
-  description = ''A HTML5 parser for Common Lisp'';
+  description = "A HTML5 parser for Common Lisp";
 
   deps = [ args."cl-ppcre" args."flexi-streams" args."string-case" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-html5-parser/2019-05-21/cl-html5-parser-20190521-git.tgz'';
-    sha256 = ''055jz0yqgjncvy2dxvnwg4iwdvmfsvkch46v58nymz5gi8gaaz7p'';
+    url = "http://beta.quicklisp.org/archive/cl-html5-parser/2019-05-21/cl-html5-parser-20190521-git.tgz";
+    sha256 = "055jz0yqgjncvy2dxvnwg4iwdvmfsvkch46v58nymz5gi8gaaz7p";
   };
 
   packageName = "cl-html5-parser";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-interpol.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-interpol'';
-  version = ''20200715-git'';
+  baseName = "cl-interpol";
+  version = "20200715-git";
 
   parasites = [ "cl-interpol-test" ];
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."cl-ppcre" args."cl-unicode" args."flexi-streams" args."named-readtables" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-interpol/2020-07-15/cl-interpol-20200715-git.tgz'';
-    sha256 = ''0qbmpgnlg9y6ykwahmw1q8b058krmcq47w3gx75xz920im46wvmw'';
+    url = "http://beta.quicklisp.org/archive/cl-interpol/2020-07-15/cl-interpol-20200715-git.tgz";
+    sha256 = "0qbmpgnlg9y6ykwahmw1q8b058krmcq47w3gx75xz920im46wvmw";
   };
 
   packageName = "cl-interpol";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-jpeg.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-jpeg'';
-  version = ''20170630-git'';
+  baseName = "cl-jpeg";
+  version = "20170630-git";
 
-  description = ''A self-contained baseline JPEG codec implementation'';
+  description = "A self-contained baseline JPEG codec implementation";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-jpeg/2017-06-30/cl-jpeg-20170630-git.tgz'';
-    sha256 = ''1wwzn2valhh5ka7qkmab59pb1ijagcj296553fp8z03migl0sil0'';
+    url = "http://beta.quicklisp.org/archive/cl-jpeg/2017-06-30/cl-jpeg-20170630-git.tgz";
+    sha256 = "1wwzn2valhh5ka7qkmab59pb1ijagcj296553fp8z03migl0sil0";
   };
 
   packageName = "cl-jpeg";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-json.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-json'';
-  version = ''20141217-git'';
+  baseName = "cl-json";
+  version = "20141217-git";
 
   parasites = [ "cl-json.test" ];
 
-  description = ''JSON in Lisp. JSON (JavaScript Object Notation) is a lightweight data-interchange format.'';
+  description = "JSON in Lisp. JSON (JavaScript Object Notation) is a lightweight data-interchange format.";
 
   deps = [ args."fiveam" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-json/2014-12-17/cl-json-20141217-git.tgz'';
-    sha256 = ''00cfppyi6njsbpv1x03jcv4zwplg0q1138174l3wjkvi3gsql17g'';
+    url = "http://beta.quicklisp.org/archive/cl-json/2014-12-17/cl-json-20141217-git.tgz";
+    sha256 = "00cfppyi6njsbpv1x03jcv4zwplg0q1138174l3wjkvi3gsql17g";
   };
 
   packageName = "cl-json";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-l10n-cldr.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-l10n-cldr'';
-  version = ''20120909-darcs'';
+  baseName = "cl-l10n-cldr";
+  version = "20120909-darcs";
 
-  description = ''The necessary CLDR files for cl-l10n packaged in a QuickLisp friendly way.'';
+  description = "The necessary CLDR files for cl-l10n packaged in a QuickLisp friendly way.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-l10n-cldr/2012-09-09/cl-l10n-cldr-20120909-darcs.tgz'';
-    sha256 = ''03l81bx8izvzwzw0qah34l4k47l4gmhr917phhhl81qp55x7zbiv'';
+    url = "http://beta.quicklisp.org/archive/cl-l10n-cldr/2012-09-09/cl-l10n-cldr-20120909-darcs.tgz";
+    sha256 = "03l81bx8izvzwzw0qah34l4k47l4gmhr917phhhl81qp55x7zbiv";
   };
 
   packageName = "cl-l10n-cldr";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-l10n.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-l10n'';
-  version = ''20161204-darcs'';
+  baseName = "cl-l10n";
+  version = "20161204-darcs";
 
   parasites = [ "cl-l10n/test" ];
 
-  description = ''Portable CL Locale Support'';
+  description = "Portable CL Locale Support";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cl-fad" args."cl-l10n-cldr" args."cl-ppcre" args."closer-mop" args."closure-common" args."cxml" args."flexi-streams" args."hu_dot_dwim_dot_stefil" args."iterate" args."local-time" args."metabang-bind" args."parse-number" args."puri" args."trivial-features" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-l10n/2016-12-04/cl-l10n-20161204-darcs.tgz'';
-    sha256 = ''1r8jgwks21az78c5kdxgw5llk9ml423vjkv1f93qg1vx3zma6vzl'';
+    url = "http://beta.quicklisp.org/archive/cl-l10n/2016-12-04/cl-l10n-20161204-darcs.tgz";
+    sha256 = "1r8jgwks21az78c5kdxgw5llk9ml423vjkv1f93qg1vx3zma6vzl";
   };
 
   packageName = "cl-l10n";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-libuv.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-libuv'';
-  version = ''20200610-git'';
+  baseName = "cl-libuv";
+  version = "20200610-git";
 
-  description = ''Low-level libuv bindings for Common Lisp.'';
+  description = "Low-level libuv bindings for Common Lisp.";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-libuv/2020-06-10/cl-libuv-20200610-git.tgz'';
-    sha256 = ''1ywk1z1ibyk3z0irg5azjrjk3x08ixv30fx4qa0p500fmbfhha19'';
+    url = "http://beta.quicklisp.org/archive/cl-libuv/2020-06-10/cl-libuv-20200610-git.tgz";
+    sha256 = "1ywk1z1ibyk3z0irg5azjrjk3x08ixv30fx4qa0p500fmbfhha19";
   };
 
   packageName = "cl-libuv";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-locale.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-locale'';
-  version = ''20151031-git'';
+  baseName = "cl-locale";
+  version = "20151031-git";
 
-  description = ''Simple i18n library for Common Lisp'';
+  description = "Simple i18n library for Common Lisp";
 
   deps = [ args."alexandria" args."anaphora" args."arnesi" args."cl-annot" args."cl-syntax" args."cl-syntax-annot" args."closer-mop" args."collectors" args."iterate" args."named-readtables" args."symbol-munger" args."trivial-types" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-locale/2015-10-31/cl-locale-20151031-git.tgz'';
-    sha256 = ''14j4xazrx2v5cj4q4irfwra0ksvl2l0s7073fimpwc0xqjfsnjpg'';
+    url = "http://beta.quicklisp.org/archive/cl-locale/2015-10-31/cl-locale-20151031-git.tgz";
+    sha256 = "14j4xazrx2v5cj4q4irfwra0ksvl2l0s7073fimpwc0xqjfsnjpg";
   };
 
   packageName = "cl-locale";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-markup.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-markup'';
-  version = ''20131003-git'';
+  baseName = "cl-markup";
+  version = "20131003-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-markup/2013-10-03/cl-markup-20131003-git.tgz'';
-    sha256 = ''1ik3a5k6axq941zbf6zyig553i5gnypbcxdq9l7bfxp8w18vbj0r'';
+    url = "http://beta.quicklisp.org/archive/cl-markup/2013-10-03/cl-markup-20131003-git.tgz";
+    sha256 = "1ik3a5k6axq941zbf6zyig553i5gnypbcxdq9l7bfxp8w18vbj0r";
   };
 
   packageName = "cl-markup";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-mysql.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-mysql'';
-  version = ''20200610-git'';
+  baseName = "cl-mysql";
+  version = "20200610-git";
 
-  description = ''Common Lisp MySQL library bindings'';
+  description = "Common Lisp MySQL library bindings";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-mysql/2020-06-10/cl-mysql-20200610-git.tgz'';
-    sha256 = ''0fzyqzz01zn9fy8v766lib3dghg9yq5wawa0hcmxslms7knzxz7w'';
+    url = "http://beta.quicklisp.org/archive/cl-mysql/2020-06-10/cl-mysql-20200610-git.tgz";
+    sha256 = "0fzyqzz01zn9fy8v766lib3dghg9yq5wawa0hcmxslms7knzxz7w";
   };
 
   packageName = "cl-mysql";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-paths-ttf.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-paths-ttf'';
-  version = ''cl-vectors-20180228-git'';
+  baseName = "cl-paths-ttf";
+  version = "cl-vectors-20180228-git";
 
-  description = ''cl-paths-ttf: vectorial paths manipulation'';
+  description = "cl-paths-ttf: vectorial paths manipulation";
 
   deps = [ args."cl-paths" args."zpb-ttf" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz'';
-    sha256 = ''0fcypjfzqra8ryb4nx1vx1fqy7fwvyz3f443qkjg2z81akhkscly'';
+    url = "http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz";
+    sha256 = "0fcypjfzqra8ryb4nx1vx1fqy7fwvyz3f443qkjg2z81akhkscly";
   };
 
   packageName = "cl-paths-ttf";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-paths.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-paths'';
-  version = ''cl-vectors-20180228-git'';
+  baseName = "cl-paths";
+  version = "cl-vectors-20180228-git";
 
-  description = ''cl-paths: vectorial paths manipulation'';
+  description = "cl-paths: vectorial paths manipulation";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz'';
-    sha256 = ''0fcypjfzqra8ryb4nx1vx1fqy7fwvyz3f443qkjg2z81akhkscly'';
+    url = "http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz";
+    sha256 = "0fcypjfzqra8ryb4nx1vx1fqy7fwvyz3f443qkjg2z81akhkscly";
   };
 
   packageName = "cl-paths";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-pdf.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-pdf'';
-  version = ''20191007-git'';
+  baseName = "cl-pdf";
+  version = "20191007-git";
 
-  description = ''Common Lisp PDF Generation Library'';
+  description = "Common Lisp PDF Generation Library";
 
   deps = [ args."iterate" args."uiop" args."zpb-ttf" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-pdf/2019-10-07/cl-pdf-20191007-git.tgz'';
-    sha256 = ''0l0hnxysy7dc4wj50nfwn8x7v188vaxvsvk8kl92zb92lfzgw7cd'';
+    url = "http://beta.quicklisp.org/archive/cl-pdf/2019-10-07/cl-pdf-20191007-git.tgz";
+    sha256 = "0l0hnxysy7dc4wj50nfwn8x7v188vaxvsvk8kl92zb92lfzgw7cd";
   };
 
   packageName = "cl-pdf";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-postgres.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-postgres'';
-  version = ''postmodern-20201016-git'';
+  baseName = "cl-postgres";
+  version = "postmodern-20201016-git";
 
   parasites = [ "cl-postgres/simple-date-tests" "cl-postgres/tests" ];
 
-  description = ''Low-level client library for PostgreSQL'';
+  description = "Low-level client library for PostgreSQL";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."cl-base64" args."cl-ppcre" args."fiveam" args."ironclad" args."md5" args."simple-date" args."simple-date_slash_postgres-glue" args."split-sequence" args."uax-15" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/postmodern/2020-10-16/postmodern-20201016-git.tgz'';
-    sha256 = ''1svaiksbqcaq8sh7q6sj9kzazdfl360zqr2nzhwbgy4xnaj4vf3n'';
+    url = "http://beta.quicklisp.org/archive/postmodern/2020-10-16/postmodern-20201016-git.tgz";
+    sha256 = "1svaiksbqcaq8sh7q6sj9kzazdfl360zqr2nzhwbgy4xnaj4vf3n";
   };
 
   packageName = "cl-postgres";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-ppcre-template.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-ppcre-template'';
-  version = ''cl-unification-20200925-git'';
+  baseName = "cl-ppcre-template";
+  version = "cl-unification-20200925-git";
 
   description = ''A system used to conditionally load the CL-PPCRE Template.
 
···
   deps = [ args."cl-ppcre" args."cl-unification" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-unification/2020-09-25/cl-unification-20200925-git.tgz'';
-    sha256 = ''05i1bmbabfgym9v28cbl37yr0r1m4a4k4a844z6wlq6qf45vzais'';
+    url = "http://beta.quicklisp.org/archive/cl-unification/2020-09-25/cl-unification-20200925-git.tgz";
+    sha256 = "05i1bmbabfgym9v28cbl37yr0r1m4a4k4a844z6wlq6qf45vzais";
   };
 
   packageName = "cl-ppcre-template";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-ppcre-unicode.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-ppcre-unicode'';
-  version = ''cl-ppcre-20190521-git'';
+  baseName = "cl-ppcre-unicode";
+  version = "cl-ppcre-20190521-git";
 
   parasites = [ "cl-ppcre-unicode-test" ];
 
-  description = ''Perl-compatible regular expression library (Unicode)'';
+  description = "Perl-compatible regular expression library (Unicode)";
 
   deps = [ args."cl-ppcre" args."cl-ppcre-test" args."cl-unicode" args."flexi-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-ppcre/2019-05-21/cl-ppcre-20190521-git.tgz'';
-    sha256 = ''0p6jcvf9afnsg80a1zqsp7fyz0lf1fxzbin7rs9bl4i6jvm0hjqx'';
+    url = "http://beta.quicklisp.org/archive/cl-ppcre/2019-05-21/cl-ppcre-20190521-git.tgz";
+    sha256 = "0p6jcvf9afnsg80a1zqsp7fyz0lf1fxzbin7rs9bl4i6jvm0hjqx";
   };
 
   packageName = "cl-ppcre-unicode";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-ppcre.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-ppcre'';
-  version = ''20190521-git'';
+  baseName = "cl-ppcre";
+  version = "20190521-git";
 
   parasites = [ "cl-ppcre-test" ];
 
-  description = ''Perl-compatible regular expression library'';
+  description = "Perl-compatible regular expression library";
 
   deps = [ args."flexi-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-ppcre/2019-05-21/cl-ppcre-20190521-git.tgz'';
-    sha256 = ''0p6jcvf9afnsg80a1zqsp7fyz0lf1fxzbin7rs9bl4i6jvm0hjqx'';
+    url = "http://beta.quicklisp.org/archive/cl-ppcre/2019-05-21/cl-ppcre-20190521-git.tgz";
+    sha256 = "0p6jcvf9afnsg80a1zqsp7fyz0lf1fxzbin7rs9bl4i6jvm0hjqx";
   };
 
   packageName = "cl-ppcre";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-prevalence.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-prevalence'';
-  version = ''20200715-git'';
+  baseName = "cl-prevalence";
+  version = "20200715-git";
 
-  description = ''Common Lisp Prevalence Package'';
+  description = "Common Lisp Prevalence Package";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."s-sysdeps" args."s-xml" args."split-sequence" args."usocket" args."usocket-server" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-prevalence/2020-07-15/cl-prevalence-20200715-git.tgz'';
-    sha256 = ''1m2wrqnly9i35kjk2wydwywjmwkbh3a3f4ds7wl63q8kpn8g0ibd'';
+    url = "http://beta.quicklisp.org/archive/cl-prevalence/2020-07-15/cl-prevalence-20200715-git.tgz";
+    sha256 = "1m2wrqnly9i35kjk2wydwywjmwkbh3a3f4ds7wl63q8kpn8g0ibd";
   };
 
   packageName = "cl-prevalence";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-project.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-project'';
-  version = ''20200715-git'';
+  baseName = "cl-project";
+  version = "20200715-git";
 
-  description = ''Generate a skeleton for modern project'';
+  description = "Generate a skeleton for modern project";
 
   deps = [ args."alexandria" args."anaphora" args."cl-ansi-text" args."cl-colors" args."cl-colors2" args."cl-emb" args."cl-ppcre" args."let-plus" args."local-time" args."prove" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-project/2020-07-15/cl-project-20200715-git.tgz'';
-    sha256 = ''044rx97wc839a8q2wv271s07bnsasl6x5fx4gr5pvy34jbrhp306'';
+    url = "http://beta.quicklisp.org/archive/cl-project/2020-07-15/cl-project-20200715-git.tgz";
+    sha256 = "044rx97wc839a8q2wv271s07bnsasl6x5fx4gr5pvy34jbrhp306";
   };
 
   packageName = "cl-project";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-protobufs.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-protobufs'';
-  version = ''20200325-git'';
+  baseName = "cl-protobufs";
+  version = "20200325-git";
 
-  description = ''Protobufs for Common Lisp'';
+  description = "Protobufs for Common Lisp";
 
   deps = [ args."alexandria" args."babel" args."closer-mop" args."trivial-features" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-protobufs/2020-03-25/cl-protobufs-20200325-git.tgz'';
-    sha256 = ''1sgvp038bvd3mq2f0xh4wawf8h21jmw449yjyahidh1zfqdibpin'';
+    url = "http://beta.quicklisp.org/archive/cl-protobufs/2020-03-25/cl-protobufs-20200325-git.tgz";
+    sha256 = "1sgvp038bvd3mq2f0xh4wawf8h21jmw449yjyahidh1zfqdibpin";
   };
 
   packageName = "cl-protobufs";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-qprint.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-qprint'';
-  version = ''20150804-git'';
+  baseName = "cl-qprint";
+  version = "20150804-git";
 
-  description = ''Encode and decode quoted-printable encoded strings.'';
+  description = "Encode and decode quoted-printable encoded strings.";
 
   deps = [ args."flexi-streams" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-qprint/2015-08-04/cl-qprint-20150804-git.tgz'';
-    sha256 = ''042nq9airkc4yaqzpmly5iszmkbwfn38wsgi9k361ldf1y54lq28'';
+    url = "http://beta.quicklisp.org/archive/cl-qprint/2015-08-04/cl-qprint-20150804-git.tgz";
+    sha256 = "042nq9airkc4yaqzpmly5iszmkbwfn38wsgi9k361ldf1y54lq28";
   };
 
   packageName = "cl-qprint";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-reexport.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-reexport'';
-  version = ''20150709-git'';
+  baseName = "cl-reexport";
+  version = "20150709-git";
 
-  description = ''Reexport external symbols in other packages.'';
+  description = "Reexport external symbols in other packages.";
 
   deps = [ args."alexandria" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-reexport/2015-07-09/cl-reexport-20150709-git.tgz'';
-    sha256 = ''1y6qlyps7g0wl4rbmzvw6s1kjdwwmh33layyjclsjp9j5nm8mdmi'';
+    url = "http://beta.quicklisp.org/archive/cl-reexport/2015-07-09/cl-reexport-20150709-git.tgz";
+    sha256 = "1y6qlyps7g0wl4rbmzvw6s1kjdwwmh33layyjclsjp9j5nm8mdmi";
   };
 
   packageName = "cl-reexport";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-slice.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-slice'';
-  version = ''20171130-git'';
+  baseName = "cl-slice";
+  version = "20171130-git";
 
   parasites = [ "cl-slice-tests" ];
 
-  description = ''DSL for array slices in Common Lisp.'';
+  description = "DSL for array slices in Common Lisp.";
 
   deps = [ args."alexandria" args."anaphora" args."clunit" args."let-plus" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-slice/2017-11-30/cl-slice-20171130-git.tgz'';
-    sha256 = ''0nay95qsnck40kdxjgjdii5rcgrdhf880pg9ajmbxilgw84xb2zn'';
+    url = "http://beta.quicklisp.org/archive/cl-slice/2017-11-30/cl-slice-20171130-git.tgz";
+    sha256 = "0nay95qsnck40kdxjgjdii5rcgrdhf880pg9ajmbxilgw84xb2zn";
   };
 
   packageName = "cl-slice";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-smtp.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-smtp'';
-  version = ''20191130-git'';
+  baseName = "cl-smtp";
+  version = "20191130-git";
 
-  description = ''Common Lisp smtp client.'';
+  description = "Common Lisp smtp client.";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl_plus_ssl" args."cl-base64" args."flexi-streams" args."split-sequence" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-smtp/2019-11-30/cl-smtp-20191130-git.tgz'';
-    sha256 = ''04x1xq1qlsnhl4wdi82l8ds6rl9rzxk72bjf2ja10jay1p6ljvdq'';
+    url = "http://beta.quicklisp.org/archive/cl-smtp/2019-11-30/cl-smtp-20191130-git.tgz";
+    sha256 = "04x1xq1qlsnhl4wdi82l8ds6rl9rzxk72bjf2ja10jay1p6ljvdq";
   };
 
   packageName = "cl-smtp";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-store.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-store'';
-  version = ''20200925-git'';
+  baseName = "cl-store";
+  version = "20200925-git";
 
   parasites = [ "cl-store-tests" ];
 
-  description = ''Serialization package'';
+  description = "Serialization package";
 
   deps = [ args."rt" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-store/2020-09-25/cl-store-20200925-git.tgz'';
-    sha256 = ''0vqlrci1634jgfg6c1dzwvx58qjjwbcbwdbpm7xxw2s823xl9jf3'';
+    url = "http://beta.quicklisp.org/archive/cl-store/2020-09-25/cl-store-20200925-git.tgz";
+    sha256 = "0vqlrci1634jgfg6c1dzwvx58qjjwbcbwdbpm7xxw2s823xl9jf3";
   };
 
   packageName = "cl-store";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-syntax-annot.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-syntax-annot'';
-  version = ''cl-syntax-20150407-git'';
+  baseName = "cl-syntax-annot";
+  version = "cl-syntax-20150407-git";
 
-  description = ''CL-Syntax Reader Syntax for cl-annot'';
+  description = "CL-Syntax Reader Syntax for cl-annot";
 
   deps = [ args."alexandria" args."cl-annot" args."cl-syntax" args."named-readtables" args."trivial-types" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz'';
-    sha256 = ''1pz9a7hiql493ax5qgs9zb3bmvf0nnmmgdx14s4j2apdy2m34v8n'';
+    url = "http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz";
+    sha256 = "1pz9a7hiql493ax5qgs9zb3bmvf0nnmmgdx14s4j2apdy2m34v8n";
   };
 
   packageName = "cl-syntax-annot";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-syntax-anonfun.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-syntax-anonfun'';
-  version = ''cl-syntax-20150407-git'';
+  baseName = "cl-syntax-anonfun";
+  version = "cl-syntax-20150407-git";
 
-  description = ''CL-Syntax Reader Syntax for cl-anonfun'';
+  description = "CL-Syntax Reader Syntax for cl-anonfun";
 
   deps = [ args."cl-anonfun" args."cl-syntax" args."named-readtables" args."trivial-types" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz'';
-    sha256 = ''1pz9a7hiql493ax5qgs9zb3bmvf0nnmmgdx14s4j2apdy2m34v8n'';
+    url = "http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz";
+    sha256 = "1pz9a7hiql493ax5qgs9zb3bmvf0nnmmgdx14s4j2apdy2m34v8n";
   };
 
   packageName = "cl-syntax-anonfun";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-syntax-markup.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-syntax-markup'';
-  version = ''cl-syntax-20150407-git'';
+  baseName = "cl-syntax-markup";
+  version = "cl-syntax-20150407-git";
 
-  description = ''CL-Syntax Reader Syntax for CL-Markup'';
+  description = "CL-Syntax Reader Syntax for CL-Markup";
 
   deps = [ args."cl-markup" args."cl-syntax" args."named-readtables" args."trivial-types" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz'';
-    sha256 = ''1pz9a7hiql493ax5qgs9zb3bmvf0nnmmgdx14s4j2apdy2m34v8n'';
+    url = "http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz";
+    sha256 = "1pz9a7hiql493ax5qgs9zb3bmvf0nnmmgdx14s4j2apdy2m34v8n";
   };
 
   packageName = "cl-syntax-markup";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-syntax.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-syntax'';
-  version = ''20150407-git'';
+  baseName = "cl-syntax";
+  version = "20150407-git";
 
-  description = ''Reader Syntax Coventions for Common Lisp and SLIME'';
+  description = "Reader Syntax Coventions for Common Lisp and SLIME";
 
   deps = [ args."named-readtables" args."trivial-types" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz'';
-    sha256 = ''1pz9a7hiql493ax5qgs9zb3bmvf0nnmmgdx14s4j2apdy2m34v8n'';
+    url = "http://beta.quicklisp.org/archive/cl-syntax/2015-04-07/cl-syntax-20150407-git.tgz";
+    sha256 = "1pz9a7hiql493ax5qgs9zb3bmvf0nnmmgdx14s4j2apdy2m34v8n";
   };
 
   packageName = "cl-syntax";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-test-more.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-test-more'';
-  version = ''prove-20200218-git'';
+  baseName = "cl-test-more";
+  version = "prove-20200218-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."anaphora" args."cl-ansi-text" args."cl-colors" args."cl-colors2" args."cl-ppcre" args."let-plus" args."prove" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/prove/2020-02-18/prove-20200218-git.tgz'';
-    sha256 = ''1sv3zyam9sdmyis5lyv0khvw82q7bcpsycpj9b3bsv9isb4j30zn'';
+    url = "http://beta.quicklisp.org/archive/prove/2020-02-18/prove-20200218-git.tgz";
+    sha256 = "1sv3zyam9sdmyis5lyv0khvw82q7bcpsycpj9b3bsv9isb4j30zn";
   };
 
   packageName = "cl-test-more";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-typesetting.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-typesetting'';
-  version = ''20170830-git'';
+  baseName = "cl-typesetting";
+  version = "20170830-git";
 
-  description = ''Common Lisp Typesetting system'';
+  description = "Common Lisp Typesetting system";
 
   deps = [ args."cl-pdf" args."iterate" args."zpb-ttf" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-typesetting/2017-08-30/cl-typesetting-20170830-git.tgz'';
-    sha256 = ''1mkdr02qikzij3jiyrqy0dldzy8wsnvgcpznfha6x8p2xap586z3'';
+    url = "http://beta.quicklisp.org/archive/cl-typesetting/2017-08-30/cl-typesetting-20170830-git.tgz";
+    sha256 = "1mkdr02qikzij3jiyrqy0dldzy8wsnvgcpznfha6x8p2xap586z3";
   };
 
   packageName = "cl-typesetting";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-unicode.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-unicode'';
-  version = ''20190521-git'';
+  baseName = "cl-unicode";
+  version = "20190521-git";
 
   parasites = [ "cl-unicode/base" "cl-unicode/build" "cl-unicode/test" ];
 
-  description = ''Portable Unicode Library'';
+  description = "Portable Unicode Library";
 
   deps = [ args."cl-ppcre" args."flexi-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-unicode/2019-05-21/cl-unicode-20190521-git.tgz'';
-    sha256 = ''0p20yrqbn3fwsnrxvh2cv0m86mh3mz9vj15m7siw1kjkbzq0vngc'';
+    url = "http://beta.quicklisp.org/archive/cl-unicode/2019-05-21/cl-unicode-20190521-git.tgz";
+    sha256 = "0p20yrqbn3fwsnrxvh2cv0m86mh3mz9vj15m7siw1kjkbzq0vngc";
   };
 
   packageName = "cl-unicode";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-unification.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-unification'';
-  version = ''20200925-git'';
+  baseName = "cl-unification";
+  version = "20200925-git";
 
   description = ''The CL-UNIFICATION system.
 
···
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-unification/2020-09-25/cl-unification-20200925-git.tgz'';
-    sha256 = ''05i1bmbabfgym9v28cbl37yr0r1m4a4k4a844z6wlq6qf45vzais'';
+    url = "http://beta.quicklisp.org/archive/cl-unification/2020-09-25/cl-unification-20200925-git.tgz";
+    sha256 = "05i1bmbabfgym9v28cbl37yr0r1m4a4k4a844z6wlq6qf45vzais";
   };
 
   packageName = "cl-unification";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-utilities.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-utilities'';
-  version = ''1.2.4'';
+  baseName = "cl-utilities";
+  version = "1.2.4";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-utilities/2010-10-06/cl-utilities-1.2.4.tgz'';
-    sha256 = ''1z2ippnv2wgyxpz15zpif7j7sp1r20fkjhm4n6am2fyp6a3k3a87'';
+    url = "http://beta.quicklisp.org/archive/cl-utilities/2010-10-06/cl-utilities-1.2.4.tgz";
+    sha256 = "1z2ippnv2wgyxpz15zpif7j7sp1r20fkjhm4n6am2fyp6a3k3a87";
   };
 
   packageName = "cl-utilities";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-vectors.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-vectors'';
-  version = ''20180228-git'';
+  baseName = "cl-vectors";
+  version = "20180228-git";
 
-  description = ''cl-paths: vectorial paths manipulation'';
+  description = "cl-paths: vectorial paths manipulation";
 
   deps = [ args."cl-aa" args."cl-paths" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz'';
-    sha256 = ''0fcypjfzqra8ryb4nx1vx1fqy7fwvyz3f443qkjg2z81akhkscly'';
+    url = "http://beta.quicklisp.org/archive/cl-vectors/2018-02-28/cl-vectors-20180228-git.tgz";
+    sha256 = "0fcypjfzqra8ryb4nx1vx1fqy7fwvyz3f443qkjg2z81akhkscly";
   };
 
   packageName = "cl-vectors";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-webkit2.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-webkit2'';
-  version = ''cl-webkit-20201016-git'';
+  baseName = "cl-webkit2";
+  version = "cl-webkit-20201016-git";
 
-  description = ''An FFI binding to WebKit2GTK+'';
+  description = "An FFI binding to WebKit2GTK+";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-cffi-gtk" args."cl-cffi-gtk-cairo" args."cl-cffi-gtk-gdk" args."cl-cffi-gtk-gdk-pixbuf" args."cl-cffi-gtk-gio" args."cl-cffi-gtk-glib" args."cl-cffi-gtk-gobject" args."cl-cffi-gtk-pango" args."closer-mop" args."iterate" args."trivial-features" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-webkit/2020-10-16/cl-webkit-20201016-git.tgz'';
-    sha256 = ''15xykhjz3j7ad3m853x1hriv3mz6zsgaqdnlc3wk664ka0f7k0vh'';
+    url = "http://beta.quicklisp.org/archive/cl-webkit/2020-10-16/cl-webkit-20201016-git.tgz";
+    sha256 = "15xykhjz3j7ad3m853x1hriv3mz6zsgaqdnlc3wk664ka0f7k0vh";
   };
 
   packageName = "cl-webkit2";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-who.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-who'';
-  version = ''20190710-git'';
+  baseName = "cl-who";
+  version = "20190710-git";
 
   parasites = [ "cl-who-test" ];
 
-  description = ''(X)HTML generation macros'';
+  description = "(X)HTML generation macros";
 
   deps = [ args."flexi-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-who/2019-07-10/cl-who-20190710-git.tgz'';
-    sha256 = ''0pbigwn38xikdwvjy9696z9f00dwg565y3wh6ja51q681y8zh9ir'';
+    url = "http://beta.quicklisp.org/archive/cl-who/2019-07-10/cl-who-20190710-git.tgz";
+    sha256 = "0pbigwn38xikdwvjy9696z9f00dwg565y3wh6ja51q681y8zh9ir";
   };
 
   packageName = "cl-who";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl-xmlspam.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl-xmlspam'';
-  version = ''20101006-http'';
+  baseName = "cl-xmlspam";
+  version = "20101006-http";
 
-  description = ''Streaming pattern matching for XML'';
+  description = "Streaming pattern matching for XML";
 
   deps = [ args."alexandria" args."babel" args."cl-ppcre" args."closure-common" args."cxml" args."puri" args."trivial-features" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-xmlspam/2010-10-06/cl-xmlspam-20101006-http.tgz'';
-    sha256 = ''1mx1a6ab4irncrx5pamh7zng35m4c5wh0pw68avaz7fbz81s953h'';
+    url = "http://beta.quicklisp.org/archive/cl-xmlspam/2010-10-06/cl-xmlspam-20101006-http.tgz";
+    sha256 = "1mx1a6ab4irncrx5pamh7zng35m4c5wh0pw68avaz7fbz81s953h";
   };
 
   packageName = "cl-xmlspam";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cl_plus_ssl.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cl_plus_ssl'';
-  version = ''cl+ssl-20200610-git'';
+  baseName = "cl_plus_ssl";
+  version = "cl+ssl-20200610-git";
 
-  description = ''Common Lisp interface to OpenSSL.'';
+  description = "Common Lisp interface to OpenSSL.";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."flexi-streams" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl+ssl/2020-06-10/cl+ssl-20200610-git.tgz'';
-    sha256 = ''1kijg8vlwcxraknp4gadf3n5zjchkgg8axr94v3kas9rb717r6ql'';
+    url = "http://beta.quicklisp.org/archive/cl+ssl/2020-06-10/cl+ssl-20200610-git.tgz";
+    sha256 = "1kijg8vlwcxraknp4gadf3n5zjchkgg8axr94v3kas9rb717r6ql";
   };
 
   packageName = "cl+ssl";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-handler-hunchentoot.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clack-handler-hunchentoot'';
-  version = ''clack-20191007-git'';
+  baseName = "clack-handler-hunchentoot";
+  version = "clack-20191007-git";
 
-  description = ''Clack handler for Hunchentoot.'';
+  description = "Clack handler for Hunchentoot.";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."chunga" args."cl_plus_ssl" args."cl-base64" args."cl-fad" args."cl-ppcre" args."clack-socket" args."flexi-streams" args."hunchentoot" args."md5" args."rfc2388" args."split-sequence" args."trivial-backtrace" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz'';
-    sha256 = ''004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w'';
+    url = "http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz";
+    sha256 = "004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w";
   };
 
   packageName = "clack-handler-hunchentoot";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-socket.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clack-socket'';
-  version = ''clack-20191007-git'';
+  baseName = "clack-socket";
+  version = "clack-20191007-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz'';
-    sha256 = ''004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w'';
+    url = "http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz";
+    sha256 = "004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w";
   };
 
   packageName = "clack-socket";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-test.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clack-test'';
-  version = ''clack-20191007-git'';
+  baseName = "clack-test";
+  version = "clack-20191007-git";
 
-  description = ''Testing Clack Applications.'';
+  description = "Testing Clack Applications.";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."chipz" args."chunga" args."cl_plus_ssl" args."cl-annot" args."cl-base64" args."cl-cookie" args."cl-fad" args."cl-ppcre" args."cl-reexport" args."cl-syntax" args."cl-syntax-annot" args."cl-utilities" args."clack" args."clack-handler-hunchentoot" args."clack-socket" args."dexador" args."dissect" args."fast-http" args."fast-io" args."flexi-streams" args."http-body" args."hunchentoot" args."ironclad" args."jonathan" args."lack" args."lack-component" args."lack-middleware-backtrace" args."lack-util" args."local-time" args."md5" args."named-readtables" args."proc-parse" args."quri" args."rfc2388" args."rove" args."smart-buffer" args."split-sequence" args."static-vectors" args."trivial-backtrace" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."trivial-mimes" args."trivial-types" args."usocket" args."xsubseq" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz'';
-    sha256 = ''004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w'';
+    url = "http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz";
+    sha256 = "004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w";
   };
 
   packageName = "clack-test";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clack-v1-compat.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clack-v1-compat'';
-  version = ''clack-20191007-git'';
+  baseName = "clack-v1-compat";
+  version = "clack-20191007-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."chipz" args."chunga" args."circular-streams" args."cl_plus_ssl" args."cl-annot" args."cl-base64" args."cl-cookie" args."cl-fad" args."cl-ppcre" args."cl-reexport" args."cl-syntax" args."cl-syntax-annot" args."cl-utilities" args."clack" args."clack-handler-hunchentoot" args."clack-socket" args."clack-test" args."dexador" args."dissect" args."fast-http" args."fast-io" args."flexi-streams" args."http-body" args."hunchentoot" args."ironclad" args."jonathan" args."lack" args."lack-component" args."lack-middleware-backtrace" args."lack-util" args."local-time" args."marshal" args."md5" args."named-readtables" args."proc-parse" args."quri" args."rfc2388" args."rove" args."smart-buffer" args."split-sequence" args."static-vectors" args."trivial-backtrace" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."trivial-mimes" args."trivial-types" args."uiop" args."usocket" args."xsubseq" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz'';
-    sha256 = ''004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w'';
+    url = "http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz";
+    sha256 = "004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w";
   };
 
   packageName = "clack-v1-compat";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clack.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clack'';
-  version = ''20191007-git'';
+  baseName = "clack";
+  version = "20191007-git";
 
-  description = ''Web application environment for Common Lisp'';
+  description = "Web application environment for Common Lisp";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."ironclad" args."lack" args."lack-component" args."lack-middleware-backtrace" args."lack-util" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz'';
-    sha256 = ''004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w'';
+    url = "http://beta.quicklisp.org/archive/clack/2019-10-07/clack-20191007-git.tgz";
+    sha256 = "004drm82mhxmcsa00lbmq2l89g4fzwn6j2drfwdazrpi27z0ry5w";
   };
 
   packageName = "clack";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clfswm.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clfswm'';
-  version = ''20161204-git'';
+  baseName = "clfswm";
+  version = "20161204-git";
 
-  description = ''CLFSWM: Fullscreen Window Manager'';
+  description = "CLFSWM: Fullscreen Window Manager";
 
   deps = [ args."clx" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clfswm/2016-12-04/clfswm-20161204-git.tgz'';
-    sha256 = ''1jgz127721dgcv3qm1knc335gy04vzh9gl0hshp256rxi82cpp73'';
+    url = "http://beta.quicklisp.org/archive/clfswm/2016-12-04/clfswm-20161204-git.tgz";
+    sha256 = "1jgz127721dgcv3qm1knc335gy04vzh9gl0hshp256rxi82cpp73";
   };
 
   packageName = "clfswm";

pkgs/development/lisp-modules/quicklisp-to-nix-output/closer-mop.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''closer-mop'';
-  version = ''20201016-git'';
+  baseName = "closer-mop";
+  version = "20201016-git";
 
-  description = ''Closer to MOP is a compatibility layer that rectifies many of the absent or incorrect CLOS MOP features across a broad range of Common Lisp implementations.'';
+  description = "Closer to MOP is a compatibility layer that rectifies many of the absent or incorrect CLOS MOP features across a broad range of Common Lisp implementations.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/closer-mop/2020-10-16/closer-mop-20201016-git.tgz'';
-    sha256 = ''1fccvxzrrfdiwjx9cdia7idp8xym1y86bf7zcyxvmpkdcvgdsdcd'';
+    url = "http://beta.quicklisp.org/archive/closer-mop/2020-10-16/closer-mop-20201016-git.tgz";
+    sha256 = "1fccvxzrrfdiwjx9cdia7idp8xym1y86bf7zcyxvmpkdcvgdsdcd";
   };
 
   packageName = "closer-mop";

pkgs/development/lisp-modules/quicklisp-to-nix-output/closure-common.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''closure-common'';
-  version = ''20181018-git'';
+  baseName = "closure-common";
+  version = "20181018-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."babel" args."trivial-features" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/closure-common/2018-10-18/closure-common-20181018-git.tgz'';
-    sha256 = ''18bp7jnxma9hscp09fa723ws9nnynjil935rp8dy9hp6ypghpxpn'';
+    url = "http://beta.quicklisp.org/archive/closure-common/2018-10-18/closure-common-20181018-git.tgz";
+    sha256 = "18bp7jnxma9hscp09fa723ws9nnynjil935rp8dy9hp6ypghpxpn";
   };
 
   packageName = "closure-common";

pkgs/development/lisp-modules/quicklisp-to-nix-output/closure-html.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''closure-html'';
-  version = ''20180711-git'';
+  baseName = "closure-html";
+  version = "20180711-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."babel" args."closure-common" args."flexi-streams" args."trivial-features" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/closure-html/2018-07-11/closure-html-20180711-git.tgz'';
-    sha256 = ''0ljcrz1wix77h1ywp0bixm3pb5ncmr1vdiwh8m1qzkygwpfjr8aq'';
+    url = "http://beta.quicklisp.org/archive/closure-html/2018-07-11/closure-html-20180711-git.tgz";
+    sha256 = "0ljcrz1wix77h1ywp0bixm3pb5ncmr1vdiwh8m1qzkygwpfjr8aq";
   };
 
   packageName = "closure-html";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clsql-postgresql-socket.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clsql-postgresql-socket'';
-  version = ''clsql-20201016-git'';
+  baseName = "clsql-postgresql-socket";
+  version = "clsql-20201016-git";
 
-  description = ''Common Lisp SQL PostgreSQL Socket Driver'';
+  description = "Common Lisp SQL PostgreSQL Socket Driver";
 
   deps = [ args."clsql" args."md5" args."uffi" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clsql/2020-10-16/clsql-20201016-git.tgz'';
-    sha256 = ''0wzjxcm7df4fipvj5qsqlllai92hkzd4cvlaghvaikcah9r63hv8'';
+    url = "http://beta.quicklisp.org/archive/clsql/2020-10-16/clsql-20201016-git.tgz";
+    sha256 = "0wzjxcm7df4fipvj5qsqlllai92hkzd4cvlaghvaikcah9r63hv8";
   };
 
   packageName = "clsql-postgresql-socket";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clsql-postgresql.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clsql-postgresql'';
-  version = ''clsql-20201016-git'';
+  baseName = "clsql-postgresql";
+  version = "clsql-20201016-git";
 
-  description = ''Common Lisp PostgreSQL API Driver'';
+  description = "Common Lisp PostgreSQL API Driver";
 
   deps = [ args."clsql" args."clsql-uffi" args."uffi" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clsql/2020-10-16/clsql-20201016-git.tgz'';
-    sha256 = ''0wzjxcm7df4fipvj5qsqlllai92hkzd4cvlaghvaikcah9r63hv8'';
+    url = "http://beta.quicklisp.org/archive/clsql/2020-10-16/clsql-20201016-git.tgz";
+    sha256 = "0wzjxcm7df4fipvj5qsqlllai92hkzd4cvlaghvaikcah9r63hv8";
   };
 
   packageName = "clsql-postgresql";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clsql-sqlite3.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clsql-sqlite3'';
-  version = ''clsql-20201016-git'';
+  baseName = "clsql-sqlite3";
+  version = "clsql-20201016-git";
 
-  description = ''Common Lisp Sqlite3 Driver'';
+  description = "Common Lisp Sqlite3 Driver";
 
   deps = [ args."clsql" args."clsql-uffi" args."uffi" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clsql/2020-10-16/clsql-20201016-git.tgz'';
-    sha256 = ''0wzjxcm7df4fipvj5qsqlllai92hkzd4cvlaghvaikcah9r63hv8'';
+    url = "http://beta.quicklisp.org/archive/clsql/2020-10-16/clsql-20201016-git.tgz";
+    sha256 = "0wzjxcm7df4fipvj5qsqlllai92hkzd4cvlaghvaikcah9r63hv8";
   };
 
   packageName = "clsql-sqlite3";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clsql-uffi.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clsql-uffi'';
-  version = ''clsql-20201016-git'';
+  baseName = "clsql-uffi";
+  version = "clsql-20201016-git";
 
-  description = ''Common UFFI Helper functions for Common Lisp SQL Interface Library'';
+  description = "Common UFFI Helper functions for Common Lisp SQL Interface Library";
 
   deps = [ args."clsql" args."uffi" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clsql/2020-10-16/clsql-20201016-git.tgz'';
-    sha256 = ''0wzjxcm7df4fipvj5qsqlllai92hkzd4cvlaghvaikcah9r63hv8'';
+    url = "http://beta.quicklisp.org/archive/clsql/2020-10-16/clsql-20201016-git.tgz";
+    sha256 = "0wzjxcm7df4fipvj5qsqlllai92hkzd4cvlaghvaikcah9r63hv8";
   };
 
   packageName = "clsql-uffi";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clsql.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clsql'';
-  version = ''20201016-git'';
+  baseName = "clsql";
+  version = "20201016-git";
 
-  description = ''Common Lisp SQL Interface library'';
+  description = "Common Lisp SQL Interface library";
 
   deps = [ args."uffi" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clsql/2020-10-16/clsql-20201016-git.tgz'';
-    sha256 = ''0wzjxcm7df4fipvj5qsqlllai92hkzd4cvlaghvaikcah9r63hv8'';
+    url = "http://beta.quicklisp.org/archive/clsql/2020-10-16/clsql-20201016-git.tgz";
+    sha256 = "0wzjxcm7df4fipvj5qsqlllai92hkzd4cvlaghvaikcah9r63hv8";
   };
 
   packageName = "clsql";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clss.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clss'';
-  version = ''20191130-git'';
+  baseName = "clss";
+  version = "20191130-git";
 
-  description = ''A DOM tree searching engine based on CSS selectors.'';
+  description = "A DOM tree searching engine based on CSS selectors.";
 
   deps = [ args."array-utils" args."documentation-utils" args."plump" args."trivial-indent" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clss/2019-11-30/clss-20191130-git.tgz'';
-    sha256 = ''0cbjzsc90fpa8zqv5s0ri7ncbv6f8azgbbfsxswqfphbibkcpcka'';
+    url = "http://beta.quicklisp.org/archive/clss/2019-11-30/clss-20191130-git.tgz";
+    sha256 = "0cbjzsc90fpa8zqv5s0ri7ncbv6f8azgbbfsxswqfphbibkcpcka";
   };
 
   packageName = "clss";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clump-2-3-tree.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clump-2-3-tree'';
-  version = ''clump-20160825-git'';
+  baseName = "clump-2-3-tree";
+  version = "clump-20160825-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."acclimation" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clump/2016-08-25/clump-20160825-git.tgz'';
-    sha256 = ''1mngxmwklpi52inihkp4akzdi7y32609spfi70yamwgzc1wijbrl'';
+    url = "http://beta.quicklisp.org/archive/clump/2016-08-25/clump-20160825-git.tgz";
+    sha256 = "1mngxmwklpi52inihkp4akzdi7y32609spfi70yamwgzc1wijbrl";
   };
 
   packageName = "clump-2-3-tree";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clump-binary-tree.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clump-binary-tree'';
-  version = ''clump-20160825-git'';
+  baseName = "clump-binary-tree";
+  version = "clump-20160825-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."acclimation" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clump/2016-08-25/clump-20160825-git.tgz'';
-    sha256 = ''1mngxmwklpi52inihkp4akzdi7y32609spfi70yamwgzc1wijbrl'';
+    url = "http://beta.quicklisp.org/archive/clump/2016-08-25/clump-20160825-git.tgz";
+    sha256 = "1mngxmwklpi52inihkp4akzdi7y32609spfi70yamwgzc1wijbrl";
   };
 
   packageName = "clump-binary-tree";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clump.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clump'';
-  version = ''20160825-git'';
+  baseName = "clump";
+  version = "20160825-git";
 
-  description = ''Library for operations on different kinds of trees'';
+  description = "Library for operations on different kinds of trees";
 
   deps = [ args."acclimation" args."clump-2-3-tree" args."clump-binary-tree" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clump/2016-08-25/clump-20160825-git.tgz'';
-    sha256 = ''1mngxmwklpi52inihkp4akzdi7y32609spfi70yamwgzc1wijbrl'';
+    url = "http://beta.quicklisp.org/archive/clump/2016-08-25/clump-20160825-git.tgz";
+    sha256 = "1mngxmwklpi52inihkp4akzdi7y32609spfi70yamwgzc1wijbrl";
   };
 
   packageName = "clump";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clunit.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clunit'';
-  version = ''20171019-git'';
+  baseName = "clunit";
+  version = "20171019-git";
 
-  description = ''CLUnit is a Common Lisp unit testing framework.'';
+  description = "CLUnit is a Common Lisp unit testing framework.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clunit/2017-10-19/clunit-20171019-git.tgz'';
-    sha256 = ''1rapyh0fbjnksj8j3y6imzya1kw80882w18j0fv9iq1hlp718zs5'';
+    url = "http://beta.quicklisp.org/archive/clunit/2017-10-19/clunit-20171019-git.tgz";
+    sha256 = "1rapyh0fbjnksj8j3y6imzya1kw80882w18j0fv9iq1hlp718zs5";
   };
 
   packageName = "clunit";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clunit2.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clunit2'';
-  version = ''20201016-git'';
+  baseName = "clunit2";
+  version = "20201016-git";
 
-  description = ''CLUnit is a Common Lisp unit testing framework.'';
+  description = "CLUnit is a Common Lisp unit testing framework.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clunit2/2020-10-16/clunit2-20201016-git.tgz'';
-    sha256 = ''1mj3c125drq9a3pxrh0r8q3gqgq68yk7qi0zbqh4mkpavl1aspdp'';
+    url = "http://beta.quicklisp.org/archive/clunit2/2020-10-16/clunit2-20201016-git.tgz";
+    sha256 = "1mj3c125drq9a3pxrh0r8q3gqgq68yk7qi0zbqh4mkpavl1aspdp";
   };
 
   packageName = "clunit2";

pkgs/development/lisp-modules/quicklisp-to-nix-output/clx.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''clx'';
-  version = ''20200715-git'';
+  baseName = "clx";
+  version = "20200715-git";
 
   parasites = [ "clx/test" ];
 
-  description = ''An implementation of the X Window System protocol in Lisp.'';
+  description = "An implementation of the X Window System protocol in Lisp.";
 
   deps = [ args."fiasco" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clx/2020-07-15/clx-20200715-git.tgz'';
-    sha256 = ''1fvx6m3imvkkd0z5a3jmm2v6mkrndwsidhykrs229rqx343zg8ra'';
+    url = "http://beta.quicklisp.org/archive/clx/2020-07-15/clx-20200715-git.tgz";
+    sha256 = "1fvx6m3imvkkd0z5a3jmm2v6mkrndwsidhykrs229rqx343zg8ra";
   };
 
   packageName = "clx";

pkgs/development/lisp-modules/quicklisp-to-nix-output/collectors.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''collectors'';
-  version = ''20161204-git'';
+  baseName = "collectors";
+  version = "20161204-git";
 
   parasites = [ "collectors-test" ];
 
···
   deps = [ args."alexandria" args."closer-mop" args."iterate" args."lisp-unit2" args."symbol-munger" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/collectors/2016-12-04/collectors-20161204-git.tgz'';
-    sha256 = ''0cf2y2yxraqs9v54gbj8hhp7s522gz8qfwwc5hvlhl2s7540b2zf'';
+    url = "http://beta.quicklisp.org/archive/collectors/2016-12-04/collectors-20161204-git.tgz";
+    sha256 = "0cf2y2yxraqs9v54gbj8hhp7s522gz8qfwwc5hvlhl2s7540b2zf";
   };
 
   packageName = "collectors";

pkgs/development/lisp-modules/quicklisp-to-nix-output/colorize.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''colorize'';
-  version = ''20180228-git'';
+  baseName = "colorize";
+  version = "20180228-git";
 
-  description = ''A Syntax highlighting library'';
+  description = "A Syntax highlighting library";
 
   deps = [ args."alexandria" args."html-encode" args."split-sequence" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/colorize/2018-02-28/colorize-20180228-git.tgz'';
-    sha256 = ''1g0xbryavsf17zy9iy0sbqsb4lyva04h93sbaj3iwv12w50fwz2h'';
+    url = "http://beta.quicklisp.org/archive/colorize/2018-02-28/colorize-20180228-git.tgz";
+    sha256 = "1g0xbryavsf17zy9iy0sbqsb4lyva04h93sbaj3iwv12w50fwz2h";
   };
 
   packageName = "colorize";

pkgs/development/lisp-modules/quicklisp-to-nix-output/command-line-arguments.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''command-line-arguments'';
-  version = ''20200325-git'';
+  baseName = "command-line-arguments";
+  version = "20200325-git";
 
-  description = ''small library to deal with command-line arguments'';
+  description = "small library to deal with command-line arguments";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/command-line-arguments/2020-03-25/command-line-arguments-20200325-git.tgz'';
-    sha256 = ''0ny0c0aw3mfjpmf31pnd9zfnylqh8ji2yi636w1f352c13z2w5sz'';
+    url = "http://beta.quicklisp.org/archive/command-line-arguments/2020-03-25/command-line-arguments-20200325-git.tgz";
+    sha256 = "0ny0c0aw3mfjpmf31pnd9zfnylqh8ji2yi636w1f352c13z2w5sz";
   };
 
   packageName = "command-line-arguments";

pkgs/development/lisp-modules/quicklisp-to-nix-output/css-lite.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''css-lite'';
-  version = ''20120407-git'';
+  baseName = "css-lite";
+  version = "20120407-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/css-lite/2012-04-07/css-lite-20120407-git.tgz'';
-    sha256 = ''1gf1qqaxhly6ixh9ykqhg9b52s8p5wlwi46vp2k29qy7gmx4f1qg'';
+    url = "http://beta.quicklisp.org/archive/css-lite/2012-04-07/css-lite-20120407-git.tgz";
+    sha256 = "1gf1qqaxhly6ixh9ykqhg9b52s8p5wlwi46vp2k29qy7gmx4f1qg";
   };
 
   packageName = "css-lite";

pkgs/development/lisp-modules/quicklisp-to-nix-output/css-selectors-simple-tree.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''css-selectors-simple-tree'';
-  version = ''css-selectors-20160628-git'';
+  baseName = "css-selectors-simple-tree";
+  version = "css-selectors-20160628-git";
 
-  description = ''An implementation of css selectors that interacts with cl-html5-parser's simple-tree'';
+  description = "An implementation of css selectors that interacts with cl-html5-parser's simple-tree";
 
   deps = [ args."alexandria" args."babel" args."buildnode" args."cl-html5-parser" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."closure-common" args."closure-html" args."collectors" args."css-selectors" args."cxml" args."flexi-streams" args."iterate" args."named-readtables" args."puri" args."split-sequence" args."string-case" args."swank" args."symbol-munger" args."trivial-features" args."trivial-gray-streams" args."yacc" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/css-selectors/2016-06-28/css-selectors-20160628-git.tgz'';
-    sha256 = ''0y9q719w5cv4g7in731q5p98n7pznb05vr7i7wi92mmpah2g1w4b'';
+    url = "http://beta.quicklisp.org/archive/css-selectors/2016-06-28/css-selectors-20160628-git.tgz";
+    sha256 = "0y9q719w5cv4g7in731q5p98n7pznb05vr7i7wi92mmpah2g1w4b";
   };
 
   packageName = "css-selectors-simple-tree";

pkgs/development/lisp-modules/quicklisp-to-nix-output/css-selectors-stp.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''css-selectors-stp'';
-  version = ''css-selectors-20160628-git'';
+  baseName = "css-selectors-stp";
+  version = "css-selectors-20160628-git";
 
-  description = ''An implementation of css selectors that interacts with cxml-stp'';
+  description = "An implementation of css selectors that interacts with cxml-stp";
 
   deps = [ args."alexandria" args."babel" args."buildnode" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."closure-common" args."closure-html" args."collectors" args."css-selectors" args."cxml" args."cxml-stp" args."flexi-streams" args."iterate" args."named-readtables" args."parse-number" args."puri" args."split-sequence" args."swank" args."symbol-munger" args."trivial-features" args."trivial-gray-streams" args."xpath" args."yacc" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/css-selectors/2016-06-28/css-selectors-20160628-git.tgz'';
-    sha256 = ''0y9q719w5cv4g7in731q5p98n7pznb05vr7i7wi92mmpah2g1w4b'';
+    url = "http://beta.quicklisp.org/archive/css-selectors/2016-06-28/css-selectors-20160628-git.tgz";
+    sha256 = "0y9q719w5cv4g7in731q5p98n7pznb05vr7i7wi92mmpah2g1w4b";
   };
 
   packageName = "css-selectors-stp";

pkgs/development/lisp-modules/quicklisp-to-nix-output/css-selectors.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''css-selectors'';
-  version = ''20160628-git'';
+  baseName = "css-selectors";
+  version = "20160628-git";
 
   parasites = [ "css-selectors-test" ];
 
-  description = ''An implementation of css selectors'';
+  description = "An implementation of css selectors";
 
   deps = [ args."alexandria" args."babel" args."buildnode" args."buildnode-xhtml" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."closure-common" args."closure-html" args."collectors" args."cxml" args."flexi-streams" args."iterate" args."lisp-unit2" args."named-readtables" args."puri" args."split-sequence" args."swank" args."symbol-munger" args."trivial-features" args."trivial-gray-streams" args."yacc" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/css-selectors/2016-06-28/css-selectors-20160628-git.tgz'';
-    sha256 = ''0y9q719w5cv4g7in731q5p98n7pznb05vr7i7wi92mmpah2g1w4b'';
+    url = "http://beta.quicklisp.org/archive/css-selectors/2016-06-28/css-selectors-20160628-git.tgz";
+    sha256 = "0y9q719w5cv4g7in731q5p98n7pznb05vr7i7wi92mmpah2g1w4b";
   };
 
   packageName = "css-selectors";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cxml-stp.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cxml-stp'';
-  version = ''20200325-git'';
+  baseName = "cxml-stp";
+  version = "20200325-git";
 
   parasites = [ "cxml-stp/test" ];
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."babel" args."cl-ppcre" args."closure-common" args."cxml" args."cxml_slash_test" args."parse-number" args."puri" args."rt" args."trivial-features" args."trivial-gray-streams" args."xpath" args."xpath_slash_test" args."yacc" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cxml-stp/2020-03-25/cxml-stp-20200325-git.tgz'';
-    sha256 = ''1y26bksmysvxifqx4lslpbsdvmcqkf7di36a3yyqnjgrb5r0jv1n'';
+    url = "http://beta.quicklisp.org/archive/cxml-stp/2020-03-25/cxml-stp-20200325-git.tgz";
+    sha256 = "1y26bksmysvxifqx4lslpbsdvmcqkf7di36a3yyqnjgrb5r0jv1n";
   };
 
   packageName = "cxml-stp";

pkgs/development/lisp-modules/quicklisp-to-nix-output/cxml.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''cxml'';
-  version = ''20200610-git'';
+  baseName = "cxml";
+  version = "20200610-git";
 
   parasites = [ "cxml/dom" "cxml/klacks" "cxml/test" "cxml/xml" ];
 
-  description = ''Closure XML - a Common Lisp XML parser'';
+  description = "Closure XML - a Common Lisp XML parser";
 
   deps = [ args."alexandria" args."babel" args."closure-common" args."puri" args."trivial-features" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cxml/2020-06-10/cxml-20200610-git.tgz'';
-    sha256 = ''0545rh4mfxqx2yn9b48s0hzd5w80kars7hpykbg0lgf7ys5218mq'';
+    url = "http://beta.quicklisp.org/archive/cxml/2020-06-10/cxml-20200610-git.tgz";
+    sha256 = "0545rh4mfxqx2yn9b48s0hzd5w80kars7hpykbg0lgf7ys5218mq";
   };
 
   packageName = "cxml";

pkgs/development/lisp-modules/quicklisp-to-nix-output/dbd-mysql.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''dbd-mysql'';
-  version = ''cl-dbi-20200610-git'';
+  baseName = "dbd-mysql";
+  version = "cl-dbi-20200610-git";
 
-  description = ''Database driver for MySQL.'';
+  description = "Database driver for MySQL.";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl-mysql" args."closer-mop" args."dbi" args."split-sequence" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz'';
-    sha256 = ''1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas'';
+    url = "http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz";
+    sha256 = "1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas";
   };
 
   packageName = "dbd-mysql";

pkgs/development/lisp-modules/quicklisp-to-nix-output/dbd-postgres.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''dbd-postgres'';
-  version = ''cl-dbi-20200610-git'';
+  baseName = "dbd-postgres";
+  version = "cl-dbi-20200610-git";
 
-  description = ''Database driver for PostgreSQL.'';
+  description = "Database driver for PostgreSQL.";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."cl-base64" args."cl-postgres" args."cl-ppcre" args."closer-mop" args."dbi" args."ironclad" args."md5" args."split-sequence" args."trivial-garbage" args."uax-15" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz'';
-    sha256 = ''1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas'';
+    url = "http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz";
+    sha256 = "1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas";
   };
 
   packageName = "dbd-postgres";

pkgs/development/lisp-modules/quicklisp-to-nix-output/dbd-sqlite3.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''dbd-sqlite3'';
-  version = ''cl-dbi-20200610-git'';
+  baseName = "dbd-sqlite3";
+  version = "cl-dbi-20200610-git";
 
-  description = ''Database driver for SQLite3.'';
+  description = "Database driver for SQLite3.";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."closer-mop" args."dbi" args."iterate" args."split-sequence" args."sqlite" args."trivial-features" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz'';
-    sha256 = ''1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas'';
+    url = "http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz";
+    sha256 = "1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas";
   };
 
   packageName = "dbd-sqlite3";

pkgs/development/lisp-modules/quicklisp-to-nix-output/dbi-test.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''dbi-test'';
-  version = ''cl-dbi-20200610-git'';
+  baseName = "dbi-test";
+  version = "cl-dbi-20200610-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."closer-mop" args."dbi" args."dissect" args."rove" args."split-sequence" args."trivial-gray-streams" args."trivial-types" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz'';
-    sha256 = ''1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas'';
+    url = "http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz";
+    sha256 = "1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas";
   };
 
   packageName = "dbi-test";

pkgs/development/lisp-modules/quicklisp-to-nix-output/dbi.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''dbi'';
-  version = ''cl-20200610-git'';
+  baseName = "dbi";
+  version = "cl-20200610-git";
 
   parasites = [ "dbi/test" ];
 
-  description = ''Database independent interface for Common Lisp'';
+  description = "Database independent interface for Common Lisp";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."cl-mysql" args."cl-postgres" args."closer-mop" args."dbd-mysql" args."dbd-postgres" args."dbd-sqlite3" args."dbi-test" args."rove" args."split-sequence" args."sqlite" args."trivial-garbage" args."trivial-types" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz'';
-    sha256 = ''1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas'';
+    url = "http://beta.quicklisp.org/archive/cl-dbi/2020-06-10/cl-dbi-20200610-git.tgz";
+    sha256 = "1d7hwywcqzqwmr5b42c0mmjq3v3xxd4cwb4fn5k1wd7j6pr0bkas";
   };
 
   packageName = "dbi";

pkgs/development/lisp-modules/quicklisp-to-nix-output/dbus.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''dbus'';
-  version = ''20200610-git'';
+  baseName = "dbus";
+  version = "20200610-git";
 
-  description = ''A D-BUS client library for Common Lisp'';
+  description = "A D-BUS client library for Common Lisp";
 
   deps = [ args."alexandria" args."asdf-package-system" args."babel" args."cl-xmlspam" args."flexi-streams" args."ieee-floats" args."iolib" args."ironclad" args."trivial-garbage" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/dbus/2020-06-10/dbus-20200610-git.tgz'';
-    sha256 = ''1njwjf1z9xngsfmlddmbcan49vcjqvvxfkhbi62xcxwbn9rgqn79'';
+    url = "http://beta.quicklisp.org/archive/dbus/2020-06-10/dbus-20200610-git.tgz";
+    sha256 = "1njwjf1z9xngsfmlddmbcan49vcjqvvxfkhbi62xcxwbn9rgqn79";
   };
 
   packageName = "dbus";

pkgs/development/lisp-modules/quicklisp-to-nix-output/dexador.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''dexador'';
-  version = ''20200427-git'';
+  baseName = "dexador";
+  version = "20200427-git";
 
-  description = ''Yet another HTTP client for Common Lisp'';
+  description = "Yet another HTTP client for Common Lisp";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."chipz" args."chunga" args."cl_plus_ssl" args."cl-base64" args."cl-cookie" args."cl-ppcre" args."cl-reexport" args."cl-utilities" args."fast-http" args."fast-io" args."flexi-streams" args."local-time" args."proc-parse" args."quri" args."smart-buffer" args."split-sequence" args."static-vectors" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."trivial-mimes" args."usocket" args."xsubseq" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/dexador/2020-04-27/dexador-20200427-git.tgz'';
-    sha256 = ''0qy8x47ni270dzwscy86nkwfzn491w2jqwyg57dm6w8lkjzwpgld'';
+    url = "http://beta.quicklisp.org/archive/dexador/2020-04-27/dexador-20200427-git.tgz";
+    sha256 = "0qy8x47ni270dzwscy86nkwfzn491w2jqwyg57dm6w8lkjzwpgld";
   };
 
   packageName = "dexador";

pkgs/development/lisp-modules/quicklisp-to-nix-output/dissect.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''dissect'';
-  version = ''20200427-git'';
+  baseName = "dissect";
+  version = "20200427-git";
 
-  description = ''A lib for introspecting the call stack and active restarts.'';
+  description = "A lib for introspecting the call stack and active restarts.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/dissect/2020-04-27/dissect-20200427-git.tgz'';
-    sha256 = ''1d7sri20jma9r105lxv0sx2q60kb8zp7bf023kain3rnyqr74v8a'';
+    url = "http://beta.quicklisp.org/archive/dissect/2020-04-27/dissect-20200427-git.tgz";
+    sha256 = "1d7sri20jma9r105lxv0sx2q60kb8zp7bf023kain3rnyqr74v8a";
   };
 
   packageName = "dissect";

pkgs/development/lisp-modules/quicklisp-to-nix-output/djula.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''djula'';
-  version = ''20201016-git'';
+  baseName = "djula";
+  version = "20201016-git";
 
-  description = ''An implementation of Django templates for Common Lisp.'';
+  description = "An implementation of Django templates for Common Lisp.";
 
   deps = [ args."access" args."alexandria" args."anaphora" args."arnesi" args."babel" args."cl-annot" args."cl-interpol" args."cl-locale" args."cl-ppcre" args."cl-slice" args."cl-syntax" args."cl-syntax-annot" args."cl-unicode" args."closer-mop" args."collectors" args."flexi-streams" args."gettext" args."iterate" args."let-plus" args."local-time" args."named-readtables" args."parser-combinators" args."split-sequence" args."symbol-munger" args."trivial-backtrace" args."trivial-features" args."trivial-gray-streams" args."trivial-types" args."yacc" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/djula/2020-10-16/djula-20201016-git.tgz'';
-    sha256 = ''09j9wmvs3vgx291p11dclrpwx0dqknazzadikg2320nv7a29zgiy'';
+    url = "http://beta.quicklisp.org/archive/djula/2020-10-16/djula-20201016-git.tgz";
+    sha256 = "09j9wmvs3vgx291p11dclrpwx0dqknazzadikg2320nv7a29zgiy";
   };
 
   packageName = "djula";

pkgs/development/lisp-modules/quicklisp-to-nix-output/do-urlencode.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''do-urlencode'';
-  version = ''20181018-git'';
+  baseName = "do-urlencode";
+  version = "20181018-git";
 
-  description = ''Percent Encoding (aka URL Encoding) library'';
+  description = "Percent Encoding (aka URL Encoding) library";
 
   deps = [ args."alexandria" args."babel" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/do-urlencode/2018-10-18/do-urlencode-20181018-git.tgz'';
-    sha256 = ''1cajd219s515y65kp562c6xczqaq0p4lyp13iv00z6i44rijmfp2'';
+    url = "http://beta.quicklisp.org/archive/do-urlencode/2018-10-18/do-urlencode-20181018-git.tgz";
+    sha256 = "1cajd219s515y65kp562c6xczqaq0p4lyp13iv00z6i44rijmfp2";
   };
 
   packageName = "do-urlencode";

pkgs/development/lisp-modules/quicklisp-to-nix-output/documentation-utils.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''documentation-utils'';
-  version = ''20190710-git'';
+  baseName = "documentation-utils";
+  version = "20190710-git";
 
-  description = ''A few simple tools to help you with documenting your library.'';
+  description = "A few simple tools to help you with documenting your library.";
 
   deps = [ args."trivial-indent" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/documentation-utils/2019-07-10/documentation-utils-20190710-git.tgz'';
-    sha256 = ''1n3z8sw75k2jjpsg6ch5g9s4v56y96dbs4338ajrfdsk3pk4wgj3'';
+    url = "http://beta.quicklisp.org/archive/documentation-utils/2019-07-10/documentation-utils-20190710-git.tgz";
+    sha256 = "1n3z8sw75k2jjpsg6ch5g9s4v56y96dbs4338ajrfdsk3pk4wgj3";
   };
 
   packageName = "documentation-utils";

pkgs/development/lisp-modules/quicklisp-to-nix-output/drakma.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''drakma'';
-  version = ''v2.0.7'';
+  baseName = "drakma";
+  version = "v2.0.7";
 
-  description = ''Full-featured http/https client based on usocket'';
+  description = "Full-featured http/https client based on usocket";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."chipz" args."chunga" args."cl_plus_ssl" args."cl-base64" args."cl-ppcre" args."flexi-streams" args."puri" args."split-sequence" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/drakma/2019-11-30/drakma-v2.0.7.tgz'';
-    sha256 = ''1r0sh0nsx7fq24yybazjw8n7grk1b85l52x523axwchnnaj58kzw'';
+    url = "http://beta.quicklisp.org/archive/drakma/2019-11-30/drakma-v2.0.7.tgz";
+    sha256 = "1r0sh0nsx7fq24yybazjw8n7grk1b85l52x523axwchnnaj58kzw";
   };
 
   packageName = "drakma";

pkgs/development/lisp-modules/quicklisp-to-nix-output/enchant.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''enchant'';
-  version = ''cl-20190521-git'';
+  baseName = "enchant";
+  version = "cl-20190521-git";
 
-  description = ''Programming interface for Enchant spell-checker library'';
+  description = "Programming interface for Enchant spell-checker library";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-enchant/2019-05-21/cl-enchant-20190521-git.tgz'';
-    sha256 = ''16ag48fr74m536an8fak5z0lfjdb265gv1ajai1lqg0vq2l5mr14'';
+    url = "http://beta.quicklisp.org/archive/cl-enchant/2019-05-21/cl-enchant-20190521-git.tgz";
+    sha256 = "16ag48fr74m536an8fak5z0lfjdb265gv1ajai1lqg0vq2l5mr14";
   };
 
   packageName = "enchant";

pkgs/development/lisp-modules/quicklisp-to-nix-output/esrap-peg.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''esrap-peg'';
-  version = ''20191007-git'';
+  baseName = "esrap-peg";
+  version = "20191007-git";
 
-  description = ''A wrapper around Esrap to allow generating Esrap grammars from PEG definitions'';
+  description = "A wrapper around Esrap to allow generating Esrap grammars from PEG definitions";
 
   deps = [ args."alexandria" args."cl-unification" args."esrap" args."iterate" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/esrap-peg/2019-10-07/esrap-peg-20191007-git.tgz'';
-    sha256 = ''0285ngcm73rpzmr0ydy6frps2b4q6n4jymjv3ncwsh81x5blfvis'';
+    url = "http://beta.quicklisp.org/archive/esrap-peg/2019-10-07/esrap-peg-20191007-git.tgz";
+    sha256 = "0285ngcm73rpzmr0ydy6frps2b4q6n4jymjv3ncwsh81x5blfvis";
   };
 
   packageName = "esrap-peg";

pkgs/development/lisp-modules/quicklisp-to-nix-output/esrap.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''esrap'';
-  version = ''20200325-git'';
+  baseName = "esrap";
+  version = "20200325-git";
 
   parasites = [ "esrap/tests" ];
 
-  description = ''A Packrat / Parsing Grammar / TDPL parser for Common Lisp.'';
+  description = "A Packrat / Parsing Grammar / TDPL parser for Common Lisp.";
 
   deps = [ args."alexandria" args."fiveam" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/esrap/2020-03-25/esrap-20200325-git.tgz'';
-    sha256 = ''1pwgjsm19nxx8d4iwbn3x7g08r6qyq1vmp9m83m87r53597b3a68'';
+    url = "http://beta.quicklisp.org/archive/esrap/2020-03-25/esrap-20200325-git.tgz";
+    sha256 = "1pwgjsm19nxx8d4iwbn3x7g08r6qyq1vmp9m83m87r53597b3a68";
   };
 
   packageName = "esrap";

pkgs/development/lisp-modules/quicklisp-to-nix-output/external-program.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''external-program'';
-  version = ''20190307-git'';
+  baseName = "external-program";
+  version = "20190307-git";
 
   parasites = [ "external-program-test" ];
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."fiveam" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/external-program/2019-03-07/external-program-20190307-git.tgz'';
-    sha256 = ''1nl3mngh7vp2l9mfbdhni4nc164zznafnl74p1kv9j07n5fcpnyz'';
+    url = "http://beta.quicklisp.org/archive/external-program/2019-03-07/external-program-20190307-git.tgz";
+    sha256 = "1nl3mngh7vp2l9mfbdhni4nc164zznafnl74p1kv9j07n5fcpnyz";
   };
 
   packageName = "external-program";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fare-csv.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fare-csv'';
-  version = ''20171227-git'';
+  baseName = "fare-csv";
+  version = "20171227-git";
 
-  description = ''Robust CSV parser and printer'';
+  description = "Robust CSV parser and printer";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fare-csv/2017-12-27/fare-csv-20171227-git.tgz'';
-    sha256 = ''1hkzg05kq2c4xihsfx4wk1k6mmjq2fw40id8vy0315rpa47a5i7x'';
+    url = "http://beta.quicklisp.org/archive/fare-csv/2017-12-27/fare-csv-20171227-git.tgz";
+    sha256 = "1hkzg05kq2c4xihsfx4wk1k6mmjq2fw40id8vy0315rpa47a5i7x";
   };
 
   packageName = "fare-csv";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fare-mop.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fare-mop'';
-  version = ''20151218-git'';
+  baseName = "fare-mop";
+  version = "20151218-git";
 
-  description = ''Utilities using the MOP; notably make informative pretty-printing trivial'';
+  description = "Utilities using the MOP; notably make informative pretty-printing trivial";
 
   deps = [ args."closer-mop" args."fare-utils" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fare-mop/2015-12-18/fare-mop-20151218-git.tgz'';
-    sha256 = ''0bvrwqvacy114xsblrk2w28qk6b484a3p0w14mzl264b3wjrdna9'';
+    url = "http://beta.quicklisp.org/archive/fare-mop/2015-12-18/fare-mop-20151218-git.tgz";
+    sha256 = "0bvrwqvacy114xsblrk2w28qk6b484a3p0w14mzl264b3wjrdna9";
   };
 
   packageName = "fare-mop";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fare-quasiquote-extras.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fare-quasiquote-extras'';
-  version = ''fare-quasiquote-20200925-git'';
+  baseName = "fare-quasiquote-extras";
+  version = "fare-quasiquote-20200925-git";
 
-  description = ''fare-quasiquote plus extras'';
+  description = "fare-quasiquote plus extras";
 
   deps = [ args."alexandria" args."closer-mop" args."fare-quasiquote" args."fare-quasiquote-optima" args."fare-quasiquote-readtable" args."fare-utils" args."lisp-namespace" args."named-readtables" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_quasiquote" args."trivia_dot_trivial" args."trivial-cltl2" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fare-quasiquote/2020-09-25/fare-quasiquote-20200925-git.tgz'';
-    sha256 = ''0k25kx4gvr046bcnv5mqxbb4483v9p2lk7dvzjkgj2cxrvczmj8b'';
+    url = "http://beta.quicklisp.org/archive/fare-quasiquote/2020-09-25/fare-quasiquote-20200925-git.tgz";
+    sha256 = "0k25kx4gvr046bcnv5mqxbb4483v9p2lk7dvzjkgj2cxrvczmj8b";
   };
 
   packageName = "fare-quasiquote-extras";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fare-quasiquote-optima.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fare-quasiquote-optima'';
-  version = ''fare-quasiquote-20200925-git'';
+  baseName = "fare-quasiquote-optima";
+  version = "fare-quasiquote-20200925-git";
 
-  description = ''fare-quasiquote extension for optima'';
+  description = "fare-quasiquote extension for optima";
 
   deps = [ args."alexandria" args."closer-mop" args."fare-quasiquote" args."fare-quasiquote-readtable" args."fare-utils" args."lisp-namespace" args."named-readtables" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_quasiquote" args."trivia_dot_trivial" args."trivial-cltl2" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fare-quasiquote/2020-09-25/fare-quasiquote-20200925-git.tgz'';
-    sha256 = ''0k25kx4gvr046bcnv5mqxbb4483v9p2lk7dvzjkgj2cxrvczmj8b'';
+    url = "http://beta.quicklisp.org/archive/fare-quasiquote/2020-09-25/fare-quasiquote-20200925-git.tgz";
+    sha256 = "0k25kx4gvr046bcnv5mqxbb4483v9p2lk7dvzjkgj2cxrvczmj8b";
   };
 
   packageName = "fare-quasiquote-optima";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fare-quasiquote-readtable.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fare-quasiquote-readtable'';
-  version = ''fare-quasiquote-20200925-git'';
+  baseName = "fare-quasiquote-readtable";
+  version = "fare-quasiquote-20200925-git";
 
-  description = ''Using fare-quasiquote with named-readtable'';
+  description = "Using fare-quasiquote with named-readtable";
 
   deps = [ args."fare-quasiquote" args."fare-utils" args."named-readtables" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fare-quasiquote/2020-09-25/fare-quasiquote-20200925-git.tgz'';
-    sha256 = ''0k25kx4gvr046bcnv5mqxbb4483v9p2lk7dvzjkgj2cxrvczmj8b'';
+    url = "http://beta.quicklisp.org/archive/fare-quasiquote/2020-09-25/fare-quasiquote-20200925-git.tgz";
+    sha256 = "0k25kx4gvr046bcnv5mqxbb4483v9p2lk7dvzjkgj2cxrvczmj8b";
   };
 
   packageName = "fare-quasiquote-readtable";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fare-quasiquote.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fare-quasiquote'';
-  version = ''20200925-git'';
+  baseName = "fare-quasiquote";
+  version = "20200925-git";
 
-  description = ''Portable, matchable implementation of quasiquote'';
+  description = "Portable, matchable implementation of quasiquote";
 
   deps = [ args."fare-utils" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fare-quasiquote/2020-09-25/fare-quasiquote-20200925-git.tgz'';
-    sha256 = ''0k25kx4gvr046bcnv5mqxbb4483v9p2lk7dvzjkgj2cxrvczmj8b'';
+    url = "http://beta.quicklisp.org/archive/fare-quasiquote/2020-09-25/fare-quasiquote-20200925-git.tgz";
+    sha256 = "0k25kx4gvr046bcnv5mqxbb4483v9p2lk7dvzjkgj2cxrvczmj8b";
   };
 
   packageName = "fare-quasiquote";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fare-utils.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fare-utils'';
-  version = ''20170124-git'';
+  baseName = "fare-utils";
+  version = "20170124-git";
 
-  description = ''Basic functions and macros, interfaces, pure and stateful datastructures'';
+  description = "Basic functions and macros, interfaces, pure and stateful datastructures";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fare-utils/2017-01-24/fare-utils-20170124-git.tgz'';
-    sha256 = ''0jhb018ccn3spkgjywgd0524m5qacn8x15fdiban4zz3amj9dapq'';
+    url = "http://beta.quicklisp.org/archive/fare-utils/2017-01-24/fare-utils-20170124-git.tgz";
+    sha256 = "0jhb018ccn3spkgjywgd0524m5qacn8x15fdiban4zz3amj9dapq";
   };
 
   packageName = "fare-utils";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fast-http.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fast-http'';
-  version = ''20191007-git'';
+  baseName = "fast-http";
+  version = "20191007-git";
 
-  description = ''A fast HTTP protocol parser in Common Lisp'';
+  description = "A fast HTTP protocol parser in Common Lisp";
 
   deps = [ args."alexandria" args."babel" args."cl-utilities" args."flexi-streams" args."proc-parse" args."smart-buffer" args."trivial-features" args."trivial-gray-streams" args."xsubseq" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fast-http/2019-10-07/fast-http-20191007-git.tgz'';
-    sha256 = ''00qnl56cfss2blm4pp03dwv84bmkyd0kbarhahclxbn8f7pgwf32'';
+    url = "http://beta.quicklisp.org/archive/fast-http/2019-10-07/fast-http-20191007-git.tgz";
+    sha256 = "00qnl56cfss2blm4pp03dwv84bmkyd0kbarhahclxbn8f7pgwf32";
   };
 
   packageName = "fast-http";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fast-io.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fast-io'';
-  version = ''20200925-git'';
+  baseName = "fast-io";
+  version = "20200925-git";
 
-  description = ''Alternative I/O mechanism to a stream or vector'';
+  description = "Alternative I/O mechanism to a stream or vector";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."static-vectors" args."trivial-features" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fast-io/2020-09-25/fast-io-20200925-git.tgz'';
-    sha256 = ''1rgyr6y20fp3jqnx5snpjf9lngzalip2a28l04ssypwagmhaa975'';
+    url = "http://beta.quicklisp.org/archive/fast-io/2020-09-25/fast-io-20200925-git.tgz";
+    sha256 = "1rgyr6y20fp3jqnx5snpjf9lngzalip2a28l04ssypwagmhaa975";
   };
 
   packageName = "fast-io";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fiasco.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fiasco'';
-  version = ''20200610-git'';
+  baseName = "fiasco";
+  version = "20200610-git";
 
   parasites = [ "fiasco-self-tests" ];
 
-  description = ''A Common Lisp test framework that treasures your failures, logical continuation of Stefil.'';
+  description = "A Common Lisp test framework that treasures your failures, logical continuation of Stefil.";
 
   deps = [ args."alexandria" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fiasco/2020-06-10/fiasco-20200610-git.tgz'';
-    sha256 = ''1wb0ibw6ka9fbsb40zjipn7vh3jbzyfsvcc9gq19nqhbqa8gy9r4'';
+    url = "http://beta.quicklisp.org/archive/fiasco/2020-06-10/fiasco-20200610-git.tgz";
+    sha256 = "1wb0ibw6ka9fbsb40zjipn7vh3jbzyfsvcc9gq19nqhbqa8gy9r4";
   };
 
   packageName = "fiasco";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fiveam.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fiveam'';
-  version = ''20200925-git'';
+  baseName = "fiveam";
+  version = "20200925-git";
 
   parasites = [ "fiveam/test" ];
 
-  description = ''A simple regression testing framework'';
+  description = "A simple regression testing framework";
 
   deps = [ args."alexandria" args."net_dot_didierverna_dot_asdf-flv" args."trivial-backtrace" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fiveam/2020-09-25/fiveam-20200925-git.tgz'';
-    sha256 = ''0j9dzjs4prlx33f5idbcic4amx2mcgnjcyrpc3dd4b7lrw426l0d'';
+    url = "http://beta.quicklisp.org/archive/fiveam/2020-09-25/fiveam-20200925-git.tgz";
+    sha256 = "0j9dzjs4prlx33f5idbcic4amx2mcgnjcyrpc3dd4b7lrw426l0d";
   };
 
   packageName = "fiveam";

pkgs/development/lisp-modules/quicklisp-to-nix-output/flexi-streams.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''flexi-streams'';
-  version = ''20200925-git'';
+  baseName = "flexi-streams";
+  version = "20200925-git";
 
   parasites = [ "flexi-streams-test" ];
 
-  description = ''Flexible bivalent streams for Common Lisp'';
+  description = "Flexible bivalent streams for Common Lisp";
 
   deps = [ args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/flexi-streams/2020-09-25/flexi-streams-20200925-git.tgz'';
-    sha256 = ''1hmsryfkjnk4gdv803s3hpp71fpdybfl1jb5hgngxpd5lsrq0gb2'';
+    url = "http://beta.quicklisp.org/archive/flexi-streams/2020-09-25/flexi-streams-20200925-git.tgz";
+    sha256 = "1hmsryfkjnk4gdv803s3hpp71fpdybfl1jb5hgngxpd5lsrq0gb2";
   };
 
   packageName = "flexi-streams";

pkgs/development/lisp-modules/quicklisp-to-nix-output/form-fiddle.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''form-fiddle'';
-  version = ''20190710-git'';
+  baseName = "form-fiddle";
+  version = "20190710-git";
 
-  description = ''A collection of utilities to destructure lambda forms.'';
+  description = "A collection of utilities to destructure lambda forms.";
 
   deps = [ args."documentation-utils" args."trivial-indent" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/form-fiddle/2019-07-10/form-fiddle-20190710-git.tgz'';
-    sha256 = ''12zmqm2vls043kaka7jp6pnsvkxlyv6x183yjyrs8jk461qfydwl'';
+    url = "http://beta.quicklisp.org/archive/form-fiddle/2019-07-10/form-fiddle-20190710-git.tgz";
+    sha256 = "12zmqm2vls043kaka7jp6pnsvkxlyv6x183yjyrs8jk461qfydwl";
   };
 
   packageName = "form-fiddle";

pkgs/development/lisp-modules/quicklisp-to-nix-output/fset.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''fset'';
-  version = ''20200925-git'';
+  baseName = "fset";
+  version = "20200925-git";
 
   parasites = [ "fset/test" ];
 
···
   deps = [ args."misc-extensions" args."mt19937" args."named-readtables" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/fset/2020-09-25/fset-20200925-git.tgz'';
-    sha256 = ''19fr6ds1a493b0kbsligpn7i771r1yfshbbkdp0hxs4l792l05wv'';
+    url = "http://beta.quicklisp.org/archive/fset/2020-09-25/fset-20200925-git.tgz";
+    sha256 = "19fr6ds1a493b0kbsligpn7i771r1yfshbbkdp0hxs4l792l05wv";
   };
 
   packageName = "fset";

pkgs/development/lisp-modules/quicklisp-to-nix-output/gettext.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''gettext'';
-  version = ''20171130-git'';
+  baseName = "gettext";
+  version = "20171130-git";
 
-  description = ''An pure Common Lisp implementation of gettext runtime. gettext is an internationalization and localization (i18n) system commonly used for writing multilingual programs on Unix-like computer operating systems.'';
+  description = "An pure Common Lisp implementation of gettext runtime. gettext is an internationalization and localization (i18n) system commonly used for writing multilingual programs on Unix-like computer operating systems.";
 
   deps = [ args."flexi-streams" args."split-sequence" args."trivial-gray-streams" args."yacc" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/gettext/2017-11-30/gettext-20171130-git.tgz'';
-    sha256 = ''0nb8i66sb5qmpnk6rk2adlr87m322bra0xpirp63872mybd3y6yd'';
+    url = "http://beta.quicklisp.org/archive/gettext/2017-11-30/gettext-20171130-git.tgz";
+    sha256 = "0nb8i66sb5qmpnk6rk2adlr87m322bra0xpirp63872mybd3y6yd";
   };
 
   packageName = "gettext";

pkgs/development/lisp-modules/quicklisp-to-nix-output/global-vars.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''global-vars'';
-  version = ''20141106-git'';
+  baseName = "global-vars";
+  version = "20141106-git";
 
-  description = ''Define efficient global variables.'';
+  description = "Define efficient global variables.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/global-vars/2014-11-06/global-vars-20141106-git.tgz'';
-    sha256 = ''0bjgmsifs9vrq409rfrsgrhlxwklvls1dpvh2d706i0incxq957j'';
+    url = "http://beta.quicklisp.org/archive/global-vars/2014-11-06/global-vars-20141106-git.tgz";
+    sha256 = "0bjgmsifs9vrq409rfrsgrhlxwklvls1dpvh2d706i0incxq957j";
   };
 
   packageName = "global-vars";

pkgs/development/lisp-modules/quicklisp-to-nix-output/html-encode.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''html-encode'';
-  version = ''1.2'';
+  baseName = "html-encode";
+  version = "1.2";
 
-  description = ''A library for encoding text in various web-savvy encodings.'';
+  description = "A library for encoding text in various web-savvy encodings.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-1.2.tgz'';
-    sha256 = ''06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf'';
+    url = "http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-1.2.tgz";
+    sha256 = "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf";
   };
 
   packageName = "html-encode";

pkgs/development/lisp-modules/quicklisp-to-nix-output/http-body.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''http-body'';
-  version = ''20190813-git'';
+  baseName = "http-body";
+  version = "20190813-git";
 
-  description = ''HTTP POST data parser for Common Lisp'';
+  description = "HTTP POST data parser for Common Lisp";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-annot" args."cl-ppcre" args."cl-syntax" args."cl-syntax-annot" args."cl-utilities" args."fast-http" args."fast-io" args."flexi-streams" args."jonathan" args."named-readtables" args."proc-parse" args."quri" args."smart-buffer" args."split-sequence" args."static-vectors" args."trivial-features" args."trivial-gray-streams" args."trivial-types" args."xsubseq" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/http-body/2019-08-13/http-body-20190813-git.tgz'';
-    sha256 = ''1mc4xinqnvjr7cdyaywdb5lv9k34pal7lhp6f9a660r1rbxybvy8'';
+    url = "http://beta.quicklisp.org/archive/http-body/2019-08-13/http-body-20190813-git.tgz";
+    sha256 = "1mc4xinqnvjr7cdyaywdb5lv9k34pal7lhp6f9a660r1rbxybvy8";
   };
 
   packageName = "http-body";

pkgs/development/lisp-modules/quicklisp-to-nix-output/hu_dot_dwim_dot_asdf.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''hu_dot_dwim_dot_asdf'';
-  version = ''20200925-darcs'';
+  baseName = "hu_dot_dwim_dot_asdf";
+  version = "20200925-darcs";
 
-  description = ''Various ASDF extensions such as attached test and documentation system, explicit development support, etc.'';
+  description = "Various ASDF extensions such as attached test and documentation system, explicit development support, etc.";
 
   deps = [ args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/hu.dwim.asdf/2020-09-25/hu.dwim.asdf-20200925-darcs.tgz'';
-    sha256 = ''1812gk65x8yy8s817zhzga52zvdlagws4sw6a8f6zk7yaaa6br8h'';
+    url = "http://beta.quicklisp.org/archive/hu.dwim.asdf/2020-09-25/hu.dwim.asdf-20200925-darcs.tgz";
+    sha256 = "1812gk65x8yy8s817zhzga52zvdlagws4sw6a8f6zk7yaaa6br8h";
   };
 
   packageName = "hu.dwim.asdf";

pkgs/development/lisp-modules/quicklisp-to-nix-output/hu_dot_dwim_dot_defclass-star.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''hu_dot_dwim_dot_defclass-star'';
-  version = ''20150709-darcs'';
+  baseName = "hu_dot_dwim_dot_defclass-star";
+  version = "20150709-darcs";
 
-  description = ''Simplify class like definitions with defclass* and friends.'';
+  description = "Simplify class like definitions with defclass* and friends.";
 
   deps = [ args."hu_dot_dwim_dot_asdf" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/hu.dwim.defclass-star/2015-07-09/hu.dwim.defclass-star-20150709-darcs.tgz'';
-    sha256 = ''032982lyp0hm0ssxlyh572whi2hr4j1nqkyqlllaj373v0dbs3vs'';
+    url = "http://beta.quicklisp.org/archive/hu.dwim.defclass-star/2015-07-09/hu.dwim.defclass-star-20150709-darcs.tgz";
+    sha256 = "032982lyp0hm0ssxlyh572whi2hr4j1nqkyqlllaj373v0dbs3vs";
   };
 
   packageName = "hu.dwim.defclass-star";

pkgs/development/lisp-modules/quicklisp-to-nix-output/hu_dot_dwim_dot_stefil.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''hu_dot_dwim_dot_stefil'';
-  version = ''20200218-darcs'';
+  baseName = "hu_dot_dwim_dot_stefil";
+  version = "20200218-darcs";
 
   parasites = [ "hu.dwim.stefil/test" ];
 
-  description = ''A Simple Test Framework In Lisp.'';
+  description = "A Simple Test Framework In Lisp.";
 
   deps = [ args."alexandria" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/hu.dwim.stefil/2020-02-18/hu.dwim.stefil-20200218-darcs.tgz'';
-    sha256 = ''16p25pq9fhk0dny6r43yl9z24g6qm6dag9zf2cila9v9jh3r76qf'';
+    url = "http://beta.quicklisp.org/archive/hu.dwim.stefil/2020-02-18/hu.dwim.stefil-20200218-darcs.tgz";
+    sha256 = "16p25pq9fhk0dny6r43yl9z24g6qm6dag9zf2cila9v9jh3r76qf";
   };
 
   packageName = "hu.dwim.stefil";

pkgs/development/lisp-modules/quicklisp-to-nix-output/hunchentoot.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''hunchentoot'';
-  version = ''v1.3.0'';
+  baseName = "hunchentoot";
+  version = "v1.3.0";
 
   parasites = [ "hunchentoot-test" ];
 
···
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."chunga" args."cl_plus_ssl" args."cl-base64" args."cl-fad" args."cl-ppcre" args."cl-who" args."drakma" args."flexi-streams" args."md5" args."rfc2388" args."split-sequence" args."trivial-backtrace" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/hunchentoot/2020-06-10/hunchentoot-v1.3.0.tgz'';
-    sha256 = ''08znpi5lq2dhgv6mhvabk3w4ggrg31dbv4k6gmshr18xd2lq43i8'';
+    url = "http://beta.quicklisp.org/archive/hunchentoot/2020-06-10/hunchentoot-v1.3.0.tgz";
+    sha256 = "08znpi5lq2dhgv6mhvabk3w4ggrg31dbv4k6gmshr18xd2lq43i8";
   };
 
   packageName = "hunchentoot";

pkgs/development/lisp-modules/quicklisp-to-nix-output/idna.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''idna'';
-  version = ''20120107-git'';
+  baseName = "idna";
+  version = "20120107-git";
 
-  description = ''IDNA (international domain names) string encoding and decoding routines'';
+  description = "IDNA (international domain names) string encoding and decoding routines";
 
   deps = [ args."split-sequence" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/idna/2012-01-07/idna-20120107-git.tgz'';
-    sha256 = ''0q9hja9v5q7z89p0bzm2whchn05hymn3255fr5zj3fkja8akma5c'';
+    url = "http://beta.quicklisp.org/archive/idna/2012-01-07/idna-20120107-git.tgz";
+    sha256 = "0q9hja9v5q7z89p0bzm2whchn05hymn3255fr5zj3fkja8akma5c";
   };
 
   packageName = "idna";

pkgs/development/lisp-modules/quicklisp-to-nix-output/ieee-floats.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''ieee-floats'';
-  version = ''20170830-git'';
+  baseName = "ieee-floats";
+  version = "20170830-git";
 
   parasites = [ "ieee-floats-tests" ];
 
-  description = ''Convert floating point values to IEEE 754 binary representation'';
+  description = "Convert floating point values to IEEE 754 binary representation";
 
   deps = [ args."fiveam" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/ieee-floats/2017-08-30/ieee-floats-20170830-git.tgz'';
-    sha256 = ''15c4q4w3cda82vqlpvdfrnah6ms6vxbjf4a0chd10daw72rwayqk'';
+    url = "http://beta.quicklisp.org/archive/ieee-floats/2017-08-30/ieee-floats-20170830-git.tgz";
+    sha256 = "15c4q4w3cda82vqlpvdfrnah6ms6vxbjf4a0chd10daw72rwayqk";
   };
 
   packageName = "ieee-floats";

pkgs/development/lisp-modules/quicklisp-to-nix-output/inferior-shell.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''inferior-shell'';
-  version = ''20200925-git'';
+  baseName = "inferior-shell";
+  version = "20200925-git";
 
   parasites = [ "inferior-shell/test" ];
 
-  description = ''spawn local or remote processes and shell pipes'';
+  description = "spawn local or remote processes and shell pipes";
 
   deps = [ args."alexandria" args."closer-mop" args."fare-mop" args."fare-quasiquote" args."fare-quasiquote-extras" args."fare-quasiquote-optima" args."fare-quasiquote-readtable" args."fare-utils" args."hu_dot_dwim_dot_stefil" args."introspect-environment" args."iterate" args."lisp-namespace" args."named-readtables" args."trivia" args."trivia_dot_balland2006" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_quasiquote" args."trivia_dot_trivial" args."trivial-cltl2" args."type-i" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/inferior-shell/2020-09-25/inferior-shell-20200925-git.tgz'';
-    sha256 = ''1hykybcmdpcjk0irl4f1lmqc4aawpp1zfvh27qp6mldsibra7l80'';
+    url = "http://beta.quicklisp.org/archive/inferior-shell/2020-09-25/inferior-shell-20200925-git.tgz";
+    sha256 = "1hykybcmdpcjk0irl4f1lmqc4aawpp1zfvh27qp6mldsibra7l80";
   };
 
   packageName = "inferior-shell";

pkgs/development/lisp-modules/quicklisp-to-nix-output/introspect-environment.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''introspect-environment'';
-  version = ''20200715-git'';
+  baseName = "introspect-environment";
+  version = "20200715-git";
 
-  description = ''Small interface to portable but nonstandard introspection of CL environments.'';
+  description = "Small interface to portable but nonstandard introspection of CL environments.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/introspect-environment/2020-07-15/introspect-environment-20200715-git.tgz'';
-    sha256 = ''1m2vqpbrvjb0mkmi2n5rg3j0dr68hyv23lbw6s474hylx02nw5ns'';
+    url = "http://beta.quicklisp.org/archive/introspect-environment/2020-07-15/introspect-environment-20200715-git.tgz";
+    sha256 = "1m2vqpbrvjb0mkmi2n5rg3j0dr68hyv23lbw6s474hylx02nw5ns";
   };
 
   packageName = "introspect-environment";

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''iolib'';
-  version = ''v0.8.3'';
+  baseName = "iolib";
+  version = "v0.8.3";
 
   parasites = [ "iolib/multiplex" "iolib/os" "iolib/pathnames" "iolib/sockets" "iolib/streams" "iolib/syscalls" "iolib/trivial-sockets" "iolib/zstreams" ];
 
-  description = ''I/O library.'';
+  description = "I/O library.";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."idna" args."iolib_dot_asdf" args."iolib_dot_base" args."iolib_dot_common-lisp" args."iolib_dot_conf" args."iolib_dot_grovel" args."split-sequence" args."swap-bytes" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz'';
-    sha256 = ''12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c'';
+    url = "http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz";
+    sha256 = "12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c";
   };
 
   packageName = "iolib";

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_dot_asdf.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''iolib_dot_asdf'';
-  version = ''iolib-v0.8.3'';
+  baseName = "iolib_dot_asdf";
+  version = "iolib-v0.8.3";
 
-  description = ''A few ASDF component classes.'';
+  description = "A few ASDF component classes.";
 
   deps = [ args."alexandria" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz'';
-    sha256 = ''12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c'';
+    url = "http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz";
+    sha256 = "12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c";
   };
 
   packageName = "iolib.asdf";

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_dot_base.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''iolib_dot_base'';
-  version = ''iolib-v0.8.3'';
+  baseName = "iolib_dot_base";
+  version = "iolib-v0.8.3";
 
-  description = ''Base IOlib package, used instead of CL.'';
+  description = "Base IOlib package, used instead of CL.";
 
   deps = [ args."alexandria" args."iolib_dot_asdf" args."iolib_dot_common-lisp" args."iolib_dot_conf" args."split-sequence" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz'';
-    sha256 = ''12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c'';
+    url = "http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz";
+    sha256 = "12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c";
   };
 
   packageName = "iolib.base";

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_dot_common-lisp.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''iolib_dot_common-lisp'';
-  version = ''iolib-v0.8.3'';
+  baseName = "iolib_dot_common-lisp";
+  version = "iolib-v0.8.3";
 
-  description = ''Slightly modified Common Lisp.'';
+  description = "Slightly modified Common Lisp.";
 
   deps = [ args."alexandria" args."iolib_dot_asdf" args."iolib_dot_conf" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz'';
-    sha256 = ''12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c'';
+    url = "http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz";
+    sha256 = "12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c";
   };
 
   packageName = "iolib.common-lisp";

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_dot_conf.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''iolib_dot_conf'';
-  version = ''iolib-v0.8.3'';
+  baseName = "iolib_dot_conf";
+  version = "iolib-v0.8.3";
 
-  description = ''Compile-time configuration for IOLib.'';
+  description = "Compile-time configuration for IOLib.";
 
   deps = [ args."alexandria" args."iolib_dot_asdf" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz'';
-    sha256 = ''12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c'';
+    url = "http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz";
+    sha256 = "12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c";
   };
 
   packageName = "iolib.conf";

pkgs/development/lisp-modules/quicklisp-to-nix-output/iolib_dot_grovel.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''iolib_dot_grovel'';
-  version = ''iolib-v0.8.3'';
+  baseName = "iolib_dot_grovel";
+  version = "iolib-v0.8.3";
 
-  description = ''The CFFI Groveller'';
+  description = "The CFFI Groveller";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."iolib_dot_asdf" args."iolib_dot_base" args."iolib_dot_common-lisp" args."iolib_dot_conf" args."split-sequence" args."trivial-features" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz'';
-    sha256 = ''12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c'';
+    url = "http://beta.quicklisp.org/archive/iolib/2018-02-28/iolib-v0.8.3.tgz";
+    sha256 = "12gsvsjyxmclwidcjvyrfvd0773ib54a3qzmf33hmgc9knxlli7c";
   };
 
   packageName = "iolib.grovel";

pkgs/development/lisp-modules/quicklisp-to-nix-output/ironclad.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''ironclad'';
-  version = ''v0.51'';
+  baseName = "ironclad";
+  version = "v0.51";
 
   parasites = [ "ironclad/tests" ];
 
-  description = ''A cryptographic toolkit written in pure Common Lisp'';
+  description = "A cryptographic toolkit written in pure Common Lisp";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."rt" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/ironclad/2020-09-25/ironclad-v0.51.tgz'';
-    sha256 = ''0zfazyvg91fxr9gm195qwwf1y5qdci7i1cwzpv0fggxhylpkswrn'';
+    url = "http://beta.quicklisp.org/archive/ironclad/2020-09-25/ironclad-v0.51.tgz";
+    sha256 = "0zfazyvg91fxr9gm195qwwf1y5qdci7i1cwzpv0fggxhylpkswrn";
   };
 
   packageName = "ironclad";

pkgs/development/lisp-modules/quicklisp-to-nix-output/iterate.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''iterate'';
-  version = ''20200610-git'';
+  baseName = "iterate";
+  version = "20200610-git";
 
   parasites = [ "iterate/tests" ];
 
-  description = ''Jonathan Amsterdam's iterator/gatherer/accumulator facility'';
+  description = "Jonathan Amsterdam's iterator/gatherer/accumulator facility";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/iterate/2020-06-10/iterate-20200610-git.tgz'';
-    sha256 = ''0xz3v321b8zgjsgak432frs0gmpr2n24sf5gq97qnqvwqfn4infb'';
+    url = "http://beta.quicklisp.org/archive/iterate/2020-06-10/iterate-20200610-git.tgz";
+    sha256 = "0xz3v321b8zgjsgak432frs0gmpr2n24sf5gq97qnqvwqfn4infb";
   };
 
   packageName = "iterate";

pkgs/development/lisp-modules/quicklisp-to-nix-output/jonathan.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''jonathan'';
-  version = ''20200925-git'';
+  baseName = "jonathan";
+  version = "20200925-git";
 
-  description = ''High performance JSON encoder and decoder. Currently support: SBCL, CCL.'';
+  description = "High performance JSON encoder and decoder. Currently support: SBCL, CCL.";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-annot" args."cl-ppcre" args."cl-syntax" args."cl-syntax-annot" args."fast-io" args."named-readtables" args."proc-parse" args."static-vectors" args."trivial-features" args."trivial-gray-streams" args."trivial-types" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/jonathan/2020-09-25/jonathan-20200925-git.tgz'';
-    sha256 = ''1y5v3g351nsy7px0frdr2asmcy0lyfbj73ic1f5yf4q65hrgvryx'';
+    url = "http://beta.quicklisp.org/archive/jonathan/2020-09-25/jonathan-20200925-git.tgz";
+    sha256 = "1y5v3g351nsy7px0frdr2asmcy0lyfbj73ic1f5yf4q65hrgvryx";
   };
 
   packageName = "jonathan";

pkgs/development/lisp-modules/quicklisp-to-nix-output/kmrcl.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''kmrcl'';
-  version = ''20201016-git'';
+  baseName = "kmrcl";
+  version = "20201016-git";
 
   parasites = [ "kmrcl/test" ];
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."rt" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/kmrcl/2020-10-16/kmrcl-20201016-git.tgz'';
-    sha256 = ''0i0k61385hrzbg15qs1wprz6sis7mx2abxv1hqcc2f53rqm9b2hf'';
+    url = "http://beta.quicklisp.org/archive/kmrcl/2020-10-16/kmrcl-20201016-git.tgz";
+    sha256 = "0i0k61385hrzbg15qs1wprz6sis7mx2abxv1hqcc2f53rqm9b2hf";
   };
 
   packageName = "kmrcl";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lack-component.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lack-component'';
-  version = ''lack-20201016-git'';
+  baseName = "lack-component";
+  version = "lack-20201016-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lack/2020-10-16/lack-20201016-git.tgz'';
-    sha256 = ''124c3k8116m5gc0rp4vvkqcvz35lglrbwdq4i929hbq65xyx5gan'';
+    url = "http://beta.quicklisp.org/archive/lack/2020-10-16/lack-20201016-git.tgz";
+    sha256 = "124c3k8116m5gc0rp4vvkqcvz35lglrbwdq4i929hbq65xyx5gan";
   };
 
   packageName = "lack-component";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lack-middleware-backtrace.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lack-middleware-backtrace'';
-  version = ''lack-20201016-git'';
+  baseName = "lack-middleware-backtrace";
+  version = "lack-20201016-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lack/2020-10-16/lack-20201016-git.tgz'';
-    sha256 = ''124c3k8116m5gc0rp4vvkqcvz35lglrbwdq4i929hbq65xyx5gan'';
+    url = "http://beta.quicklisp.org/archive/lack/2020-10-16/lack-20201016-git.tgz";
+    sha256 = "124c3k8116m5gc0rp4vvkqcvz35lglrbwdq4i929hbq65xyx5gan";
   };
 
   packageName = "lack-middleware-backtrace";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lack-util.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lack-util'';
-  version = ''lack-20201016-git'';
+  baseName = "lack-util";
+  version = "lack-20201016-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."ironclad" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lack/2020-10-16/lack-20201016-git.tgz'';
-    sha256 = ''124c3k8116m5gc0rp4vvkqcvz35lglrbwdq4i929hbq65xyx5gan'';
+    url = "http://beta.quicklisp.org/archive/lack/2020-10-16/lack-20201016-git.tgz";
+    sha256 = "124c3k8116m5gc0rp4vvkqcvz35lglrbwdq4i929hbq65xyx5gan";
   };
 
   packageName = "lack-util";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lack.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lack'';
-  version = ''20201016-git'';
+  baseName = "lack";
+  version = "20201016-git";
 
-  description = ''A minimal Clack'';
+  description = "A minimal Clack";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."ironclad" args."lack-component" args."lack-util" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lack/2020-10-16/lack-20201016-git.tgz'';
-    sha256 = ''124c3k8116m5gc0rp4vvkqcvz35lglrbwdq4i929hbq65xyx5gan'';
+    url = "http://beta.quicklisp.org/archive/lack/2020-10-16/lack-20201016-git.tgz";
+    sha256 = "124c3k8116m5gc0rp4vvkqcvz35lglrbwdq4i929hbq65xyx5gan";
   };
 
   packageName = "lack";

pkgs/development/lisp-modules/quicklisp-to-nix-output/let-plus.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''let-plus'';
-  version = ''20191130-git'';
+  baseName = "let-plus";
+  version = "20191130-git";
 
   parasites = [ "let-plus/tests" ];
 
-  description = ''Destructuring extension of LET*.'';
+  description = "Destructuring extension of LET*.";
 
   deps = [ args."alexandria" args."anaphora" args."lift" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/let-plus/2019-11-30/let-plus-20191130-git.tgz'';
-    sha256 = ''0zj0fgb7lvczgpz4jq8q851p77kma7ikn7hd2jk2c37iv4nmz29p'';
+    url = "http://beta.quicklisp.org/archive/let-plus/2019-11-30/let-plus-20191130-git.tgz";
+    sha256 = "0zj0fgb7lvczgpz4jq8q851p77kma7ikn7hd2jk2c37iv4nmz29p";
   };
 
   packageName = "let-plus";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lev.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lev'';
-  version = ''20150505-git'';
+  baseName = "lev";
+  version = "20150505-git";
 
-  description = ''libev bindings for Common Lisp'';
+  description = "libev bindings for Common Lisp";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lev/2015-05-05/lev-20150505-git.tgz'';
-    sha256 = ''0lkkzb221ks4f0qjgh6pr5lyvb4884a87p96ir4m36x411pyk5xl'';
+    url = "http://beta.quicklisp.org/archive/lev/2015-05-05/lev-20150505-git.tgz";
+    sha256 = "0lkkzb221ks4f0qjgh6pr5lyvb4884a87p96ir4m36x411pyk5xl";
   };
 
   packageName = "lev";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lfarm-client.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lfarm-client'';
-  version = ''lfarm-20150608-git'';
+  baseName = "lfarm-client";
+  version = "lfarm-20150608-git";
 
-  description = ''Client component of lfarm, a library for distributing work across machines.'';
+  description = "Client component of lfarm, a library for distributing work across machines.";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."cl-store" args."flexi-streams" args."lfarm-common" args."lparallel" args."split-sequence" args."trivial-gray-streams" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lfarm/2015-06-08/lfarm-20150608-git.tgz'';
-    sha256 = ''1rkjcfam4601yczs13pi2qgi5jql0c150dxja53hkcnqhkyqgl66'';
+    url = "http://beta.quicklisp.org/archive/lfarm/2015-06-08/lfarm-20150608-git.tgz";
+    sha256 = "1rkjcfam4601yczs13pi2qgi5jql0c150dxja53hkcnqhkyqgl66";
   };
 
   packageName = "lfarm-client";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lfarm-common.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lfarm-common'';
-  version = ''lfarm-20150608-git'';
+  baseName = "lfarm-common";
+  version = "lfarm-20150608-git";
 
   description = ''(private) Common components of lfarm, a library for distributing
 work across machines.'';
···
   deps = [ args."alexandria" args."bordeaux-threads" args."cl-store" args."flexi-streams" args."split-sequence" args."trivial-gray-streams" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lfarm/2015-06-08/lfarm-20150608-git.tgz'';
-    sha256 = ''1rkjcfam4601yczs13pi2qgi5jql0c150dxja53hkcnqhkyqgl66'';
+    url = "http://beta.quicklisp.org/archive/lfarm/2015-06-08/lfarm-20150608-git.tgz";
+    sha256 = "1rkjcfam4601yczs13pi2qgi5jql0c150dxja53hkcnqhkyqgl66";
   };
 
   packageName = "lfarm-common";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lfarm-server.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lfarm-server'';
-  version = ''lfarm-20150608-git'';
+  baseName = "lfarm-server";
+  version = "lfarm-20150608-git";
 
-  description = ''Server component of lfarm, a library for distributing work across machines.'';
+  description = "Server component of lfarm, a library for distributing work across machines.";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."cl-store" args."flexi-streams" args."lfarm-common" args."split-sequence" args."trivial-gray-streams" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lfarm/2015-06-08/lfarm-20150608-git.tgz'';
-    sha256 = ''1rkjcfam4601yczs13pi2qgi5jql0c150dxja53hkcnqhkyqgl66'';
+    url = "http://beta.quicklisp.org/archive/lfarm/2015-06-08/lfarm-20150608-git.tgz";
+    sha256 = "1rkjcfam4601yczs13pi2qgi5jql0c150dxja53hkcnqhkyqgl66";
   };
 
   packageName = "lfarm-server";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lfarm-ssl.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lfarm-ssl'';
-  version = ''lfarm-20150608-git'';
+  baseName = "lfarm-ssl";
+  version = "lfarm-20150608-git";
 
-  description = ''SSL support for lfarm'';
+  description = "SSL support for lfarm";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cl_plus_ssl" args."cl-store" args."flexi-streams" args."lfarm-common" args."split-sequence" args."trivial-features" args."trivial-garbage" args."trivial-gray-streams" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lfarm/2015-06-08/lfarm-20150608-git.tgz'';
-    sha256 = ''1rkjcfam4601yczs13pi2qgi5jql0c150dxja53hkcnqhkyqgl66'';
+    url = "http://beta.quicklisp.org/archive/lfarm/2015-06-08/lfarm-20150608-git.tgz";
+    sha256 = "1rkjcfam4601yczs13pi2qgi5jql0c150dxja53hkcnqhkyqgl66";
   };
 
   packageName = "lfarm-ssl";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lift.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lift'';
-  version = ''20190521-git'';
+  baseName = "lift";
+  version = "20190521-git";
 
-  description = ''LIsp Framework for Testing'';
+  description = "LIsp Framework for Testing";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lift/2019-05-21/lift-20190521-git.tgz'';
-    sha256 = ''0cinilin9bxzsj3mzd4488zx2irvyl5qpbykv0xbyfz2mjh94ac9'';
+    url = "http://beta.quicklisp.org/archive/lift/2019-05-21/lift-20190521-git.tgz";
+    sha256 = "0cinilin9bxzsj3mzd4488zx2irvyl5qpbykv0xbyfz2mjh94ac9";
   };
 
   packageName = "lift";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lisp-namespace.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lisp-namespace'';
-  version = ''20171130-git'';
+  baseName = "lisp-namespace";
+  version = "20171130-git";
 
-  description = ''Provides LISP-N --- extensible namespaces in Common Lisp.'';
+  description = "Provides LISP-N --- extensible namespaces in Common Lisp.";
 
   deps = [ args."alexandria" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lisp-namespace/2017-11-30/lisp-namespace-20171130-git.tgz'';
-    sha256 = ''0vxk06c5434kcjv9p414yk23gs4rkibfq695is9y7wglck31fz2j'';
+    url = "http://beta.quicklisp.org/archive/lisp-namespace/2017-11-30/lisp-namespace-20171130-git.tgz";
+    sha256 = "0vxk06c5434kcjv9p414yk23gs4rkibfq695is9y7wglck31fz2j";
   };
 
   packageName = "lisp-namespace";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lisp-unit2.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lisp-unit2'';
-  version = ''20180131-git'';
+  baseName = "lisp-unit2";
+  version = "20180131-git";
 
   parasites = [ "lisp-unit2-test" ];
 
-  description = ''Common Lisp library that supports unit testing.'';
+  description = "Common Lisp library that supports unit testing.";
 
   deps = [ args."alexandria" args."cl-interpol" args."cl-ppcre" args."cl-unicode" args."flexi-streams" args."iterate" args."named-readtables" args."symbol-munger" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lisp-unit2/2018-01-31/lisp-unit2-20180131-git.tgz'';
-    sha256 = ''04kwrg605mqzf3ghshgbygvvryk5kipl6gyc5kdaxafjxvhxaak7'';
+    url = "http://beta.quicklisp.org/archive/lisp-unit2/2018-01-31/lisp-unit2-20180131-git.tgz";
+    sha256 = "04kwrg605mqzf3ghshgbygvvryk5kipl6gyc5kdaxafjxvhxaak7";
   };
 
   packageName = "lisp-unit2";

pkgs/development/lisp-modules/quicklisp-to-nix-output/local-time.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''local-time'';
-  version = ''20200925-git'';
+  baseName = "local-time";
+  version = "20200925-git";
 
   parasites = [ "local-time/test" ];
 
-  description = ''A library for manipulating dates and times, based on a paper by Erik Naggum'';
+  description = "A library for manipulating dates and times, based on a paper by Erik Naggum";
 
   deps = [ args."stefil" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/local-time/2020-09-25/local-time-20200925-git.tgz'';
-    sha256 = ''0rr2bs93vhj7ngplw85572jfx8250fr2iki8y9spxmfz1sldm12f'';
+    url = "http://beta.quicklisp.org/archive/local-time/2020-09-25/local-time-20200925-git.tgz";
+    sha256 = "0rr2bs93vhj7ngplw85572jfx8250fr2iki8y9spxmfz1sldm12f";
   };
 
   packageName = "local-time";

pkgs/development/lisp-modules/quicklisp-to-nix-output/log4cl.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''log4cl'';
-  version = ''20200925-git'';
+  baseName = "log4cl";
+  version = "20200925-git";
 
   parasites = [ "log4cl/syslog" "log4cl/test" ];
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."stefil" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/log4cl/2020-09-25/log4cl-20200925-git.tgz'';
-    sha256 = ''1z98ly71hsbd46i0dqqv2s3cm9y8bi0pl3yg8a168vz629c6mdrf'';
+    url = "http://beta.quicklisp.org/archive/log4cl/2020-09-25/log4cl-20200925-git.tgz";
+    sha256 = "1z98ly71hsbd46i0dqqv2s3cm9y8bi0pl3yg8a168vz629c6mdrf";
   };
 
   packageName = "log4cl";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lparallel.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lparallel'';
-  version = ''20160825-git'';
+  baseName = "lparallel";
+  version = "20160825-git";
 
-  description = ''Parallelism for Common Lisp'';
+  description = "Parallelism for Common Lisp";
 
   deps = [ args."alexandria" args."bordeaux-threads" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lparallel/2016-08-25/lparallel-20160825-git.tgz'';
-    sha256 = ''0wwwwszbj6m0b2rsp8mpn4m6y7xk448bw8fb7gy0ggmsdfgchfr1'';
+    url = "http://beta.quicklisp.org/archive/lparallel/2016-08-25/lparallel-20160825-git.tgz";
+    sha256 = "0wwwwszbj6m0b2rsp8mpn4m6y7xk448bw8fb7gy0ggmsdfgchfr1";
   };
 
   packageName = "lparallel";

pkgs/development/lisp-modules/quicklisp-to-nix-output/lquery.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''lquery'';
-  version = ''20200715-git'';
+  baseName = "lquery";
+  version = "20200715-git";
 
-  description = ''A library to allow jQuery-like HTML/DOM manipulation.'';
+  description = "A library to allow jQuery-like HTML/DOM manipulation.";
 
   deps = [ args."array-utils" args."clss" args."documentation-utils" args."form-fiddle" args."plump" args."trivial-indent" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/lquery/2020-07-15/lquery-20200715-git.tgz'';
-    sha256 = ''1akj9yzz71733yfbqq9jig0zkx8brphzh35d8zzic0469idd3rcd'';
+    url = "http://beta.quicklisp.org/archive/lquery/2020-07-15/lquery-20200715-git.tgz";
+    sha256 = "1akj9yzz71733yfbqq9jig0zkx8brphzh35d8zzic0469idd3rcd";
   };
 
   packageName = "lquery";

pkgs/development/lisp-modules/quicklisp-to-nix-output/map-set.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''map-set'';
-  version = ''20190307-hg'';
+  baseName = "map-set";
+  version = "20190307-hg";
 
-  description = ''Set-like data structure.'';
+  description = "Set-like data structure.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/map-set/2019-03-07/map-set-20190307-hg.tgz'';
-    sha256 = ''1x7yh4gzdvypr1q45qgmjln5pjlh82bfpk6sqyrihrldmwwnbzg9'';
+    url = "http://beta.quicklisp.org/archive/map-set/2019-03-07/map-set-20190307-hg.tgz";
+    sha256 = "1x7yh4gzdvypr1q45qgmjln5pjlh82bfpk6sqyrihrldmwwnbzg9";
   };
 
   packageName = "map-set";

pkgs/development/lisp-modules/quicklisp-to-nix-output/marshal.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''marshal'';
-  version = ''cl-20201016-git'';
+  baseName = "marshal";
+  version = "cl-20201016-git";
 
-  description = ''marshal: Simple (de)serialization of Lisp datastructures.'';
+  description = "marshal: Simple (de)serialization of Lisp datastructures.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-marshal/2020-10-16/cl-marshal-20201016-git.tgz'';
-    sha256 = ''03j52yhgpc2myypgy07213l20rznxvf6m3sfbzy2wyapcmv7nxnz'';
+    url = "http://beta.quicklisp.org/archive/cl-marshal/2020-10-16/cl-marshal-20201016-git.tgz";
+    sha256 = "03j52yhgpc2myypgy07213l20rznxvf6m3sfbzy2wyapcmv7nxnz";
   };
 
   packageName = "marshal";

pkgs/development/lisp-modules/quicklisp-to-nix-output/md5.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''md5'';
-  version = ''20180228-git'';
+  baseName = "md5";
+  version = "20180228-git";
 
-  description = ''The MD5 Message-Digest Algorithm RFC 1321'';
+  description = "The MD5 Message-Digest Algorithm RFC 1321";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/md5/2018-02-28/md5-20180228-git.tgz'';
-    sha256 = ''1261ix6bmkjyx8bkpj6ksa0kgyrhngm31as77dyy3vfg6dvrsnd4'';
+    url = "http://beta.quicklisp.org/archive/md5/2018-02-28/md5-20180228-git.tgz";
+    sha256 = "1261ix6bmkjyx8bkpj6ksa0kgyrhngm31as77dyy3vfg6dvrsnd4";
   };
 
   packageName = "md5";

pkgs/development/lisp-modules/quicklisp-to-nix-output/metabang-bind.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''metabang-bind'';
-  version = ''20200218-git'';
+  baseName = "metabang-bind";
+  version = "20200218-git";
 
-  description = ''Bind is a macro that generalizes multiple-value-bind, let, let*, destructuring-bind, structure and slot accessors, and a whole lot more.'';
+  description = "Bind is a macro that generalizes multiple-value-bind, let, let*, destructuring-bind, structure and slot accessors, and a whole lot more.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/metabang-bind/2020-02-18/metabang-bind-20200218-git.tgz'';
-    sha256 = ''0mfjzfsv8v6i9ahwldfzznl29i42cmh5srmpgq64ar1vp6bdn1hq'';
+    url = "http://beta.quicklisp.org/archive/metabang-bind/2020-02-18/metabang-bind-20200218-git.tgz";
+    sha256 = "0mfjzfsv8v6i9ahwldfzznl29i42cmh5srmpgq64ar1vp6bdn1hq";
   };
 
   packageName = "metabang-bind";

pkgs/development/lisp-modules/quicklisp-to-nix-output/metatilities-base.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''metatilities-base'';
-  version = ''20191227-git'';
+  baseName = "metatilities-base";
+  version = "20191227-git";
 
-  description = ''These are metabang.com's Common Lisp basic utilities.'';
+  description = "These are metabang.com's Common Lisp basic utilities.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/metatilities-base/2019-12-27/metatilities-base-20191227-git.tgz'';
-    sha256 = ''1mal51p7mknya2ljcwl3wdjvnirw5vvzic6qcnci7qhmfrb1awil'';
+    url = "http://beta.quicklisp.org/archive/metatilities-base/2019-12-27/metatilities-base-20191227-git.tgz";
+    sha256 = "1mal51p7mknya2ljcwl3wdjvnirw5vvzic6qcnci7qhmfrb1awil";
   };
 
   packageName = "metatilities-base";

pkgs/development/lisp-modules/quicklisp-to-nix-output/mgl-pax.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''mgl-pax'';
-  version = ''20201016-git'';
+  baseName = "mgl-pax";
+  version = "20201016-git";
 
   parasites = [ "mgl-pax/test" ];
 
···
   deps = [ args."_3bmd" args."_3bmd-ext-code-blocks" args."alexandria" args."babel" args."bordeaux-threads" args."cl-fad" args."colorize" args."esrap" args."html-encode" args."ironclad" args."named-readtables" args."pythonic-string-reader" args."split-sequence" args."swank" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/mgl-pax/2020-10-16/mgl-pax-20201016-git.tgz'';
-    sha256 = ''0n48fw4a21sqy491bfi9fygrjl9psrryw00iha40dxy2ww86s6li'';
+    url = "http://beta.quicklisp.org/archive/mgl-pax/2020-10-16/mgl-pax-20201016-git.tgz";
+    sha256 = "0n48fw4a21sqy491bfi9fygrjl9psrryw00iha40dxy2ww86s6li";
   };
 
   packageName = "mgl-pax";

pkgs/development/lisp-modules/quicklisp-to-nix-output/misc-extensions.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''misc-extensions'';
-  version = ''20150608-git'';
+  baseName = "misc-extensions";
+  version = "20150608-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/misc-extensions/2015-06-08/misc-extensions-20150608-git.tgz'';
-    sha256 = ''0pkvi1l5djwpvm0p8m0bcdjm61gxvzy0vgn415gngdixvbbchdqj'';
+    url = "http://beta.quicklisp.org/archive/misc-extensions/2015-06-08/misc-extensions-20150608-git.tgz";
+    sha256 = "0pkvi1l5djwpvm0p8m0bcdjm61gxvzy0vgn415gngdixvbbchdqj";
   };
 
   packageName = "misc-extensions";

pkgs/development/lisp-modules/quicklisp-to-nix-output/mk-string-metrics.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''mk-string-metrics'';
-  version = ''20180131-git'';
+  baseName = "mk-string-metrics";
+  version = "20180131-git";
 
-  description = ''efficient implementations of various string metric algorithms'';
+  description = "efficient implementations of various string metric algorithms";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/mk-string-metrics/2018-01-31/mk-string-metrics-20180131-git.tgz'';
-    sha256 = ''10xb9n6568nh019nq3phijbc7l6hkv69yllfiqvc1zzsprxpkwc4'';
+    url = "http://beta.quicklisp.org/archive/mk-string-metrics/2018-01-31/mk-string-metrics-20180131-git.tgz";
+    sha256 = "10xb9n6568nh019nq3phijbc7l6hkv69yllfiqvc1zzsprxpkwc4";
   };
 
   packageName = "mk-string-metrics";

pkgs/development/lisp-modules/quicklisp-to-nix-output/moptilities.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''moptilities'';
-  version = ''20170403-git'';
+  baseName = "moptilities";
+  version = "20170403-git";
 
-  description = ''Common Lisp MOP utilities'';
+  description = "Common Lisp MOP utilities";
 
   deps = [ args."closer-mop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/moptilities/2017-04-03/moptilities-20170403-git.tgz'';
-    sha256 = ''0az01wx60ll3nybqlp21f5bps3fnpqhvvfg6d9x84969wdj7q4q8'';
+    url = "http://beta.quicklisp.org/archive/moptilities/2017-04-03/moptilities-20170403-git.tgz";
+    sha256 = "0az01wx60ll3nybqlp21f5bps3fnpqhvvfg6d9x84969wdj7q4q8";
   };
 
   packageName = "moptilities";

pkgs/development/lisp-modules/quicklisp-to-nix-output/more-conditions.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''more-conditions'';
-  version = ''20180831-git'';
+  baseName = "more-conditions";
+  version = "20180831-git";
 
   parasites = [ "more-conditions/test" ];
 
···
   deps = [ args."alexandria" args."closer-mop" args."fiveam" args."let-plus" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/more-conditions/2018-08-31/more-conditions-20180831-git.tgz'';
-    sha256 = ''0wa989kv3sl977g9szxkx52fdnww6aj2a9i77363f90iq02vj97x'';
+    url = "http://beta.quicklisp.org/archive/more-conditions/2018-08-31/more-conditions-20180831-git.tgz";
+    sha256 = "0wa989kv3sl977g9szxkx52fdnww6aj2a9i77363f90iq02vj97x";
   };
 
   packageName = "more-conditions";

pkgs/development/lisp-modules/quicklisp-to-nix-output/mt19937.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''mt19937'';
-  version = ''1.1.1'';
+  baseName = "mt19937";
+  version = "1.1.1";
 
-  description = ''Portable MT19937 Mersenne Twister random number generator'';
+  description = "Portable MT19937 Mersenne Twister random number generator";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/mt19937/2011-02-19/mt19937-1.1.1.tgz'';
-    sha256 = ''1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv'';
+    url = "http://beta.quicklisp.org/archive/mt19937/2011-02-19/mt19937-1.1.1.tgz";
+    sha256 = "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv";
   };
 
   packageName = "mt19937";

pkgs/development/lisp-modules/quicklisp-to-nix-output/myway.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''myway'';
-  version = ''20200325-git'';
+  baseName = "myway";
+  version = "20200325-git";
 
-  description = ''Sinatra-compatible routing library.'';
+  description = "Sinatra-compatible routing library.";
 
   deps = [ args."alexandria" args."babel" args."cl-ppcre" args."cl-utilities" args."map-set" args."quri" args."split-sequence" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/myway/2020-03-25/myway-20200325-git.tgz'';
-    sha256 = ''07r0mq9n0gmm7n20mkpsnmjvcr4gj9nckpnh1c2mddrb3sag8n15'';
+    url = "http://beta.quicklisp.org/archive/myway/2020-03-25/myway-20200325-git.tgz";
+    sha256 = "07r0mq9n0gmm7n20mkpsnmjvcr4gj9nckpnh1c2mddrb3sag8n15";
   };
 
   packageName = "myway";

pkgs/development/lisp-modules/quicklisp-to-nix-output/named-readtables.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''named-readtables'';
-  version = ''20200925-git'';
+  baseName = "named-readtables";
+  version = "20200925-git";
 
   parasites = [ "named-readtables/test" ];
 
···
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/named-readtables/2020-09-25/named-readtables-20200925-git.tgz'';
-    sha256 = ''0klbvv2syv8a8agacxdjrmmhibvhgfbxxwv6k4hx0ifk6n5iazxl'';
+    url = "http://beta.quicklisp.org/archive/named-readtables/2020-09-25/named-readtables-20200925-git.tgz";
+    sha256 = "0klbvv2syv8a8agacxdjrmmhibvhgfbxxwv6k4hx0ifk6n5iazxl";
   };
 
   packageName = "named-readtables";

pkgs/development/lisp-modules/quicklisp-to-nix-output/net-telent-date.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''net-telent-date'';
-  version = ''net-telent-date_0.42'';
+  baseName = "net-telent-date";
+  version = "net-telent-date_0.42";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/net-telent-date/2010-10-06/net-telent-date_0.42.tgz'';
-    sha256 = ''06vdlddwi6kx999n1093chwgw0ksbys4j4w9i9zqvw768wxp4li1'';
+    url = "http://beta.quicklisp.org/archive/net-telent-date/2010-10-06/net-telent-date_0.42.tgz";
+    sha256 = "06vdlddwi6kx999n1093chwgw0ksbys4j4w9i9zqvw768wxp4li1";
   };
 
   packageName = "net-telent-date";

pkgs/development/lisp-modules/quicklisp-to-nix-output/net_dot_didierverna_dot_asdf-flv.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''net_dot_didierverna_dot_asdf-flv'';
-  version = ''asdf-flv-version-2.1'';
+  baseName = "net_dot_didierverna_dot_asdf-flv";
+  version = "asdf-flv-version-2.1";
 
-  description = ''ASDF extension to provide support for file-local variables.'';
+  description = "ASDF extension to provide support for file-local variables.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/asdf-flv/2016-04-21/asdf-flv-version-2.1.tgz'';
-    sha256 = ''12k0d4xyv6s9vy6gq18p8c9bm334jsfjly22lhg680kx2zr7y0lc'';
+    url = "http://beta.quicklisp.org/archive/asdf-flv/2016-04-21/asdf-flv-version-2.1.tgz";
+    sha256 = "12k0d4xyv6s9vy6gq18p8c9bm334jsfjly22lhg680kx2zr7y0lc";
   };
 
   packageName = "net.didierverna.asdf-flv";

pkgs/development/lisp-modules/quicklisp-to-nix-output/nibbles.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''nibbles'';
-  version = ''20200925-git'';
+  baseName = "nibbles";
+  version = "20200925-git";
 
   parasites = [ "nibbles/tests" ];
 
-  description = ''A library for accessing octet-addressed blocks of data in big- and little-endian orders'';
+  description = "A library for accessing octet-addressed blocks of data in big- and little-endian orders";
 
   deps = [ args."rt" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/nibbles/2020-09-25/nibbles-20200925-git.tgz'';
-    sha256 = ''14k9hg8kmzwcb9b5aiwqhimc0zmcs3xp8q29sck8zklf8ziqaqb4'';
+    url = "http://beta.quicklisp.org/archive/nibbles/2020-09-25/nibbles-20200925-git.tgz";
+    sha256 = "14k9hg8kmzwcb9b5aiwqhimc0zmcs3xp8q29sck8zklf8ziqaqb4";
   };
 
   packageName = "nibbles";

pkgs/development/lisp-modules/quicklisp-to-nix-output/optima.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''optima'';
-  version = ''20150709-git'';
+  baseName = "optima";
+  version = "20150709-git";
 
-  description = ''Optimized Pattern Matching Library'';
+  description = "Optimized Pattern Matching Library";
 
   deps = [ args."alexandria" args."closer-mop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/optima/2015-07-09/optima-20150709-git.tgz'';
-    sha256 = ''0vqyqrnx2d8qwa2jlg9l2wn6vrykraj8a1ysz0gxxxnwpqc29hdc'';
+    url = "http://beta.quicklisp.org/archive/optima/2015-07-09/optima-20150709-git.tgz";
+    sha256 = "0vqyqrnx2d8qwa2jlg9l2wn6vrykraj8a1ysz0gxxxnwpqc29hdc";
   };
 
   packageName = "optima";

pkgs/development/lisp-modules/quicklisp-to-nix-output/osicat.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''osicat'';
-  version = ''20200925-git'';
+  baseName = "osicat";
+  version = "20200925-git";
 
   parasites = [ "osicat/tests" ];
 
-  description = ''A lightweight operating system interface'';
+  description = "A lightweight operating system interface";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."rt" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/osicat/2020-09-25/osicat-20200925-git.tgz'';
-    sha256 = ''191ncd5arfx6i9cw3iny4a473wsrr3dpv2lwb9jr02p6qpmqwysk'';
+    url = "http://beta.quicklisp.org/archive/osicat/2020-09-25/osicat-20200925-git.tgz";
+    sha256 = "191ncd5arfx6i9cw3iny4a473wsrr3dpv2lwb9jr02p6qpmqwysk";
   };
 
   packageName = "osicat";

pkgs/development/lisp-modules/quicklisp-to-nix-output/parenscript.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''parenscript'';
-  version = ''Parenscript-2.7.1'';
+  baseName = "parenscript";
+  version = "Parenscript-2.7.1";
 
-  description = ''Lisp to JavaScript transpiler'';
+  description = "Lisp to JavaScript transpiler";
 
   deps = [ args."anaphora" args."cl-ppcre" args."named-readtables" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/parenscript/2018-12-10/Parenscript-2.7.1.tgz'';
-    sha256 = ''1vbldjzj9py8vqyk0f3rb795cjai0h7p858dflm4l8p0kp4mll6f'';
+    url = "http://beta.quicklisp.org/archive/parenscript/2018-12-10/Parenscript-2.7.1.tgz";
+    sha256 = "1vbldjzj9py8vqyk0f3rb795cjai0h7p858dflm4l8p0kp4mll6f";
   };
 
   packageName = "parenscript";

pkgs/development/lisp-modules/quicklisp-to-nix-output/parse-declarations-1_dot_0.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''parse-declarations-1_dot_0'';
-  version = ''parse-declarations-20101006-darcs'';
+  baseName = "parse-declarations-1_dot_0";
+  version = "parse-declarations-20101006-darcs";
 
-  description = ''Library to parse and rebuild declarations.'';
+  description = "Library to parse and rebuild declarations.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/parse-declarations/2010-10-06/parse-declarations-20101006-darcs.tgz'';
-    sha256 = ''0r85b0jfacd28kr65kw9c13dx4i6id1dpmby68zjy63mqbnyawrd'';
+    url = "http://beta.quicklisp.org/archive/parse-declarations/2010-10-06/parse-declarations-20101006-darcs.tgz";
+    sha256 = "0r85b0jfacd28kr65kw9c13dx4i6id1dpmby68zjy63mqbnyawrd";
   };
 
   packageName = "parse-declarations-1.0";

pkgs/development/lisp-modules/quicklisp-to-nix-output/parse-number.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''parse-number'';
-  version = ''v1.7'';
+  baseName = "parse-number";
+  version = "v1.7";
 
   parasites = [ "parse-number/tests" ];
 
-  description = ''Number parsing library'';
+  description = "Number parsing library";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/parse-number/2018-02-28/parse-number-v1.7.tgz'';
-    sha256 = ''11ji8856ipmqki5i4cw1zgx8hahfi8x1raz1xb20c4rmgad6nsha'';
+    url = "http://beta.quicklisp.org/archive/parse-number/2018-02-28/parse-number-v1.7.tgz";
+    sha256 = "11ji8856ipmqki5i4cw1zgx8hahfi8x1raz1xb20c4rmgad6nsha";
   };
 
   packageName = "parse-number";

pkgs/development/lisp-modules/quicklisp-to-nix-output/parser-combinators.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''parser-combinators'';
-  version = ''cl-20131111-git'';
+  baseName = "parser-combinators";
+  version = "cl-20131111-git";
 
-  description = ''An implementation of parser combinators for Common Lisp'';
+  description = "An implementation of parser combinators for Common Lisp";
 
   deps = [ args."alexandria" args."iterate" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-parser-combinators/2013-11-11/cl-parser-combinators-20131111-git.tgz'';
-    sha256 = ''0wg1a7favbwqcxyqcy2zxi4l11qsp4ar9fvddmx960grf2d72lds'';
+    url = "http://beta.quicklisp.org/archive/cl-parser-combinators/2013-11-11/cl-parser-combinators-20131111-git.tgz";
+    sha256 = "0wg1a7favbwqcxyqcy2zxi4l11qsp4ar9fvddmx960grf2d72lds";
   };
 
   packageName = "parser-combinators";

pkgs/development/lisp-modules/quicklisp-to-nix-output/parser_dot_common-rules.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''parser_dot_common-rules'';
-  version = ''20200715-git'';
+  baseName = "parser_dot_common-rules";
+  version = "20200715-git";
 
   parasites = [ "parser.common-rules/test" ];
 
-  description = ''Provides common parsing rules that are useful in many grammars.'';
+  description = "Provides common parsing rules that are useful in many grammars.";
 
   deps = [ args."alexandria" args."anaphora" args."esrap" args."fiveam" args."let-plus" args."split-sequence" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/parser.common-rules/2020-07-15/parser.common-rules-20200715-git.tgz'';
-    sha256 = ''17nw0shhb8079b26ldwpfxggkzs6ysfqm4s4nr1rfhba9mkvxdxy'';
+    url = "http://beta.quicklisp.org/archive/parser.common-rules/2020-07-15/parser.common-rules-20200715-git.tgz";
+    sha256 = "17nw0shhb8079b26ldwpfxggkzs6ysfqm4s4nr1rfhba9mkvxdxy";
   };
 
   packageName = "parser.common-rules";

pkgs/development/lisp-modules/quicklisp-to-nix-output/pcall-queue.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''pcall-queue'';
-  version = ''pcall-0.3'';
+  baseName = "pcall-queue";
+  version = "pcall-0.3";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."bordeaux-threads" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/pcall/2010-10-06/pcall-0.3.tgz'';
-    sha256 = ''02idx1wnv9770fl2nh179sb8njw801g70b5mf8jqhqm2gwsb731y'';
+    url = "http://beta.quicklisp.org/archive/pcall/2010-10-06/pcall-0.3.tgz";
+    sha256 = "02idx1wnv9770fl2nh179sb8njw801g70b5mf8jqhqm2gwsb731y";
   };
 
   packageName = "pcall-queue";

pkgs/development/lisp-modules/quicklisp-to-nix-output/pcall.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''pcall'';
-  version = ''0.3'';
+  baseName = "pcall";
+  version = "0.3";
 
   parasites = [ "pcall-tests" ];
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."fiveam" args."pcall-queue" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/pcall/2010-10-06/pcall-0.3.tgz'';
-    sha256 = ''02idx1wnv9770fl2nh179sb8njw801g70b5mf8jqhqm2gwsb731y'';
+    url = "http://beta.quicklisp.org/archive/pcall/2010-10-06/pcall-0.3.tgz";
+    sha256 = "02idx1wnv9770fl2nh179sb8njw801g70b5mf8jqhqm2gwsb731y";
   };
 
   packageName = "pcall";

pkgs/development/lisp-modules/quicklisp-to-nix-output/plump.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''plump'';
-  version = ''20200427-git'';
+  baseName = "plump";
+  version = "20200427-git";
 
-  description = ''An XML / XHTML / HTML parser that aims to be as lenient as possible.'';
+  description = "An XML / XHTML / HTML parser that aims to be as lenient as possible.";
 
   deps = [ args."array-utils" args."documentation-utils" args."trivial-indent" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/plump/2020-04-27/plump-20200427-git.tgz'';
-    sha256 = ''0l5bi503djjkhrih94h5jbihlm60h267qm2ycq9m9fldp4fjrjic'';
+    url = "http://beta.quicklisp.org/archive/plump/2020-04-27/plump-20200427-git.tgz";
+    sha256 = "0l5bi503djjkhrih94h5jbihlm60h267qm2ycq9m9fldp4fjrjic";
   };
 
   packageName = "plump";

pkgs/development/lisp-modules/quicklisp-to-nix-output/postmodern.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''postmodern'';
-  version = ''20201016-git'';
+  baseName = "postmodern";
+  version = "20201016-git";
 
   parasites = [ "postmodern/tests" ];
 
-  description = ''PostgreSQL programming API'';
+  description = "PostgreSQL programming API";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."cl-base64" args."cl-postgres" args."cl-postgres_slash_tests" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."fiveam" args."flexi-streams" args."global-vars" args."ironclad" args."md5" args."s-sql" args."s-sql_slash_tests" args."simple-date" args."simple-date_slash_postgres-glue" args."split-sequence" args."uax-15" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/postmodern/2020-10-16/postmodern-20201016-git.tgz'';
-    sha256 = ''1svaiksbqcaq8sh7q6sj9kzazdfl360zqr2nzhwbgy4xnaj4vf3n'';
+    url = "http://beta.quicklisp.org/archive/postmodern/2020-10-16/postmodern-20201016-git.tgz";
+    sha256 = "1svaiksbqcaq8sh7q6sj9kzazdfl360zqr2nzhwbgy4xnaj4vf3n";
   };
 
   packageName = "postmodern";

pkgs/development/lisp-modules/quicklisp-to-nix-output/proc-parse.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''proc-parse'';
-  version = ''20190813-git'';
+  baseName = "proc-parse";
+  version = "20190813-git";
 
-  description = ''Procedural vector parser'';
+  description = "Procedural vector parser";
 
   deps = [ args."alexandria" args."babel" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/proc-parse/2019-08-13/proc-parse-20190813-git.tgz'';
-    sha256 = ''126l7mqxjcgw2limddgrdq63cdhwkhaxabxl9l0bjadf92nczg0j'';
+    url = "http://beta.quicklisp.org/archive/proc-parse/2019-08-13/proc-parse-20190813-git.tgz";
+    sha256 = "126l7mqxjcgw2limddgrdq63cdhwkhaxabxl9l0bjadf92nczg0j";
   };
 
   packageName = "proc-parse";

pkgs/development/lisp-modules/quicklisp-to-nix-output/prove-asdf.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''prove-asdf'';
-  version = ''prove-20200218-git'';
+  baseName = "prove-asdf";
+  version = "prove-20200218-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/prove/2020-02-18/prove-20200218-git.tgz'';
-    sha256 = ''1sv3zyam9sdmyis5lyv0khvw82q7bcpsycpj9b3bsv9isb4j30zn'';
+    url = "http://beta.quicklisp.org/archive/prove/2020-02-18/prove-20200218-git.tgz";
+    sha256 = "1sv3zyam9sdmyis5lyv0khvw82q7bcpsycpj9b3bsv9isb4j30zn";
   };
 
   packageName = "prove-asdf";

pkgs/development/lisp-modules/quicklisp-to-nix-output/prove.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''prove'';
-  version = ''20200218-git'';
+  baseName = "prove";
+  version = "20200218-git";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."alexandria" args."anaphora" args."cl-ansi-text" args."cl-colors" args."cl-colors2" args."cl-ppcre" args."let-plus" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/prove/2020-02-18/prove-20200218-git.tgz'';
-    sha256 = ''1sv3zyam9sdmyis5lyv0khvw82q7bcpsycpj9b3bsv9isb4j30zn'';
+    url = "http://beta.quicklisp.org/archive/prove/2020-02-18/prove-20200218-git.tgz";
+    sha256 = "1sv3zyam9sdmyis5lyv0khvw82q7bcpsycpj9b3bsv9isb4j30zn";
   };
 
   packageName = "prove";

pkgs/development/lisp-modules/quicklisp-to-nix-output/ptester.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''ptester'';
-  version = ''20160929-git'';
+  baseName = "ptester";
+  version = "20160929-git";
 
-  description = ''Portable test harness package'';
+  description = "Portable test harness package";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/ptester/2016-09-29/ptester-20160929-git.tgz'';
-    sha256 = ''04rlq1zljhxc65pm31bah3sq3as24l0sdivz440s79qlnnyh13hz'';
+    url = "http://beta.quicklisp.org/archive/ptester/2016-09-29/ptester-20160929-git.tgz";
+    sha256 = "04rlq1zljhxc65pm31bah3sq3as24l0sdivz440s79qlnnyh13hz";
   };
 
   packageName = "ptester";

pkgs/development/lisp-modules/quicklisp-to-nix-output/puri.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''puri'';
-  version = ''20201016-git'';
+  baseName = "puri";
+  version = "20201016-git";
 
   parasites = [ "puri/test" ];
 
-  description = ''Portable Universal Resource Indentifier Library'';
+  description = "Portable Universal Resource Indentifier Library";
 
   deps = [ args."ptester" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/puri/2020-10-16/puri-20201016-git.tgz'';
-    sha256 = ''16h7gip6d0564s9yba3jg0rjzndmysv531hcrngvi3j3sandjfzx'';
+    url = "http://beta.quicklisp.org/archive/puri/2020-10-16/puri-20201016-git.tgz";
+    sha256 = "16h7gip6d0564s9yba3jg0rjzndmysv531hcrngvi3j3sandjfzx";
   };
 
   packageName = "puri";

pkgs/development/lisp-modules/quicklisp-to-nix-output/pythonic-string-reader.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''pythonic-string-reader'';
-  version = ''20180711-git'';
+  baseName = "pythonic-string-reader";
+  version = "20180711-git";
 
   description = ''A simple and unintrusive read table modification that allows for
 simple string literal definition that doesn't require escaping characters.'';
···
   deps = [ args."named-readtables" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/pythonic-string-reader/2018-07-11/pythonic-string-reader-20180711-git.tgz'';
-    sha256 = ''0gr6sbkmfwca9r0xa5vczjm4s9psbrqy5hvijkp5g42b0b7x5myx'';
+    url = "http://beta.quicklisp.org/archive/pythonic-string-reader/2018-07-11/pythonic-string-reader-20180711-git.tgz";
+    sha256 = "0gr6sbkmfwca9r0xa5vczjm4s9psbrqy5hvijkp5g42b0b7x5myx";
   };
 
   packageName = "pythonic-string-reader";

pkgs/development/lisp-modules/quicklisp-to-nix-output/query-fs.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''query-fs'';
-  version = ''20200610-git'';
+  baseName = "query-fs";
+  version = "20200610-git";
 
-  description = ''High-level virtual FS using CL-Fuse-Meta-FS to represent results of queries'';
+  description = "High-level virtual FS using CL-Fuse-Meta-FS to represent results of queries";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-fuse" args."cl-fuse-meta-fs" args."cl-ppcre" args."cl-utilities" args."command-line-arguments" args."iterate" args."pcall" args."pcall-queue" args."trivial-backtrace" args."trivial-features" args."trivial-utf-8" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/query-fs/2020-06-10/query-fs-20200610-git.tgz'';
-    sha256 = ''1kcq2xs5dqwbhapknrynanwqn3c9h4cpi7hf362il2p6v6y4r413'';
+    url = "http://beta.quicklisp.org/archive/query-fs/2020-06-10/query-fs-20200610-git.tgz";
+    sha256 = "1kcq2xs5dqwbhapknrynanwqn3c9h4cpi7hf362il2p6v6y4r413";
   };
 
   packageName = "query-fs";

pkgs/development/lisp-modules/quicklisp-to-nix-output/quri.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''quri'';
-  version = ''20200610-git'';
+  baseName = "quri";
+  version = "20200610-git";
 
-  description = ''Yet another URI library for Common Lisp'';
+  description = "Yet another URI library for Common Lisp";
 
   deps = [ args."alexandria" args."babel" args."cl-utilities" args."split-sequence" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/quri/2020-06-10/quri-20200610-git.tgz'';
-    sha256 = ''1qv8x1m6m70jczvydfq9ws5zw3jw6y74s607vfrqaf0ck5rrwsk6'';
+    url = "http://beta.quicklisp.org/archive/quri/2020-06-10/quri-20200610-git.tgz";
+    sha256 = "1qv8x1m6m70jczvydfq9ws5zw3jw6y74s607vfrqaf0ck5rrwsk6";
   };
 
   packageName = "quri";

pkgs/development/lisp-modules/quicklisp-to-nix-output/rfc2388.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''rfc2388'';
-  version = ''20180831-git'';
+  baseName = "rfc2388";
+  version = "20180831-git";
 
-  description = ''Implementation of RFC 2388'';
+  description = "Implementation of RFC 2388";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/rfc2388/2018-08-31/rfc2388-20180831-git.tgz'';
-    sha256 = ''1r7vvrlq2wl213bm2aknkf34ynpl8y4nbkfir79srrdsl1337z33'';
+    url = "http://beta.quicklisp.org/archive/rfc2388/2018-08-31/rfc2388-20180831-git.tgz";
+    sha256 = "1r7vvrlq2wl213bm2aknkf34ynpl8y4nbkfir79srrdsl1337z33";
   };
 
   packageName = "rfc2388";

pkgs/development/lisp-modules/quicklisp-to-nix-output/rove.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''rove'';
-  version = ''20200325-git'';
+  baseName = "rove";
+  version = "20200325-git";
 
-  description = ''Yet another testing framework intended to be a successor of Prove'';
+  description = "Yet another testing framework intended to be a successor of Prove";
 
   deps = [ args."bordeaux-threads" args."dissect" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/rove/2020-03-25/rove-20200325-git.tgz'';
-    sha256 = ''0zn8d3408rgy2nibia5hdfbf80ix1fgssywx01izx7z99l5x50z5'';
+    url = "http://beta.quicklisp.org/archive/rove/2020-03-25/rove-20200325-git.tgz";
+    sha256 = "0zn8d3408rgy2nibia5hdfbf80ix1fgssywx01izx7z99l5x50z5";
   };
 
   packageName = "rove";

pkgs/development/lisp-modules/quicklisp-to-nix-output/rt.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''rt'';
-  version = ''20101006-git'';
+  baseName = "rt";
+  version = "20101006-git";
 
-  description = ''MIT Regression Tester'';
+  description = "MIT Regression Tester";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/rt/2010-10-06/rt-20101006-git.tgz'';
-    sha256 = ''1jncar0xwkqk8yrc2dln389ivvgzs7ijdhhs3zpfyi5d21f0qa1v'';
+    url = "http://beta.quicklisp.org/archive/rt/2010-10-06/rt-20101006-git.tgz";
+    sha256 = "1jncar0xwkqk8yrc2dln389ivvgzs7ijdhhs3zpfyi5d21f0qa1v";
   };
 
   packageName = "rt";

pkgs/development/lisp-modules/quicklisp-to-nix-output/s-sql.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''s-sql'';
-  version = ''postmodern-20201016-git'';
+  baseName = "s-sql";
+  version = "postmodern-20201016-git";
 
   parasites = [ "s-sql/tests" ];
 
-  description = ''Lispy DSL for SQL'';
+  description = "Lispy DSL for SQL";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."cl-base64" args."cl-postgres" args."cl-postgres_slash_tests" args."cl-ppcre" args."cl-unicode" args."closer-mop" args."fiveam" args."global-vars" args."ironclad" args."md5" args."postmodern" args."split-sequence" args."uax-15" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/postmodern/2020-10-16/postmodern-20201016-git.tgz'';
-    sha256 = ''1svaiksbqcaq8sh7q6sj9kzazdfl360zqr2nzhwbgy4xnaj4vf3n'';
+    url = "http://beta.quicklisp.org/archive/postmodern/2020-10-16/postmodern-20201016-git.tgz";
+    sha256 = "1svaiksbqcaq8sh7q6sj9kzazdfl360zqr2nzhwbgy4xnaj4vf3n";
   };
 
   packageName = "s-sql";

pkgs/development/lisp-modules/quicklisp-to-nix-output/s-sysdeps.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''s-sysdeps'';
-  version = ''20200427-git'';
+  baseName = "s-sysdeps";
+  version = "20200427-git";
 
-  description = ''An abstraction layer over platform dependent functionality'';
+  description = "An abstraction layer over platform dependent functionality";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."split-sequence" args."usocket" args."usocket-server" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/s-sysdeps/2020-04-27/s-sysdeps-20200427-git.tgz'';
-    sha256 = ''04dhi0mibqz4i1jly9i6lrd9lf93i25k2f0hba1sqis3x6sm38zy'';
+    url = "http://beta.quicklisp.org/archive/s-sysdeps/2020-04-27/s-sysdeps-20200427-git.tgz";
+    sha256 = "04dhi0mibqz4i1jly9i6lrd9lf93i25k2f0hba1sqis3x6sm38zy";
   };
 
   packageName = "s-sysdeps";

pkgs/development/lisp-modules/quicklisp-to-nix-output/s-xml.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''s-xml'';
-  version = ''20150608-git'';
+  baseName = "s-xml";
+  version = "20150608-git";
 
   parasites = [ "s-xml.examples" "s-xml.test" ];
 
-  description = ''Simple Common Lisp XML Parser'';
+  description = "Simple Common Lisp XML Parser";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/s-xml/2015-06-08/s-xml-20150608-git.tgz'';
-    sha256 = ''0cy36wqzasqma4maw9djq1vdwsp5hxq8svlbnhbv9sq9zzys5viq'';
+    url = "http://beta.quicklisp.org/archive/s-xml/2015-06-08/s-xml-20150608-git.tgz";
+    sha256 = "0cy36wqzasqma4maw9djq1vdwsp5hxq8svlbnhbv9sq9zzys5viq";
   };
 
   packageName = "s-xml";

pkgs/development/lisp-modules/quicklisp-to-nix-output/salza2.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''salza2'';
-  version = ''2.0.9'';
+  baseName = "salza2";
+  version = "2.0.9";
 
   description = ''Create compressed data in the ZLIB, DEFLATE, or GZIP
   data formats'';
···
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/salza2/2013-07-20/salza2-2.0.9.tgz'';
-    sha256 = ''1m0hksgvq3njd9xa2nxlm161vgzw77djxmisq08v9pz2bz16v8va'';
+    url = "http://beta.quicklisp.org/archive/salza2/2013-07-20/salza2-2.0.9.tgz";
+    sha256 = "1m0hksgvq3njd9xa2nxlm161vgzw77djxmisq08v9pz2bz16v8va";
   };
 
   packageName = "salza2";

pkgs/development/lisp-modules/quicklisp-to-nix-output/serapeum.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''serapeum'';
-  version = ''20201016-git'';
+  baseName = "serapeum";
+  version = "20201016-git";
 
-  description = ''Utilities beyond Alexandria.'';
+  description = "Utilities beyond Alexandria.";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."closer-mop" args."fare-quasiquote" args."fare-quasiquote-extras" args."fare-quasiquote-optima" args."fare-quasiquote-readtable" args."fare-utils" args."global-vars" args."introspect-environment" args."iterate" args."lisp-namespace" args."named-readtables" args."parse-declarations-1_dot_0" args."parse-number" args."split-sequence" args."string-case" args."trivia" args."trivia_dot_balland2006" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_quasiquote" args."trivia_dot_trivial" args."trivial-cltl2" args."trivial-file-size" args."trivial-garbage" args."trivial-macroexpand-all" args."type-i" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/serapeum/2020-10-16/serapeum-20201016-git.tgz'';
-    sha256 = ''0rbxa0r75jxkhisyjwjh7zn7m1450k58sc9g68bgkj0fsjvr44sq'';
+    url = "http://beta.quicklisp.org/archive/serapeum/2020-10-16/serapeum-20201016-git.tgz";
+    sha256 = "0rbxa0r75jxkhisyjwjh7zn7m1450k58sc9g68bgkj0fsjvr44sq";
   };
 
   packageName = "serapeum";

pkgs/development/lisp-modules/quicklisp-to-nix-output/simple-date-time.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''simple-date-time'';
-  version = ''20160421-git'';
+  baseName = "simple-date-time";
+  version = "20160421-git";
 
-  description = ''date and time library for common lisp'';
+  description = "date and time library for common lisp";
 
   deps = [ args."cl-ppcre" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/simple-date-time/2016-04-21/simple-date-time-20160421-git.tgz'';
-    sha256 = ''1db9n7pspxkqkzz12829a1lp7v4ghrnlb7g3wh04yz6m224d3i4h'';
+    url = "http://beta.quicklisp.org/archive/simple-date-time/2016-04-21/simple-date-time-20160421-git.tgz";
+    sha256 = "1db9n7pspxkqkzz12829a1lp7v4ghrnlb7g3wh04yz6m224d3i4h";
   };
 
   packageName = "simple-date-time";

pkgs/development/lisp-modules/quicklisp-to-nix-output/simple-date.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''simple-date'';
-  version = ''postmodern-20201016-git'';
+  baseName = "simple-date";
+  version = "postmodern-20201016-git";
 
   parasites = [ "simple-date/tests" ];
 
-  description = ''Simple date library that can be used with postmodern'';
+  description = "Simple date library that can be used with postmodern";
 
   deps = [ args."fiveam" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/postmodern/2020-10-16/postmodern-20201016-git.tgz'';
-    sha256 = ''1svaiksbqcaq8sh7q6sj9kzazdfl360zqr2nzhwbgy4xnaj4vf3n'';
+    url = "http://beta.quicklisp.org/archive/postmodern/2020-10-16/postmodern-20201016-git.tgz";
+    sha256 = "1svaiksbqcaq8sh7q6sj9kzazdfl360zqr2nzhwbgy4xnaj4vf3n";
   };
 
   packageName = "simple-date";

pkgs/development/lisp-modules/quicklisp-to-nix-output/simple-tasks.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''simple-tasks'';
-  version = ''20190710-git'';
+  baseName = "simple-tasks";
+  version = "20190710-git";
 
-  description = ''A very simple task scheduling framework.'';
+  description = "A very simple task scheduling framework.";
 
   deps = [ args."alexandria" args."array-utils" args."bordeaux-threads" args."dissect" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/simple-tasks/2019-07-10/simple-tasks-20190710-git.tgz'';
-    sha256 = ''12y5phnbj9s2fsrz1ab6xj857zf1fv8kjk7jj2mdjs6k2d8gk8v3'';
+    url = "http://beta.quicklisp.org/archive/simple-tasks/2019-07-10/simple-tasks-20190710-git.tgz";
+    sha256 = "12y5phnbj9s2fsrz1ab6xj857zf1fv8kjk7jj2mdjs6k2d8gk8v3";
   };
 
   packageName = "simple-tasks";

pkgs/development/lisp-modules/quicklisp-to-nix-output/smart-buffer.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''smart-buffer'';
-  version = ''20160628-git'';
+  baseName = "smart-buffer";
+  version = "20160628-git";
 
-  description = ''Smart octets buffer'';
+  description = "Smart octets buffer";
 
   deps = [ args."flexi-streams" args."trivial-gray-streams" args."uiop" args."xsubseq" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/smart-buffer/2016-06-28/smart-buffer-20160628-git.tgz'';
-    sha256 = ''1wp50snkc8739n91xlnfnq1dzz3kfp0awgp92m7xbpcw3hbaib1s'';
+    url = "http://beta.quicklisp.org/archive/smart-buffer/2016-06-28/smart-buffer-20160628-git.tgz";
+    sha256 = "1wp50snkc8739n91xlnfnq1dzz3kfp0awgp92m7xbpcw3hbaib1s";
   };
 
   packageName = "smart-buffer";

pkgs/development/lisp-modules/quicklisp-to-nix-output/split-sequence.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''split-sequence'';
-  version = ''v2.0.0'';
+  baseName = "split-sequence";
+  version = "v2.0.0";
 
   parasites = [ "split-sequence/tests" ];
 
···
   deps = [ args."fiveam" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/split-sequence/2019-05-21/split-sequence-v2.0.0.tgz'';
-    sha256 = ''09cmmswzl1kahvlzgqv8lqm9qcnz5iqg8f26fw3mm9rb3dcp7aba'';
+    url = "http://beta.quicklisp.org/archive/split-sequence/2019-05-21/split-sequence-v2.0.0.tgz";
+    sha256 = "09cmmswzl1kahvlzgqv8lqm9qcnz5iqg8f26fw3mm9rb3dcp7aba";
   };
 
   packageName = "split-sequence";

pkgs/development/lisp-modules/quicklisp-to-nix-output/sqlite.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''sqlite'';
-  version = ''cl-20190813-git'';
+  baseName = "sqlite";
+  version = "cl-20190813-git";
 
-  description = ''CL-SQLITE package is an interface to the SQLite embedded relational database engine.'';
+  description = "CL-SQLITE package is an interface to the SQLite embedded relational database engine.";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."iterate" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-sqlite/2019-08-13/cl-sqlite-20190813-git.tgz'';
-    sha256 = ''07zla2h7i7ggmzsyj33f12vpxvcbbvq6x022c2dy13flx8a83rmk'';
+    url = "http://beta.quicklisp.org/archive/cl-sqlite/2019-08-13/cl-sqlite-20190813-git.tgz";
+    sha256 = "07zla2h7i7ggmzsyj33f12vpxvcbbvq6x022c2dy13flx8a83rmk";
   };
 
   packageName = "sqlite";

pkgs/development/lisp-modules/quicklisp-to-nix-output/static-vectors.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''static-vectors'';
-  version = ''v1.8.6'';
+  baseName = "static-vectors";
+  version = "v1.8.6";
 
   parasites = [ "static-vectors/test" ];
 
-  description = ''Create vectors allocated in static memory.'';
+  description = "Create vectors allocated in static memory.";
 
   deps = [ args."alexandria" args."babel" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."fiveam" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/static-vectors/2020-06-10/static-vectors-v1.8.6.tgz'';
-    sha256 = ''0s549cxd8a8ix6jl4dfxj2nh01nl9f4hgnlmb88w7iixanxn58mc'';
+    url = "http://beta.quicklisp.org/archive/static-vectors/2020-06-10/static-vectors-v1.8.6.tgz";
+    sha256 = "0s549cxd8a8ix6jl4dfxj2nh01nl9f4hgnlmb88w7iixanxn58mc";
   };
 
   packageName = "static-vectors";

pkgs/development/lisp-modules/quicklisp-to-nix-output/stefil.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''stefil'';
-  version = ''20181210-git'';
+  baseName = "stefil";
+  version = "20181210-git";
 
   parasites = [ "stefil-test" ];
 
-  description = ''Stefil - Simple Test Framework In Lisp'';
+  description = "Stefil - Simple Test Framework In Lisp";
 
   deps = [ args."alexandria" args."iterate" args."metabang-bind" args."swank" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/stefil/2018-12-10/stefil-20181210-git.tgz'';
-    sha256 = ''10dr8yjrjc2pyx55knds5llh9k716khlvbkmpxh0vn8rdmxmz96g'';
+    url = "http://beta.quicklisp.org/archive/stefil/2018-12-10/stefil-20181210-git.tgz";
+    sha256 = "10dr8yjrjc2pyx55knds5llh9k716khlvbkmpxh0vn8rdmxmz96g";
   };
 
   packageName = "stefil";

pkgs/development/lisp-modules/quicklisp-to-nix-output/str.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''str'';
-  version = ''cl-20200925-git'';
+  baseName = "str";
+  version = "cl-20200925-git";
 
-  description = ''Modern, consistent and terse Common Lisp string manipulation library.'';
+  description = "Modern, consistent and terse Common Lisp string manipulation library.";
 
   deps = [ args."cl-change-case" args."cl-ppcre" args."cl-ppcre-unicode" args."cl-unicode" args."flexi-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-str/2020-09-25/cl-str-20200925-git.tgz'';
-    sha256 = ''06k81x80vjw7qd8gca6lnm5k5ws40c6kl99s7m4z72v7jxwa9ykn'';
+    url = "http://beta.quicklisp.org/archive/cl-str/2020-09-25/cl-str-20200925-git.tgz";
+    sha256 = "06k81x80vjw7qd8gca6lnm5k5ws40c6kl99s7m4z72v7jxwa9ykn";
   };
 
   packageName = "str";

pkgs/development/lisp-modules/quicklisp-to-nix-output/string-case.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''string-case'';
-  version = ''20180711-git'';
+  baseName = "string-case";
+  version = "20180711-git";
 
-  description = ''string-case is a macro that generates specialised decision trees to dispatch on string equality'';
+  description = "string-case is a macro that generates specialised decision trees to dispatch on string equality";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/string-case/2018-07-11/string-case-20180711-git.tgz'';
-    sha256 = ''1n36ign4bv0idw14zyayn6i0n3iaff9yw92kpjh3qmdcq3asv90z'';
+    url = "http://beta.quicklisp.org/archive/string-case/2018-07-11/string-case-20180711-git.tgz";
+    sha256 = "1n36ign4bv0idw14zyayn6i0n3iaff9yw92kpjh3qmdcq3asv90z";
   };
 
   packageName = "string-case";

pkgs/development/lisp-modules/quicklisp-to-nix-output/stumpwm.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''stumpwm'';
-  version = ''20201016-git'';
+  baseName = "stumpwm";
+  version = "20201016-git";
 
-  description = ''A tiling, keyboard driven window manager'';
+  description = "A tiling, keyboard driven window manager";
 
   deps = [ args."alexandria" args."cl-ppcre" args."clx" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/stumpwm/2020-10-16/stumpwm-20201016-git.tgz'';
-    sha256 = ''06lc1d9y83x0ckqd9pls7a1dyriz650mpv1rigncr02qsj3aqpp2'';
+    url = "http://beta.quicklisp.org/archive/stumpwm/2020-10-16/stumpwm-20201016-git.tgz";
+    sha256 = "06lc1d9y83x0ckqd9pls7a1dyriz650mpv1rigncr02qsj3aqpp2";
   };
 
   packageName = "stumpwm";

pkgs/development/lisp-modules/quicklisp-to-nix-output/swank.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''swank'';
-  version = ''slime-v2.26'';
+  baseName = "swank";
+  version = "slime-v2.26";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/slime/2020-09-25/slime-v2.26.tgz'';
-    sha256 = ''0zba4vm73g9zamhqkqcb0prm51kf4clixm2rjz89mq180qa7rrqc'';
+    url = "http://beta.quicklisp.org/archive/slime/2020-09-25/slime-v2.26.tgz";
+    sha256 = "0zba4vm73g9zamhqkqcb0prm51kf4clixm2rjz89mq180qa7rrqc";
   };
 
   packageName = "swank";

pkgs/development/lisp-modules/quicklisp-to-nix-output/swap-bytes.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''swap-bytes'';
-  version = ''v1.2'';
+  baseName = "swap-bytes";
+  version = "v1.2";
 
   parasites = [ "swap-bytes/test" ];
 
-  description = ''Optimized byte-swapping primitives.'';
+  description = "Optimized byte-swapping primitives.";
 
   deps = [ args."fiveam" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/swap-bytes/2019-11-30/swap-bytes-v1.2.tgz'';
-    sha256 = ''05g37m4cpsszh16jz7kiscd6m6l66ms73f3s6s94i56c49jfxdy8'';
+    url = "http://beta.quicklisp.org/archive/swap-bytes/2019-11-30/swap-bytes-v1.2.tgz";
+    sha256 = "05g37m4cpsszh16jz7kiscd6m6l66ms73f3s6s94i56c49jfxdy8";
   };
 
   packageName = "swap-bytes";

pkgs/development/lisp-modules/quicklisp-to-nix-output/symbol-munger.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''symbol-munger'';
-  version = ''20150407-git'';
+  baseName = "symbol-munger";
+  version = "20150407-git";
 
   description = ''Functions to convert between the spacing and
   capitalization conventions of various environments'';
···
   deps = [ args."alexandria" args."iterate" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/symbol-munger/2015-04-07/symbol-munger-20150407-git.tgz'';
-    sha256 = ''0dccli8557kvyy2rngh646rmavf96p7xqn5bry65d7c1f61lyqv6'';
+    url = "http://beta.quicklisp.org/archive/symbol-munger/2015-04-07/symbol-munger-20150407-git.tgz";
+    sha256 = "0dccli8557kvyy2rngh646rmavf96p7xqn5bry65d7c1f61lyqv6";
   };
 
   packageName = "symbol-munger";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivia'';
-  version = ''20200925-git'';
+  baseName = "trivia";
+  version = "20200925-git";
 
-  description = ''NON-optimized pattern matcher compatible with OPTIMA, with extensible optimizer interface and clean codebase'';
+  description = "NON-optimized pattern matcher compatible with OPTIMA, with extensible optimizer interface and clean codebase";
 
   deps = [ args."alexandria" args."closer-mop" args."introspect-environment" args."iterate" args."lisp-namespace" args."trivia_dot_balland2006" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_trivial" args."trivial-cltl2" args."type-i" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz'';
-    sha256 = ''192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z'';
+    url = "http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz";
+    sha256 = "192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z";
   };
 
   packageName = "trivia";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_balland2006.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivia_dot_balland2006'';
-  version = ''trivia-20200925-git'';
+  baseName = "trivia_dot_balland2006";
+  version = "trivia-20200925-git";
 
-  description = ''Optimizer for Trivia based on (Balland 2006)'';
+  description = "Optimizer for Trivia based on (Balland 2006)";
 
   deps = [ args."alexandria" args."closer-mop" args."introspect-environment" args."iterate" args."lisp-namespace" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_trivial" args."trivial-cltl2" args."type-i" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz'';
-    sha256 = ''192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z'';
+    url = "http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz";
+    sha256 = "192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z";
   };
 
   packageName = "trivia.balland2006";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level0.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivia_dot_level0'';
-  version = ''trivia-20200925-git'';
+  baseName = "trivia_dot_level0";
+  version = "trivia-20200925-git";
 
-  description = ''Bootstrapping Pattern Matching Library for implementing Trivia'';
+  description = "Bootstrapping Pattern Matching Library for implementing Trivia";
 
   deps = [ args."alexandria" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz'';
-    sha256 = ''192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z'';
+    url = "http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz";
+    sha256 = "192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z";
   };
 
   packageName = "trivia.level0";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level1.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivia_dot_level1'';
-  version = ''trivia-20200925-git'';
+  baseName = "trivia_dot_level1";
+  version = "trivia-20200925-git";
 
-  description = ''Core patterns of Trivia'';
+  description = "Core patterns of Trivia";
 
   deps = [ args."alexandria" args."trivia_dot_level0" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz'';
-    sha256 = ''192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z'';
+    url = "http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz";
+    sha256 = "192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z";
   };
 
   packageName = "trivia.level1";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_level2.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivia_dot_level2'';
-  version = ''trivia-20200925-git'';
+  baseName = "trivia_dot_level2";
+  version = "trivia-20200925-git";
 
-  description = ''NON-optimized pattern matcher compatible with OPTIMA, with extensible optimizer interface and clean codebase'';
+  description = "NON-optimized pattern matcher compatible with OPTIMA, with extensible optimizer interface and clean codebase";
 
   deps = [ args."alexandria" args."closer-mop" args."lisp-namespace" args."trivia_dot_level0" args."trivia_dot_level1" args."trivial-cltl2" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz'';
-    sha256 = ''192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z'';
+    url = "http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz";
+    sha256 = "192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z";
   };
 
   packageName = "trivia.level2";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_quasiquote.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivia_dot_quasiquote'';
-  version = ''trivia-20200925-git'';
+  baseName = "trivia_dot_quasiquote";
+  version = "trivia-20200925-git";
 
-  description = ''fare-quasiquote extension for trivia'';
+  description = "fare-quasiquote extension for trivia";
 
   deps = [ args."alexandria" args."closer-mop" args."fare-quasiquote" args."fare-quasiquote-readtable" args."fare-utils" args."lisp-namespace" args."named-readtables" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_trivial" args."trivial-cltl2" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz'';
-    sha256 = ''192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z'';
+    url = "http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz";
+    sha256 = "192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z";
   };
 
   packageName = "trivia.quasiquote";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivia_dot_trivial.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivia_dot_trivial'';
-  version = ''trivia-20200925-git'';
+  baseName = "trivia_dot_trivial";
+  version = "trivia-20200925-git";
 
   description = ''Base level system of Trivia with a trivial optimizer.
  Systems that intend to enhance Trivia should depend on this package, not the TRIVIA system,
···
   deps = [ args."alexandria" args."closer-mop" args."lisp-namespace" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivial-cltl2" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz'';
-    sha256 = ''192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z'';
+    url = "http://beta.quicklisp.org/archive/trivia/2020-09-25/trivia-20200925-git.tgz";
+    sha256 = "192306pdx50nikph36swipdy2xz1jqrr8p9c3bi91m8qws75wi4z";
   };
 
   packageName = "trivia.trivial";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-backtrace.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-backtrace'';
-  version = ''20200610-git'';
+  baseName = "trivial-backtrace";
+  version = "20200610-git";
 
-  description = ''trivial-backtrace'';
+  description = "trivial-backtrace";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-backtrace/2020-06-10/trivial-backtrace-20200610-git.tgz'';
-    sha256 = ''0slz2chal6vpiqx9zmjh4cnihhw794rq3267s7kz7livpiv52rks'';
+    url = "http://beta.quicklisp.org/archive/trivial-backtrace/2020-06-10/trivial-backtrace-20200610-git.tgz";
+    sha256 = "0slz2chal6vpiqx9zmjh4cnihhw794rq3267s7kz7livpiv52rks";
   };
 
   packageName = "trivial-backtrace";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-clipboard.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-clipboard'';
-  version = ''20200925-git'';
+  baseName = "trivial-clipboard";
+  version = "20200925-git";
 
-  description = ''trivial-clipboard let access system clipboard.'';
+  description = "trivial-clipboard let access system clipboard.";
 
   deps = [ args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-clipboard/2020-09-25/trivial-clipboard-20200925-git.tgz'';
-    sha256 = ''1aksag9nfklkg0bshd7dxfip4dj9gl3x0cbisgd2c143k2csb1yc'';
+    url = "http://beta.quicklisp.org/archive/trivial-clipboard/2020-09-25/trivial-clipboard-20200925-git.tgz";
+    sha256 = "1aksag9nfklkg0bshd7dxfip4dj9gl3x0cbisgd2c143k2csb1yc";
   };
 
   packageName = "trivial-clipboard";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-cltl2.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-cltl2'';
-  version = ''20200325-git'';
+  baseName = "trivial-cltl2";
+  version = "20200325-git";
 
-  description = ''Compatibility package exporting CLtL2 functionality'';
+  description = "Compatibility package exporting CLtL2 functionality";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-cltl2/2020-03-25/trivial-cltl2-20200325-git.tgz'';
-    sha256 = ''0hahi36v47alsvamg62d0cgay8l0razcgxl089ifj6sqy7s8iwys'';
+    url = "http://beta.quicklisp.org/archive/trivial-cltl2/2020-03-25/trivial-cltl2-20200325-git.tgz";
+    sha256 = "0hahi36v47alsvamg62d0cgay8l0razcgxl089ifj6sqy7s8iwys";
   };
 
   packageName = "trivial-cltl2";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-features.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-features'';
-  version = ''20200715-git'';
+  baseName = "trivial-features";
+  version = "20200715-git";
 
-  description = ''Ensures consistent *FEATURES* across multiple CLs.'';
+  description = "Ensures consistent *FEATURES* across multiple CLs.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-features/2020-07-15/trivial-features-20200715-git.tgz'';
-    sha256 = ''0h0xxkp7vciq5yj6a1b5k76h7mzqgb5f9v25nssijgp738nmkni2'';
+    url = "http://beta.quicklisp.org/archive/trivial-features/2020-07-15/trivial-features-20200715-git.tgz";
+    sha256 = "0h0xxkp7vciq5yj6a1b5k76h7mzqgb5f9v25nssijgp738nmkni2";
   };
 
   packageName = "trivial-features";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-file-size.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-file-size'';
-  version = ''20200427-git'';
+  baseName = "trivial-file-size";
+  version = "20200427-git";
 
   parasites = [ "trivial-file-size/tests" ];
 
-  description = ''Stat a file's size.'';
+  description = "Stat a file's size.";
 
   deps = [ args."fiveam" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-file-size/2020-04-27/trivial-file-size-20200427-git.tgz'';
-    sha256 = ''1vspkgygrldbjb4gdm1fsn04j50rwil41x0fvvm4fxm84rwrscsa'';
+    url = "http://beta.quicklisp.org/archive/trivial-file-size/2020-04-27/trivial-file-size-20200427-git.tgz";
+    sha256 = "1vspkgygrldbjb4gdm1fsn04j50rwil41x0fvvm4fxm84rwrscsa";
   };
 
   packageName = "trivial-file-size";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-garbage.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-garbage'';
-  version = ''20200925-git'';
+  baseName = "trivial-garbage";
+  version = "20200925-git";
 
   parasites = [ "trivial-garbage/tests" ];
 
-  description = ''Portable finalizers, weak hash-tables and weak pointers.'';
+  description = "Portable finalizers, weak hash-tables and weak pointers.";
 
   deps = [ args."rt" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-garbage/2020-09-25/trivial-garbage-20200925-git.tgz'';
-    sha256 = ''00iw2iw6qzji9b2gwy798l54jdk185sxh1k7m2qd9srs8s730k83'';
+    url = "http://beta.quicklisp.org/archive/trivial-garbage/2020-09-25/trivial-garbage-20200925-git.tgz";
+    sha256 = "00iw2iw6qzji9b2gwy798l54jdk185sxh1k7m2qd9srs8s730k83";
   };
 
   packageName = "trivial-garbage";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-gray-streams.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-gray-streams'';
-  version = ''20200925-git'';
+  baseName = "trivial-gray-streams";
+  version = "20200925-git";
 
-  description = ''Compatibility layer for Gray Streams (see http://www.cliki.net/Gray%20streams).'';
+  description = "Compatibility layer for Gray Streams (see http://www.cliki.net/Gray%20streams).";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-gray-streams/2020-09-25/trivial-gray-streams-20200925-git.tgz'';
-    sha256 = ''1mg31fwjixd04lfqbpzjan3cny1i478xm1a9l3p0i9m4dv4g2k2b'';
+    url = "http://beta.quicklisp.org/archive/trivial-gray-streams/2020-09-25/trivial-gray-streams-20200925-git.tgz";
+    sha256 = "1mg31fwjixd04lfqbpzjan3cny1i478xm1a9l3p0i9m4dv4g2k2b";
   };
 
   packageName = "trivial-gray-streams";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-indent.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-indent'';
-  version = ''20191007-git'';
+  baseName = "trivial-indent";
+  version = "20191007-git";
 
-  description = ''A very simple library to allow indentation hints for SWANK.'';
+  description = "A very simple library to allow indentation hints for SWANK.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-indent/2019-10-07/trivial-indent-20191007-git.tgz'';
-    sha256 = ''0v5isxg6lfbgcpmndb3c515d7bswhwqgjm97li85w39krnw1bfmv'';
+    url = "http://beta.quicklisp.org/archive/trivial-indent/2019-10-07/trivial-indent-20191007-git.tgz";
+    sha256 = "0v5isxg6lfbgcpmndb3c515d7bswhwqgjm97li85w39krnw1bfmv";
   };
 
   packageName = "trivial-indent";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-macroexpand-all.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-macroexpand-all'';
-  version = ''20171023-git'';
+  baseName = "trivial-macroexpand-all";
+  version = "20171023-git";
 
-  description = ''Call each implementation's macroexpand-all equivalent'';
+  description = "Call each implementation's macroexpand-all equivalent";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-macroexpand-all/2017-10-23/trivial-macroexpand-all-20171023-git.tgz'';
-    sha256 = ''0h5h9zn32pn26x7ll9h08g0csr2f5hvk1wgbr7kdhx5zbrszd7zm'';
+    url = "http://beta.quicklisp.org/archive/trivial-macroexpand-all/2017-10-23/trivial-macroexpand-all-20171023-git.tgz";
+    sha256 = "0h5h9zn32pn26x7ll9h08g0csr2f5hvk1wgbr7kdhx5zbrszd7zm";
   };
 
   packageName = "trivial-macroexpand-all";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-main-thread.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-main-thread'';
-  version = ''20190710-git'';
+  baseName = "trivial-main-thread";
+  version = "20190710-git";
 
-  description = ''Compatibility library to run things in the main thread.'';
+  description = "Compatibility library to run things in the main thread.";
 
   deps = [ args."alexandria" args."array-utils" args."bordeaux-threads" args."dissect" args."simple-tasks" args."trivial-features" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-main-thread/2019-07-10/trivial-main-thread-20190710-git.tgz'';
-    sha256 = ''1zj12rc29rrff5grmi7sjxfzdv78khbb4sg43hy2cb33hykpvg2h'';
+    url = "http://beta.quicklisp.org/archive/trivial-main-thread/2019-07-10/trivial-main-thread-20190710-git.tgz";
+    sha256 = "1zj12rc29rrff5grmi7sjxfzdv78khbb4sg43hy2cb33hykpvg2h";
   };
 
   packageName = "trivial-main-thread";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-mimes.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-mimes'';
-  version = ''20200715-git'';
+  baseName = "trivial-mimes";
+  version = "20200715-git";
 
-  description = ''Tiny library to detect mime types in files.'';
+  description = "Tiny library to detect mime types in files.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-mimes/2020-07-15/trivial-mimes-20200715-git.tgz'';
-    sha256 = ''10mk1v5ad0m3bg5pl7lqhh827jvg5jb896807vmi8wznwk7zaif1'';
+    url = "http://beta.quicklisp.org/archive/trivial-mimes/2020-07-15/trivial-mimes-20200715-git.tgz";
+    sha256 = "10mk1v5ad0m3bg5pl7lqhh827jvg5jb896807vmi8wznwk7zaif1";
   };
 
   packageName = "trivial-mimes";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-package-local-nicknames.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-package-local-nicknames'';
-  version = ''20200610-git'';
+  baseName = "trivial-package-local-nicknames";
+  version = "20200610-git";
 
-  description = ''Portability library for package-local nicknames'';
+  description = "Portability library for package-local nicknames";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-package-local-nicknames/2020-06-10/trivial-package-local-nicknames-20200610-git.tgz'';
-    sha256 = ''1wabkcwz0v144rb2w3rvxlcj264indfnvlyigk1wds7nq0c8lwk5'';
+    url = "http://beta.quicklisp.org/archive/trivial-package-local-nicknames/2020-06-10/trivial-package-local-nicknames-20200610-git.tgz";
+    sha256 = "1wabkcwz0v144rb2w3rvxlcj264indfnvlyigk1wds7nq0c8lwk5";
   };
 
   packageName = "trivial-package-local-nicknames";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-types.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-types'';
-  version = ''20120407-git'';
+  baseName = "trivial-types";
+  version = "20120407-git";
 
-  description = ''Trivial type definitions'';
+  description = "Trivial type definitions";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-types/2012-04-07/trivial-types-20120407-git.tgz'';
-    sha256 = ''0y3lfbbvi2qp2cwswzmk1awzqrsrrcfkcm1qn744bgm1fiqhxbxx'';
+    url = "http://beta.quicklisp.org/archive/trivial-types/2012-04-07/trivial-types-20120407-git.tgz";
+    sha256 = "0y3lfbbvi2qp2cwswzmk1awzqrsrrcfkcm1qn744bgm1fiqhxbxx";
   };
 
   packageName = "trivial-types";

pkgs/development/lisp-modules/quicklisp-to-nix-output/trivial-utf-8.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''trivial-utf-8'';
-  version = ''20200925-git'';
+  baseName = "trivial-utf-8";
+  version = "20200925-git";
 
   parasites = [ "trivial-utf-8/doc" "trivial-utf-8/tests" ];
 
-  description = ''A small library for doing UTF-8-based input and output.'';
+  description = "A small library for doing UTF-8-based input and output.";
 
   deps = [ args."mgl-pax" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/trivial-utf-8/2020-09-25/trivial-utf-8-20200925-git.tgz'';
-    sha256 = ''06v9jif4f5xyl5jd7ldg69ds7cypf72xl7nda5q55fssmgcydi1b'';
+    url = "http://beta.quicklisp.org/archive/trivial-utf-8/2020-09-25/trivial-utf-8-20200925-git.tgz";
+    sha256 = "06v9jif4f5xyl5jd7ldg69ds7cypf72xl7nda5q55fssmgcydi1b";
   };
 
   packageName = "trivial-utf-8";

pkgs/development/lisp-modules/quicklisp-to-nix-output/type-i.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''type-i'';
-  version = ''20191227-git'';
+  baseName = "type-i";
+  version = "20191227-git";
 
-  description = ''Type Inference Utility on Fundamentally 1-arg Predicates'';
+  description = "Type Inference Utility on Fundamentally 1-arg Predicates";
 
   deps = [ args."alexandria" args."closer-mop" args."introspect-environment" args."lisp-namespace" args."trivia_dot_level0" args."trivia_dot_level1" args."trivia_dot_level2" args."trivia_dot_trivial" args."trivial-cltl2" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/type-i/2019-12-27/type-i-20191227-git.tgz'';
-    sha256 = ''0f8q6klqjgz1kdyhisfkk07izvgs04jchlv2kl3srjxfr5dj5jl5'';
+    url = "http://beta.quicklisp.org/archive/type-i/2019-12-27/type-i-20191227-git.tgz";
+    sha256 = "0f8q6klqjgz1kdyhisfkk07izvgs04jchlv2kl3srjxfr5dj5jl5";
   };
 
   packageName = "type-i";

pkgs/development/lisp-modules/quicklisp-to-nix-output/uax-15.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''uax-15'';
-  version = ''20200325-git'';
+  baseName = "uax-15";
+  version = "20200325-git";
 
   parasites = [ "uax-15/tests" ];
 
-  description = ''Common lisp implementation of Unicode normalization functions :nfc, :nfd, :nfkc and :nfkd (Uax-15)'';
+  description = "Common lisp implementation of Unicode normalization functions :nfc, :nfd, :nfkc and :nfkd (Uax-15)";
 
   deps = [ args."cl-ppcre" args."fiveam" args."split-sequence" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/uax-15/2020-03-25/uax-15-20200325-git.tgz'';
-    sha256 = ''0nld8a95fy0nfni8g663786cz5q3x63bxymx0jlaknb6lfibb6pc'';
+    url = "http://beta.quicklisp.org/archive/uax-15/2020-03-25/uax-15-20200325-git.tgz";
+    sha256 = "0nld8a95fy0nfni8g663786cz5q3x63bxymx0jlaknb6lfibb6pc";
   };
 
   packageName = "uax-15";

pkgs/development/lisp-modules/quicklisp-to-nix-output/uffi.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''uffi'';
-  version = ''20180228-git'';
+  baseName = "uffi";
+  version = "20180228-git";
 
-  description = ''Universal Foreign Function Library for Common Lisp'';
+  description = "Universal Foreign Function Library for Common Lisp";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/uffi/2018-02-28/uffi-20180228-git.tgz'';
-    sha256 = ''1kknzwxsbg2ydy2w0n88y2bq37lqqwg02ffsmz57gqbxvlk26479'';
+    url = "http://beta.quicklisp.org/archive/uffi/2018-02-28/uffi-20180228-git.tgz";
+    sha256 = "1kknzwxsbg2ydy2w0n88y2bq37lqqwg02ffsmz57gqbxvlk26479";
   };
 
   packageName = "uffi";

pkgs/development/lisp-modules/quicklisp-to-nix-output/uiop.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''uiop'';
-  version = ''3.3.4'';
+  baseName = "uiop";
+  version = "3.3.4";
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/uiop/2020-02-18/uiop-3.3.4.tgz'';
-    sha256 = ''0n0fp55ivwi6gzhaywdkngnk2snpp9nn3mz5rq3pnrwldi9q7aav'';
+    url = "http://beta.quicklisp.org/archive/uiop/2020-02-18/uiop-3.3.4.tgz";
+    sha256 = "0n0fp55ivwi6gzhaywdkngnk2snpp9nn3mz5rq3pnrwldi9q7aav";
   };
 
   packageName = "uiop";

pkgs/development/lisp-modules/quicklisp-to-nix-output/unit-test.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''unit-test'';
-  version = ''20120520-git'';
+  baseName = "unit-test";
+  version = "20120520-git";
 
-  description = ''unit-testing framework for common lisp'';
+  description = "unit-testing framework for common lisp";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/unit-test/2012-05-20/unit-test-20120520-git.tgz'';
-    sha256 = ''1bwbx9d2z9qll46ksfh7bgd0dgh4is2dyfhkladq53qycvjywv9l'';
+    url = "http://beta.quicklisp.org/archive/unit-test/2012-05-20/unit-test-20120520-git.tgz";
+    sha256 = "1bwbx9d2z9qll46ksfh7bgd0dgh4is2dyfhkladq53qycvjywv9l";
   };
 
   packageName = "unit-test";

pkgs/development/lisp-modules/quicklisp-to-nix-output/unix-options.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''unix-options'';
-  version = ''20151031-git'';
+  baseName = "unix-options";
+  version = "20151031-git";
 
-  description = ''Easy to use command line option parser'';
+  description = "Easy to use command line option parser";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/unix-options/2015-10-31/unix-options-20151031-git.tgz'';
-    sha256 = ''0c9vbvvyx5qwvns87624gzxjcbdkbkcwssg29cxjfv3ci3qwqcd5'';
+    url = "http://beta.quicklisp.org/archive/unix-options/2015-10-31/unix-options-20151031-git.tgz";
+    sha256 = "0c9vbvvyx5qwvns87624gzxjcbdkbkcwssg29cxjfv3ci3qwqcd5";
   };
 
   packageName = "unix-options";

pkgs/development/lisp-modules/quicklisp-to-nix-output/unix-opts.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''unix-opts'';
-  version = ''20200925-git'';
+  baseName = "unix-opts";
+  version = "20200925-git";
 
   parasites = [ "unix-opts/tests" ];
 
-  description = ''minimalistic parser of command line arguments'';
+  description = "minimalistic parser of command line arguments";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/unix-opts/2020-09-25/unix-opts-20200925-git.tgz'';
-    sha256 = ''0y7bg825l8my7kpk4iwx0n8wn7rgy7bir60kb0s55g3x0nx5vx35'';
+    url = "http://beta.quicklisp.org/archive/unix-opts/2020-09-25/unix-opts-20200925-git.tgz";
+    sha256 = "0y7bg825l8my7kpk4iwx0n8wn7rgy7bir60kb0s55g3x0nx5vx35";
   };
 
   packageName = "unix-opts";

pkgs/development/lisp-modules/quicklisp-to-nix-output/usocket-server.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''usocket-server'';
-  version = ''usocket-0.8.3'';
+  baseName = "usocket-server";
+  version = "usocket-0.8.3";
 
-  description = ''Universal socket library for Common Lisp (server side)'';
+  description = "Universal socket library for Common Lisp (server side)";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."split-sequence" args."usocket" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/usocket/2019-12-27/usocket-0.8.3.tgz'';
-    sha256 = ''19gl72r9jqms8slzn7i7bww2cqng9mhiqqhhccadlrx2xv6d3lm7'';
+    url = "http://beta.quicklisp.org/archive/usocket/2019-12-27/usocket-0.8.3.tgz";
+    sha256 = "19gl72r9jqms8slzn7i7bww2cqng9mhiqqhhccadlrx2xv6d3lm7";
   };
 
   packageName = "usocket-server";

pkgs/development/lisp-modules/quicklisp-to-nix-output/usocket.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''usocket'';
-  version = ''0.8.3'';
+  baseName = "usocket";
+  version = "0.8.3";
 
-  description = ''Universal socket library for Common Lisp'';
+  description = "Universal socket library for Common Lisp";
 
   deps = [ args."split-sequence" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/usocket/2019-12-27/usocket-0.8.3.tgz'';
-    sha256 = ''19gl72r9jqms8slzn7i7bww2cqng9mhiqqhhccadlrx2xv6d3lm7'';
+    url = "http://beta.quicklisp.org/archive/usocket/2019-12-27/usocket-0.8.3.tgz";
+    sha256 = "19gl72r9jqms8slzn7i7bww2cqng9mhiqqhhccadlrx2xv6d3lm7";
   };
 
   packageName = "usocket";

pkgs/development/lisp-modules/quicklisp-to-nix-output/utilities_dot_print-items.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''utilities_dot_print-items'';
-  version = ''20190813-git'';
+  baseName = "utilities_dot_print-items";
+  version = "20190813-git";
 
   parasites = [ "utilities.print-items/test" ];
 
-  description = ''A protocol for flexible and composable printing.'';
+  description = "A protocol for flexible and composable printing.";
 
   deps = [ args."alexandria" args."fiveam" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/utilities.print-items/2019-08-13/utilities.print-items-20190813-git.tgz'';
-    sha256 = ''12l4kzz621qfcg8p5qzyxp4n4hh9wdlpiziykwb4c80g32rdwkc2'';
+    url = "http://beta.quicklisp.org/archive/utilities.print-items/2019-08-13/utilities.print-items-20190813-git.tgz";
+    sha256 = "12l4kzz621qfcg8p5qzyxp4n4hh9wdlpiziykwb4c80g32rdwkc2";
   };
 
   packageName = "utilities.print-items";

pkgs/development/lisp-modules/quicklisp-to-nix-output/utilities_dot_print-tree.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''utilities_dot_print-tree'';
-  version = ''20200325-git'';
+  baseName = "utilities_dot_print-tree";
+  version = "20200325-git";
 
   parasites = [ "utilities.print-tree/test" ];
 
-  description = ''This system provides simple facilities for printing tree structures.'';
+  description = "This system provides simple facilities for printing tree structures.";
 
   deps = [ args."alexandria" args."fiveam" args."uiop" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/utilities.print-tree/2020-03-25/utilities.print-tree-20200325-git.tgz'';
-    sha256 = ''1nam8g2ppzkzpkwwhmil9y68is43ljpvc7hd64zxp4zsaqab5dww'';
+    url = "http://beta.quicklisp.org/archive/utilities.print-tree/2020-03-25/utilities.print-tree-20200325-git.tgz";
+    sha256 = "1nam8g2ppzkzpkwwhmil9y68is43ljpvc7hd64zxp4zsaqab5dww";
   };
 
   packageName = "utilities.print-tree";

pkgs/development/lisp-modules/quicklisp-to-nix-output/uuid.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''uuid'';
-  version = ''20200715-git'';
+  baseName = "uuid";
+  version = "20200715-git";
 
-  description = ''UUID Generation'';
+  description = "UUID Generation";
 
   deps = [ args."alexandria" args."bordeaux-threads" args."ironclad" args."trivial-utf-8" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/uuid/2020-07-15/uuid-20200715-git.tgz'';
-    sha256 = ''1ymir6hgax1vbbcgyprnwbsx224ih03a55v10l35xridwyzhzrx0'';
+    url = "http://beta.quicklisp.org/archive/uuid/2020-07-15/uuid-20200715-git.tgz";
+    sha256 = "1ymir6hgax1vbbcgyprnwbsx224ih03a55v10l35xridwyzhzrx0";
   };
 
   packageName = "uuid";

pkgs/development/lisp-modules/quicklisp-to-nix-output/vom.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''vom'';
-  version = ''20160825-git'';
+  baseName = "vom";
+  version = "20160825-git";
 
-  description = ''A tiny logging utility.'';
+  description = "A tiny logging utility.";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/vom/2016-08-25/vom-20160825-git.tgz'';
-    sha256 = ''0mvln0xx8qnrsmaj7c0f2ilgahvf078qvhqag7qs3j26xmamjm93'';
+    url = "http://beta.quicklisp.org/archive/vom/2016-08-25/vom-20160825-git.tgz";
+    sha256 = "0mvln0xx8qnrsmaj7c0f2ilgahvf078qvhqag7qs3j26xmamjm93";
   };
 
   packageName = "vom";

pkgs/development/lisp-modules/quicklisp-to-nix-output/woo.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''woo'';
-  version = ''20200427-git'';
+  baseName = "woo";
+  version = "20200427-git";
 
-  description = ''An asynchronous HTTP server written in Common Lisp'';
+  description = "An asynchronous HTTP server written in Common Lisp";
 
   deps = [ args."alexandria" args."babel" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."cl-utilities" args."clack-socket" args."fast-http" args."fast-io" args."flexi-streams" args."lev" args."proc-parse" args."quri" args."smart-buffer" args."split-sequence" args."static-vectors" args."swap-bytes" args."trivial-features" args."trivial-gray-streams" args."trivial-utf-8" args."vom" args."xsubseq" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/woo/2020-04-27/woo-20200427-git.tgz'';
-    sha256 = ''1mmgwgf9n74zab96x1n4faij30l2vk19xy74fcp0xnpj4lrp7v29'';
+    url = "http://beta.quicklisp.org/archive/woo/2020-04-27/woo-20200427-git.tgz";
+    sha256 = "1mmgwgf9n74zab96x1n4faij30l2vk19xy74fcp0xnpj4lrp7v29";
   };
 
   packageName = "woo";

pkgs/development/lisp-modules/quicklisp-to-nix-output/wookie.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''wookie'';
-  version = ''20191130-git'';
+  baseName = "wookie";
+  version = "20191130-git";
 
-  description = ''An evented webserver for Common Lisp.'';
+  description = "An evented webserver for Common Lisp.";
 
   deps = [ args."alexandria" args."babel" args."blackbird" args."bordeaux-threads" args."cffi" args."cffi-grovel" args."cffi-toolchain" args."chunga" args."cl-async" args."cl-async-base" args."cl-async-ssl" args."cl-async-util" args."cl-fad" args."cl-libuv" args."cl-ppcre" args."cl-utilities" args."do-urlencode" args."fast-http" args."fast-io" args."flexi-streams" args."proc-parse" args."quri" args."smart-buffer" args."split-sequence" args."static-vectors" args."trivial-features" args."trivial-gray-streams" args."vom" args."xsubseq" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/wookie/2019-11-30/wookie-20191130-git.tgz'';
-    sha256 = ''13f9fi7yv28lag79z03jrnm7aih2x5zwvh4hw9cadw75956975d2'';
+    url = "http://beta.quicklisp.org/archive/wookie/2019-11-30/wookie-20191130-git.tgz";
+    sha256 = "13f9fi7yv28lag79z03jrnm7aih2x5zwvh4hw9cadw75956975d2";
   };
 
   packageName = "wookie";

pkgs/development/lisp-modules/quicklisp-to-nix-output/xembed.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''xembed'';
-  version = ''clx-20191130-git'';
+  baseName = "xembed";
+  version = "clx-20191130-git";
 
-  description = ''An implementation of the XEMBED protocol that integrates with CLX.'';
+  description = "An implementation of the XEMBED protocol that integrates with CLX.";
 
   deps = [ args."clx" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clx-xembed/2019-11-30/clx-xembed-20191130-git.tgz'';
-    sha256 = ''1ik5gxzhn9j7827jg6g8rk2wa5jby11n2db24y6wrf0ldnbpj7jd'';
+    url = "http://beta.quicklisp.org/archive/clx-xembed/2019-11-30/clx-xembed-20191130-git.tgz";
+    sha256 = "1ik5gxzhn9j7827jg6g8rk2wa5jby11n2db24y6wrf0ldnbpj7jd";
   };
 
   packageName = "xembed";

pkgs/development/lisp-modules/quicklisp-to-nix-output/xkeyboard.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''xkeyboard'';
-  version = ''clx-20120811-git'';
+  baseName = "xkeyboard";
+  version = "clx-20120811-git";
 
   parasites = [ "xkeyboard-test" ];
 
-  description = ''XKeyboard is X11 extension for clx of the same name.'';
+  description = "XKeyboard is X11 extension for clx of the same name.";
 
   deps = [ args."clx" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/clx-xkeyboard/2012-08-11/clx-xkeyboard-20120811-git.tgz'';
-    sha256 = ''11q70drx3xn7rvk528qlnzpnxd6hg6801kc54ys3jz1l7074458n'';
+    url = "http://beta.quicklisp.org/archive/clx-xkeyboard/2012-08-11/clx-xkeyboard-20120811-git.tgz";
+    sha256 = "11q70drx3xn7rvk528qlnzpnxd6hg6801kc54ys3jz1l7074458n";
   };
 
   packageName = "xkeyboard";

pkgs/development/lisp-modules/quicklisp-to-nix-output/xml_dot_location.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''xml_dot_location'';
-  version = ''20200325-git'';
+  baseName = "xml_dot_location";
+  version = "20200325-git";
 
   parasites = [ "xml.location/test" ];
 
···
   deps = [ args."alexandria" args."anaphora" args."babel" args."cl-ppcre" args."closer-mop" args."closure-common" args."cxml" args."cxml-stp" args."iterate" args."let-plus" args."lift" args."more-conditions" args."parse-number" args."puri" args."split-sequence" args."trivial-features" args."trivial-gray-streams" args."xpath" args."yacc" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/xml.location/2020-03-25/xml.location-20200325-git.tgz'';
-    sha256 = ''0wfccj1p1al0w9pc5rhxpsvm3wb2lr5fc4cfjyg751pwsasjikwx'';
+    url = "http://beta.quicklisp.org/archive/xml.location/2020-03-25/xml.location-20200325-git.tgz";
+    sha256 = "0wfccj1p1al0w9pc5rhxpsvm3wb2lr5fc4cfjyg751pwsasjikwx";
   };
 
   packageName = "xml.location";

pkgs/development/lisp-modules/quicklisp-to-nix-output/xmls.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''xmls'';
-  version = ''3.0.2'';
+  baseName = "xmls";
+  version = "3.0.2";
 
   parasites = [ "xmls/test" "xmls/unit-test" ];
 
-  description = ''System lacks description'';
+  description = "System lacks description";
 
   deps = [ args."fiveam" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/xmls/2018-04-30/xmls-3.0.2.tgz'';
-    sha256 = ''1r7mvw62zjcg45j3hm8jlbiisad2b415pghn6qcmhl03dmgp7kgi'';
+    url = "http://beta.quicklisp.org/archive/xmls/2018-04-30/xmls-3.0.2.tgz";
+    sha256 = "1r7mvw62zjcg45j3hm8jlbiisad2b415pghn6qcmhl03dmgp7kgi";
   };
 
   packageName = "xmls";

pkgs/development/lisp-modules/quicklisp-to-nix-output/xpath.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''xpath'';
-  version = ''plexippus-20190521-git'';
+  baseName = "xpath";
+  version = "plexippus-20190521-git";
 
   parasites = [ "xpath/test" ];
 
-  description = ''An implementation of the XML Path Language (XPath) Version 1.0'';
+  description = "An implementation of the XML Path Language (XPath) Version 1.0";
 
   deps = [ args."alexandria" args."babel" args."cl-ppcre" args."closure-common" args."cxml" args."parse-number" args."puri" args."trivial-features" args."trivial-gray-streams" args."yacc" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/plexippus-xpath/2019-05-21/plexippus-xpath-20190521-git.tgz'';
-    sha256 = ''15357w1rlmahld4rh8avix7m40mwiiv7n2vlyc57ldw2k1m0n7xa'';
+    url = "http://beta.quicklisp.org/archive/plexippus-xpath/2019-05-21/plexippus-xpath-20190521-git.tgz";
+    sha256 = "15357w1rlmahld4rh8avix7m40mwiiv7n2vlyc57ldw2k1m0n7xa";
   };
 
   packageName = "xpath";

pkgs/development/lisp-modules/quicklisp-to-nix-output/xsubseq.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''xsubseq'';
-  version = ''20170830-git'';
+  baseName = "xsubseq";
+  version = "20170830-git";
 
   description = ''Efficient way to manage "subseq"s in Common Lisp'';
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/xsubseq/2017-08-30/xsubseq-20170830-git.tgz'';
-    sha256 = ''1am63wkha97hyvkqf4ydx3q07mqpa0chkx65znr7kmqi83a8waml'';
+    url = "http://beta.quicklisp.org/archive/xsubseq/2017-08-30/xsubseq-20170830-git.tgz";
+    sha256 = "1am63wkha97hyvkqf4ydx3q07mqpa0chkx65znr7kmqi83a8waml";
   };
 
   packageName = "xsubseq";

pkgs/development/lisp-modules/quicklisp-to-nix-output/yacc.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''yacc'';
-  version = ''cl-20101006-darcs'';
+  baseName = "yacc";
+  version = "cl-20101006-darcs";
 
-  description = ''A LALR(1) parser generator for Common Lisp'';
+  description = "A LALR(1) parser generator for Common Lisp";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/cl-yacc/2010-10-06/cl-yacc-20101006-darcs.tgz'';
-    sha256 = ''0cymvl0arp4yahqcnhxggs1z2g42bf6z4ix75ba7wbsi52zirjp7'';
+    url = "http://beta.quicklisp.org/archive/cl-yacc/2010-10-06/cl-yacc-20101006-darcs.tgz";
+    sha256 = "0cymvl0arp4yahqcnhxggs1z2g42bf6z4ix75ba7wbsi52zirjp7";
   };
 
   packageName = "yacc";

pkgs/development/lisp-modules/quicklisp-to-nix-output/yason.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''yason'';
-  version = ''v0.7.8'';
+  baseName = "yason";
+  version = "v0.7.8";
 
-  description = ''JSON parser/encoder'';
+  description = "JSON parser/encoder";
 
   deps = [ args."alexandria" args."trivial-gray-streams" ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/yason/2019-12-27/yason-v0.7.8.tgz'';
-    sha256 = ''11d51i2iw4nxsparwbh3s6w9zyms3wi0z0fprwz1d3sqlf03j6f1'';
+    url = "http://beta.quicklisp.org/archive/yason/2019-12-27/yason-v0.7.8.tgz";
+    sha256 = "11d51i2iw4nxsparwbh3s6w9zyms3wi0z0fprwz1d3sqlf03j6f1";
   };
 
   packageName = "yason";

pkgs/development/lisp-modules/quicklisp-to-nix-output/zpb-ttf.nix

···
 args @ { fetchurl, ... }:
 rec {
-  baseName = ''zpb-ttf'';
-  version = ''1.0.3'';
+  baseName = "zpb-ttf";
+  version = "1.0.3";
 
-  description = ''Access TrueType font metrics and outlines from Common Lisp'';
+  description = "Access TrueType font metrics and outlines from Common Lisp";
 
   deps = [ ];
 
   src = fetchurl {
-    url = ''http://beta.quicklisp.org/archive/zpb-ttf/2013-07-20/zpb-ttf-1.0.3.tgz'';
-    sha256 = ''1irv0d0pcbwi2wx6hhjjyxzw12lnw8pvyg6ljsljh8xmhppbg5j6'';
+    url = "http://beta.quicklisp.org/archive/zpb-ttf/2013-07-20/zpb-ttf-1.0.3.tgz";
+    sha256 = "1irv0d0pcbwi2wx6hhjjyxzw12lnw8pvyg6ljsljh8xmhppbg5j6";
   };
 
   packageName = "zpb-ttf";

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

···
     stdio
   ];
 
-  preBuild = ''export LIBTORCH=${pytorch.dev}/'';
+  preBuild = "export LIBTORCH=${pytorch.dev}/";
 
   doCheck = !stdenv.isAarch64;
   checkPhase = "dune runtest";

pkgs/development/pure-modules/gl/default.nix

···
   nativeBuildInputs = [ pkg-config ];
   propagatedBuildInputs = [ pure freeglut libGLU libGL xlibsWrapper ];
   makeFlags = [
-    "libdir=${placeholder ''out''}/lib"
-    "prefix=${placeholder ''out''}/"
+    "libdir=${placeholder "out"}/lib"
+    "prefix=${placeholder "out"}/"
   ];
   setupHook = ../generic-setup-hook.sh;
 

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

···
   ];
 
   doCheck = true;
-  checkPhase = ''HOME=$TMP nosetests'';
+  checkPhase = "HOME=$TMP nosetests";
 
   meta = with lib; {
     description = "Set of packages that Enthought has found useful in creating a number of applications.";

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

···
     inherit pname version;
     sha256 = "0s84kd9vblbjz61q7zchx64a6hmdqb4lillna5ryh0g9ij76g6r5";
   };
-  preBuild = ''echo > README.rst'';
+  preBuild = "echo > README.rst";
   # setup.py uses a python3 os.path.join
   disabled = !isPy3k;
   propagatedBuildInputs = [ pygtrie ];

pkgs/development/python-modules/bravado-core/default.nix

···
     pytest-benchmark
   ];
 
-  checkPhase = ''pytest --benchmark-skip'';
+  checkPhase = "pytest --benchmark-skip";
 
   propagatedBuildInputs = [
     python-dateutil

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

···
 
   checkInputs = [ nose ];
 
-  checkPhase = ''nosetests'';
+  checkPhase = "nosetests";
 
   meta = with lib; {
     description = "Emoji for Python";

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

···
           and not test_conditional_upload and not test_conditional_download_with_older_target \
   ''
   # need until https://ftputil.sschwarzer.net/trac/ticket/140#ticket is fixed
-  + lib.optionalString stdenv.isDarwin ''and not test_error_message_reuse''
+  + lib.optionalString stdenv.isDarwin "and not test_error_message_reuse"
   + ''"'';
 
   meta = with lib; {

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

···
 
   checkInputs = [ pytest ];
   # Suppress overly verbose output if tests run successfully
-  checkPhase = ''pytest >/dev/null || pytest'';
+  checkPhase = "pytest >/dev/null || pytest";
 
   meta = {
    homepage = "https://github.com/jpvanhal/inflection";

pkgs/development/python-modules/jenkins-job-builder/default.nix

···
   propagatedBuildInputs = [ pbr python-jenkins pyyaml six stevedore fasteners jinja2 ];
 
   # Need to fix test deps, relies on stestr and a few other packages that aren't available on nixpkgs
-  checkPhase = ''$out/bin/jenkins-jobs --help'';
+  checkPhase = "$out/bin/jenkins-jobs --help";
 
   meta = with lib; {
     description = "Jenkins Job Builder is a system for configuring Jenkins jobs using simple YAML files stored in Git";

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

···
   '';
 
   # We do not want any wrappers here.
-  postFixup = '''';
+  postFixup = "";
 
   checkPhase = ''
     tests/run-tests

pkgs/development/python-modules/pytest-virtualenv/default.nix

···
 
   checkInputs = [ pytest pytestcov mock cmdline ];
   propagatedBuildInputs = [ pytest-fixture-config pytest-shutil virtualenv ];
-  checkPhase = '' py.test tests/unit '';
+  checkPhase = "py.test tests/unit ";
 
   nativeBuildInputs = [ pytest ];
 

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

···
        else
         ''--replace 'ALT_TOOL = "bsdtar"' "ALT_TOOL = \"${libarchive}/bin/bsdtar\""
         '')
-     + ''
-   '';
+     + "";
   # the tests only work with the standard unrar package
   doCheck = useUnrar;
   LC_ALL = "en_US.UTF-8";

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

···
 
   buildInputs = [ lua5_3 python ];
 
-  buildPhase = ''${stdenv.shell} make_unix.sh'';
+  buildPhase = "${stdenv.shell} make_unix.sh";
 
-  checkPhase = ''${python.interpreter} scripts/test.py'';
+  checkPhase = "${python.interpreter} scripts/test.py";
 
   installPhase = ''
     mkdir -p "$out/share/bam"

pkgs/development/tools/go-motion/default.nix

···
   rev = "218875ebe23806e7af82f3b5b14bb3355534f679";
 
   goPackagePath = "github.com/fatih/motion";
-  excludedPackages = ''testdata'';
+  excludedPackages = "testdata";
 
   src = fetchFromGitHub {
     inherit rev;

pkgs/development/tools/go2nix/default.nix

···
 
   nativeBuildInputs = [ go-bindata gotools makeWrapper ];
 
-  preBuild = ''go generate ./...'';
+  preBuild = "go generate ./...";
 
   postInstall = ''
     wrapProgram $out/bin/go2nix \

pkgs/development/tools/gocode-gomod/default.nix

···
   # standard packages.
   allowGoReference = true;
 
-  excludedPackages = ''internal/suggest/testdata'';
+  excludedPackages = "internal/suggest/testdata";
 
   src = fetchFromGitHub {
     owner = "stamblerre";

pkgs/development/tools/gocode/default.nix

···
   rev = "4acdcbdea79de6b3dee1c637eca5cbea0fdbe37c";
 
   goPackagePath = "github.com/mdempsky/gocode";
-  excludedPackages = ''internal/suggest/testdata'';
+  excludedPackages = "internal/suggest/testdata";
 
   # we must allow references to the original `go` package,
   # because `gocode` needs to dig into $GOROOT to provide completions for the

pkgs/development/tools/iaca/2.1.nix

···
         --set-rpath $out/lib:"${libPath}" \
         $out/bin/iaca
   '';
-  postFixup = ''wrapProgram $out/bin/iaca --set LD_LIBRARY_PATH $out/lib'';
+  postFixup = "wrapProgram $out/bin/iaca --set LD_LIBRARY_PATH $out/lib";
   meta = {
     description = "Intel Architecture Code Analyzer";
     homepage = "https://software.intel.com/en-us/articles/intel-architecture-code-analyzer/";

pkgs/development/tools/ineffassign/default.nix

···
   rev = "1003c8bd00dc2869cb5ca5282e6ce33834fed514";
 
   goPackagePath = "github.com/gordonklaus/ineffassign";
-  excludedPackages = ''testdata'';
+  excludedPackages = "testdata";
 
   src = fetchFromGitHub {
     inherit rev;

pkgs/development/tools/interfacer/default.nix

···
   rev = "c20040233aedb03da82d460eca6130fcd91c629a";
 
   goPackagePath = "mvdan.cc/interfacer";
-  excludedPackages = ''check/testdata'';
+  excludedPackages = "check/testdata";
 
   src = fetchFromGitHub {
     inherit rev;

pkgs/development/tools/misc/bossa/default.nix

···
     name = "bossa-bin2c";
     src = ./bin2c.c;
     dontUnpack = true;
-    buildPhase = ''cc $src -o bin2c'';
-    installPhase = ''mkdir -p $out/bin; cp bin2c $out/bin/'';
+    buildPhase = "cc $src -o bin2c";
+    installPhase = "mkdir -p $out/bin; cp bin2c $out/bin/";
   };
 
 in

pkgs/development/tools/misc/cl-launch/default.nix

···
 
   meta = {
     inherit (s) version;
-    description = ''Common Lisp launcher script'';
+    description = "Common Lisp launcher script";
     license = lib.licenses.llgpl21 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

pkgs/development/tools/misc/luarocks/default.nix

···
 
   meta = with lib; {
     inherit version;
-    description = ''A package manager for Lua'';
+    description = "A package manager for Lua";
     license = licenses.mit ;
     maintainers = with maintainers; [raskin teto];
     platforms = platforms.linux ++ platforms.darwin;

pkgs/development/tools/misc/tet/default.nix

···
 
   buildInputs = [ ];
 
-  patchPhase = ''chmod +x configure'';
+  patchPhase = "chmod +x configure";
 
-  configurePhase = ''./configure -t lite'';
+  configurePhase = "./configure -t lite";
 
-  buildPhase = ''cd src; make; cd -'';
+  buildPhase = "cd src; make; cd -";
 
-  installPhase = ''cd src; make install; cd -; cp -vr $PWD $out'';
+  installPhase = "cd src; make install; cd -; cp -vr $PWD $out";
 
   meta = {
     description = "The Test Environment Toolkit is used in test applications like The Open Group's UNIX Certification program and the Free Standards Group's LSB Certification program";

pkgs/development/tools/poetry2nix/poetry2nix/pep508.nix

···
               mVal = ''[a-zA-Z0-9\'"_\. ]+'';
               mOp = "in|[!=<>]+";
               e = stripStr exprs.value;
-              m = builtins.map stripStr (builtins.match ''^(${mVal}) *(${mOp}) *(${mVal})$'' e);
+              m = builtins.map stripStr (builtins.match "^(${mVal}) *(${mOp}) *(${mVal})$" e);
               m0 = processVar (builtins.elemAt m 0);
               m2 = processVar (builtins.elemAt m 2);
             in

pkgs/development/tools/setupcfg2nix/info.nix

···
 {
-  pname = ''setupcfg2nix'';
-  version = ''2.0.1'';
+  pname = "setupcfg2nix";
+  version = "2.0.1";
   install_requires = [
-    ''setuptools''
+    "setuptools"
   ];
 }

pkgs/development/tools/slimerjs/default.nix

···
   '';
   meta = {
     inherit (s) version;
-    description = ''Gecko-based programmatically-driven browser'';
+    description = "Gecko-based programmatically-driven browser";
     license = lib.licenses.mpl20 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/development/tools/yj/default.nix

···
   buildFlagsArray = [ "-ldflags=-s -w -X main.Version=${version}" ];
 
   meta = with lib; {
-    description = ''Convert YAML <=> TOML <=> JSON <=> HCL'';
+    description = "Convert YAML <=> TOML <=> JSON <=> HCL";
     license = licenses.asl20;
     maintainers = with maintainers; [ Profpatsch ];
     homepage = "https://github.com/sclevine/yj";

pkgs/games/blobby/default.nix

···
   '';
 
   meta = with lib; {
-    description = ''A blobby volleyball game'';
+    description = "A blobby volleyball game";
     license = licenses.bsd3;
     platforms = platforms.linux;
     maintainers = with maintainers; [ raskin ];

pkgs/games/fairymax/default.nix

···
   '';
   meta = {
     inherit version;
-    description = ''A small chess engine supporting fairy pieces'';
+    description = "A small chess engine supporting fairy pieces";
     longDescription = ''
        A version of micro-Max that reads the piece description
        from a file fmax.ini, so that arbitrary fairy pieces can be

pkgs/games/fish-fillets-ng/default.nix

···
 
   meta = with lib; {
     inherit version;
-    description = ''A puzzle game'';
+    description = "A puzzle game";
     license = licenses.gpl2Plus;
     maintainers = with maintainers; [ raskin ];
     platforms = platforms.linux;

pkgs/games/liquidwar/5.nix

···
   NIX_CFLAGS_COMPILE = [ "-lm" ];
 
   meta = with lib; {
-    description = ''The classic version of a quick tactics game LiquidWar'';
+    description = "The classic version of a quick tactics game LiquidWar";
     maintainers = [ maintainers.raskin ];
     license = licenses.gpl2Plus;
     platforms = platforms.linux;

pkgs/games/moon-buggy/default.nix

···
   };
 
   meta = {
-    description = ''A simple character graphics game where you drive some kind of car across the moon's surface'';
+    description = "A simple character graphics game where you drive some kind of car across the moon's surface";
     license = lib.licenses.gpl2;
     maintainers = [lib.maintainers.rybern];
     platforms = lib.platforms.linux;

pkgs/games/n2048/default.nix

···
     inherit (s) url sha256;
   };
   makeFlags = [
-    ''DESTDIR=$(out)''
+    "DESTDIR=$(out)"
   ];
   preInstall = ''
     mkdir -p "$out"/{share/man,bin}
   '';
   meta = {
     inherit (s) version;
-    description = ''Console implementation of 2048 game'';
+    description = "Console implementation of 2048 game";
     license = lib.licenses.bsd2;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/games/pingus/default.nix

···
   };
 
   meta = {
-    description = ''A puzzle game with mechanics similar to Lemmings'';
+    description = "A puzzle game with mechanics similar to Lemmings";
     platforms = lib.platforms.linux;
     maintainers = [lib.maintainers.raskin];
     license = lib.licenses.gpl3;

pkgs/games/quantumminigolf/default.nix

···
   '';
   meta = {
     inherit (s) version;
-    description = ''Quantum mechanics-based minigolf-like game'';
+    description = "Quantum mechanics-based minigolf-like game";
     license = lib.licenses.gpl2 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/games/xboard/default.nix

···
   };
   meta = {
     inherit (s) version;
-    description = ''GUI for chess engines'';
+    description = "GUI for chess engines";
     homepage = "https://www.gnu.org/software/xboard/";
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

pkgs/games/xbomb/default.nix

···
   buildInputs = [ libX11 libXaw ];
 
   makeFlags = [
-    "INSTDIR=${placeholder ''out''}"
+    "INSTDIR=${placeholder "out"}"
   ];
 
   meta = with lib; {

pkgs/games/xpilot/bloodspilot-client.nix

···
   NIX_LDFLAGS = "-lX11";
 
   meta = {
-    description = ''A multiplayer space combat game (client part)'';
+    description = "A multiplayer space combat game (client part)";
     homepage = "http://bloodspilot.sf.net/";
     license = lib.licenses.gpl2Plus ;
     maintainers = [lib.maintainers.raskin];

pkgs/games/xskat/default.nix

···
   installTargets = [ "install" "install.man" ];
 
   meta = with lib; {
-    description = ''Famous german card game'';
+    description = "Famous german card game";
     platforms = platforms.unix;
     license = licenses.free;
-    longDescription = ''Play the german card game Skat against the AI or over IRC.'';
+    longDescription = "Play the german card game Skat against the AI or over IRC.";
     homepage = "http://www.xskat.de/";
   };
 }

pkgs/misc/drivers/xow/default.nix

···
   makeFlags = [
     "BUILD=RELEASE"
     "VERSION=${version}"
-    "BINDIR=${placeholder ''out''}/bin"
-    "UDEVDIR=${placeholder ''out''}/lib/udev/rules.d"
-    "MODLDIR=${placeholder ''out''}/lib/modules-load.d"
-    "MODPDIR=${placeholder ''out''}/lib/modprobe.d"
-    "SYSDDIR=${placeholder ''out''}/lib/systemd/system"
+    "BINDIR=${placeholder "out"}/bin"
+    "UDEVDIR=${placeholder "out"}/lib/udev/rules.d"
+    "MODLDIR=${placeholder "out"}/lib/modules-load.d"
+    "MODPDIR=${placeholder "out"}/lib/modprobe.d"
+    "SYSDDIR=${placeholder "out"}/lib/systemd/system"
   ];
 
   postUnpack = ''

pkgs/misc/emulators/termtekst/default.nix

···
     '';
 
   meta = with lib; {
-    description = ''Console NOS Teletekst viewer in Python'';
+    description = "Console NOS Teletekst viewer in Python";
     longDescription = ''
       Small Python app using curses to display Dutch NOS Teletekst on
       the Linux console. The original Teletekst font includes 2x6

pkgs/misc/vscode-extensions/vscodeExts2nix.nix

···
 
   for line in $(${vscode}/bin/code --list-extensions --show-versions \
     ${lib.optionalString (extensionsToIgnore != []) ''
-      | grep -v -i '^\(${lib.concatMapStringsSep "\\|" (e : ''${e.publisher}.${e.name}'') extensionsToIgnore}\)'
+      | grep -v -i '^\(${lib.concatMapStringsSep "\\|" (e : "${e.publisher}.${e.name}") extensionsToIgnore}\)'
     ''}
   ) ; do
     [[ $line =~ ([^.]*)\.([^@]*)@(.*) ]]
···
     publisher=''${BASH_REMATCH[1]}
     version=''${BASH_REMATCH[3]}
 
-    extensions="${lib.concatMapStringsSep "." (e : ''${e.publisher}${e.name}@${e.sha256}'') extensions}"
+    extensions="${lib.concatMapStringsSep "." (e : "${e.publisher}${e.name}@${e.sha256}") extensions}"
     reCurrentExt=$publisher$name"@([^.]*)"
     if [[ $extensions =~ $reCurrentExt ]]; then
       sha256=''${BASH_REMATCH[1]}

pkgs/misc/vscode-extensions/vscodeWithConfiguration.nix

···
   mutExtsDrvs = extensionsFromVscodeMarketplace mutableExtensions;
   mutableExtsPaths = lib.forEach mutExtsDrvs ( e:
   {
-    origin = ''${e}/share/vscode/extensions/${e.vscodeExtUniqueId}'';
-    target = ''${vscodeExtsFolderName}/${e.vscodeExtUniqueId}-${(lib.findSingle (ext: ''${ext.publisher}.${ext.name}'' == e.vscodeExtUniqueId) "" "m" mutableExtensions ).version}'';
+    origin = "${e}/share/vscode/extensions/${e.vscodeExtUniqueId}";
+    target = ''${vscodeExtsFolderName}/${e.vscodeExtUniqueId}-${(lib.findSingle (ext: "${ext.publisher}.${ext.name}" == e.vscodeExtUniqueId) "" "m" mutableExtensions ).version}'';
   }
   );
 
   #removed not defined extensions
   rmExtensions =  lib.optionalString (nixExtensions++mutableExtensions != []) ''
     find ${vscodeExtsFolderName} -mindepth 1 -maxdepth 1 ${
-        lib.concatMapStringsSep " " (e : ''! -iname ${e.publisher}.${e.name} '') nixExtensions
+        lib.concatMapStringsSep " " (e : "! -iname ${e.publisher}.${e.name} ") nixExtensions
         +
-        lib.concatMapStringsSep " " (e : ''! -iname ${e.publisher}.${e.name}-${e.version} '') mutableExtensions
+        lib.concatMapStringsSep " " (e : "! -iname ${e.publisher}.${e.name}-${e.version} ") mutableExtensions
       } -exec rm -rf {} \;
   '';
   #copy mutable extension out of the nix store
   cpExtensions = ''
-    ${lib.concatMapStringsSep "\n" (e : ''ln -sfn ${e}/share/vscode/extensions/* ${vscodeExtsFolderName}/'') nixExtsDrvs}
+    ${lib.concatMapStringsSep "\n" (e : "ln -sfn ${e}/share/vscode/extensions/* ${vscodeExtsFolderName}/") nixExtsDrvs}
     ${lib.concatMapStringsSep "\n" (ePath : ''
       if [ ! -d ${ePath.target} ]; then
         cp -a ${ePath.origin} ${ePath.target}
···
       ${cpExtensions}
     fi
     ${vscode}/bin/code --extensions-dir "${vscodeExtsFolderName}" ${
-      lib.optionalString (user-data-dir != "") ''--user-data-dir ${user-data-dir }''
+      lib.optionalString (user-data-dir != "") "--user-data-dir ${user-data-dir}"
       } "$@"
   ''

pkgs/os-specific/darwin/trash/default.nix

···
 
   patches = [ ./trash.diff ];
 
-  buildPhase = ''make all docs'';
+  buildPhase = "make all docs";
 
   installPhase = ''
     mkdir -p $out/bin

pkgs/os-specific/linux/apparmor/default.nix

···
     name = "apparmor-kernel-patches-${apparmor-version}";
     src = apparmor-sources;
 
-    phases = ''unpackPhase installPhase'';
+    phases = "unpackPhase installPhase";
 
     installPhase = ''
       mkdir "$out"

pkgs/os-specific/linux/atop/default.nix

···
   meta = with lib; {
     platforms = platforms.linux;
     maintainers = with maintainers; [ raskin ];
-    description = ''Console system performance monitor'';
+    description = "Console system performance monitor";
 
     longDescription = ''
       Atop is an ASCII full-screen performance monitor that is capable of reporting the activity of all processes (even if processes have finished during the interval), daily logging of system and process activity for long-term analysis, highlighting overloaded system resources by using colors, etc. At regular intervals, it shows system-level activity related to the CPU, memory, swap, disks and network layers, and for every active process it shows the CPU utilization, memory growth, disk utilization, priority, username, state, and exit code.

pkgs/os-specific/linux/eudev/default.nix

···
   enableParallelBuilding = true;
   meta = {
     inherit (s) version;
-    description = ''An udev fork by Gentoo'';
+    description = "An udev fork by Gentoo";
     license = lib.licenses.gpl2Plus ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;
-    homepage = ''https://www.gentoo.org/proj/en/eudev/'';
-    downloadPage = ''http://dev.gentoo.org/~blueness/eudev/'';
+    homepage = "https://www.gentoo.org/proj/en/eudev/";
+    downloadPage = "http://dev.gentoo.org/~blueness/eudev/";
     updateWalker = true;
   };
 }

pkgs/os-specific/linux/firejail/default.nix

···
 
   meta = {
     inherit (s) version;
-    description = ''Namespace-based sandboxing tool for Linux'';
+    description = "Namespace-based sandboxing tool for Linux";
     license = lib.licenses.gpl2Plus ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/os-specific/linux/forktty/default.nix

···
   makeFlags = [ "prefix=$(out)" "manprefix=$(out)/share/" ];
   meta = {
     inherit (s) version;
-    description = ''Tool to detach from controlling TTY and attach to another'';
+    description = "Tool to detach from controlling TTY and attach to another";
     license = lib.licenses.gpl2 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/os-specific/linux/gfxtablet/default.nix

···
     sha256 = "1i2m98yypfa9phshlmvjlgw7axfisxmldzrvnbzm5spvv5s4kvvb";
   };
 
-  preBuild = ''cd driver-uinput'';
+  preBuild = "cd driver-uinput";
 
   installPhase = ''
     mkdir -p "$out/bin"
···
   '';
 
   meta = {
-    description = ''Uinput driver for Android GfxTablet tablet-as-input-device app'';
+    description = "Uinput driver for Android GfxTablet tablet-as-input-device app";
     license = lib.licenses.mit ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/os-specific/linux/gradm/default.nix

···
     mkdir -p "$out/etc/udev/rules.d"
   '';
 
-  postInstall = ''rmdir $out/dev'';
+  postInstall = "rmdir $out/dev";
 
   meta = with lib; {
     description = "grsecurity RBAC administration and policy analysis utility";

pkgs/os-specific/linux/libaio/default.nix

···
   '';
 
   makeFlags = [
-    "prefix=${placeholder ''out''}"
+    "prefix=${placeholder "out"}"
   ];
 
   hardeningDisable = lib.optional (stdenv.isi686) "stackprotector";

pkgs/os-specific/linux/pcmciautils/default.nix

···
     " src/{startup.c,pcmcia-check-broken-cis.c} # fix-color */
   ''
   + (if firmware == [] then ''sed -i "s,STARTUP = true,STARTUP = false," Makefile'' else "")
-  + (if configOpts == null then "" else ''
-    ln -sf ${configOpts} ./config/config.opts'')
+  + (if configOpts == null then "" else "ln -sf ${configOpts} ./config/config.opts")
   ;
 
   makeFlags = [ "LEX=flex" ];

pkgs/servers/computing/storm/default.nix

···
        -e 's|java.library.path: .*|java.library.path: "${lib.concatStringsSep ":" extraLibraryPaths}"|' \
        -e 's|storm.log4j2.conf.dir: .*|storm.log4j2.conf.dir: "conf/log4j2"|' \
       defaults.yaml
-    ${if confFile != "" then ''cat ${confFile} >> defaults.yaml'' else ""}
+    ${if confFile != "" then "cat ${confFile} >> defaults.yaml" else ""}
     mv defaults.yaml $out/conf;
 
     # Link to extra jars

pkgs/servers/fingerd/bsd-fingerd/default.nix

···
 
   preBuild = "cd fingerd";
 
-  preInstall = '' mkdir -p $out/man/man8 $out/sbin '';
+  preInstall = "mkdir -p $out/man/man8 $out/sbin ";
 
   meta = with lib; {
     platforms = platforms.linux;

pkgs/servers/firebird/default.nix

···
   # dosen't work. Copying the files manually which can be found
   # in ubuntu -dev -classic, -example packages:
   # maybe some of those files can be removed again
-  installPhase = ''cp -r gen/firebird $out'';
+  installPhase = "cp -r gen/firebird $out";
 
   meta = {
     description = "SQL relational database management system";

pkgs/servers/http/apache-modules/mod_ca/default.nix

···
   ];
 
   installFlags = [
-    "INCLUDEDIR=${placeholder ''out''}/include"
-    "LIBEXECDIR=${placeholder ''out''}/modules"
+    "INCLUDEDIR=${placeholder "out"}/include"
+    "LIBEXECDIR=${placeholder "out"}/modules"
   ];
 
   meta = with lib; {

pkgs/servers/hylafaxplus/default.nix

···
     openldap  # optional
     pam  # optional
   ];
-  postPatch = ''. ${postPatch}'';
+  postPatch = ". ${postPatch}";
   dontAddPrefix = true;
-  postInstall = ''. ${postInstall}'';
-  postInstallCheck = ''. ${./post-install-check.sh}'';
+  postInstall = ". ${postInstall}";
+  postInstallCheck = ". ${./post-install-check.sh}";
   meta = {
     description = "enterprise-class system for sending and receiving facsimiles";
     downloadPage = "https://hylafax.sourceforge.io/download.php";

pkgs/servers/x11/xorg/overrides.nix

···
     outputs = [ "out" "dev" ]; # to get rid of xorgserver.dev; man is tiny
     preBuild = "sed -e '/motion_history_proc/d; /history_size/d;' -i src/*.c";
     installFlags = [
-      "sdkdir=${placeholder ''out''}/include/xorg"
+      "sdkdir=${placeholder "out"}/include/xorg"
     ];
   });
 
   xf86inputmouse = super.xf86inputmouse.overrideAttrs (attrs: {
     installFlags = [
-      "sdkdir=${placeholder ''out''}/include/xorg"
+      "sdkdir=${placeholder "out"}/include/xorg"
     ];
   });
 
   xf86inputjoystick = super.xf86inputjoystick.overrideAttrs (attrs: {
     installFlags = [
-      "sdkdir=${placeholder ''out''}/include/xorg"
+      "sdkdir=${placeholder "out"}/include/xorg"
     ];
   });
 
   xf86inputlibinput = super.xf86inputlibinput.overrideAttrs (attrs: {
     outputs = [ "out" "dev" ];
     installFlags = [
-      "sdkdir=${placeholder ''dev''}/include/xorg"
+      "sdkdir=${placeholder "dev"}/include/xorg"
     ];
   });
 
   xf86inputsynaptics = super.xf86inputsynaptics.overrideAttrs (attrs: {
     outputs = [ "out" "dev" ]; # *.pc pulls xorgserver.dev
     installFlags = [
-      "sdkdir=${placeholder ''out''}/include/xorg"
-      "configdir=${placeholder ''out''}/share/X11/xorg.conf.d"
+      "sdkdir=${placeholder "out"}/include/xorg"
+      "configdir=${placeholder "out"}/share/X11/xorg.conf.d"
     ];
   });
 
   xf86inputvmmouse = super.xf86inputvmmouse.overrideAttrs (attrs: {
     configureFlags = [
-      "--sysconfdir=${placeholder ''out''}/etc"
-      "--with-xorg-conf-dir=${placeholder ''out''}/share/X11/xorg.conf.d"
-      "--with-udev-rules-dir=${placeholder ''out''}/lib/udev/rules.d"
+      "--sysconfdir=${placeholder "out"}/etc"
+      "--with-xorg-conf-dir=${placeholder "out"}/share/X11/xorg.conf.d"
+      "--with-udev-rules-dir=${placeholder "out"}/lib/udev/rules.d"
     ];
 
     meta = attrs.meta // {

pkgs/shells/mksh/default.nix

···
 
   dontConfigure = true;
 
-  buildPhase = ''sh ./Build.sh -r'';
+  buildPhase = "sh ./Build.sh -r";
 
   installPhase = ''
     install -D -m 755 mksh $out/bin/mksh

pkgs/stdenv/freebsd/default.nix

···
         isClang      = true;
       };
 
-      preHook = ''export NIX_NO_SELF_RPATH=1'';
+      preHook = "export NIX_NO_SELF_RPATH=1";
     };
   })
 

pkgs/tools/X11/xmagnify/default.nix

···
     sha256 = "1ngnp5f5zl3v35vhbdyjpymy6mwrs0476fm5nd7dzkba7n841jdh";
   };
 
-  prePatch = ''substituteInPlace ./Makefile --replace /usr $out'';
+  prePatch = "substituteInPlace ./Makefile --replace /usr $out";
 
   buildInputs = [ libX11 xorgproto ];
 

pkgs/tools/X11/xprintidle-ng/default.nix

···
 
   meta = {
     inherit  version;
-    description = ''A command-line tool to print idle time from libXss'';
+    description = "A command-line tool to print idle time from libXss";
     homepage = "http://taktoa.me/xprintidle-ng/";
     license = lib.licenses.gpl2;
     maintainers = [lib.maintainers.raskin];

pkgs/tools/X11/xwinmosaic/default.nix

···
 
   meta = {
     inherit version;
-    description = ''X window switcher drawing a colourful grid'';
+    description = "X window switcher drawing a colourful grid";
     license = lib.licenses.bsd2 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/tools/archivers/unzip/default.nix

···
   '';
 
   installFlags = [
-    "prefix=${placeholder ''out''}"
+    "prefix=${placeholder "out"}"
   ];
 
   setupHook = ./setup-hook.sh;

pkgs/tools/archivers/zip/default.nix

···
   makefile = "unix/Makefile";
   buildFlags = if stdenv.isCygwin then [ "cygwin" ] else [ "generic" ];
   installFlags = [
-    "prefix=${placeholder ''out''}"
+    "prefix=${placeholder "out"}"
     "INSTALL=cp"
   ];
 

pkgs/tools/audio/pa-applet/default.nix

···
   # work around a problem related to gtk3 updates
   NIX_CFLAGS_COMPILE = "-Wno-error=deprecated-declarations";
 
-  postInstall = ''
-  '';
+  postInstall = "";
 
   meta = with lib; {
     description = "";

pkgs/tools/backup/mydumper/default.nix

···
   cmakeFlags = [ "-DMYSQL_INCLUDE_DIR=${getDev libmysqlclient}/include/mysql" ];
 
   meta = with lib; {
-    description = ''High-perfomance MySQL backup tool'';
+    description = "High-perfomance MySQL backup tool";
     homepage = "https://github.com/maxbube/mydumper";
     license = licenses.gpl3;
     platforms = platforms.linux;

pkgs/tools/compression/advancecomp/default.nix

···
   '';
 
   meta = with lib; {
-    description = ''A set of tools to optimize deflate-compressed files'';
+    description = "A set of tools to optimize deflate-compressed files";
     license = licenses.gpl3 ;
     maintainers = [ maintainers.raskin ];
     platforms = platforms.linux ++ platforms.darwin;

pkgs/tools/compression/pixz/default.nix

···
 
   meta = {
     inherit version;
-    description = ''A parallel compressor/decompressor for xz format'';
+    description = "A parallel compressor/decompressor for xz format";
     license = lib.licenses.bsd2;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.unix;

pkgs/tools/filesystems/catcli/default.nix

···
 
   propagatedBuildInputs = [ docopt anytree ];
 
-  postPatch = '' patchShebangs . '';
+  postPatch = "patchShebangs . ";
 
   meta = with lib; {
     description = "The command line catalog tool for your offline data";

pkgs/tools/filesystems/glusterfs/default.nix

···
     '';
 
   configureFlags = [
-    ''--localstatedir=/var''
+    "--localstatedir=/var"
     ];
 
   nativeBuildInputs = [ rpcsvc-proto ];

pkgs/tools/filesystems/irods/default.nix

···
     '';
 
     meta = common.meta // {
-      longDescription = common.meta.longDescription + ''
-        This package provides the servers and libraries.'';
+      longDescription = common.meta.longDescription + "This package provides the servers and libraries.";
     };
   });
 
···
 
      meta = common.meta // {
        description = common.meta.description + " CLI clients";
-       longDescription = common.meta.longDescription + ''
-         This package provides the CLI clients, called 'icommands'.'';
+       longDescription = common.meta.longDescription + "This package provides the CLI clients, called 'icommands'.";
      };
   });
 }

pkgs/tools/graphics/argyllcms/default.nix

···
   buildFlags = [ "all" ];
 
   makeFlags = [
-    "PREFIX=${placeholder ''out''}"
+    "PREFIX=${placeholder "out"}"
   ];
 
   # Install udev rules, but remove lines that set up the udev-acl

pkgs/tools/graphics/cfdg/src-info-for-default.nix

···
 {
   downloadPage = "https://contextfreeart.org/mediawiki/index.php/Download_page";
   baseName = "cfdg";
-  sourceRegexp = ''.*[.]tgz'';
+  sourceRegexp = ".*[.]tgz";
   versionExtractorSedScript = ''s/[^0-9]*([0-9.]*)[.]tgz/\1/'';
 }

pkgs/tools/graphics/convchain/default.nix

···
   buildInputs = [mono];
   meta = {
     inherit version;
-    description = ''Bitmap generation from a single example with convolutions and MCMC'';
+    description = "Bitmap generation from a single example with convolutions and MCMC";
     license = lib.licenses.mit;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/tools/graphics/gmic-qt/default.nix

···
 assert lib.assertMsg (builtins.all (d: d != null) variants.${variant}.extraDeps or []) "gmic-qt variant “${variant}” is missing one of its dependencies.";
 
 mkDerivation rec {
-  pname = "gmic-qt${lib.optionalString (variant != "standalone") ''-${variant}''}";
+  pname = "gmic-qt${lib.optionalString (variant != "standalone") "-${variant}"}";
   version = "2.7.1";
 
   gmic-community = fetchFromGitHub {

pkgs/tools/graphics/qrcode/default.nix

···
   '';
 
   meta = with lib; {
-    description = ''A small QR-code tool'';
+    description = "A small QR-code tool";
     license = licenses.gpl3Plus;
     maintainers = with maintainers; [ raskin ];
     platforms = with platforms; linux;

pkgs/tools/graphics/quirc/default.nix

···
   makeFlags = [ "PREFIX=$(out)" ];
   meta = {
     inherit (s) version;
-    description = ''A small QR code decoding library'';
+    description = "A small QR code decoding library";
     license = lib.licenses.isc;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/tools/graphics/syntex/default.nix

···
   buildInputs = [mono];
   meta = {
     inherit version;
-    description = ''Texture synthesis from examples'';
+    description = "Texture synthesis from examples";
     license = lib.licenses.mit;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/tools/graphics/wavefunctioncollapse/default.nix

···
   buildInputs = [mono];
   meta = {
     inherit version;
-    description = ''A generator of bitmaps that are locally similar to the input bitmap'';
+    description = "A generator of bitmaps that are locally similar to the input bitmap";
     license = lib.licenses.mit;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/tools/graphics/zxing/default.nix

···
   '';
   meta = {
     inherit version;
-    description = ''1D and 2D code reading library'';
+    description = "1D and 2D code reading library";
     license = lib.licenses.asl20;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/tools/inputmethods/ibus-engines/ibus-uniemoji/default.nix

···
   ];
 
   makeFlags = [
-    "PREFIX=${placeholder ''out''}"
-    "SYSCONFDIR=${placeholder ''out''}/etc"
+    "PREFIX=${placeholder "out"}"
+    "SYSCONFDIR=${placeholder "out"}/etc"
     "PYTHON=${python.interpreter}"
   ];
 

pkgs/tools/inputmethods/ibus/default.nix

···
   ];
 
   makeFlags = [
-    "test_execsdir=${placeholder ''installedTests''}/libexec/installed-tests/ibus"
-    "test_sourcesdir=${placeholder ''installedTests''}/share/installed-tests/ibus"
+    "test_execsdir=${placeholder "installedTests"}/libexec/installed-tests/ibus"
+    "test_sourcesdir=${placeholder "installedTests"}/share/installed-tests/ibus"
   ];
 
   nativeBuildInputs = [

pkgs/tools/misc/ccze/default.nix

···
 
   buildInputs = [ autoconf ncurses pcre ];
 
-  preConfigure = '' autoheader && autoconf '';
+  preConfigure = "autoheader && autoconf ";
 
   meta = with lib; {
     description = "Fast, modular log colorizer";

pkgs/tools/misc/debian-devscripts/default.nix

···
   '';
 
   meta = with lib; {
-    description = ''Debian package maintenance scripts'';
+    description = "Debian package maintenance scripts";
     license = licenses.free; # Mix of public domain, Artistic+GPL, GPL1+, GPL2+, GPL3+, and GPL2-only... TODO
     maintainers = with maintainers; [raskin];
     platforms = with platforms; linux;

pkgs/tools/networking/badvpn/default.nix

···
 
   meta = {
     inherit (s) version;
-    description = ''A set of network-related (mostly VPN-related) tools'';
+    description = "A set of network-related (mostly VPN-related) tools";
     license = lib.licenses.bsd3 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/tools/networking/bgpdump/default.nix

···
 
   meta = {
     homepage = "https://bitbucket.org/ripencc/bgpdump/";
-    description = ''Analyze dump files produced by Zebra/Quagga or MRT'';
+    description = "Analyze dump files produced by Zebra/Quagga or MRT";
     license = lib.licenses.hpnd;
     maintainers = with lib.maintainers; [ lewo ];
     platforms = with lib.platforms; linux;

pkgs/tools/networking/bsd-finger/default.nix

···
 
   preBuild = "cd finger";
 
-  preInstall = '' mkdir -p $out/man/man1 $out/bin '';
+  preInstall = "mkdir -p $out/man/man1 $out/bin ";
 
   meta = with lib; {
     platforms = platforms.linux;

pkgs/tools/networking/jnettop/default.nix

···
     })
   ];
 
-  preConfigure = '' autoconf '';
+  preConfigure = "autoconf ";
 
   meta = {
     description = "Network traffic visualizer";

pkgs/tools/networking/mailsend/default.nix

···
   ];
   meta = {
     inherit (s) version;
-    description = ''CLI email sending tool'';
+    description = "CLI email sending tool";
     license = lib.licenses.bsd3 ;
     maintainers = [lib.maintainers.raskin];
     platforms = lib.platforms.linux;

pkgs/tools/networking/persepolis/default.nix

···
   # feed args to wrapPythonApp
   makeWrapperArgs = [
     "--prefix PATH : ${lib.makeBinPath [aria libnotify ]}"
-    ''''${qtWrapperArgs[@]}''
+    "\${qtWrapperArgs[@]}"
   ];
 
   propagatedBuildInputs = [

pkgs/tools/package-management/disnix/DisnixWebService/default.nix

···
     sha256 = "0m451msd127ay09yb8rbflg68szm8s4hh65j99f7s3mz375vc114";
   };
   buildInputs = [ apacheAnt jdk ];
-  PREFIX = ''''${env.out}'';
+  PREFIX = "\${env.out}";
   AXIS2_LIB = "${axis2}/lib";
   AXIS2_WEBAPP = "${axis2}/webapps/axis2";
   DBUS_JAVA_LIB = "${dbus_java}/share/java";

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

···
         ]
         ++ lib.optional (
             stdenv.hostPlatform != stdenv.buildPlatform && stdenv.hostPlatform ? nix && stdenv.hostPlatform.nix ? system
-        ) ''--with-system=${stdenv.hostPlatform.nix.system}''
+        ) "--with-system=${stdenv.hostPlatform.nix.system}"
            # RISC-V support in progress https://github.com/seccomp/libseccomp/pull/50
         ++ lib.optional (!withLibseccomp) "--disable-seccomp-sandboxing";
 

pkgs/tools/security/gencfsm/default.nix

···
 
   configureFlags = [ "--disable-appindicator" ];
 
-  preFixup = ''gappsWrapperArgs+=(--prefix PATH : ${encfs}/bin)'';
+  preFixup = "gappsWrapperArgs+=(--prefix PATH : ${encfs}/bin)";
 
   enableParallelBuilding = true;
 

pkgs/tools/security/pbis/default.nix

···
     fi
     NIX_CFLAGS_COMPILE="$NIX_CFLAGS_COMPILE -isystem ${lib.getDev libxml2}/include/libxml2 -Wno-error=array-bounds -Wno-error=pointer-sign -Wno-error=deprecated-declarations -Wno-error=unused-variable"
   '';
-  configureScript = ''../configure'';
+  configureScript = "../configure";
   configureFlags = [
     "CFLAGS=-O"
     "--docdir=${placeholder "prefix"}/share/doc"

pkgs/tools/security/tcpcrypt/default.nix

···
     sha256 = "0a015rlyvagz714pgwr85f8gjq1fkc0il7d7l39qcgxrsp15b96w";
   };
 
-  postUnpack = ''mkdir -vp $sourceRoot/m4'';
+  postUnpack = "mkdir -vp $sourceRoot/m4";
 
   outputs = [ "bin" "dev" "out" ];
   nativeBuildInputs = [ autoreconfHook ];

pkgs/tools/system/at/default.nix

···
   '';
 
   meta = {
-    description = ''The classical Unix `at' job scheduling command'';
+    description = "The classical Unix `at' job scheduling command";
     license = lib.licenses.gpl2Plus;
     homepage = "https://packages.qa.debian.org/at";
     platforms = lib.platforms.linux;

pkgs/tools/system/ipmitool/default.nix

···
   dontDisableStatic = static;
 
   meta = with lib; {
-    description = ''Command-line interface to IPMI-enabled devices'';
+    description = "Command-line interface to IPMI-enabled devices";
     license = licenses.bsd3;
     homepage = "https://sourceforge.net/projects/ipmitool/";
     platforms = platforms.unix;

pkgs/tools/system/socklog/default.nix

···
     echo "$NIX_CC/bin/cc -s"                    >src/conf-ld
   '';
 
-  buildPhase = ''package/compile'';
+  buildPhase = "package/compile";
 
   installPhase = ''
     mkdir -p $out/bin
···
     mv doc/*.html $doc/share/doc/socklog/html/
   '';
 
-  checkPhase = ''package/check'';
+  checkPhase = "package/check";
 
   doCheck = true;
 

pkgs/tools/system/throttled/default.nix

···
     runHook postInstall
   '';
 
-  postFixup = ''wrapPythonPrograms'';
+  postFixup = "wrapPythonPrograms";
 
   meta = with lib; {
     description = "Fix for Intel CPU throttling issues";

pkgs/tools/video/rtmpdump/default.nix

···
     })
   ];
 
-  makeFlags = [ ''prefix=$(out)'' ]
+  makeFlags = [ "prefix=$(out)" ]
     ++ optional gnutlsSupport "CRYPTO=GNUTLS"
     ++ optional opensslSupport "CRYPTO=OPENSSL"
     ++ optional stdenv.isDarwin "SYS=darwin"

pkgs/top-level/all-packages.nix

···
 
   octoprint = callPackage ../applications/misc/octoprint { };
 
-  octoprint-plugins = throw ''octoprint-plugins are now part of the octoprint.python.pkgs package set.'';
+  octoprint-plugins = throw "octoprint-plugins are now part of the octoprint.python.pkgs package set.";
 
   ocrad = callPackage ../applications/graphics/ocrad { };
 

pkgs/top-level/perl-packages.nix

···
       sha256 = "0wfdixpm3p94mnng474l0nh9mjiy8q8hbrbh2af4vwn2hmazr91f";
     };
     buildInputs = [ TestDeep TestDifferences TestLongString TestWarn ];
-    preBuild = ''ls'';
+    preBuild = "ls";
     meta = {
       homepage = "https://github.com/Sereal/Sereal";
       description = "Fast, compact, powerful binary deserialization";
···
     };
     buildInputs = [ pkgs.xorg.libXext pkgs.xorg.libXScrnSaver pkgs.xorg.libX11 ];
     propagatedBuildInputs = [ InlineC ];
-    patchPhase = ''sed -ie 's,-L/usr/X11R6/lib/,-L${pkgs.xorg.libX11.out}/lib/ -L${pkgs.xorg.libXext.out}/lib/ -L${pkgs.xorg.libXScrnSaver}/lib/,' IdleTime.pm'';
+    patchPhase = "sed -ie 's,-L/usr/X11R6/lib/,-L${pkgs.xorg.libX11.out}/lib/ -L${pkgs.xorg.libXext.out}/lib/ -L${pkgs.xorg.libXScrnSaver}/lib/,' IdleTime.pm";
     meta = {
       description = "Get the idle time of X11";
     };