Merge master into staging-next

maintainers/scripts/haskell/mark-broken.sh

···
 
 echo "Remember that you need to manually run 'maintainers/scripts/haskell/hydra-report.hs get-report' sometime before running this script."
 echo "Generating a list of broken builds and displaying for manual confirmation ..."
-maintainers/scripts/haskell/hydra-report.hs mark-broken-list | sort -i > $tmpfile
+maintainers/scripts/haskell/hydra-report.hs mark-broken-list | sort -i > "$tmpfile"
 
-$EDITOR $tmpfile
+$EDITOR "$tmpfile"
 
 tail -n +3 "$broken_config" >> "$tmpfile"
 
···
   # These packages don't compile.
 EOF
 
+# clear environment here to avoid things like allowing broken builds in
 sort -iu "$tmpfile" >> "$broken_config"
-maintainers/scripts/haskell/regenerate-hackage-packages.sh
-maintainers/scripts/haskell/regenerate-transitive-broken-packages.sh
-maintainers/scripts/haskell/regenerate-hackage-packages.sh
+env -i maintainers/scripts/haskell/regenerate-hackage-packages.sh
+env -i maintainers/scripts/haskell/regenerate-transitive-broken-packages.sh
+env -i maintainers/scripts/haskell/regenerate-hackage-packages.sh
 
 if [[ "${1:-}" == "--do-commit" ]]; then
 git add $broken_config

nixos/doc/manual/development/nixos-tests.xml

···
   one or more virtual machines containing the NixOS system(s) required for the
   test.
  </para>
- <xi:include href="writing-nixos-tests.xml" />
- <xi:include href="running-nixos-tests.xml" />
- <xi:include href="running-nixos-tests-interactively.xml" />
+ <xi:include href="../from_md/development/writing-nixos-tests.section.xml" />
+ <xi:include href="../from_md/development/running-nixos-tests.section.xml" />
+ <xi:include href="../from_md/development/running-nixos-tests-interactively.section.xml" />
 </chapter>

nixos/doc/manual/development/running-nixos-tests-interactively.section.md

···
+# Running Tests interactively {#sec-running-nixos-tests-interactively}
+
+The test itself can be run interactively. This is particularly useful
+when developing or debugging a test:
+
+```ShellSession
+$ nix-build nixos/tests/login.nix -A driverInteractive
+$ ./result/bin/nixos-test-driver
+starting VDE switch for network 1
+>
+```
+
+You can then take any Python statement, e.g.
+
+```py
+> start_all()
+> test_script()
+> machine.succeed("touch /tmp/foo")
+> print(machine.succeed("pwd")) # Show stdout of command
+```
+
+The function `test_script` executes the entire test script and drops you
+back into the test driver command line upon its completion. This allows
+you to inspect the state of the VMs after the test (e.g. to debug the
+test script).
+
+To just start and experiment with the VMs, run:
+
+```ShellSession
+$ nix-build nixos/tests/login.nix -A driverInteractive
+$ ./result/bin/nixos-run-vms
+```
+
+The script `nixos-run-vms` starts the virtual machines defined by test.
+
+You can re-use the VM states coming from a previous run by setting the
+`--keep-vm-state` flag.
+
+```ShellSession
+$ ./result/bin/nixos-run-vms --keep-vm-state
+```
+
+The machine state is stored in the `$TMPDIR/vm-state-machinename`
+directory.

nixos/doc/manual/development/running-nixos-tests-interactively.xml

···
-<section xmlns="http://docbook.org/ns/docbook"
-        xmlns:xlink="http://www.w3.org/1999/xlink"
-        xmlns:xi="http://www.w3.org/2001/XInclude"
-        version="5.0"
-        xml:id="sec-running-nixos-tests-interactively">
- <title>Running Tests interactively</title>
-
- <para>
-  The test itself can be run interactively. This is particularly useful when
-  developing or debugging a test:
-<screen>
-<prompt>$ </prompt>nix-build nixos/tests/login.nix -A driverInteractive
-<prompt>$ </prompt>./result/bin/nixos-test-driver
-starting VDE switch for network 1
-<prompt>&gt;</prompt>
-</screen>
-  You can then take any Python statement, e.g.
-<screen>
-<prompt>&gt;</prompt> start_all()
-<prompt>&gt;</prompt> test_script()
-<prompt>&gt;</prompt> machine.succeed("touch /tmp/foo")
-<prompt>&gt;</prompt> print(machine.succeed("pwd")) # Show stdout of command
-</screen>
-  The function <command>test_script</command> executes the entire test script
-  and drops you back into the test driver command line upon its completion.
-  This allows you to inspect the state of the VMs after the test (e.g. to debug
-  the test script).
- </para>
-
- <para>
-  To just start and experiment with the VMs, run:
-<screen>
-<prompt>$ </prompt>nix-build nixos/tests/login.nix -A driverInteractive
-<prompt>$ </prompt>./result/bin/nixos-run-vms
-</screen>
-  The script <command>nixos-run-vms</command> starts the virtual machines
-  defined by test.
- </para>
-
- <para>
-   You can re-use the VM states coming from a previous run
-   by setting the <command>--keep-vm-state</command> flag.
-<screen>
-<prompt>$ </prompt>./result/bin/nixos-run-vms --keep-vm-state
-</screen>
-  The machine state is stored in the
-  <filename>$TMPDIR/vm-state-</filename><varname>machinename</varname> directory.
- </para>
-</section>

nixos/doc/manual/development/running-nixos-tests.section.md

···
+# Running Tests {#sec-running-nixos-tests}
+
+You can run tests using `nix-build`. For example, to run the test
+[`login.nix`](https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/login.nix),
+you just do:
+
+```ShellSession
+$ nix-build '<nixpkgs/nixos/tests/login.nix>'
+```
+
+or, if you don't want to rely on `NIX_PATH`:
+
+```ShellSession
+$ cd /my/nixpkgs/nixos/tests
+$ nix-build login.nix
+…
+running the VM test script
+machine: QEMU running (pid 8841)
+…
+6 out of 6 tests succeeded
+```
+
+After building/downloading all required dependencies, this will perform
+a build that starts a QEMU/KVM virtual machine containing a NixOS
+system. The virtual machine mounts the Nix store of the host; this makes
+VM creation very fast, as no disk image needs to be created. Afterwards,
+you can view a pretty-printed log of the test:
+
+```ShellSession
+$ firefox result/log.html
+```

nixos/doc/manual/development/running-nixos-tests.xml

···
-<section xmlns="http://docbook.org/ns/docbook"
-        xmlns:xlink="http://www.w3.org/1999/xlink"
-        xmlns:xi="http://www.w3.org/2001/XInclude"
-        version="5.0"
-        xml:id="sec-running-nixos-tests">
- <title>Running Tests</title>
-
- <para>
-  You can run tests using <command>nix-build</command>. For example, to run the
-  test
-  <filename
-xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/login.nix">login.nix</filename>,
-  you just do:
-<screen>
-<prompt>$ </prompt>nix-build '&lt;nixpkgs/nixos/tests/login.nix>'
-</screen>
-  or, if you don’t want to rely on <envar>NIX_PATH</envar>:
-<screen>
-<prompt>$ </prompt>cd /my/nixpkgs/nixos/tests
-<prompt>$ </prompt>nix-build login.nix
-…
-running the VM test script
-machine: QEMU running (pid 8841)
-…
-6 out of 6 tests succeeded
-</screen>
-  After building/downloading all required dependencies, this will perform a
-  build that starts a QEMU/KVM virtual machine containing a NixOS system. The
-  virtual machine mounts the Nix store of the host; this makes VM creation very
-  fast, as no disk image needs to be created. Afterwards, you can view a
-  pretty-printed log of the test:
-<screen>
-<prompt>$ </prompt>firefox result/log.html
-</screen>
- </para>
-</section>

nixos/doc/manual/development/writing-nixos-tests.section.md

···
+# Writing Tests {#sec-writing-nixos-tests}
+
+A NixOS test is a Nix expression that has the following structure:
+
+```nix
+import ./make-test-python.nix {
+
+  # Either the configuration of a single machine:
+  machine =
+    { config, pkgs, ... }:
+    { configuration…
+    };
+
+  # Or a set of machines:
+  nodes =
+    { machine1 =
+        { config, pkgs, ... }: { … };
+      machine2 =
+        { config, pkgs, ... }: { … };
+      …
+    };
+
+  testScript =
+    ''
+      Python code…
+    '';
+}
+```
+
+The attribute `testScript` is a bit of Python code that executes the
+test (described below). During the test, it will start one or more
+virtual machines, the configuration of which is described by the
+attribute `machine` (if you need only one machine in your test) or by
+the attribute `nodes` (if you need multiple machines). For instance,
+[`login.nix`](https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/login.nix)
+only needs a single machine to test whether users can log in
+on the virtual console, whether device ownership is correctly maintained
+when switching between consoles, and so on. On the other hand,
+[`nfs/simple.nix`](https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/nfs/simple.nix),
+which tests NFS client and server functionality in the
+Linux kernel (including whether locks are maintained across server
+crashes), requires three machines: a server and two clients.
+
+There are a few special NixOS configuration options for test VMs:
+
+`virtualisation.memorySize`
+
+:   The memory of the VM in megabytes.
+
+`virtualisation.vlans`
+
+:   The virtual networks to which the VM is connected. See
+    [`nat.nix`](https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/nat.nix)
+    for an example.
+
+`virtualisation.writableStore`
+
+:   By default, the Nix store in the VM is not writable. If you enable
+    this option, a writable union file system is mounted on top of the
+    Nix store to make it appear writable. This is necessary for tests
+    that run Nix operations that modify the store.
+
+For more options, see the module
+[`qemu-vm.nix`](https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/virtualisation/qemu-vm.nix).
+
+The test script is a sequence of Python statements that perform various
+actions, such as starting VMs, executing commands in the VMs, and so on.
+Each virtual machine is represented as an object stored in the variable
+`name` if this is also the identifier of the machine in the declarative
+config. If you didn\'t specify multiple machines using the `nodes`
+attribute, it is just `machine`. The following example starts the
+machine, waits until it has finished booting, then executes a command
+and checks that the output is more-or-less correct:
+
+```py
+machine.start()
+machine.wait_for_unit("default.target")
+if not "Linux" in machine.succeed("uname"):
+  raise Exception("Wrong OS")
+```
+
+The first line is actually unnecessary; machines are implicitly started
+when you first execute an action on them (such as `wait_for_unit` or
+`succeed`). If you have multiple machines, you can speed up the test by
+starting them in parallel:
+
+```py
+start_all()
+```
+
+The following methods are available on machine objects:
+
+`start`
+
+:   Start the virtual machine. This method is asynchronous --- it does
+    not wait for the machine to finish booting.
+
+`shutdown`
+
+:   Shut down the machine, waiting for the VM to exit.
+
+`crash`
+
+:   Simulate a sudden power failure, by telling the VM to exit
+    immediately.
+
+`block`
+
+:   Simulate unplugging the Ethernet cable that connects the machine to
+    the other machines.
+
+`unblock`
+
+:   Undo the effect of `block`.
+
+`screenshot`
+
+:   Take a picture of the display of the virtual machine, in PNG format.
+    The screenshot is linked from the HTML log.
+
+`get_screen_text_variants`
+
+:   Return a list of different interpretations of what is currently
+    visible on the machine\'s screen using optical character
+    recognition. The number and order of the interpretations is not
+    specified and is subject to change, but if no exception is raised at
+    least one will be returned.
+
+    ::: {.note}
+    This requires passing `enableOCR` to the test attribute set.
+    :::
+
+`get_screen_text`
+
+:   Return a textual representation of what is currently visible on the
+    machine\'s screen using optical character recognition.
+
+    ::: {.note}
+    This requires passing `enableOCR` to the test attribute set.
+    :::
+
+`send_monitor_command`
+
+:   Send a command to the QEMU monitor. This is rarely used, but allows
+    doing stuff such as attaching virtual USB disks to a running
+    machine.
+
+`send_key`
+
+:   Simulate pressing keys on the virtual keyboard, e.g.,
+    `send_key("ctrl-alt-delete")`.
+
+`send_chars`
+
+:   Simulate typing a sequence of characters on the virtual keyboard,
+    e.g., `send_chars("foobar\n")` will type the string `foobar`
+    followed by the Enter key.
+
+`execute`
+
+:   Execute a shell command, returning a list `(status, stdout)`.
+
+`succeed`
+
+:   Execute a shell command, raising an exception if the exit status is
+    not zero, otherwise returning the standard output. Commands are run
+    with `set -euo pipefail` set:
+
+    -   If several commands are separated by `;` and one fails, the
+        command as a whole will fail.
+
+    -   For pipelines, the last non-zero exit status will be returned
+        (if there is one, zero will be returned otherwise).
+
+    -   Dereferencing unset variables fail the command.
+
+`fail`
+
+:   Like `succeed`, but raising an exception if the command returns a zero
+    status.
+
+`wait_until_succeeds`
+
+:   Repeat a shell command with 1-second intervals until it succeeds.
+
+`wait_until_fails`
+
+:   Repeat a shell command with 1-second intervals until it fails.
+
+`wait_for_unit`
+
+:   Wait until the specified systemd unit has reached the "active"
+    state.
+
+`wait_for_file`
+
+:   Wait until the specified file exists.
+
+`wait_for_open_port`
+
+:   Wait until a process is listening on the given TCP port (on
+    `localhost`, at least).
+
+`wait_for_closed_port`
+
+:   Wait until nobody is listening on the given TCP port.
+
+`wait_for_x`
+
+:   Wait until the X11 server is accepting connections.
+
+`wait_for_text`
+
+:   Wait until the supplied regular expressions matches the textual
+    contents of the screen by using optical character recognition (see
+    `get_screen_text` and `get_screen_text_variants`).
+
+    ::: {.note}
+    This requires passing `enableOCR` to the test attribute set.
+    :::
+
+`wait_for_console_text`
+
+:   Wait until the supplied regular expressions match a line of the
+    serial console output. This method is useful when OCR is not
+    possibile or accurate enough.
+
+`wait_for_window`
+
+:   Wait until an X11 window has appeared whose name matches the given
+    regular expression, e.g., `wait_for_window("Terminal")`.
+
+`copy_from_host`
+
+:   Copies a file from host to machine, e.g.,
+    `copy_from_host("myfile", "/etc/my/important/file")`.
+
+    The first argument is the file on the host. The file needs to be
+    accessible while building the nix derivation. The second argument is
+    the location of the file on the machine.
+
+`systemctl`
+
+:   Runs `systemctl` commands with optional support for
+    `systemctl --user`
+
+    ```py
+    machine.systemctl("list-jobs --no-pager") # runs `systemctl list-jobs --no-pager`
+    machine.systemctl("list-jobs --no-pager", "any-user") # spawns a shell for `any-user` and runs `systemctl --user list-jobs --no-pager`
+    ```
+
+`shell_interact`
+
+:   Allows you to directly interact with the guest shell. This should
+    only be used during test development, not in production tests.
+    Killing the interactive session with `Ctrl-d` or `Ctrl-c` also ends
+    the guest session.
+
+To test user units declared by `systemd.user.services` the optional
+`user` argument can be used:
+
+```py
+machine.start()
+machine.wait_for_x()
+machine.wait_for_unit("xautolock.service", "x-session-user")
+```
+
+This applies to `systemctl`, `get_unit_info`, `wait_for_unit`,
+`start_job` and `stop_job`.
+
+For faster dev cycles it\'s also possible to disable the code-linters
+(this shouldn\'t be commited though):
+
+```nix
+import ./make-test-python.nix {
+  skipLint = true;
+  machine =
+    { config, pkgs, ... }:
+    { configuration…
+    };
+
+  testScript =
+    ''
+      Python code…
+    '';
+}
+```
+
+This will produce a Nix warning at evaluation time. To fully disable the
+linter, wrap the test script in comment directives to disable the Black
+linter directly (again, don\'t commit this within the Nixpkgs
+repository):
+
+```nix
+  testScript =
+    ''
+      # fmt: off
+      Python code…
+      # fmt: on
+    '';
+```

nixos/doc/manual/development/writing-nixos-tests.xml

···
-<section xmlns="http://docbook.org/ns/docbook"
-        xmlns:xlink="http://www.w3.org/1999/xlink"
-        xmlns:xi="http://www.w3.org/2001/XInclude"
-        version="5.0"
-        xml:id="sec-writing-nixos-tests">
- <title>Writing Tests</title>
-
- <para>
-  A NixOS test is a Nix expression that has the following structure:
-<programlisting>
-import ./make-test-python.nix {
-
-  # Either the configuration of a single machine:
-  machine =
-    { config, pkgs, ... }:
-    { <replaceable>configuration…</replaceable>
-    };
-
-  # Or a set of machines:
-  nodes =
-    { <replaceable>machine1</replaceable> =
-        { config, pkgs, ... }: { <replaceable>…</replaceable> };
-      <replaceable>machine2</replaceable> =
-        { config, pkgs, ... }: { <replaceable>…</replaceable> };
-      …
-    };
-
-  testScript =
-    ''
-      <replaceable>Python code…</replaceable>
-    '';
-}
-</programlisting>
-  The attribute <literal>testScript</literal> is a bit of Python code that
-  executes the test (described below). During the test, it will start one or
-  more virtual machines, the configuration of which is described by the
-  attribute <literal>machine</literal> (if you need only one machine in your
-  test) or by the attribute <literal>nodes</literal> (if you need multiple
-  machines). For instance,
-  <filename
-xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/login.nix">login.nix</filename>
-  only needs a single machine to test whether users can log in on the virtual
-  console, whether device ownership is correctly maintained when switching
-  between consoles, and so on. On the other hand,
-  <filename
-xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/nfs/simple.nix">nfs/simple.nix</filename>,
-  which tests NFS client and server functionality in the Linux kernel
-  (including whether locks are maintained across server crashes), requires
-  three machines: a server and two clients.
- </para>
-
- <para>
-  There are a few special NixOS configuration options for test VMs:
-<!-- FIXME: would be nice to generate this automatically. -->
-  <variablelist>
-   <varlistentry>
-    <term>
-     <option>virtualisation.memorySize</option>
-    </term>
-    <listitem>
-     <para>
-      The memory of the VM in megabytes.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <option>virtualisation.vlans</option>
-    </term>
-    <listitem>
-     <para>
-      The virtual networks to which the VM is connected. See
-      <filename
-    xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/nat.nix">nat.nix</filename>
-      for an example.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <option>virtualisation.writableStore</option>
-    </term>
-    <listitem>
-     <para>
-      By default, the Nix store in the VM is not writable. If you enable this
-      option, a writable union file system is mounted on top of the Nix store
-      to make it appear writable. This is necessary for tests that run Nix
-      operations that modify the store.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
-  For more options, see the module
-  <filename
-xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/virtualisation/qemu-vm.nix">qemu-vm.nix</filename>.
- </para>
-
- <para>
-  The test script is a sequence of Python statements that perform various
-  actions, such as starting VMs, executing commands in the VMs, and so on. Each
-  virtual machine is represented as an object stored in the variable
-  <literal><replaceable>name</replaceable></literal> if this is also the
-  identifier of the machine in the declarative config.
-  If you didn't specify multiple machines using the <literal>nodes</literal>
-  attribute, it is just <literal>machine</literal>.
-  The following example starts the machine, waits until it has finished booting,
-  then executes a command and checks that the output is more-or-less correct:
-<programlisting>
-machine.start()
-machine.wait_for_unit("default.target")
-if not "Linux" in machine.succeed("uname"):
-  raise Exception("Wrong OS")
-</programlisting>
-  The first line is actually unnecessary; machines are implicitly started when
-  you first execute an action on them (such as <literal>wait_for_unit</literal>
-  or <literal>succeed</literal>). If you have multiple machines, you can speed
-  up the test by starting them in parallel:
-<programlisting>
-start_all()
-</programlisting>
- </para>
-
- <para>
-  The following methods are available on machine objects:
-  <variablelist>
-   <varlistentry>
-    <term>
-     <methodname>start</methodname>
-    </term>
-    <listitem>
-     <para>
-      Start the virtual machine. This method is asynchronous — it does not
-      wait for the machine to finish booting.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>shutdown</methodname>
-    </term>
-    <listitem>
-     <para>
-      Shut down the machine, waiting for the VM to exit.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>crash</methodname>
-    </term>
-    <listitem>
-     <para>
-      Simulate a sudden power failure, by telling the VM to exit immediately.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>block</methodname>
-    </term>
-    <listitem>
-     <para>
-      Simulate unplugging the Ethernet cable that connects the machine to the
-      other machines.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>unblock</methodname>
-    </term>
-    <listitem>
-     <para>
-      Undo the effect of <methodname>block</methodname>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>screenshot</methodname>
-    </term>
-    <listitem>
-     <para>
-      Take a picture of the display of the virtual machine, in PNG format. The
-      screenshot is linked from the HTML log.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>get_screen_text_variants</methodname>
-    </term>
-    <listitem>
-     <para>
-      Return a list of different interpretations of what is currently visible
-      on the machine's screen using optical character recognition. The number
-      and order of the interpretations is not specified and is subject to
-      change, but if no exception is raised at least one will be returned.
-     </para>
-     <note>
-      <para>
-       This requires passing <option>enableOCR</option> to the test attribute
-       set.
-      </para>
-     </note>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>get_screen_text</methodname>
-    </term>
-    <listitem>
-     <para>
-      Return a textual representation of what is currently visible on the
-      machine's screen using optical character recognition.
-     </para>
-     <note>
-      <para>
-       This requires passing <option>enableOCR</option> to the test attribute
-       set.
-      </para>
-     </note>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>send_monitor_command</methodname>
-    </term>
-    <listitem>
-     <para>
-      Send a command to the QEMU monitor. This is rarely used, but allows doing
-      stuff such as attaching virtual USB disks to a running machine.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>send_key</methodname>
-    </term>
-    <listitem>
-     <para>
-      Simulate pressing keys on the virtual keyboard, e.g.,
-      <literal>send_key("ctrl-alt-delete")</literal>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>send_chars</methodname>
-    </term>
-    <listitem>
-     <para>
-      Simulate typing a sequence of characters on the virtual keyboard, e.g.,
-      <literal>send_chars("foobar\n")</literal> will type the string
-      <literal>foobar</literal> followed by the Enter key.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>execute</methodname>
-    </term>
-    <listitem>
-     <para>
-      Execute a shell command, returning a list
-      <literal>(<replaceable>status</replaceable>,
-      <replaceable>stdout</replaceable>)</literal>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>succeed</methodname>
-    </term>
-    <listitem>
-     <para>
-      Execute a shell command, raising an exception if the exit status
-      is not zero, otherwise returning the standard output. Commands
-      are run with <literal>set -euo pipefail</literal> set:
-      <itemizedlist>
-        <listitem>
-          <para>
-            If several commands are separated by <literal>;</literal>
-            and one fails, the command as a whole will fail.
-          </para>
-        </listitem>
-        <listitem>
-          <para>
-            For pipelines, the last non-zero exit status will be
-            returned (if there is one, zero will be returned
-            otherwise).
-          </para>
-        </listitem>
-        <listitem>
-          <para>
-            Dereferencing unset variables fail the command.
-          </para>
-        </listitem>
-      </itemizedlist>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>fail</methodname>
-    </term>
-    <listitem>
-     <para>
-      Like <methodname>succeed</methodname>, but raising an exception if the
-      command returns a zero status.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>wait_until_succeeds</methodname>
-    </term>
-    <listitem>
-     <para>
-      Repeat a shell command with 1-second intervals until it succeeds.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>wait_until_fails</methodname>
-    </term>
-    <listitem>
-     <para>
-      Repeat a shell command with 1-second intervals until it fails.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>wait_for_unit</methodname>
-    </term>
-    <listitem>
-     <para>
-      Wait until the specified systemd unit has reached the “active” state.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>wait_for_file</methodname>
-    </term>
-    <listitem>
-     <para>
-      Wait until the specified file exists.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>wait_for_open_port</methodname>
-    </term>
-    <listitem>
-     <para>
-      Wait until a process is listening on the given TCP port (on
-      <literal>localhost</literal>, at least).
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>wait_for_closed_port</methodname>
-    </term>
-    <listitem>
-     <para>
-      Wait until nobody is listening on the given TCP port.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>wait_for_x</methodname>
-    </term>
-    <listitem>
-     <para>
-      Wait until the X11 server is accepting connections.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>wait_for_text</methodname>
-    </term>
-    <listitem>
-     <para>
-      Wait until the supplied regular expressions matches the textual contents
-      of the screen by using optical character recognition (see
-     <methodname>get_screen_text</methodname> and
-     <methodname>get_screen_text_variants</methodname>).
-     </para>
-     <note>
-      <para>
-       This requires passing <option>enableOCR</option> to the test attribute
-       set.
-      </para>
-     </note>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>wait_for_console_text</methodname>
-    </term>
-    <listitem>
-     <para>
-      Wait until the supplied regular expressions match a line of the serial
-      console output. This method is useful when OCR is not possibile or
-      accurate enough.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>wait_for_window</methodname>
-    </term>
-    <listitem>
-     <para>
-      Wait until an X11 window has appeared whose name matches the given
-      regular expression, e.g., <literal>wait_for_window("Terminal")</literal>.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>copy_from_host</methodname>
-    </term>
-    <listitem>
-     <para>
-      Copies a file from host to machine, e.g.,
-      <literal>copy_from_host("myfile", "/etc/my/important/file")</literal>.
-     </para>
-     <para>
-      The first argument is the file on the host. The file needs to be
-      accessible while building the nix derivation. The second argument is the
-      location of the file on the machine.
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>systemctl</methodname>
-    </term>
-    <listitem>
-     <para>
-      Runs <literal>systemctl</literal> commands with optional support for
-      <literal>systemctl --user</literal>
-     </para>
-     <para>
-<programlisting>
-machine.systemctl("list-jobs --no-pager") # runs `systemctl list-jobs --no-pager`
-machine.systemctl("list-jobs --no-pager", "any-user") # spawns a shell for `any-user` and runs `systemctl --user list-jobs --no-pager`
-</programlisting>
-     </para>
-    </listitem>
-   </varlistentry>
-   <varlistentry>
-    <term>
-     <methodname>shell_interact</methodname>
-    </term>
-    <listitem>
-     <para>
-      Allows you to directly interact with the guest shell.
-      This should only be used during test development, not in production tests.
-      Killing the interactive session with <literal>Ctrl-d</literal> or <literal>Ctrl-c</literal> also ends the guest session.
-     </para>
-    </listitem>
-   </varlistentry>
-  </variablelist>
- </para>
-
- <para>
-  To test user units declared by <literal>systemd.user.services</literal> the
-  optional <literal>user</literal> argument can be used:
-<programlisting>
-machine.start()
-machine.wait_for_x()
-machine.wait_for_unit("xautolock.service", "x-session-user")
-</programlisting>
-  This applies to <literal>systemctl</literal>, <literal>get_unit_info</literal>,
-  <literal>wait_for_unit</literal>, <literal>start_job</literal> and
-  <literal>stop_job</literal>.
- </para>
-
- <para>
-  For faster dev cycles it's also possible to disable the code-linters (this shouldn't
-  be commited though):
-<programlisting>
-import ./make-test-python.nix {
-  skipLint = true;
-  machine =
-    { config, pkgs, ... }:
-    { <replaceable>configuration…</replaceable>
-    };
-
-  testScript =
-    ''
-      <replaceable>Python code…</replaceable>
-    '';
-}
-</programlisting>
-  This will produce a Nix warning at evaluation time. To fully disable the
-  linter, wrap the test script in comment directives to disable the Black linter
-  directly (again, don't commit this within the Nixpkgs repository):
-<programlisting>
-  testScript =
-    ''
-      # fmt: off
-      <replaceable>Python code…</replaceable>
-      # fmt: on
-    '';
-</programlisting>
- </para>
-</section>

nixos/doc/manual/from_md/development/running-nixos-tests-interactively.section.xml

···
+<section xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xml:id="sec-running-nixos-tests-interactively">
+  <title>Running Tests interactively</title>
+  <para>
+    The test itself can be run interactively. This is particularly
+    useful when developing or debugging a test:
+  </para>
+  <programlisting>
+$ nix-build nixos/tests/login.nix -A driverInteractive
+$ ./result/bin/nixos-test-driver
+starting VDE switch for network 1
+&gt;
+</programlisting>
+  <para>
+    You can then take any Python statement, e.g.
+  </para>
+  <programlisting language="python">
+&gt; start_all()
+&gt; test_script()
+&gt; machine.succeed(&quot;touch /tmp/foo&quot;)
+&gt; print(machine.succeed(&quot;pwd&quot;)) # Show stdout of command
+</programlisting>
+  <para>
+    The function <literal>test_script</literal> executes the entire test
+    script and drops you back into the test driver command line upon its
+    completion. This allows you to inspect the state of the VMs after
+    the test (e.g. to debug the test script).
+  </para>
+  <para>
+    To just start and experiment with the VMs, run:
+  </para>
+  <programlisting>
+$ nix-build nixos/tests/login.nix -A driverInteractive
+$ ./result/bin/nixos-run-vms
+</programlisting>
+  <para>
+    The script <literal>nixos-run-vms</literal> starts the virtual
+    machines defined by test.
+  </para>
+  <para>
+    You can re-use the VM states coming from a previous run by setting
+    the <literal>--keep-vm-state</literal> flag.
+  </para>
+  <programlisting>
+$ ./result/bin/nixos-run-vms --keep-vm-state
+</programlisting>
+  <para>
+    The machine state is stored in the
+    <literal>$TMPDIR/vm-state-machinename</literal> directory.
+  </para>
+</section>

nixos/doc/manual/from_md/development/running-nixos-tests.section.xml

···
+<section xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xml:id="sec-running-nixos-tests">
+  <title>Running Tests</title>
+  <para>
+    You can run tests using <literal>nix-build</literal>. For example,
+    to run the test
+    <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/login.nix"><literal>login.nix</literal></link>,
+    you just do:
+  </para>
+  <programlisting>
+$ nix-build '&lt;nixpkgs/nixos/tests/login.nix&gt;'
+</programlisting>
+  <para>
+    or, if you don’t want to rely on <literal>NIX_PATH</literal>:
+  </para>
+  <programlisting>
+$ cd /my/nixpkgs/nixos/tests
+$ nix-build login.nix
+…
+running the VM test script
+machine: QEMU running (pid 8841)
+…
+6 out of 6 tests succeeded
+</programlisting>
+  <para>
+    After building/downloading all required dependencies, this will
+    perform a build that starts a QEMU/KVM virtual machine containing a
+    NixOS system. The virtual machine mounts the Nix store of the host;
+    this makes VM creation very fast, as no disk image needs to be
+    created. Afterwards, you can view a pretty-printed log of the test:
+  </para>
+  <programlisting>
+$ firefox result/log.html
+</programlisting>
+</section>

nixos/doc/manual/from_md/development/writing-nixos-tests.section.xml

···
+<section xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xml:id="sec-writing-nixos-tests">
+  <title>Writing Tests</title>
+  <para>
+    A NixOS test is a Nix expression that has the following structure:
+  </para>
+  <programlisting language="bash">
+import ./make-test-python.nix {
+
+  # Either the configuration of a single machine:
+  machine =
+    { config, pkgs, ... }:
+    { configuration…
+    };
+
+  # Or a set of machines:
+  nodes =
+    { machine1 =
+        { config, pkgs, ... }: { … };
+      machine2 =
+        { config, pkgs, ... }: { … };
+      …
+    };
+
+  testScript =
+    ''
+      Python code…
+    '';
+}
+</programlisting>
+  <para>
+    The attribute <literal>testScript</literal> is a bit of Python code
+    that executes the test (described below). During the test, it will
+    start one or more virtual machines, the configuration of which is
+    described by the attribute <literal>machine</literal> (if you need
+    only one machine in your test) or by the attribute
+    <literal>nodes</literal> (if you need multiple machines). For
+    instance,
+    <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/login.nix"><literal>login.nix</literal></link>
+    only needs a single machine to test whether users can log in on the
+    virtual console, whether device ownership is correctly maintained
+    when switching between consoles, and so on. On the other hand,
+    <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/nfs/simple.nix"><literal>nfs/simple.nix</literal></link>,
+    which tests NFS client and server functionality in the Linux kernel
+    (including whether locks are maintained across server crashes),
+    requires three machines: a server and two clients.
+  </para>
+  <para>
+    There are a few special NixOS configuration options for test VMs:
+  </para>
+  <variablelist>
+    <varlistentry>
+      <term>
+        <literal>virtualisation.memorySize</literal>
+      </term>
+      <listitem>
+        <para>
+          The memory of the VM in megabytes.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>virtualisation.vlans</literal>
+      </term>
+      <listitem>
+        <para>
+          The virtual networks to which the VM is connected. See
+          <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/tests/nat.nix"><literal>nat.nix</literal></link>
+          for an example.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>virtualisation.writableStore</literal>
+      </term>
+      <listitem>
+        <para>
+          By default, the Nix store in the VM is not writable. If you
+          enable this option, a writable union file system is mounted on
+          top of the Nix store to make it appear writable. This is
+          necessary for tests that run Nix operations that modify the
+          store.
+        </para>
+      </listitem>
+    </varlistentry>
+  </variablelist>
+  <para>
+    For more options, see the module
+    <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/nixos/modules/virtualisation/qemu-vm.nix"><literal>qemu-vm.nix</literal></link>.
+  </para>
+  <para>
+    The test script is a sequence of Python statements that perform
+    various actions, such as starting VMs, executing commands in the
+    VMs, and so on. Each virtual machine is represented as an object
+    stored in the variable <literal>name</literal> if this is also the
+    identifier of the machine in the declarative config. If you didn't
+    specify multiple machines using the <literal>nodes</literal>
+    attribute, it is just <literal>machine</literal>. The following
+    example starts the machine, waits until it has finished booting,
+    then executes a command and checks that the output is more-or-less
+    correct:
+  </para>
+  <programlisting language="python">
+machine.start()
+machine.wait_for_unit(&quot;default.target&quot;)
+if not &quot;Linux&quot; in machine.succeed(&quot;uname&quot;):
+  raise Exception(&quot;Wrong OS&quot;)
+</programlisting>
+  <para>
+    The first line is actually unnecessary; machines are implicitly
+    started when you first execute an action on them (such as
+    <literal>wait_for_unit</literal> or <literal>succeed</literal>). If
+    you have multiple machines, you can speed up the test by starting
+    them in parallel:
+  </para>
+  <programlisting language="python">
+start_all()
+</programlisting>
+  <para>
+    The following methods are available on machine objects:
+  </para>
+  <variablelist>
+    <varlistentry>
+      <term>
+        <literal>start</literal>
+      </term>
+      <listitem>
+        <para>
+          Start the virtual machine. This method is asynchronous — it
+          does not wait for the machine to finish booting.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>shutdown</literal>
+      </term>
+      <listitem>
+        <para>
+          Shut down the machine, waiting for the VM to exit.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>crash</literal>
+      </term>
+      <listitem>
+        <para>
+          Simulate a sudden power failure, by telling the VM to exit
+          immediately.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>block</literal>
+      </term>
+      <listitem>
+        <para>
+          Simulate unplugging the Ethernet cable that connects the
+          machine to the other machines.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>unblock</literal>
+      </term>
+      <listitem>
+        <para>
+          Undo the effect of <literal>block</literal>.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>screenshot</literal>
+      </term>
+      <listitem>
+        <para>
+          Take a picture of the display of the virtual machine, in PNG
+          format. The screenshot is linked from the HTML log.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>get_screen_text_variants</literal>
+      </term>
+      <listitem>
+        <para>
+          Return a list of different interpretations of what is
+          currently visible on the machine's screen using optical
+          character recognition. The number and order of the
+          interpretations is not specified and is subject to change, but
+          if no exception is raised at least one will be returned.
+        </para>
+        <note>
+          <para>
+            This requires passing <literal>enableOCR</literal> to the
+            test attribute set.
+          </para>
+        </note>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>get_screen_text</literal>
+      </term>
+      <listitem>
+        <para>
+          Return a textual representation of what is currently visible
+          on the machine's screen using optical character recognition.
+        </para>
+        <note>
+          <para>
+            This requires passing <literal>enableOCR</literal> to the
+            test attribute set.
+          </para>
+        </note>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>send_monitor_command</literal>
+      </term>
+      <listitem>
+        <para>
+          Send a command to the QEMU monitor. This is rarely used, but
+          allows doing stuff such as attaching virtual USB disks to a
+          running machine.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>send_key</literal>
+      </term>
+      <listitem>
+        <para>
+          Simulate pressing keys on the virtual keyboard, e.g.,
+          <literal>send_key(&quot;ctrl-alt-delete&quot;)</literal>.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>send_chars</literal>
+      </term>
+      <listitem>
+        <para>
+          Simulate typing a sequence of characters on the virtual
+          keyboard, e.g.,
+          <literal>send_chars(&quot;foobar\n&quot;)</literal> will type
+          the string <literal>foobar</literal> followed by the Enter
+          key.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>execute</literal>
+      </term>
+      <listitem>
+        <para>
+          Execute a shell command, returning a list
+          <literal>(status, stdout)</literal>.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>succeed</literal>
+      </term>
+      <listitem>
+        <para>
+          Execute a shell command, raising an exception if the exit
+          status is not zero, otherwise returning the standard output.
+          Commands are run with <literal>set -euo pipefail</literal>
+          set:
+        </para>
+        <itemizedlist>
+          <listitem>
+            <para>
+              If several commands are separated by <literal>;</literal>
+              and one fails, the command as a whole will fail.
+            </para>
+          </listitem>
+          <listitem>
+            <para>
+              For pipelines, the last non-zero exit status will be
+              returned (if there is one, zero will be returned
+              otherwise).
+            </para>
+          </listitem>
+          <listitem>
+            <para>
+              Dereferencing unset variables fail the command.
+            </para>
+          </listitem>
+        </itemizedlist>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>fail</literal>
+      </term>
+      <listitem>
+        <para>
+          Like <literal>succeed</literal>, but raising an exception if
+          the command returns a zero status.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>wait_until_succeeds</literal>
+      </term>
+      <listitem>
+        <para>
+          Repeat a shell command with 1-second intervals until it
+          succeeds.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>wait_until_fails</literal>
+      </term>
+      <listitem>
+        <para>
+          Repeat a shell command with 1-second intervals until it fails.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>wait_for_unit</literal>
+      </term>
+      <listitem>
+        <para>
+          Wait until the specified systemd unit has reached the
+          <quote>active</quote> state.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>wait_for_file</literal>
+      </term>
+      <listitem>
+        <para>
+          Wait until the specified file exists.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>wait_for_open_port</literal>
+      </term>
+      <listitem>
+        <para>
+          Wait until a process is listening on the given TCP port (on
+          <literal>localhost</literal>, at least).
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>wait_for_closed_port</literal>
+      </term>
+      <listitem>
+        <para>
+          Wait until nobody is listening on the given TCP port.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>wait_for_x</literal>
+      </term>
+      <listitem>
+        <para>
+          Wait until the X11 server is accepting connections.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>wait_for_text</literal>
+      </term>
+      <listitem>
+        <para>
+          Wait until the supplied regular expressions matches the
+          textual contents of the screen by using optical character
+          recognition (see <literal>get_screen_text</literal> and
+          <literal>get_screen_text_variants</literal>).
+        </para>
+        <note>
+          <para>
+            This requires passing <literal>enableOCR</literal> to the
+            test attribute set.
+          </para>
+        </note>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>wait_for_console_text</literal>
+      </term>
+      <listitem>
+        <para>
+          Wait until the supplied regular expressions match a line of
+          the serial console output. This method is useful when OCR is
+          not possibile or accurate enough.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>wait_for_window</literal>
+      </term>
+      <listitem>
+        <para>
+          Wait until an X11 window has appeared whose name matches the
+          given regular expression, e.g.,
+          <literal>wait_for_window(&quot;Terminal&quot;)</literal>.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>copy_from_host</literal>
+      </term>
+      <listitem>
+        <para>
+          Copies a file from host to machine, e.g.,
+          <literal>copy_from_host(&quot;myfile&quot;, &quot;/etc/my/important/file&quot;)</literal>.
+        </para>
+        <para>
+          The first argument is the file on the host. The file needs to
+          be accessible while building the nix derivation. The second
+          argument is the location of the file on the machine.
+        </para>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>systemctl</literal>
+      </term>
+      <listitem>
+        <para>
+          Runs <literal>systemctl</literal> commands with optional
+          support for <literal>systemctl --user</literal>
+        </para>
+        <programlisting language="python">
+machine.systemctl(&quot;list-jobs --no-pager&quot;) # runs `systemctl list-jobs --no-pager`
+machine.systemctl(&quot;list-jobs --no-pager&quot;, &quot;any-user&quot;) # spawns a shell for `any-user` and runs `systemctl --user list-jobs --no-pager`
+</programlisting>
+      </listitem>
+    </varlistentry>
+    <varlistentry>
+      <term>
+        <literal>shell_interact</literal>
+      </term>
+      <listitem>
+        <para>
+          Allows you to directly interact with the guest shell. This
+          should only be used during test development, not in production
+          tests. Killing the interactive session with
+          <literal>Ctrl-d</literal> or <literal>Ctrl-c</literal> also
+          ends the guest session.
+        </para>
+      </listitem>
+    </varlistentry>
+  </variablelist>
+  <para>
+    To test user units declared by
+    <literal>systemd.user.services</literal> the optional
+    <literal>user</literal> argument can be used:
+  </para>
+  <programlisting language="python">
+machine.start()
+machine.wait_for_x()
+machine.wait_for_unit(&quot;xautolock.service&quot;, &quot;x-session-user&quot;)
+</programlisting>
+  <para>
+    This applies to <literal>systemctl</literal>,
+    <literal>get_unit_info</literal>, <literal>wait_for_unit</literal>,
+    <literal>start_job</literal> and <literal>stop_job</literal>.
+  </para>
+  <para>
+    For faster dev cycles it's also possible to disable the code-linters
+    (this shouldn't be commited though):
+  </para>
+  <programlisting language="bash">
+import ./make-test-python.nix {
+  skipLint = true;
+  machine =
+    { config, pkgs, ... }:
+    { configuration…
+    };
+
+  testScript =
+    ''
+      Python code…
+    '';
+}
+</programlisting>
+  <para>
+    This will produce a Nix warning at evaluation time. To fully disable
+    the linter, wrap the test script in comment directives to disable
+    the Black linter directly (again, don't commit this within the
+    Nixpkgs repository):
+  </para>
+  <programlisting language="bash">
+  testScript =
+    ''
+      # fmt: off
+      Python code…
+      # fmt: on
+    '';
+</programlisting>
+</section>

nixos/modules/config/shells-environment.nix

···
       type = types.bool;
     };
 
+    environment.localBinInPath = mkOption {
+      description = ''
+        Add ~/.local/bin/ to $PATH
+      '';
+      default = false;
+      type = types.bool;
+    };
+
     environment.binsh = mkOption {
       default = "${config.system.build.binsh}/bin/sh";
       defaultText = "\${config.system.build.binsh}/bin/sh";
···
         ${optionalString cfg.homeBinInPath ''
           # ~/bin if it exists overrides other bin directories.
           export PATH="$HOME/bin:$PATH"
+        ''}
+
+        ${optionalString cfg.localBinInPath ''
+          export PATH="$HOME/.local/bin:$PATH"
         ''}
       '';
 

nixos/modules/services/misc/geoipupdate.nix

···
       LockFile = "/run/geoipupdate/.lock";
     };
 
+    systemd.services.geoipupdate-create-db-dir = {
+      serviceConfig.Type = "oneshot";
+      script = ''
+        mkdir -p ${cfg.settings.DatabaseDirectory}
+        chmod 0755 ${cfg.settings.DatabaseDirectory}
+      '';
+    };
+
     systemd.services.geoipupdate = {
       description = "GeoIP Updater";
-      after = [ "network-online.target" "nss-lookup.target" ];
+      requires = [ "geoipupdate-create-db-dir.service" ];
+      after = [
+        "geoipupdate-create-db-dir.service"
+        "network-online.target"
+        "nss-lookup.target"
+      ];
       wants = [ "network-online.target" ];
       startAt = cfg.interval;
       serviceConfig = {
···
               };
             };
 
-            geoipupdateConf = pkgs.writeText "discourse.conf" (geoipupdateKeyValue cfg.settings);
+            geoipupdateConf = pkgs.writeText "geoipupdate.conf" (geoipupdateKeyValue cfg.settings);
 
             script = ''
-              mkdir -p "${cfg.settings.DatabaseDirectory}"
-              chmod 755 "${cfg.settings.DatabaseDirectory}"
               chown geoip "${cfg.settings.DatabaseDirectory}"
 
               cp ${geoipupdateConf} /run/geoipupdate/GeoIP.conf
···
         ReadWritePaths = cfg.settings.DatabaseDirectory;
         RuntimeDirectory = "geoipupdate";
         RuntimeDirectoryMode = 0700;
+        CapabilityBoundingSet = "";
+        PrivateDevices = true;
+        PrivateMounts = true;
+        PrivateUsers = true;
+        ProtectClock = true;
+        ProtectControlGroups = true;
+        ProtectHome = true;
+        ProtectHostname = true;
+        ProtectKernelLogs = true;
+        ProtectKernelModules = true;
+        ProtectKernelTunables = true;
+        ProtectProc = "invisible";
+        ProcSubset = "pid";
+        SystemCallFilter = [ "@system-service" "~@privileged" "~@resources" ];
+        RestrictAddressFamilies = [ "AF_INET" "AF_INET6" ];
+        RestrictRealtime = true;
+        RestrictNamespaces = true;
+        MemoryDenyWriteExecute = true;
+        LockPersonality = true;
+        SystemCallArchitectures = "native";
+      };
+    };
+
+    systemd.timers.geoipupdate-initial-run = {
+      wantedBy = [ "timers.target" ];
+      unitConfig.ConditionPathExists = "!${cfg.settings.DatabaseDirectory}";
+      timerConfig = {
+        Unit = "geoipupdate.service";
+        OnActiveSec = 0;
       };
     };
   };
+
+  meta.maintainers = [ lib.maintainers.talyz ];
 }

pkgs/applications/misc/seatd/default.nix

···
 
   outputs = [ "bin" "out" "dev" "man" ];
 
+  depsBuildBuild = [ pkg-config ];
+
   nativeBuildInputs = [ meson ninja pkg-config scdoc ];
 
   buildInputs = [ systemd ];

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

···
 
 stdenv.mkDerivation rec {
   pname = "lean";
-  version = "3.30.0";
+  version = "3.31.0";
 
   src = fetchFromGitHub {
     owner  = "leanprover-community";
···
     # from. this is then used to check whether an olean file should be
     # rebuilt. don't use a tag as rev because this will get replaced into
     # src/githash.h.in in preConfigure.
-    rev    = "a5822ea47ebc52eec6323d8f1b60f6ec025daf99";
-    sha256 = "sha256-gJhbkl19iilNyfCt2TfPmghYA3yCjg6kS+yk/x/k14Y=";
+    rev    = "333783350cd3fe38f25fed1da7d6a433d8f85b77";
+    sha256 = "sha256-N8Ju7pSGssvt84/0e1o6G/p7fWM1c0Mzw+ftL1/++J4=";
   };
 
   nativeBuildInputs = [ cmake ];

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

···
 }:
 
 let
-  version = "1.8.0";
+  version = "1.8.1";
 
   # build stimuli file for PGO build and the script to generate it
   # independently of the foot's build, so we can cache the result
···
 
   src = fetchzip {
     url = "https://codeberg.org/dnkl/${pname}/archive/${version}.tar.gz";
-    sha256 = "07irlhkvziv51cp5zn1yz8ljfnrnfjcykv5pgfwmpslw3nl5szxv";
+    sha256 = "0yrz7n0wls8g8w7ja934icwxmng3sxh70x87qmzc9c9cb1wyd989";
   };
 
   nativeBuildInputs = [

pkgs/data/misc/hackage/pin.json

···
 {
-  "commit": "8005ce7c7ba90fa92db65f86c544623353a96cf8",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/8005ce7c7ba90fa92db65f86c544623353a96cf8.tar.gz",
-  "sha256": "1kzhh7h0csb0vh9avbjsm6hziaa3lbpmzp4pkij4s3bbl4l664aa",
-  "msg": "Update from Hackage at 2021-06-22T07:13:30Z"
+  "commit": "1567e96c400fcd62dfc0d9412881591d6e1e9f22",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/1567e96c400fcd62dfc0d9412881591d6e1e9f22.tar.gz",
+  "sha256": "04z26ypfp3nip2x6gwrv5k1lmckmmi03ry3z97syc72qqj59n9hq",
+  "msg": "Update from Hackage at 2021-06-26T12:56:56Z"
 }

pkgs/development/haskell-modules/configuration-common.nix

···
   uuid-types = doJailbreak super.uuid-types;
   uuid = doJailbreak super.uuid;
 
-  # Bypass version check for random < 1.2 (1.2 works fine).
-  # https://github.com/yeyan/xmonad-wallpaper/issues/2
-  xmonad-wallpaper = doJailbreak super.xmonad-wallpaper;
-
   # The tests spuriously fail
   libmpd = dontCheck super.libmpd;
 
···
   # To strict bound on hspec
   # https://github.com/dagit/zenc/issues/5
   zenc = doJailbreak super.zenc;
+
+  # Indeterministic tests
+  # Fixed on upstream: https://github.com/softwarefactory-project/matrix-client-haskell/commit/4ca4963cfd06379d9bdce49742af854aed6a0d37
+  matrix-client = dontCheck super.matrix-client;
+
+  # Flakey tests
+  # upstream https://github.com/circuithub/rel8/issues/86
+  rel8 = dontCheck super.rel8;
 
 } // import ./configuration-tensorflow.nix {inherit pkgs haskellLib;} self super

pkgs/development/haskell-modules/configuration-darwin.nix

···
   hls-brittany-plugin = dontCheck super.hls-brittany-plugin;
   hls-fourmolu-plugin = dontCheck super.hls-fourmolu-plugin;
   hls-module-name-plugin = dontCheck super.hls-module-name-plugin;
+  hls-splice-plugin = dontCheck super.hls-splice-plugin;
 
   # We are lacking pure pgrep at the moment for tests to work
   tmp-postgres = dontCheck super.tmp-postgres;

pkgs/development/haskell-modules/configuration-hackage2nix/broken.yaml

···
   - chunky
   - church
   - church-maybe
+  - churros
   - cielo
   - cil
   - cinvoke
···
   - gitter
   - git-vogue
   - gi-vips
-  - gi-wnck
   - glade
   - glapp
   - Gleam
···
   - hs-rs-notify
   - hs-scrape
   - hsseccomp
+  - hssh
   - hs-snowtify
   - hs-speedscope
   - hsSqlite3
···
   - initialize
   - inject-function
   - inline-asm
+  - inline-r
   - inserts
   - instana-haskell-trace-sdk
   - instance-map
···
   - mi
   - miconix-test
   - microbase
+  - microformats2-parser
   - microgroove
   - microlens-each
   - micrologger
···
   - plat
   - platinum-parsing
   - PlayingCards
+  - plex
   - plist
   - plist-buddy
   - plot-gtk
···
   - reversi
   - ReviewBoard
   - rewrite-inspector
+  - rfc
   - rfc-prelude
   - rhbzquery
   - ribbit
···
   - turing-music
   - turtle-options
   - tweak
+  - twee
   - twentefp-websockets
   - twfy-api-client
   - twhs

pkgs/development/haskell-modules/configuration-hackage2nix/main.yaml

···
     - hlint
     - hmatrix
     - iCalendar
+    - matrix-client
     - neuron
     - optics
     - reflex-dom
···
   gi-ibus:                                      [ x86_64-darwin ]
   gi-ostree:                                    [ x86_64-darwin ]
   gi-vte:                                       [ x86_64-darwin ]
+  gi-wnck:                                      [ x86_64-darwin ]
   gnome-keyring:                                [ x86_64-darwin ]
   gtk-mac-integration:                          [ i686-linux, x86_64-linux, aarch64-linux, armv7l-linux ]
   gtk-sni-tray:                                 [ x86_64-darwin ]

pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml

···
 dont-distribute-packages:
 
  - 4Blocks
- - a50
- - abcBridge
+ - AC-Vector-Fancy
+ - ADPfusionForest
+ - ADPfusionSet
+ - AERN-Net
+ - AERN-Real
+ - AERN-Real-Double
+ - AERN-Real-Interval
+ - AERN-RnToRm
+ - AERN-RnToRm-Plot
+ - ASN1
  - AbortT-monadstf
  - AbortT-mtl
+ - Advgame
+ - Advise-me
+ - AlgoRhythm
+ - AlignmentAlgorithms
+ - AndroidViewHierarchyImporter
+ - Annotations
+ - ApplePush
+ - AttoJson
+ - AutoForms
+ - AvlTree
+ - BASIC
+ - Barracuda
+ - BerlekampAlgorithm
+ - BioHMM
+ - Biobase
+ - BiobaseBlast
+ - BiobaseDotP
+ - BiobaseENA
+ - BiobaseEnsembl
+ - BiobaseFR3D
+ - BiobaseFasta
+ - BiobaseHTTP
+ - BiobaseHTTPTools
+ - BiobaseInfernal
+ - BiobaseMAF
+ - BiobaseTrainingData
+ - BiobaseTurner
+ - BiobaseTypes
+ - BiobaseVienna
+ - BiobaseXNA
+ - BirdPP
+ - Bitly
+ - BlastHTTP
+ - Blobs
+ - BlogLiterately
+ - BlogLiterately-diagrams
+ - Bookshelf
+ - CBOR
+ - CC-delcont-alt
+ - CMCompare
+ - CPBrainfuck
+ - CPL
+ - CSPM-Interpreter
+ - CSPM-ToProlog
+ - CSPM-cspm
+ - CarneadesIntoDung
+ - Chart-fltkhs
+ - ClustalParser
+ - Coadjute
+ - Combinatorrent
+ - ComonadSheet
+ - Condor
+ - Configger
+ - Control-Monad-MultiPass
+ - CoreFoundation
+ - DMuCheck
+ - DOM
+ - DP
+ - DSH
+ - DSTM
+ - Dangerous
+ - DarcsHelpers
+ - DefendTheKing
+ - DifferenceLogic
+ - DisTract
+ - DnaProteinAlignment
+ - DocTest
+ - DrHylo
+ - Dust
+ - Dust-tools
+ - Dust-tools-pcap
+ - DysFRP-Cairo
+ - DysFRP-Craftwerk
+ - EditTimeReport
+ - EntrezHTTP
+ - EsounD
+ - EtaMOO
+ - Etage-Graph
+ - Eternal10Seconds
+ - Etherbunny
+ - EventSocket
+ - FComp
+ - FM-SBLEX
+ - FTPLine
+ - Facts
+ - FailureT
+ - FermatsLastMargin
+ - FieldTrip
+ - FilePather
+ - Finance-Treasury
+ - FiniteMap
+ - FirstOrderTheory
+ - Flippi
+ - Forestry
+ - FormalGrammars
+ - Foster
+ - Frames-beam
+ - Frames-dsv
+ - Frank
+ - GLFW-OGL
+ - GLFW-task
+ - GPX
+ - GPipe-Collada
+ - GPipe-Examples
+ - GPipe-GLFW
+ - GPipe-GLFW4
+ - GPipe-TextureLoad
+ - Gamgine
+ - GeBoP
+ - GenI
+ - GenSmsPdu
+ - Genbank
+ - Gene-CluEDO
+ - GenussFold
+ - GlomeView
+ - GoogleDirections
+ - GoogleSB
+ - GoogleTranslate
+ - GrammarProducts
+ - GraphHammer
+ - GraphHammer-examples
+ - GrowlNotify
+ - Gtk2hsGenerics
+ - GtkGLTV
+ - GuiHaskell
+ - GuiTV
+ - H
+ - HAppS-Data
+ - HAppS-IxSet
+ - HAppS-Server
+ - HAppS-State
+ - HGamer3D-API
+ - HGamer3D-CAudio-Binding
+ - HGamer3D-OIS-Binding
+ - HJScript
+ - HLearn-algebra
+ - HLearn-approximation
+ - HLearn-classification
+ - HLearn-datastructures
+ - HLearn-distributions
+ - HNM
+ - HPlot
+ - HPong
+ - HROOT
+ - HROOT-core
+ - HROOT-graf
+ - HROOT-hist
+ - HROOT-io
+ - HROOT-math
+ - HROOT-tree
+ - HRay
+ - HSGEP
+ - HSHHelpers
+ - HSoundFile
+ - HStringTemplateHelpers
+ - HTab
+ - HXMPP
+ - HaMinitel
+ - HaRe
+ - HaTeX-meta
+ - HaTeX-qq
+ - HaVSA
+ - Hach
+ - HarmTrace
+ - HasGP
+ - Hashell
+ - HaskRel
+ - Hate
+ - Hawk
+ - Hayoo
+ - Hedi
+ - Hieroglyph
+ - HiggsSet
+ - Hipmunk-Utils
+ - HipmunkPlayground
+ - Hoed
+ - Holumbus-Distribution
+ - Holumbus-MapReduce
+ - Holumbus-Searchengine
+ - Holumbus-Storage
+ - HongoDB
+ - Hs2lib
+ - HsParrot
+ - HsWebots
+ - Hsed
+ - Hydrogen
+ - INblobs
+ - IORefCAS
+ - IndexedList
+ - InfixApplicative
+ - JSON-Combinator
+ - JSON-Combinator-Examples
+ - JSONb
+ - Javasf
+ - JsContracts
+ - JsonGrammar
+ - JuPyTer-notebook
+ - JunkDB-driver-gdbm
+ - JunkDB-driver-hashtables
+ - KiCS
+ - KiCS-debugger
+ - KiCS-prophecy
+ - LDAPv3
+ - LambdaDesigner
+ - LambdaINet
+ - LambdaPrettyQuote
+ - LambdaShell
+ - LinearSplit
+ - LinkChecker
+ - LogicGrowsOnTrees
+ - LogicGrowsOnTrees-MPI
+ - LogicGrowsOnTrees-network
+ - LogicGrowsOnTrees-processes
+ - LslPlus
+ - Lucu
+ - Lykah
+ - MC-Fold-DP
+ - MFlow
+ - MIP-glpk
+ - MSQueue
+ - MaybeT-transformers
+ - MetaObject
+ - Metrics
+ - Mhailist
+ - Michelangelo
+ - MicrosoftTranslator
+ - MissingPy
+ - MonadCatchIO-mtl
+ - MonadCatchIO-mtl-foreign
+ - MonadCatchIO-transformers-foreign
+ - MonadLab
+ - Monaris
+ - Monatron-IO
+ - Monocle
+ - MuCheck-HUnit
+ - MuCheck-Hspec
+ - MuCheck-QuickCheck
+ - MuCheck-SmallCheck
+ - MutationOrder
+ - NXT
+ - NaperianNetCDF
+ - NearContextAlgebra
+ - Ninjas
+ - NoSlow
+ - Nomyx
+ - Nomyx-Core
+ - Nomyx-Language
+ - Nomyx-Rules
+ - Nomyx-Web
+ - NonEmptyList
+ - Nussinov78
+ - OSM
+ - OnRmt
+ - OpenAFP-Utils
+ - OpenGLCheck
+ - OpenSCAD
+ - OpenVG
+ - PCLT-DB
+ - PageIO
+ - Paraiso
+ - Parallel-Arrows-Eden
+ - PermuteEffects
+ - Plot-ho-matic
+ - PlslTools
+ - Printf-TH
+ - ProbabilityMonads
+ - Pugs
+ - Pup-Events
+ - Pup-Events-Demo
+ - Quelea
+ - RESTng
+ - RMP
+ - RNAFold
+ - RNAFoldProgs
+ - RNAdesign
+ - RNAdraw
+ - RNAlien
+ - RNAwolf
+ - Ranka
+ - Rlang-QQ
+ - RollingDirectory
+ - S3
+ - SBench
+ - SCRIPTWriter
+ - SCalendar
+ - SFML-control
+ - SFont
+ - SGdemo
+ - STLinkUSB
+ - STM32-Zombie
+ - SVG2Q
+ - SciFlow
+ - SciFlow-drmaa
+ - Scurry
+ - SelectSequencesFromMSA
+ - Shellac-compatline
+ - Shellac-editline
+ - Shellac-haskeline
+ - Shellac-readline
+ - ShortestPathProblems
+ - Shpadoinkle-backend-pardiff
+ - Shpadoinkle-backend-static
+ - Shpadoinkle-developer-tools
+ - Shpadoinkle-disembodied
+ - Shpadoinkle-examples
+ - Shpadoinkle-html
+ - Shpadoinkle-router
+ - Shpadoinkle-template
+ - Shpadoinkle-widgets
+ - SimpleGL
+ - SimpleLog
+ - SimpleServer
+ - Smooth
+ - Snusmumrik
+ - SoccerFun
+ - SoccerFunGL
+ - SourceGraph
+ - SpinCounter
+ - Spock-auth
+ - Spock-lucid
+ - Spock-worker
+ - StockholmAlignment
+ - Strafunski-Sdf2Haskell
+ - SyntaxMacros
+ - Taxonomy
+ - TaxonomyTools
+ - TeX-my-math
+ - TeaHS
+ - TreeCounter
+ - Treiber
+ - TrieMap
+ - TypeClass
+ - TypeIlluminator
+ - UMM
+ - URLT
+ - UrlDisp
+ - ViennaRNA-extras
+ - WAVE
+ - WEditorBrick
+ - WEditorHyphen
+ - WL500gPControl
+ - WURFL
+ - WXDiffCtrl
+ - WashNGo
+ - WaveFront
+ - WebBits-Html
+ - WebBits-multiplate
+ - WebCont
+ - WordAlignment
+ - WxGeneric
+ - XML
+ - XMPP
+ - XSaiga
+ - YACPong
+ - Yablog
+ - Yogurt
+ - Yogurt-Standalone
+ - Z-Botan
+ - Z-IO
+ - Z-MessagePack
+ - Z-YAML
+ - a50
+ - abcBridge
+ - ac-machine-conduit
  - accelerate-arithmetic
  - accelerate-fourier
  - accelerate-typelits
  - access-token-provider
- - ac-machine-conduit
  - acme-php
  - acme-safe
  - acousticbrainz-client
  - activehs
  - actor
- - AC-Vector-Fancy
  - adhoc-network
  - adict
- - ADPfusionForest
- - ADPfusionSet
  - adp-multi-monadiccp
- - Advgame
- - Advise-me
  - aern2-real
- - AERN-Net
- - AERN-Real
- - AERN-Real-Double
- - AERN-Real-Interval
- - AERN-RnToRm
- - AERN-RnToRm-Plot
  - aeson-native
  - afv
  - agda-server
···
  - algebra-driven-design
  - algebra-sql
  - algolia
- - AlgoRhythm
- - AlignmentAlgorithms
  - alms
  - alpha
  - alsa-gui
···
  - amqp-streamly
  - analyze-client
  - anatomy
- - AndroidViewHierarchyImporter
  - animate-example
  - animate-frames
  - animate-preview
  - animate-sdl2
  - annah
- - Annotations
  - anonymous-sums-tests
  - antagonist
  - anticiv
  - antlrc
  - apelsin
+ - api-rpc-pegnet
+ - api-yoti
  - apiary
  - apiary-authenticate
  - apiary-clientsession
···
  - apiary-redis
  - apiary-session
  - apiary-websockets
- - api-rpc-pegnet
  - apis
- - api-yoti
  - apotiki
- - ApplePush
  - approx-rand-test
  - arbor-monad-metric-datadog
  - arch-hs
···
  - arraylist
  - ascii-table
  - asic
- - ASN1
  - assert4hs-hspec
  - assert4hs-tasty
  - assimp
···
  - atmos-dimensional-tf
  - atomic-primops-foreign
  - atp
- - AttoJson
  - attoparsec-enumerator
  - attoparsec-iteratee
  - attoparsec-text-enumerator
···
  - audiovisual
  - aura
  - authoring
- - AutoForms
  - autonix-deps-kf5
  - avers
  - avers-api
  - avers-api-docs
  - avers-server
- - AvlTree
  - avro-piper
  - awesomium
  - awesomium-glut
···
  - azure-functions-worker
  - azure-service-api
  - azure-servicebus
+ - b-tree
  - babylon
  - backblaze-b2-hs
  - backdropper
···
  - bamboo-theme-mini-html5
  - bamse
  - bamstats
- - Barracuda
  - base16-lens
  - base32-bytestring
  - base64-bytes
  - baserock-schema
- - BASIC
  - batchd
  - battlenet-yesod
  - battleships
···
  - beam-th
  - beautifHOL
  - bech32-th
+ - bech32-th_1_1_1
  - bein
  - belka
- - BerlekampAlgorithm
  - berp
  - bff
  - bglib
···
  - binary-file
  - binary-protocol-zmq
  - binary-streams
+ - binding-wx
  - bindings-apr-util
  - bindings-linux-videodev2
  - bindings-ppdev
- - binding-wx
  - binembed-example
  - bioace
  - bioalign
- - Biobase
- - BiobaseBlast
- - BiobaseDotP
- - BiobaseENA
- - BiobaseEnsembl
- - BiobaseFasta
- - BiobaseFR3D
- - BiobaseHTTP
- - BiobaseHTTPTools
- - BiobaseInfernal
- - BiobaseMAF
- - BiobaseTrainingData
- - BiobaseTurner
- - BiobaseTypes
- - BiobaseVienna
- - BiobaseXNA
  - biofasta
  - biofastq
- - BioHMM
  - bioinformatics-toolkit
  - biophd
  - biopsl
···
  - bip32
  - birch-beer
  - bird
- - BirdPP
  - bit-array
  - bitcoin-address
  - bitcoin-api
  - bitcoin-api-extra
  - bitcoin-block
  - bitcoin-compact-filters
- - bitcoind-regtest
- - bitcoind-rpc
  - bitcoin-keys
  - bitcoin-rpc
  - bitcoin-scripting
  - bitcoin-tx
  - bitcoin-types
- - Bitly
+ - bitcoind-regtest
+ - bitcoind-rpc
  - bitly-cli
  - bitmaps
  - bittorrent
  - bla
  - blakesum-demo
- - BlastHTTP
  - blastxml
  - blatex
  - blaze-builder-enumerator
···
  - ble
  - blink1
  - blip
- - Blobs
  - blogination
- - BlogLiterately
- - BlogLiterately-diagrams
  - bloodhound-amazonka-auth
  - bloxorz
  - blubber
···
  - bond-haskell
  - bond-haskell-compiler
  - bookkeeper-permissions
- - Bookshelf
  - boomslang
  - boopadoop
  - boots-cloud
···
  - bronyradiogermany-streaming
  - brotli-conduit
  - brotli-streams
- - b-tree
  - btree
  - buchhaltung
  - buildbox-tools
···
  - bytelog
  - bytestring-read
  - c0check
- - cabal2arch
  - cabal-bounds
  - cabal-cache
  - cabal-cargs
+ - cabal-query
+ - cabal-test
+ - cabal2arch
  - cabalmdvrpm
- - cabal-query
  - cabalrpmdeps
- - cabal-test
  - cake
  - cakyrespa
  - cal3d-examples
···
  - canteven-http
  - cao
  - cap
+ - car-pool
  - carboncopy
- - CarneadesIntoDung
- - car-pool
  - cartel
  - casadi-bindings
  - casadi-bindings-control
···
  - casui
  - categorical-algebra
  - category-extras
- - CBOR
- - CC-delcont-alt
  - cctools-workqueue
  - cef3-simple
  - ceilometer-common
···
  - cfopu
  - cgrep
  - chainweb-mining-client
- - chakra
  - chalkboard-viewer
  - charade
  - chart-cli
- - Chart-fltkhs
  - chart-svg
  - chart-svg-various
  - chart-unit
···
  - cloud-seeder
  - cloudyfs
  - clua
- - ClustalParser
  - clustertools
  - clutterhs
  - cmathml3
- - CMCompare
  - cmptype
  - cmv
  - cnc-spec-compiler
- - Coadjute
+ - co-feldspar
+ - co-log-polysemy-formatting
+ - code-conjure
  - codec
- - code-conjure
  - codec-rpm
  - codemonitor
- - co-feldspar
  - cognimeta-utils
  - coinbase-exchange
  - colada
  - collapse-duplication
  - collection-json
  - collections-base-instances
- - co-log-polysemy-formatting
  - color-counter
  - colorless-http-client
  - colorless-scotty
  - colour-space
  - columbia
  - comark
- - Combinatorrent
  - comic
  - commsec-keyexchange
  - comonad-random
- - ComonadSheet
  - compact-mutable
  - complexity
  - computational-algebra
···
  - concrete-haskell
  - concrete-haskell-autogen
  - condor
- - Condor
  - conductive-hsc3
  - conductive-song
  - conduit-vfs-zip
···
  - conferer-source-dhall
  - conferer-source-yaml
  - conffmt
- - Configger
+ - config-select
  - configifier
- - config-select
  - configurator-ng
  - constraint-manip
  - constructible
···
  - control
  - control-monad-attempt
  - control-monad-exception-monadsfd
- - Control-Monad-MultiPass
  - conversions
  - convert
  - convertible-ascii
···
  - copilot-language
  - copilot-libraries
  - copilot-theorem
- - CoreFoundation
  - coroutine-enumerator
  - coroutine-iteratee
+ - couch-simple
  - couchdb-enumerator
- - couch-simple
- - CPBrainfuck
- - CPL
  - cprng-aes-effect
  - cql-io-tinylog
  - cqrs-example
···
  - criu-rpc
  - crockford
  - cron-compat
- - cryptocipher
  - crypto-conduit
+ - cryptocipher
  - cryptoids
  - cryptoids-class
  - cryptol
  - crystalfontz
  - csg
  - cspmchecker
- - CSPM-cspm
- - CSPM-Interpreter
- - CSPM-ToProlog
  - csv-enumerator
  - ctpl
  - cube
···
  - cursor-fuzzy-time-gen
  - cv-combinators
  - cypher
- - Dangerous
  - dapi
  - darcs-benchmark
  - darcs-beta
+ - darcs-fastconvert
  - darcsden
- - darcs-fastconvert
- - DarcsHelpers
  - darcswatch
  - darkplaces-demo
  - darkplaces-rcon-util
···
  - data-accessor-monads-fd
  - data-basic
  - data-cycle
- - datadog-tracing
  - data-elf
- - dataflow
  - data-layer
  - data-lens-fd
  - data-lens-ixset
···
  - data-result
  - data-rtuple
  - data-structure-inferrer
+ - datadog-tracing
+ - dataflow
  - date-conversions
  - dbjava
  - dbus-client
···
  - ddc-core-simpl
  - ddc-core-tetra
  - ddc-driver
- - ddci-core
  - ddc-interface
  - ddc-source-tetra
  - ddc-tools
  - ddc-war
+ - ddci-core
  - debug
  - debug-trace-var
  - decidable
···
  - deeplearning-hs
  - deepzoom
  - defargs
- - DefendTheKing
  - definitive-graphics
  - deka-tests
  - delaunay
···
  - delimiter-separated
  - delta
  - delta-h
+ - dep-t-advice
  - dependent-state
  - dephd
- - dep-t-advice
  - deptrack-devops
  - deptrack-dot
  - dequeue
···
  - dewdrop
  - dfinity-radix-tree
  - dhall-docs
+ - di-polysemy
  - dia-functions
  - diagrams-haddock
  - diagrams-html5
···
  - diagrams-pgf
  - diagrams-reflex
  - diagrams-wx
- - DifferenceLogic
  - difference-monoid
  - digestive-functors-hsp
  - dingo-core
···
  - dingo-widgets
  - diplomacy
  - diplomacy-server
- - di-polysemy
  - dirfiles
  - discogs-haskell
  - discord-gateway
  - discord-hs
  - discord-register
  - discord-rest
- - DisTract
  - distributed-process-async
  - distributed-process-azure
  - distributed-process-client-server
···
  - dmenu-pkill
  - dmenu-pmount
  - dmenu-search
- - DMuCheck
- - DnaProteinAlignment
  - doc-review
- - DocTest
  - doi
- - DOM
  - domain
  - domain-core
  - domain-optics
  - dow
  - download-media-content
- - DP
  - dph-examples
  - dph-lifted-base
  - dph-lifted-copy
···
  - dph-prim-interface
  - dph-prim-par
  - dph-prim-seq
- - DrHylo
  - dropbox-sdk
  - dropsolve
- - DSH
  - dsh-sql
  - dsmc-tools
- - DSTM
  - dtd
  - dumb-cas
- - Dust
- - Dust-tools
- - Dust-tools-pcap
  - dvda
  - dynamic-cabal
  - dynamic-pipeline
  - dynamic-plot
  - dynobud
- - DysFRP-Cairo
- - DysFRP-Craftwerk
  - eccrypto-ed25519-bindings
  - ecdsa
  - edenskel
···
  - edge
  - edges
  - editable
- - EditTimeReport
  - effective-aspects-mzv
  - egison
  - egison-pattern-src-haskell-mode
···
  - embroidery
  - engine-io-growler
  - entangle
- - EntrezHTTP
  - enumerate
  - enumerate-function
  - enumerator-fd
···
  - errors-ext
  - ersatz-toysat
  - esotericbot
- - EsounD
  - estreps
- - Etage-Graph
- - EtaMOO
- - Eternal10Seconds
  - eternity
  - eternity-timestamped
  - ether
- - Etherbunny
  - ethereum-analyzer
  - ethereum-analyzer-cli
  - ethereum-analyzer-webui
  - ethereum-client-haskell
  - ethereum-merkle-patricia-db
  - evdev-streamly
+ - event-monad
  - eventful-postgresql
  - eventful-sqlite
- - event-monad
- - EventSocket
  - eventsource-geteventstore-store
  - every-bit-counts
  - exception-monads-fd
···
  - extensible-data
  - extract-dependencies
  - extrapolate
- - Facts
  - factual-api
- - FailureT
  - fakedata-quickcheck
+ - falling-turnip
  - fallingblocks
- - falling-turnip
  - family-tree
  - fast-digits
  - fastirc
  - fault-tree
  - fbrnch
  - fcd
- - FComp
  - feature-flipper-postgres
  - fedora-img-dl
- - feed2lj
- - feed2twitter
  - feed-gipeda
  - feed-translator
+ - feed2lj
+ - feed2twitter
  - fei-base
  - fei-cocoapi
  - fei-dataiter
···
  - fei-nn
  - feldspar-compiler
  - feldspar-language
- - FermatsLastMargin
  - festung
  - ffmpeg-tutorials
  - ficketed
  - fields
- - FieldTrip
  - filepath-crypto
+ - filepath-io-access
  - filepather
- - FilePather
- - filepath-io-access
  - filesystem-enumerator
- - Finance-Treasury
  - find-clumpiness
  - findhttp
- - FiniteMap
  - firstify
- - FirstOrderTheory
+ - fix-parser-simple
  - fixed-point-vector
  - fixed-point-vector-space
  - fixhs
- - fix-parser-simple
  - flac-picture
  - flashblast
  - flatbuffers
  - flexiwrap
  - flexiwrap-smallcheck
- - Flippi
  - flite
  - flowdock-api
  - flower
···
  - fltkhs-themes
  - fluent-logger
  - fluent-logger-conduit
- - FM-SBLEX
  - foldl-transduce-attoparsec
  - follower
  - foo
- - Forestry
  - formal
- - FormalGrammars
  - format
  - format-status
  - forml
···
  - fortran-src-extras
  - foscam-directory
  - foscam-sort
- - Foster
  - fp-ieee
  - fplll
  - fpnla-examples
  - frame-markdown
- - Frames-beam
- - Frames-dsv
- - Frank
- - freekick2
- - freelude
- - freer-converse
  - free-theorems-counterexamples
  - free-theorems-seq
  - free-theorems-seq-webui
  - free-theorems-webui
+ - freekick2
+ - freelude
+ - freer-converse
  - frpnow-gloss
  - frpnow-gtk
  - frpnow-gtk3
  - frpnow-vty
  - ftdi
  - ftp-client-conduit
- - FTPLine
  - ftree
  - ftshell
  - funbot
···
  - funcons-lambda-cbv-mp
  - funcons-simple
  - funcons-tools
- - functional-arrow
  - function-combine
+ - functional-arrow
  - functor-combo
  - funflow-nix
  - funion
···
  - g2q
  - gact
  - galois-fft
- - Gamgine
  - gargoyle-postgresql-connect
  - gbu
  - gdax
  - gdiff-ig
- - GeBoP
  - gedcom
  - geek
  - geek-server
···
  - gelatin-gl
  - gelatin-sdl2
  - gelatin-shaders
- - Genbank
- - Gene-CluEDO
  - generics-mrsop-gdiff
  - genesis
  - genesis-test
- - GenI
- - geniconvert
  - geni-gui
- - geniserver
  - geni-util
- - GenSmsPdu
- - GenussFold
+ - geniconvert
+ - geniserver
  - geodetic
  - geolite-csv
  - getemx
···
  - ghc-debug-stub
  - ghc-imported-from
  - ghc-instances
- - ghci-pretty
- - ghcjs-hplay
  - ghc-mod
  - ghc-tags-plugin
  - ghc-vis
+ - ghci-pretty
+ - ghcjs-hplay
  - ght
  - gi-cairo-again
  - gi-gsk
···
  - gi-gtk_4_0_4
  - git-fmt
  - git-gpush
+ - git-object
+ - git-remote-ipfs
  - github-webhook-handler-snap
  - gitlib-cross
  - gitlib-s3
- - git-object
- - git-remote-ipfs
  - givegif
  - gladexml-accessor
  - glazier
···
  - glazier-react
  - glazier-react-examples
  - glazier-react-widget
- - GLFW-OGL
- - GLFW-task
  - global
  - global-config
  - glome-hs
- - GlomeView
  - gloss-accelerate
  - gloss-devil
  - gloss-examples
···
  - goal-probability
  - goal-simulation
  - goat
- - GoogleDirections
  - google-drive
  - google-mail-filters
  - google-maps-geocoding
+ - google-static-maps
  - googleplus
- - GoogleSB
- - google-static-maps
- - GoogleTranslate
  - gore-and-ash-actor
  - gore-and-ash-async
  - gore-and-ash-demo
···
  - gore-and-ash-network
  - gore-and-ash-sdl
  - gore-and-ash-sync
- - GPipe-Collada
- - GPipe-Examples
- - GPipe-GLFW
- - GPipe-GLFW4
- - GPipe-TextureLoad
  - gps
  - gps2htmlReport
- - GPX
  - grab-form
  - graflog
  - grammar-combinators
- - GrammarProducts
  - grapefruit-examples
  - grapefruit-records
  - grapefruit-ui
  - grapefruit-ui-gtk
- - GraphHammer
- - GraphHammer-examples
- - graphicsFormats
- - graphicstools
- - graphql-client
  - graph-rewriting-cl
  - graph-rewriting-gl
  - graph-rewriting-lambdascope
···
  - graph-rewriting-strategies
  - graph-rewriting-trs
  - graph-rewriting-ww
+ - graph-visit
+ - graphicsFormats
+ - graphicstools
+ - graphql-client
  - graphtype
- - graph-visit
  - greencard-lib
+ - grid-proto
  - gridbounds
  - gridland
- - grid-proto
- - GrowlNotify
  - grpc-etcd-client
  - grpc-haskell
  - grpc-haskell-core
···
  - gsmenu
  - gstorable
  - gtfs
+ - gtk-serialized-event
  - gtk2hs-cast-glade
  - gtk2hs-cast-gnomevfs
  - gtk2hs-cast-gtkglext
  - gtk2hs-cast-gtksourceview2
- - Gtk2hsGenerics
- - GtkGLTV
  - gtkimageview
  - gtkrsync
- - gtk-serialized-event
  - guarded-rewriting
  - guess-combinator
- - GuiHaskell
- - GuiTV
+ - hArduino
+ - hOff-display
+ - hPDB
+ - hPDB-examples
  - habit
  - hablo
  - hablog
- - Hach
- - hack2-handler-happstack-server
- - hack2-handler-mongrel2-http
- - hack2-handler-snap-server
- - hackage2twitter
- - hackage-server
  - hack-contrib
  - hack-contrib-press
  - hack-handler-epoll
···
  - hack-handler-fastcgi
  - hack-handler-hyena
  - hack-handler-simpleserver
- - hackmanager
  - hack-middleware-cleanpath
  - hack-middleware-clientsession
  - hack-middleware-jsonp
+ - hack2-handler-happstack-server
+ - hack2-handler-mongrel2-http
+ - hack2-handler-snap-server
+ - hackage-server
+ - hackage2twitter
+ - hackmanager
  - haddock
  - haddock_2_23_1
  - haddocset
···
  - halma-gui
  - halma-telegram-bot
  - ham
- - HaMinitel
  - hamusic
  - hans-pcap
  - happlets-lib-gtk
- - HAppS-Data
  - happs-hsp
  - happs-hsp-template
- - HAppS-IxSet
- - HAppS-Server
- - HAppS-State
+ - happs-tutorial
  - happstack-auth
  - happstack-authenticate
  - happstack-contrib
···
  - happstack-state
  - happstack-static-routing
  - happstack-yui
- - happs-tutorial
  - happybara-webkit
  - haquil
- - hArduino
  - hardware-edsl
- - HaRe
  - harg
  - hark
  - harmony
- - HarmTrace
  - haroonga-httpd
+ - has-th
  - hascat
  - hascat-lib
  - hascat-setup
  - hascat-system
- - HasGP
- - Hashell
  - hashflare
+ - hask-home
  - haskarrow
  - haskdeep
  - haskeem
  - haskell-abci
  - haskell-aliyun
  - haskell-bitmex-client
- - haskelldb-connect-hdbc
- - haskelldb-connect-hdbc-catchio-mtl
- - haskelldb-connect-hdbc-catchio-tf
- - haskelldb-connect-hdbc-catchio-transformers
- - haskelldb-connect-hdbc-lifted
- - haskelldb-dynamic
- - haskelldb-flat
- - haskelldb-hdbc
- - haskelldb-hdbc-mysql
- - haskelldb-hdbc-odbc
- - haskelldb-hdbc-postgresql
- - haskelldb-hdbc-sqlite3
- - haskelldb-hsql
- - haskelldb-hsql-mysql
- - haskelldb-hsql-odbc
- - haskelldb-hsql-postgresql
- - haskelldb-hsql-sqlite3
- - haskelldb-th
  - haskell-docs
  - haskell-eigen-util
  - haskell-ftp
···
  - haskell-tools-refactor
  - haskell-tools-rewrite
  - haskell-tor
+ - haskelldb-connect-hdbc
+ - haskelldb-connect-hdbc-catchio-mtl
+ - haskelldb-connect-hdbc-catchio-tf
+ - haskelldb-connect-hdbc-catchio-transformers
+ - haskelldb-connect-hdbc-lifted
+ - haskelldb-dynamic
+ - haskelldb-flat
+ - haskelldb-hdbc
+ - haskelldb-hdbc-mysql
+ - haskelldb-hdbc-odbc
+ - haskelldb-hdbc-postgresql
+ - haskelldb-hdbc-sqlite3
+ - haskelldb-hsql
+ - haskelldb-hsql-mysql
+ - haskelldb-hsql-odbc
+ - haskelldb-hsql-postgresql
+ - haskelldb-hsql-sqlite3
+ - haskelldb-th
  - haskelm
  - haskey-mtl
  - haskgame
- - hask-home
  - haskoin-bitcoind
  - haskoin-core
  - haskoin-crypto
···
  - haskore-realtime
  - haskore-supercollider
  - haskore-synthesizer
- - HaskRel
  - hasktorch
  - hasktorch-ffi-thc
  - hasktorch-indef
···
  - haste-lib
  - haste-markup
  - haste-perch
- - has-th
- - Hate
- - HaTeX-meta
  - hatexmpp3
- - HaTeX-qq
- - HaVSA
  - hawitter
- - Hawk
  - haxy
- - Hayoo
  - hback
  - hbayes
  - hbb
···
  - hdph
  - heart-app
  - heatitup
+ - heavy-log-shortcuts
  - heavy-logger
  - heavy-logger-amazon
  - heavy-logger-instances
- - heavy-log-shortcuts
  - hecc
  - hedgehog-checkers-lens
  - hedgehog-fakedata
  - hedgehog-gen-json
- - Hedi
  - hedis-pile
  - heist-aeson
  - helics
···
  - hfd
  - hfiar
  - hgalib
- - HGamer3D-API
- - HGamer3D-CAudio-Binding
- - HGamer3D-OIS-Binding
  - hgen
  - hgeometry-svg
  - hgithub
  - hiccup
  - hierarchical-spectral-clustering
- - Hieroglyph
- - HiggsSet
  - highjson-swagger
  - highjson-th
  - himpy
···
  - hinvaders
  - hinze-streams
  - hipbot
- - HipmunkPlayground
- - Hipmunk-Utils
  - hipsql-client
  - hipsql-server
  - hirt
···
  - hist-pl-lmf
  - hit
  - hit-graph
- - HJScript
  - hjsonschema
  - hjugement-cli
  - hlcm
- - HLearn-algebra
- - HLearn-approximation
- - HLearn-classification
- - HLearn-datastructures
- - HLearn-distributions
  - hledger-api
  - hlrdb
  - hls
···
  - hmm-lapack
  - hmt
  - hmt-diagrams
- - HNM
  - hnormalise
  - hob
- - Hoed
- - hOff-display
  - hogre
  - hogre-examples
- - Holumbus-Distribution
- - Holumbus-MapReduce
- - Holumbus-Searchengine
- - Holumbus-Storage
  - holy-project
  - hommage
- - HongoDB
  - hood
  - hoodie
  - hoodle
···
  - hpage
  - hpaste
  - hpc-tracer
- - hPDB
- - hPDB-examples
  - hplayground
- - HPlot
- - HPong
  - hpqtypes-extras
  - hprotoc-fork
  - hps
···
  - hpython
  - hquantlib
  - hranker
- - HRay
  - hreader
  - hreader-lens
  - hreq-client
  - hreq-conduit
- - HROOT
- - HROOT-core
- - HROOT-graf
- - HROOT-hist
- - HROOT-io
- - HROOT-math
- - HROOT-tree
+ - hs-blake2
+ - hs-brotli
+ - hs-ffmpeg
+ - hs-gen-iface
+ - hs-pkpass
+ - hs-swisstable-hashtables-class
  - hs2dot
- - Hs2lib
  - hsautogui
  - hsbackup
  - hsbencher-codespeed
  - hsbencher-fusion
- - hs-blake2
- - hs-brotli
  - hsc3-auditor
  - hsc3-cairo
  - hsc3-data
···
  - hscassandra
  - hscope
  - hsdev
- - Hsed
  - hset
  - hsfacter
- - hs-ffmpeg
- - hs-gen-iface
- - HSGEP
- - HSHHelpers
  - hslogstash
  - hsnock
- - HSoundFile
- - HsParrot
  - hspec-expectations-pretty
  - hspec-pg-transact
  - hspec-setup
  - hspec-shouldbe
  - hspec-test-sandbox
  - hspecVariant
- - hs-pkpass
  - hsprocess
  - hsql-mysql
  - hsql-odbc
···
  - hsqml-morris
  - hsreadability
  - hssqlppp-th
- - hs-swisstable-hashtables-class
  - hstar
  - hstox
  - hstradeking
- - HStringTemplateHelpers
  - hstzaar
  - hsubconvert
- - HsWebots
  - hswip
  - hsx-jmacro
  - hsx-xhtml
- - HTab
  - hts
- - http2-client-exe
- - http2-client-grpc
  - http-client-auth
  - http-enumerator
  - http-io-streams
+ - http2-client-exe
+ - http2-client-grpc
  - https-everywhere-rules
  - https-everywhere-rules-raw
  - httpspec
···
  - hw-json-simple-cursor
  - hw-json-standard-cursor
  - hw-kafka-avro
+ - hw-simd-cli
+ - hw-uri
  - hworker-ses
  - hwormhole
  - hws
- - hw-simd-cli
  - hwsl2-bytevector
  - hwsl2-reducers
- - hw-uri
- - HXMPP
  - hxmppc
  - hxournal
  - hxt-binary
···
  - hxthelper
  - hxweb
  - hybrid
- - Hydrogen
  - hydrogen-cli
  - hydrogen-cli-args
  - hydrogen-data
···
  - hyloutils
  - hyperpublic
  - ice40-prim
+ - ide-backend
+ - ide-backend-common
+ - ide-backend-server
  - ideas-math
  - ideas-math-types
  - ideas-statistics
- - ide-backend
- - ide-backend-common
- - ide-backend-server
  - ige-mac-integration
+ - ihaskell-inline-r
  - ihaskell-rlangqq
  - ihttp
  - imap
···
  - importify
  - imprevu-happstack
  - improve
- - INblobs
  - inch
  - incremental-computing
  - incremental-maps
···
  - indentation-parsec
  - indentation-trifecta
  - indexation
- - IndexedList
  - indieweb-algorithms
  - infernu
- - InfixApplicative
  - inline-java
  - inspector-wrecker
  - instant-aeson
···
  - intset
  - invertible-hlist
  - ion
- - IORefCAS
  - ipatch
  - ipc
  - ipld-cid
···
  - ismtp
  - isobmff-builder
  - isohunt
+ - iter-stats
  - iteratee-compress
  - iteratee-mtl
  - iteratee-parsec
  - iteratee-stm
  - iterio-server
- - iter-stats
  - ivor
  - ivory-avr-atmega328p-registers
  - ivory-backend-c
···
  - jail
  - java-bridge-extras
  - java-character
- - javaclass
  - java-reflect
+ - javaclass
  - javasf
- - Javasf
  - jmacro
  - jmacro-rpc
  - jmacro-rpc-happstack
···
  - jobs-ui
  - join
  - jot
- - JsContracts
  - jsmw
- - json2-hdbc
  - json-ast-json-encoder
  - json-autotype
  - json-b
- - JSONb
- - JSON-Combinator
- - JSON-Combinator-Examples
  - json-enumerator
- - JsonGrammar
  - json-incremental-decoder
  - json-query
- - jsons-to-schema
  - json-togo
  - json-tokens
+ - json2-hdbc
+ - jsons-to-schema
  - jspath
- - JunkDB-driver-gdbm
- - JunkDB-driver-hashtables
- - JuPyTer-notebook
  - jvm
  - jvm-batching
  - jvm-streaming
···
  - keera-hails-reactive-fs
  - keera-hails-reactive-gtk
  - keera-hails-reactive-htmldom
- - keera-hails-reactivelenses
  - keera-hails-reactive-network
  - keera-hails-reactive-polling
  - keera-hails-reactive-wx
  - keera-hails-reactive-yampa
+ - keera-hails-reactivelenses
  - keera-posture
  - kevin
  - keysafe
  - keyvaluehash
  - keyword-args
  - kicad-data
- - KiCS
- - KiCS-debugger
- - KiCS-prophecy
  - kif-parser
  - kit
  - kleene
···
  - labyrinth
  - labyrinth-server
  - laika
- - lambdabot-zulip
  - lambda-calculator
+ - lambda-devs
+ - lambda-options
+ - lambdaFeed
+ - lambdaLit
+ - lambdabot-zulip
  - lambdacms-media
  - lambdacube
  - lambdacube-bullet
···
  - lambdacube-examples
  - lambdacube-gl
  - lambdacube-samples
- - LambdaDesigner
- - lambda-devs
- - lambdaFeed
- - LambdaINet
- - lambdaLit
- - lambda-options
- - LambdaPrettyQuote
- - LambdaShell
  - lambdaya-bus
  - lambdiff
  - lang
+ - language-Modula2
  - language-boogie
  - language-eiffel
  - language-kort
- - language-Modula2
  - language-ninja
  - language-oberon
  - language-python-colour
···
  - lazy-hash
  - lazy-hash-cache
  - ldapply
- - LDAPv3
  - leaky
  - lean
  - legion
···
  - linear-circuit
  - linearmap-category
  - linearscan-hoopl
- - LinearSplit
- - LinkChecker
  - linkchk
  - linkcore
  - linux-ptrace
···
  - liquid-bytestring
  - liquid-containers
  - liquid-ghc-prim
- - liquidhaskell-cabal-demo
  - liquid-parallel
  - liquid-platform
  - liquid-prelude
  - liquid-vector
- - listenbrainz-client
+ - liquidhaskell-cabal-demo
  - list-t-attoparsec
  - list-t-html-parser
  - list-witnesses
+ - listenbrainz-client
  - live-sequencer
  - llvm
  - llvm-analysis
···
  - llvm-tf
  - llvm-tools
  - lmonad-yesod
- - localize
  - local-search
+ - localize
  - locked-poll
  - log
- - logging-effect-extra
- - logic-classes
- - LogicGrowsOnTrees
- - LogicGrowsOnTrees-MPI
- - LogicGrowsOnTrees-network
- - LogicGrowsOnTrees-processes
  - log-postgres
  - log-utils
+ - logging-effect-extra
+ - logic-classes
  - lojban
  - lojysamban
  - lol-apps
  - lol-benches
  - lol-cpp
- - loli
  - lol-repa
  - lol-tests
  - lol-typing
+ - loli
  - longshot
  - loop-effin
  - lorentz
  - lostcities
  - loup
- - LslPlus
  - ls-usb
  - lsystem
  - lti13
  - luachunk
  - lucid-colonnade
  - lucienne
- - Lucu
  - luhn
  - lui
  - luminance-samples
  - lvish
- - Lykah
  - lz4-conduit
  - lzma-enumerator
+ - mDNSResponder-client
  - macbeth-lib
  - machines-amazonka
  - macosx-make-standalone
+ - magic-wormhole
  - magicbane
  - magico
- - magic-wormhole
  - mahoro
  - maid
- - mailgun
  - mail-pool
+ - mailgun
  - majordomo
  - majority
  - manatee
···
  - manifold-random
  - manifolds
  - marionetta
- - markdown2svg
  - markdown-pap
+ - markdown2svg
  - markov-processes
  - marmalade-upload
  - marquise
  - marvin
  - masakazu-bot
  - matchers
+ - math-programming-glpk
+ - math-programming-tests
  - mathblog
  - mathlink
- - math-programming-glpk
- - math-programming-tests
  - matsuri
  - maxent
  - maxent-learner-hw-gui
  - maxsharing
- - MaybeT-transformers
- - MC-Fold-DP
  - mcmc
  - mcmc-samplers
- - mDNSResponder-client
  - mealy
  - mediabus-fdk-aac
  - mediabus-rtp
···
  - mergeful-persistent
  - mergeless-persistent
  - merkle-patricia-db
- - MetaObject
  - meta-par-accelerate
  - metaplug
  - metar
  - metar-http
- - Metrics
  - metronome
- - MFlow
- - Mhailist
- - Michelangelo
- - microformats2-parser
+ - micro-gateway
  - microformats2-types
- - micro-gateway
- - MicrosoftTranslator
  - midimory
  - mighttpd
  - minecraft-data
···
  - minilight-lua
  - minimung
  - minioperational
- - MIP-glpk
  - miss
- - MissingPy
+ - miss-porcelain
  - missing-py2
- - miss-porcelain
  - mixed-strategies
  - mkbndl
  - mkcabal
···
  - moan
  - modify-fasta
  - modsplit
- - modularity
  - modular-prelude-classy
+ - modularity
  - modulo
  - mole
- - MonadCatchIO-mtl
- - MonadCatchIO-mtl-foreign
- - MonadCatchIO-transformers-foreign
  - monad-exception
- - monadiccp-gecode
- - MonadLab
  - monad-state
  - monad-stlike-stm
+ - monadiccp-gecode
  - monarch
- - Monaris
- - Monatron-IO
  - monetdb-mapi
  - mongrel2-handler
  - monky
- - Monocle
  - monte-carlo
  - moo
  - moo-nad
···
  - msgpack-idl
  - msgpack-rpc
  - msgpack-rpc-conduit
- - MSQueue
  - mtgoxapi
- - MuCheck-Hspec
- - MuCheck-HUnit
- - MuCheck-QuickCheck
- - MuCheck-SmallCheck
  - mu-grpc-client
  - mu-grpc-server
- - multibase
+ - mu-tracing
  - multi-cabal
+ - multibase
  - multifocal
  - multihash-serialise
  - multilinear-io
···
  - multisetrewrite
  - murder
  - murmurhash3
- - musicbrainz-email
  - music-graphics
  - music-parts
  - music-pitch
···
  - music-score
  - music-sibelius
  - music-suite
+ - musicbrainz-email
  - musicxml2
  - mutable-iter
- - MutationOrder
  - mute-unmute
- - mu-tracing
- - mvclient
  - mvc-updates
+ - mvclient
  - mxnet-dataiter
  - mxnet-examples
  - mxnet-nn
+ - myTestlll
  - mysnapsession-example
  - mysql-haskell-openssl
  - mysql-simple-typed
- - myTestlll
  - mywatch
  - n2o-web
  - nakadi-client
  - nanovg-simple
- - NaperianNetCDF
  - nats-queue
  - natural-number
- - NearContextAlgebra
  - nemesis-titan
  - nerf
  - nero-wai
  - nero-warp
  - nested-routes
- - netcore
- - netlines
  - net-spider-cli
  - net-spider-pangraph
  - net-spider-rpl
  - net-spider-rpl-cli
+ - netcore
+ - netlines
  - netstring-enumerator
  - nettle-frp
  - nettle-netkit
···
  - ngrams-loader
  - ngx-export-tools-extra
  - nikepub
- - Ninjas
  - nirum
  - nlp-scores-scripts
- - Nomyx
  - nomyx-api
  - nomyx-core
- - Nomyx-Core
  - nomyx-language
- - Nomyx-Language
  - nomyx-library
- - Nomyx-Rules
  - nomyx-server
- - Nomyx-Web
- - NonEmptyList
- - NoSlow
  - notmuch-haskell
  - notmuch-web
- - numerical
  - numeric-ode
+ - numerical
  - numhask-hedgehog
  - numhask-histogram
  - numhask-range
  - numhask-test
- - Nussinov78
- - NXT
  - nymphaea
  - obd
  - obdd
···
  - one-liner_2_0
  - online
  - online-csv
- - OnRmt
  - open-adt-tutorial
- - OpenAFP-Utils
- - OpenGLCheck
+ - open-union
  - openpgp-crypto-api
- - OpenSCAD
  - openssh-github-keys
  - opentracing-jaeger
  - opentracing-zipkin-v1
- - open-union
- - OpenVG
  - optima-for-hasql
  - optimal-blocks
  - optimusprime
···
  - orchid-demo
  - order-maintenance
  - org-mode-lucid
- - OSM
  - osm-download
  - otp-authenticator
  - padKONTROL
- - PageIO
  - pairing
  - panda
  - pandoc-japanese-filters
···
  - papa-implement
  - papa-semigroupoids
  - paprika
- - Paraiso
- - Parallel-Arrows-Eden
  - parco-attoparsec
- - parconc-examples
  - parco-parsec
+ - parconc-examples
  - parquet-hs
  - parse-help
  - parsestar
···
  - pcapng
  - pcf
  - pcf-font-embed
- - PCLT-DB
  - pdf-slave
  - peakachu
  - pec
···
  - periodic-client-exe
  - periodic-server
  - perm
- - PermuteEffects
  - persistent-audit
  - persistent-hssqlppp
  - persistent-map
···
  - planet-mitchell
  - plocketed
  - ploterific
- - Plot-ho-matic
- - PlslTools
  - png-file
  - pngload
  - pocket-dns
+ - point-octree
  - pointless-lenses
  - pointless-rewrite
- - point-octree
  - poke
  - polh-lexicon
  - polydata
+ - polysemy-RandomFu
  - polysemy-chronos
  - polysemy-conc
  - polysemy-extra
···
  - polysemy-optics
  - polysemy-path
  - polysemy-plugin
- - polysemy-RandomFu
+ - polysemy-readline
  - polysemy-resume
  - polysemy-test
  - polysemy-time
···
  - powerqueue-sqs
  - pqueue-mtl
  - practice-room
- - prednote-test
  - pred-set
  - pred-trie
+ - prednote-test
  - presto-hdbc
  - preview
  - primula-board
  - primula-bot
- - Printf-TH
- - ProbabilityMonads
  - proc
  - process-iterio
  - process-progress
···
  - proplang
  - prosidyc
  - proteome
+ - proto-lens-descriptors
  - proto3-suite
  - protobuf-native
  - protocol-buffers-descriptor-fork
- - proto-lens-descriptors
  - proton
  - psc-ide
  - puffytools
- - Pugs
  - pugs-compat
  - pugs-hsregex
  - punkt
- - Pup-Events
- - Pup-Events-Demo
  - puppetresources
  - pure-cdb
  - pure-priority-queue-tests
···
  - qhs
  - qr-repa
  - quantum-random
- - Quelea
  - queryparser
  - queryparser-demo
  - queryparser-hive
···
  - random-effin
  - random-hypergeometric
  - range-space
- - Ranka
  - rasa
  - rasa-example-config
  - rasa-ext-bufs
···
  - record-aeson
  - record-gl
  - record-preprocessor
- - records-th
  - record-syntax
- - reddit
+ - records-th
  - redHandlers
+ - reddit
  - reduce-equations
  - refh
  - reflex-animation
···
  - regex-genex
  - regex-pcre-text
  - regex-pderiv
- - regexp-tries
  - regex-xmlschema
+ - regexp-tries
  - regional-pointers
  - regions-monadsfd
  - regions-monadstf
···
  - rest-client
  - rest-core
  - rest-example
- - restful-snap
  - rest-gen
  - rest-happstack
- - RESTng
- - restricted-workers
  - rest-snap
  - rest-stringmap
  - rest-types
  - rest-wai
+ - restful-snap
+ - restricted-workers
  - rethinkdb-model
  - rewrite
  - rewriting
  - rezoom
- - rfc
  - rfc-env
  - rfc-http-client
  - rfc-psql
···
  - ripple
  - risc-v
  - rivet
- - Rlang-QQ
  - rlwe-challenges
  - rmonad
- - RMP
- - RNAdesign
- - RNAdraw
- - RNAFold
- - RNAFoldProgs
- - RNAlien
- - RNAwolf
  - rncryptor
  - rob
  - robot
···
  - rollbar-cli
  - rollbar-wai
  - rollbar-yesod
- - RollingDirectory
  - ron-schema
  - ron-storage
  - rose-trie
···
  - ruler
  - ruler-core
  - runtime-arbitrary
- - S3
+ - s-expression
  - safer-file-handles
  - safer-file-handles-bytestring
  - safer-file-handles-text
···
  - samtools-iteratee
  - sarsi
  - sasl
+ - sat-micro-hs
  - satchmo-backends
  - satchmo-examples
  - satchmo-funsat
  - satchmo-minisat
  - satchmo-toysat
- - sat-micro-hs
- - SBench
- - sc2hs
  - sc2-lowlevel
  - sc2-support
+ - sc2hs
  - sc3-rdu
  - scalable-server
- - SCalendar
+ - scalp-webhooks
  - scalpel-search
- - scalp-webhooks
  - scan-vector-machine
  - schema
  - schematic
  - scholdoc
  - scholdoc-citeproc
  - scholdoc-texmath
- - SciFlow
- - SciFlow-drmaa
  - scion
  - scion-browser
  - scope
···
  - scp-streams
  - scrabble-bot
  - scrapbook
- - SCRIPTWriter
- - Scurry
  - sde-solver
  - seakale-postgresql
  - seakale-tests
  - secrm
  - sednaDBXML
  - seitz-symbol
- - SelectSequencesFromMSA
  - selenium-server
  - self-extract
  - semi-iso
···
  - sequor
  - serpentine
  - serv
+ - serv-wai
  - servant-auth-token
  - servant-auth-token-acid
  - servant-auth-token-leveldb
···
  - servant-zeppelin-client
  - servant-zeppelin-server
  - servant-zeppelin-swagger
- - serv-wai
  - sessiontypes-distributed
- - s-expression
- - SFML-control
- - SFont
- - SGdemo
  - sgf
  - sgrep
  - sha1
···
  - shapefile
  - shapely-data
  - shelduck
- - Shellac-compatline
- - Shellac-editline
- - Shellac-haskeline
- - Shellac-readline
  - shellmate-extras
  - shine-varying
- - ShortestPathProblems
  - showdown
- - Shpadoinkle-backend-pardiff
- - Shpadoinkle-backend-static
- - Shpadoinkle-developer-tools
- - Shpadoinkle-disembodied
- - Shpadoinkle-examples
- - Shpadoinkle-html
- - Shpadoinkle-router
- - Shpadoinkle-template
- - Shpadoinkle-widgets
  - shpider
  - shuffle
- - sibe
  - si-clock
+ - sibe
  - sigma-ij
  - signable
  - signals
···
  - simgi
  - simple-c-value
  - simple-firewire
- - SimpleGL
- - simpleirc-lens
- - SimpleLog
  - simple-nix
  - simple-pascal
- - SimpleServer
+ - simpleirc-lens
  - simseq
  - singleton-nats_0_4_6
  - singletons-base
···
  - smcdel
  - smith-cli
  - smith-client
- - Smooth
  - smtlib2-debug
  - smtlib2-pipe
  - smtlib2-quickcheck
···
  - snap-auth-cli
  - snap-elm
  - snap-extras
+ - snap-utils
  - snaplet-actionlog
  - snaplet-auth-acid
  - snaplet-coffee
···
  - snaplet-tasks
  - snaplet-wordpress
  - snappy-iteratee
- - snap-utils
  - sndfile-enumerators
  - sneathlane-haste
  - snm
  - snmp
+ - snow-white
  - snowflake-core
  - snowflake-server
- - snow-white
- - Snusmumrik
- - SoccerFun
- - SoccerFunGL
  - sock2stream
  - sockets
  - solga-swagger
···
  - sounddelay
  - soundgen
  - source-code-server
- - SourceGraph
  - sparkle
  - sparrow
  - sparsebit
···
  - sphero
  - sphinx-cli
  - spice
- - SpinCounter
  - spline3
  - splines
- - Spock-auth
- - Spock-lucid
- - Spock-worker
  - sprinkles
  - sproxy
- - sproxy2
  - sproxy-web
- - sqlite-simple-typed
+ - sproxy2
  - sql-simple-mysql
  - sql-simple-pool
  - sql-simple-postgresql
  - sql-simple-sqlite
+ - sqlite-simple-typed
  - sr-extra
  - sscgi
  - sshd-lint
  - sssp
  - sstable
  - stable-tree
+ - stack-hpc-coveralls
+ - stack-network
+ - stack-run-auto
  - stackage
- - stackage2nix
  - stackage-build-plan
  - stackage-cabal
  - stackage-query
  - stackage-sandbox
  - stackage-setup
  - stackage-upload
- - stack-hpc-coveralls
- - stack-network
- - stack-run-auto
+ - stackage2nix
  - starrover2
  - stateful-mtl
  - static-closure
  - statsd-client
  - statsdi
- - STLinkUSB
- - STM32-Zombie
  - stmcontrol
- - StockholmAlignment
  - storablevector-streamfusion
- - Strafunski-Sdf2Haskell
  - stratux
  - stratux-demo
  - stratux-http
···
  - superconstraints
  - sv
  - sv-cassava
+ - sv-svfactor
  - svg2q
- - SVG2Q
  - svgone
- - sv-svfactor
  - swapper
  - swearjure
  - sweet-egison
  - switch
  - sylvia
+ - sym-plot
  - symantic-atom
  - symantic-lib
  - symbiote
  - symmetry-operations-symbols
- - sym-plot
  - syncthing-hs
  - syntax
  - syntax-attoparsec
  - syntax-example
  - syntax-example-json
- - SyntaxMacros
- - syntaxnet-haskell
  - syntax-pretty
  - syntax-printer
+ - syntaxnet-haskell
  - synthesizer-llvm
  - systemstats
  - t3-client
  - ta
+ - tag-stream
  - tagged-list
  - tagged-th
  - tagsoup-navigate
  - tagstew
- - tag-stream
  - tal
  - tamarin-prover
  - tamarin-prover-term
···
  - tasty-laws
  - tasty-lens
  - tateti-tateti
- - Taxonomy
- - TaxonomyTools
  - tbox
  - tccli
  - tdd-util
  - tdlib
  - tdlib-gen
  - tdlib-types
- - TeaHS
  - techlab
  - telegram-bot
  - telegram-raw-api
···
  - tensorflow-ops
  - terminal-text
  - terrahs
- - testbench
  - test-framework-sandbox
  - test-sandbox-compose
  - test-sandbox-hunit
  - test-sandbox-quickcheck
  - test-simple
- - TeX-my-math
- - textmatetags
+ - testbench
  - text-plus
  - text-trie
  - text-xml-generic
+ - textmatetags
  - th-alpha
  - th-context
+ - th-instances
+ - th-typegraph
  - theatre
  - theoremquest-client
  - thimk
- - th-instances
- - th-typegraph
  - thumbnail-polish
+ - tic-tac-toe
  - tickle
- - tic-tac-toe
  - tidal-serial
  - tighttp
  - timberc
  - time-exts
  - time-http
  - time-io-access
- - timeprint
  - time-warp
+ - timeprint
  - timezone-unix
  - tinyMesh
  - tip-haskell-frontend
···
  - titan
  - tls-extra
  - tn
+ - to-string-instances
  - toboggan
  - todos
  - toktok
  - too-many-cells
  - top
  - topkata
- - to-string-instances
  - total-map
  - toxcore
  - toxcore-c
···
  - trasa-reflex
  - trasa-server
  - trasa-th
- - TreeCounter
  - treemap-html-tools
  - treersec
- - Treiber
  - trek-app
  - trek-db
  - triangulation
- - TrieMap
  - tries
  - trimpolya
  - truelevel
···
  - type-assertions
  - type-cache
  - type-cereal
- - TypeClass
  - type-combinators-quote
  - type-combinators-singletons
- - typed-encoding-encoding
  - type-digits
- - typed-spreadsheet
- - typed-streams
- - TypeIlluminator
- - typelevel
- - typelevel-rewrite-rules
  - type-ord
  - type-ord-spine-cereal
- - typescript-docs
  - type-sets
  - type-structure
  - type-sub-th
+ - typed-encoding-encoding
+ - typed-spreadsheet
+ - typed-streams
+ - typelevel
+ - typelevel-rewrite-rules
+ - typescript-docs
  - typson-beam
  - typson-esqueleto
  - typson-selda
···
  - ucam-webauth
  - uhc-light
  - uhc-util
- - UMM
  - unagi-bloomfilter
  - unbound
  - unfoldable-restricted
- - unicode-normalization
  - uni-events
- - uniformBase
- - uniform-io
  - uni-graphs
  - uni-htk
  - uni-posixutil
- - uniqueness-periods-vector-examples
  - uni-reactor
  - uni-uDrawGraph
+ - unicode-normalization
+ - uniform-io
+ - uniformBase
+ - uniqueness-periods-vector-examples
  - universe-th
  - unix-fcntl
  - unix-simple
···
  - urembed
  - uri-enumerator
  - uri-enumerator-file
- - UrlDisp
- - URLT
  - usb
  - usb-enumerator
  - usb-hid
···
  - vformat-aeson
  - vformat-time
  - vfr-waypoints
- - ViennaRNA-extras
  - vigilance
  - vimeta
  - vinyl-operational
···
  - vty-ui-extras
  - waargonaut
  - wahsp
- - wai-cli
  - wai-devel
  - wai-dispatch
  - wai-handler-snap
···
  - wai-thrift
  - waldo
  - warped
- - WashNGo
- - WAVE
- - WaveFront
  - wavesurfer
  - wavy
- - web3
- - webapi
- - WebBits-Html
- - WebBits-multiplate
- - WebCont
- - webcrank-wai
- - webdriver-w3c
  - web-mongrel2
  - web-page
  - web-rep
  - web-routes-regular
  - web-routing
+ - web3
+ - webapi
+ - webcrank-wai
+ - webdriver-w3c
  - webserver
- - WEditorBrick
- - WEditorHyphen
  - weighted
  - werewolf-slack
  - what4
···
  - wikipedia4epub
  - windowslive
  - winio
- - WL500gPControl
- - wlc-hs
  - wl-pprint-ansiterm
  - wl-pprint-terminfo
+ - wlc-hs
  - wobsurv
  - wolf
- - WordAlignment
  - workflow-extra
  - workflow-pure
  - workflow-types
···
  - writer-cps-full
  - wss-client
  - wtk-gtk
+ - wu-wei
  - wumpus-basic
  - wumpus-drawing
  - wumpus-microprint
  - wumpus-tree
- - WURFL
- - wu-wei
  - wx
  - wxAsteroids
+ - wxFruit
+ - wxSimpleCanvas
  - wxc
  - wxcore
- - WXDiffCtrl
- - wxFruit
- - WxGeneric
  - wxhnotepad
- - wxSimpleCanvas
  - wxturtle
  - wyvern
  - xdcc
  - xhb-atom-cache
  - xhb-ewmh
- - XML
- - xml2x
  - xml-catalog
  - xml-enumerator
  - xml-enumerator-combinators
···
  - xml-push
  - xml-query-xml-conduit
  - xml-query-xml-types
+ - xml-tydom-conduit
+ - xml2x
  - xmltv
- - xml-tydom-conduit
  - xmms2-client
  - xmms2-client-glib
  - xmonad-contrib-bluetilebranch
  - xmpipe
- - XMPP
  - xournal-builder
  - xournal-convert
  - xournal-parser
  - xournal-render
- - XSaiga
  - xtc
- - Yablog
- - YACPong
  - yajl-enumerator
  - yam
  - yam-datasource
  - yam-job
  - yam-logger
- - yaml-rpc-scotty
- - yaml-rpc-snap
- - yaml-unscrambler
  - yam-redis
  - yam-transaction
  - yam-transaction-odbc
  - yam-transaction-postgresql
  - yam-web
+ - yaml-rpc-scotty
+ - yaml-rpc-snap
+ - yaml-unscrambler
  - yarr-image-io
  - yavie
  - ycextra
···
  - yesod-session-redis
  - yjftp
  - yjftp-libs
- - Yogurt
- - Yogurt-Standalone
  - yoko
  - york-lava
  - yql
  - yu-launch
  - yuuko
  - zasni-gerna
- - Z-Botan
  - zephyr
  - zerobin
  - zeromq3-conduit
···
  - zifter-hindent
  - zifter-hlint
  - zifter-stack
- - Z-IO
  - zipper
  - zippo
  - ziptastic-client
  - zlib-enum
  - zmcat
- - Z-MessagePack
  - zoom-cache
  - zoom-cache-pcm
  - zoom-cache-sndfile
  - zoovisitor
  - zuramaru
- - Z-YAML

pkgs/development/haskell-modules/generic-builder.nix

···
 , libraryFrameworkDepends ? [], executableFrameworkDepends ? []
 , homepage ? "https://hackage.haskell.org/package/${pname}"
 , platforms ? with lib.platforms; all # GHC can cross-compile
+, badPlatforms ? lib.platforms.none
 , hydraPlatforms ? null
 , hyperlinkSource ? true
 , isExecutable ? false, isLibrary ? !isExecutable
···
 assert allPkgconfigDepends != [] -> pkg-config != null;
 
 stdenv.mkDerivation ({
-  name = "${pname}-${version}";
+  inherit pname version;
 
   outputs = [ "out" ]
          ++ (optional enableSeparateDataOutput "data")
···
          // optionalAttrs (args ? description)    { inherit description; }
          // optionalAttrs (args ? maintainers)    { inherit maintainers; }
          // optionalAttrs (args ? hydraPlatforms) { inherit hydraPlatforms; }
+         // optionalAttrs (args ? badPlatforms)   { inherit badPlatforms; }
          // optionalAttrs (args ? changelog)      { inherit changelog; }
          ;
 

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

···
        ];
        description = "The Haskell/R mixed programming environment";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "HABQT" = callPackage
···
     ({ mkDerivation, base, constraints, containers, data-default
      , deepseq, directory, doctest-exitcode-stdio, doctest-lib
      , exceptions, extra, hspec, monad-control, mono-traversable, mtl
-     , QuickCheck, regex-tdfa, syb, template-haskell, transformers-base
-     , unliftio
+     , QuickCheck, regex-tdfa, stm, syb, template-haskell
+     , transformers-base, unliftio
      }:
      mkDerivation {
        pname = "HMock";
-       version = "0.1.0.1";
-       sha256 = "1viv8aggapxvk1akm1z3976h4b12wa8zwkr5qinfpvmsgvlkhhlz";
+       version = "0.2.0.0";
+       sha256 = "1i5b9fxb5fii3ib97dncr5pfsylj5bsppi45qx7wq1idmz0fq3rj";
        libraryHaskellDepends = [
          base constraints containers data-default exceptions extra
-         monad-control mono-traversable mtl regex-tdfa syb template-haskell
-         transformers-base unliftio
+         monad-control mono-traversable mtl regex-tdfa stm syb
+         template-haskell transformers-base unliftio
        ];
        testHaskellDepends = [
          base containers data-default deepseq directory
···
      }:
      mkDerivation {
        pname = "attoparsec-data";
-       version = "1.0.5.1";
-       sha256 = "1fn28rg79w5kkv3lrmqjcff8fhn1kc2b84vnblr0xqbfdjdbzgp6";
+       version = "1.0.5.2";
+       sha256 = "05x7xij5jyfzcl0hyjjw4lxlzgkmi55q48s5vbgvba48a2crv0qj";
        libraryHaskellDepends = [
          attoparsec attoparsec-time base bytestring scientific text time
          uuid
···
      }) {};
 
   "attoparsec-time" = callPackage
-    ({ mkDerivation, attoparsec, base, bytestring, scientific, text
-     , time
-     }:
+    ({ mkDerivation, attoparsec, base, bytestring, text, time }:
      mkDerivation {
        pname = "attoparsec-time";
-       version = "1.0.1.1";
-       sha256 = "1g3wfc499zdz79i06hgg4286ky9yv4mi3jgq1zf92ik1wcw23q6l";
-       libraryHaskellDepends = [
-         attoparsec base bytestring scientific text time
-       ];
+       version = "1.0.1.2";
+       sha256 = "1pc4dy4d6q11cfmgrg41h2nm34vgnnarah85gnwbd6x48cissrpp";
+       libraryHaskellDepends = [ attoparsec base bytestring text time ];
        description = "Attoparsec parsers of time";
        license = lib.licenses.mit;
      }) {};
···
        pname = "base32";
        version = "0.2.1.0";
        sha256 = "1c1qzbri6m8b2m1cr68vrjbny6wlvfyrbfyzd61s83a3y3w39plp";
+       revision = "1";
+       editedCabalFile = "0apyphnlsnr16s5xb9b9g7d5aw3ny4qx8nz8y71zpglk63sy0cq0";
        libraryHaskellDepends = [
          base bytestring deepseq ghc-byteorder text text-short
        ];
···
        broken = true;
      }) {};
 
+  "bech32_1_1_1" = callPackage
+    ({ mkDerivation, array, base, base58-bytestring, bytestring
+     , containers, deepseq, extra, hspec, hspec-discover, memory
+     , optparse-applicative, process, QuickCheck, text, vector
+     }:
+     mkDerivation {
+       pname = "bech32";
+       version = "1.1.1";
+       sha256 = "0ibdibki3f51wpxby3cl6p0xzd32ddczlg2dcqxy7lgx7j3h9xgn";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         array base bytestring containers extra text
+       ];
+       executableHaskellDepends = [
+         base base58-bytestring bytestring extra memory optparse-applicative
+         text
+       ];
+       testHaskellDepends = [
+         base base58-bytestring bytestring containers deepseq extra hspec
+         memory process QuickCheck text vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Implementation of the Bech32 cryptocurrency address format (BIP 0173)";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "bech32-th" = callPackage
     ({ mkDerivation, base, bech32, hspec, hspec-discover
      , template-haskell, text
···
        sha256 = "0ypn8y4b0iw7jb167biy0zjs4hp9k9nlf8y4nsczfv5n4p4cadnq";
        revision = "1";
        editedCabalFile = "1b614lymjd3idcbzrkha7labfskv1m0kbljrnhwcz7sbymfcbdbk";
+       libraryHaskellDepends = [ base bech32 template-haskell text ];
+       testHaskellDepends = [ base bech32 hspec template-haskell ];
+       testToolDepends = [ hspec-discover ];
+       description = "Template Haskell extensions to the Bech32 library";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
+  "bech32-th_1_1_1" = callPackage
+    ({ mkDerivation, base, bech32, hspec, hspec-discover
+     , template-haskell, text
+     }:
+     mkDerivation {
+       pname = "bech32-th";
+       version = "1.1.1";
+       sha256 = "0548an9v6y14qalb1agl5bskcmpb9865lxyap162xzgskd9s4iik";
        libraryHaskellDepends = [ base bech32 template-haskell text ];
        testHaskellDepends = [ base bech32 hspec template-haskell ];
        testToolDepends = [ hspec-discover ];
···
      }:
      mkDerivation {
        pname = "blucontrol";
-       version = "0.5.1.1";
-       sha256 = "0v3ifwxjbxm86ybn5daqqfdm4nmbfzlbkyc19d4nawnzjyf8v2p9";
+       version = "0.6.0.0";
+       sha256 = "1rywy6r5wachz3y9vw1iy5b46fvlxcv5s33lrriffimqprkglbcj";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "bytebuild";
-       version = "0.3.7.0";
-       sha256 = "1vckm98sarxzqh6ib89y5kzhbf1yxc9wgrbpwbsrh0dv5gi3pclj";
+       version = "0.3.8.0";
+       sha256 = "19gg4qjlj595j8zd0n6cz2kgz70g8z6w666c6wlf5lj32j8p6yh5";
        libraryHaskellDepends = [
          base byteslice bytestring integer-logarithms natural-arithmetic
          primitive primitive-offset primitive-unlifted run-st text-short
···
      }:
      mkDerivation {
        pname = "calamity";
-       version = "0.1.30.2";
-       sha256 = "0i0v8cb0a3mbkrb3liw60gb7zflnps5w04a6nx5aynini7mpwanj";
+       version = "0.1.30.3";
+       sha256 = "0r6vrcdqqf6a8rihjgppmp625ws5vmsmq98i177xfg14hsal49pp";
        libraryHaskellDepends = [
          aeson async base bytestring calamity-commands colour
          concurrent-extra connection containers data-default-class
···
        ];
        description = "A REST Web Api server template for building (micro)services";
        license = lib.licenses.mit;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "chalk" = callPackage
···
        ];
        description = "Channel/Arrow based streaming computation library";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "cielo" = callPackage
···
        license = lib.licenses.mit;
      }) {};
 
+  "colour_2_3_6" = callPackage
+    ({ mkDerivation, base, QuickCheck, random, test-framework
+     , test-framework-quickcheck2
+     }:
+     mkDerivation {
+       pname = "colour";
+       version = "2.3.6";
+       sha256 = "0wgqj64mh2y2zk77kv59k3xb3dk4wmgfp988y74sp9a4d76mvlrc";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base QuickCheck random test-framework test-framework-quickcheck2
+       ];
+       description = "A model for human colour/color perception";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "colour-accelerate" = callPackage
     ({ mkDerivation, accelerate, base }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "cuckoo";
-       version = "0.2.1";
-       sha256 = "1bv39vfg0yzancyya1cdbrcdc0gasp0djcc9ryiwrc3kf9y0nbzn";
+       version = "0.2.2";
+       sha256 = "1wm81a5fsq0wdvx3ayxfrljya7rm9c0vfmy5dhxa6h9zxnqrkvav";
        libraryHaskellDepends = [ base memory primitive random vector ];
        testHaskellDepends = [
          base bytestring cryptonite doctest hashable memory primitive
···
        license = lib.licenses.mit;
      }) {};
 
+  "data-lens-light_0_1_2_3" = callPackage
+    ({ mkDerivation, base, mtl, template-haskell }:
+     mkDerivation {
+       pname = "data-lens-light";
+       version = "0.1.2.3";
+       sha256 = "1xczbmgin315qh9wpl6v2vvnp6hv1irfbfqs7pk034qcpx61fwdl";
+       libraryHaskellDepends = [ base mtl template-haskell ];
+       description = "Simple lenses, minimum dependencies";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "data-lens-template" = callPackage
     ({ mkDerivation, base, data-lens, template-haskell }:
      mkDerivation {
···
        pname = "dhall-docs";
        version = "1.0.6";
        sha256 = "004n8kh8riw67aqwp6z9199jwv2c9r1dbkg92s71vd9zc04wxljv";
+       revision = "1";
+       editedCabalFile = "1m8ms4y4pxiays620k4zjf7hnfk103y990pnhnb6hr0h70n7i157";
        isLibrary = true;
        isExecutable = true;
        enableSeparateDataOutput = true;
···
        pname = "diagrams-graphviz";
        version = "1.4.1.1";
        sha256 = "0lscrxd682jvyrl5bj4dxp7593qwyis01sl0p4jm2jfn335wdq40";
+       revision = "1";
+       editedCabalFile = "1qx69541pxf71whfz2a913yzbhfcks2pyzfprkgrcmiiyv0a3i7b";
        libraryHaskellDepends = [
          base containers diagrams-lib fgl graphviz split
        ];
···
      }:
      mkDerivation {
        pname = "digraph";
-       version = "0.2";
-       sha256 = "0k6kr1vr25i2jvv2q1xby06b7xkpg2dr4sq2ffnv0lmznshjy8y5";
+       version = "0.2.1";
+       sha256 = "04x8y6snlfm8w22l0mn58sqbgdsc3av9l6qz2wqfdjmcp7h7s79r";
        libraryHaskellDepends = [
          base containers deepseq hashable massiv mwc-random streaming
          transformers unordered-containers
···
      }:
      mkDerivation {
        pname = "domain";
-       version = "0.1.1.1";
-       sha256 = "1vy789dv1lpha2bxvr0x1vk2vvgb9z43abkqi1rbj2vvirqsbr1n";
+       version = "0.1.1.2";
+       sha256 = "0s4x7jhhcx94fzi8cg5bqfqn2vajdlv1yjrakfnfdqk187zbdc6r";
        libraryHaskellDepends = [
          attoparsec base bytestring domain-core foldl hashable
          parser-combinators template-haskell template-haskell-compat-v0208
···
        ];
        testHaskellDepends = [
          base domain-core QuickCheck quickcheck-instances rerebase tasty
-         tasty-hunit tasty-quickcheck template-haskell text th-orphans
+         tasty-hunit tasty-quickcheck template-haskell
+         template-haskell-compat-v0208 text th-orphans
        ];
        description = "Codegen helping you define domain models";
        license = lib.licenses.mit;
···
        license = lib.licenses.bsd3;
      }) {};
 
-  "esqueleto_3_5_1_0" = callPackage
+  "esqueleto_3_5_2_0" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring
      , conduit, containers, exceptions, hspec, hspec-core, monad-logger
      , mtl, mysql, mysql-simple, persistent, persistent-mysql
···
      }:
      mkDerivation {
        pname = "esqueleto";
-       version = "3.5.1.0";
-       sha256 = "1r77lym11gh53059b3hg5wyzb4ymaynk5awrmzgnwfkmx041sqp8";
+       version = "3.5.2.0";
+       sha256 = "06z5n0nbyrdvzlfqmx3jvh76kkss3bis19k5ppqkifsfgwi07rzw";
        libraryHaskellDepends = [
          aeson attoparsec base blaze-html bytestring conduit containers
          monad-logger persistent resourcet tagged text time transformers
···
      }:
      mkDerivation {
        pname = "fakedata-quickcheck";
-       version = "0.1.0";
-       sha256 = "0al5brin9bs0553rrw073za4jzw2whrf05yj6h34lmx4kxzciv6s";
+       version = "0.2.0";
+       sha256 = "0m70r66vbkgi1d016cpgahaas17hysabp44nigz4cda9l3x6qmh6";
        libraryHaskellDepends = [ base fakedata QuickCheck random ];
        testHaskellDepends = [
          base fakedata hspec hspec-core QuickCheck random regex-tdfa text
···
      }:
      mkDerivation {
        pname = "funcons-tools";
-       version = "0.2.0.11";
-       sha256 = "1gi7db5mjq25xwl27ihsrg0ya1jgw5zhki5c1431rizj72yx5ji9";
+       version = "0.2.0.13";
+       sha256 = "0favv5lfhhhsjasn0gfx2m9q18j8qjk3w92ih78nqaam8gfg59vm";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
     ({ mkDerivation, base, bv, containers, multiset, text, vector }:
      mkDerivation {
        pname = "funcons-values";
-       version = "0.1.0.7";
-       sha256 = "0jdgwv44gs4zr8z5pg6lzikrgn3dzna8z0vriq71anlifjyci8yq";
+       version = "0.1.0.9";
+       sha256 = "1817jhp9vpipkvxdqvn4yj88z7z3pyrxs22h4d51c3056ighq6wn";
        revision = "1";
-       editedCabalFile = "1aam84wminmcy530vkv8g2qkag6gz45yyx5xks7gq1y7jifm1kkb";
+       editedCabalFile = "1g807b4lpz0whz0v4xl7y0qj0682y9lvmng06rxxyabn2lcvx5sc";
        libraryHaskellDepends = [
          base bv containers multiset text vector
        ];
···
        pname = "futhark-data";
        version = "1.0.0.1";
        sha256 = "126b7igrk0aldj4kjwkyvvsy3v64g9iv6w9ladbbfnd4qw7svswm";
+       revision = "1";
+       editedCabalFile = "08p820dmdlg5x6ikgi69sddkywj71cnnjwz2fppnv901bbn55fav";
        libraryHaskellDepends = [
          base binary bytestring bytestring-to-vector containers megaparsec
          mtl text vector vector-binary-instances
···
        libraryPkgconfigDepends = [ libwnck ];
        description = "Wnck bindings";
        license = lib.licenses.lgpl21Only;
-       hydraPlatforms = lib.platforms.none;
-       broken = true;
+       platforms = [
+         "aarch64-linux" "armv7l-linux" "i686-linux" "x86_64-linux"
+       ];
      }) {inherit (pkgs) libwnck;};
 
   "gi-xlib" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "githash_0_1_6_1" = callPackage
+    ({ mkDerivation, base, bytestring, directory, filepath, hspec
+     , process, template-haskell, temporary, th-compat, unliftio
+     }:
+     mkDerivation {
+       pname = "githash";
+       version = "0.1.6.1";
+       sha256 = "0g922g2l3xv795gvhri5ccrh751dnyckjs7mzv1d8pg2lffpj0bi";
+       libraryHaskellDepends = [
+         base bytestring directory filepath process template-haskell
+         th-compat
+       ];
+       testHaskellDepends = [
+         base bytestring directory filepath hspec process template-haskell
+         temporary th-compat unliftio
+       ];
+       description = "Compile git revision info into Haskell projects";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "github" = callPackage
     ({ mkDerivation, aeson, base, base-compat, base16-bytestring
      , binary, binary-instances, bytestring, containers, cryptohash-sha1
···
        testHaskellDepends = [ aeson base bytestring tasty tasty-hunit ];
        description = "A Haskell library for the GitLab web API";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "gitlab-haskell_0_3_0" = callPackage
+    ({ mkDerivation, aeson, base, bytestring, connection, http-conduit
+     , http-types, tasty, tasty-hunit, temporary, text, time
+     , transformers, unix, unliftio, unliftio-core
+     }:
+     mkDerivation {
+       pname = "gitlab-haskell";
+       version = "0.3.0";
+       sha256 = "0krcan8i9lkickl77r9dyf93k96yxj5zp0asmzq86ds13m8f3s9i";
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+         aeson base bytestring connection http-conduit http-types temporary
+         text time transformers unix unliftio unliftio-core
+       ];
+       testHaskellDepends = [ aeson base bytestring tasty tasty-hunit ];
+       description = "A Haskell library for the GitLab web API";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "gitlib" = callPackage
···
      }:
      mkDerivation {
   "jira-wiki-markup" = callPackage
-  "jira-wiki-markup" = callPackage
-  "jira-wiki-markup" = callPackage
+       version = "0.14.4";
+       sha256 = "1qvh5vgnk6vrhhr1kjqsycz13acxa7ynpqnd1bmchfl4q3aga9gw";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        ];
        description = "SSH protocol implementation";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "hsshellscript" = callPackage
···
        pname = "html-parse";
        version = "0.2.0.2";
        sha256 = "0dm771lrrqc87ygbr3dzyl1vsyi30jgr7l0isvsbqyah7s4zyg38";
-       revision = "1";
-       editedCabalFile = "1hr9bskwwx3svxqaxcyaz8v0brli1bb03xcvg7zpgbisf8x6r316";
+       revision = "2";
+       editedCabalFile = "1arck1sfcnqfczpi6zq4rja3svd3vcxxdi69dv9983v3sl01hk2g";
        libraryHaskellDepends = [
          attoparsec base containers deepseq text
        ];
···
      }:
      mkDerivation {
        pname = "hypertypes";
-       version = "0.1.0.1";
-       sha256 = "0b3cnjw07pryqslnx0k6lxdpwnihnk6pnhp6l9d09mqyxymd9nyx";
+       version = "0.1.0.2";
+       sha256 = "1zh10884a2fvj06ndh4hz2vk97x4nibr57b30kgq731x4q50zgfs";
        libraryHaskellDepends = [
          array base base-compat binary constraints containers deepseq
          generic-constraints generic-data lattices lens monad-st mtl pretty
···
        ];
        description = "Embed R quasiquotes and plots in IHaskell notebooks";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "ihaskell-juicypixels" = callPackage
···
        ];
        description = "Seamlessly call R from Haskell and vice versa. No FFI required.";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {inherit (pkgs) R;};
 
   "inliterate" = callPackage
···
     ({ mkDerivation, base, binary, bytestring, iproute }:
      mkDerivation {
        pname = "ip2location";
-       version = "8.2.1";
-       sha256 = "1ccr15yn2ska5wgwlcnfpi9w1xxkly0pwqibmdl9a1ggmwfsskv0";
+       version = "8.3.1";
+       sha256 = "01sdx0j0rm7rgylac51mk4ph5krdnzdd8532di5g5ik3p112dzg8";
        libraryHaskellDepends = [ base binary bytestring iproute ];
        description = "IP2Location Haskell package for IP geolocation";
        license = lib.licenses.mit;
···
      }:
      mkDerivation {
        pname = "jukebox";
-       version = "0.5.3";
-       sha256 = "00774gby970jxa69zw8baki40r6nw7vrprc670n8skmlp03p38j2";
+       version = "0.5.4";
+       sha256 = "10lmx9xwikk4sbc3ffpzqff9qxpphgp2q8w2rdm2iskaa7qi3skn";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
      }:
      mkDerivation {
        pname = "knit";
-       version = "0.2.0.0";
-       sha256 = "0a1swv5w9fxissxqr2x61qijqyhdxs71fv21fjz4r0kcqywnvy6x";
+       version = "0.3.0.0";
+       sha256 = "0wp16yrlibfl32b4akcwali074wxar96mvaykgh0xsf4pq1czx3q";
        libraryHaskellDepends = [
          base bytestring containers deepseq hashtables vector
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "literatex_0_2_0_0" = callPackage
+    ({ mkDerivation, ansi-wl-pprint, base, bytestring, conduit
+     , filepath, optparse-applicative, tasty, tasty-hunit, text, ttc
+     , unliftio
+     }:
+     mkDerivation {
+       pname = "literatex";
+       version = "0.2.0.0";
+       sha256 = "1j5x1hfh71jpywgwpbyir74h58b6lzaj7gpk2f07xlcwqmm68syz";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base bytestring conduit text ttc unliftio
+       ];
+       executableHaskellDepends = [
+         ansi-wl-pprint base optparse-applicative ttc
+       ];
+       testHaskellDepends = [
+         base bytestring filepath tasty tasty-hunit text ttc unliftio
+       ];
+       description = "transform literate source code to Markdown";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "little-earley" = callPackage
     ({ mkDerivation, base, containers, mtl, tasty, tasty-hunit }:
      mkDerivation {
···
      }:
      mkDerivation {
        pname = "log-elasticsearch";
-       version = "0.12.0.0";
-       sha256 = "05cvk93s61k42bmsmj4997hdij4xk74a6jrd1qvdbkq13w20260m";
+       version = "0.12.1.0";
+       sha256 = "07z0p5jcd5gjhk4dyf9ny74l68ja58ffa80mbfsyaz66ff6k4y6s";
        libraryHaskellDepends = [
          aeson aeson-pretty base base64-bytestring bytestring deepseq
          http-client http-client-tls http-types log-base network-uri
···
        broken = true;
      }) {};
 
+  "matrix-client" = callPackage
+    ({ mkDerivation, aeson, base, base64, bytestring, doctest
+     , exceptions, hashable, hspec, http-client, http-client-tls, retry
+     , SHA, text, time, unordered-containers
+     }:
+     mkDerivation {
+       pname = "matrix-client";
+       version = "0.1.0.0";
+       sha256 = "10w1q846b4jnyg9yb87d69ixfyhl205ryrib6a53pbk0bx6zn59w";
+       libraryHaskellDepends = [
+         aeson base base64 bytestring exceptions hashable http-client
+         http-client-tls retry SHA text time unordered-containers
+       ];
+       testHaskellDepends = [
+         aeson base base64 bytestring doctest exceptions hashable hspec
+         http-client http-client-tls retry SHA text time
+         unordered-containers
+       ];
+       description = "A matrix client library";
+       license = lib.licenses.asl20;
+       maintainers = with lib.maintainers; [ maralorn ];
+     }) {};
+
   "matrix-lens" = callPackage
     ({ mkDerivation, base, hedgehog, lens, matrix, tasty
      , tasty-discover, tasty-hedgehog, tasty-hspec, vector
···
      }) {};
 
   "merkle-log" = callPackage
-    ({ mkDerivation, base, bytestring, cereal, criterion, cryptonite
-     , deepseq, exceptions, hash-tree, memory, merkle-tree, mwc-random
-     , QuickCheck, random, random-bytestring, text
+    ({ mkDerivation, base, bytestring, criterion, cryptonite, deepseq
+     , exceptions, hash-tree, memory, mwc-random, QuickCheck, random
+     , random-bytestring, text
      }:
      mkDerivation {
        pname = "merkle-log";
-       version = "0.1.0.0";
-       sha256 = "07q0ifgwq8agwm62k1k83sdrln4zbj6ln90nw9p9g3pgxnp3inia";
-       revision = "1";
-       editedCabalFile = "1vrzsflvmx0mrsdb7i7pbz4d74k6yjccrb7979yw0r91qhmzlcir";
+       version = "0.1.1";
+       sha256 = "17a6s9xbv460289avbwdnf8c4vhw9qzj5xddxvfmnjjwp58qxvj1";
        libraryHaskellDepends = [
          base bytestring cryptonite deepseq exceptions memory text
        ];
···
          base bytestring cryptonite deepseq exceptions memory QuickCheck
        ];
        benchmarkHaskellDepends = [
-         base bytestring cereal criterion cryptonite deepseq hash-tree
-         memory merkle-tree mwc-random QuickCheck random random-bytestring
+         base bytestring criterion cryptonite deepseq hash-tree memory
+         mwc-random QuickCheck random random-bytestring
        ];
        description = "Merkle Tree Logs";
        license = lib.licenses.bsd3;
···
      }) {};
 
   "microformats2-parser" = callPackage
-    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, attoparsec, base
-     , base-compat, blaze-html, blaze-markup, bytestring, containers
-     , data-default, either, errors, hspec
-     , hspec-expectations-pretty-diff, html-conduit, lens-aeson, mtl
-     , network, network-uri, options, pcre-heavy, raw-strings-qq, safe
-     , scotty, tagsoup, template-haskell, text, time, transformers
-     , unordered-containers, vector, wai-cli, wai-extra, xml-lens
-     , xss-sanitize
+    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, attoparsec
+     , aws-lambda-haskell-runtime, aws-lambda-haskell-runtime-wai, base
+     , base-compat, blaze-html, blaze-markup, bytestring
+     , case-insensitive, containers, data-default, either, errors
+     , githash, hspec, hspec-expectations-pretty-diff, html-conduit
+     , lens, lens-aeson, mtl, network, network-uri, options, pcre-heavy
+     , raw-strings-qq, safe, scotty, tagsoup, template-haskell, text
+     , time, transformers, unordered-containers, vector, wai, wai-cli
+     , wai-extra, xml-lens, xss-sanitize
      }:
      mkDerivation {
        pname = "microformats2-parser";
-       version = "1.0.1.9";
-       sha256 = "1lxbw825yg16nmflf93l1sy6mxa3dnd7a5mdalc034brsnf1vish";
+       version = "1.0.2.0";
+       sha256 = "1vrw60az8jb3m9kk2vsn1v5l68jmwxsfw3p7lfwl9a8d4gk5m1gp";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          aeson aeson-qq attoparsec base base-compat blaze-markup bytestring
-         containers data-default either errors html-conduit lens-aeson
-         network-uri pcre-heavy safe tagsoup text time transformers
-         unordered-containers vector xml-lens xss-sanitize
+         case-insensitive containers data-default either errors html-conduit
+         lens lens-aeson network-uri pcre-heavy safe tagsoup text time
+         transformers unordered-containers vector xml-lens xss-sanitize
        ];
        executableHaskellDepends = [
-         aeson aeson-pretty base base-compat blaze-html blaze-markup
-         data-default network network-uri options scotty text wai-cli
-         wai-extra
+         aeson aeson-pretty aws-lambda-haskell-runtime
+         aws-lambda-haskell-runtime-wai base base-compat blaze-html
+         blaze-markup data-default githash network network-uri options
+         scotty text wai wai-cli wai-extra
        ];
        testHaskellDepends = [
          aeson-qq base base-compat bytestring data-default hspec
···
        description = "A Microformats 2 parser";
        license = lib.licenses.publicDomain;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "microformats2-types" = callPackage
···
        pname = "nvim-hs";
        version = "2.1.0.4";
        sha256 = "0bg94adja6xvzlv1x849nrfpb0i5mjbp19f9cwhaa4iw1qs532rf";
-       revision = "1";
-       editedCabalFile = "0yzdq8nxf2n7n4ns6frgl5nhgb3vj3nkh7336mz994iydam17wcl";
+       revision = "2";
+       editedCabalFile = "0bd90ndkk4lll4rvr87b9vil2h8jlchkh1fag1nrhj90lnczgpnl";
        libraryHaskellDepends = [
          base bytestring cereal cereal-conduit conduit containers
          data-default deepseq foreign-store hslogger megaparsec messagepack
···
        testToolDepends = [ hspec-discover ];
        description = "Haskell plugin backend for neovim";
        license = lib.licenses.asl20;
+     }) {};
+
+  "nvim-hs_2_1_0_5" = callPackage
+    ({ mkDerivation, base, bytestring, cereal, cereal-conduit, conduit
+     , containers, data-default, deepseq, foreign-store, hslogger, hspec
+     , hspec-discover, HUnit, megaparsec, messagepack, mtl, network
+     , optparse-applicative, path, path-io, prettyprinter
+     , prettyprinter-ansi-terminal, QuickCheck, resourcet, stm
+     , streaming-commons, template-haskell, text, time
+     , time-locale-compat, transformers, transformers-base
+     , typed-process, unliftio, unliftio-core, utf8-string, vector, void
+     }:
+     mkDerivation {
+       pname = "nvim-hs";
+       version = "2.1.0.5";
+       sha256 = "11ld5bgrica3ma54f7x37hcbcl0ms3x6gi0326by3jsnskxplz0z";
+       libraryHaskellDepends = [
+         base bytestring cereal cereal-conduit conduit containers
+         data-default deepseq foreign-store hslogger megaparsec messagepack
+         mtl network optparse-applicative path path-io prettyprinter
+         prettyprinter-ansi-terminal resourcet stm streaming-commons
+         template-haskell text time time-locale-compat transformers
+         transformers-base typed-process unliftio unliftio-core utf8-string
+         vector void
+       ];
+       testHaskellDepends = [
+         base bytestring cereal cereal-conduit conduit containers
+         data-default foreign-store hslogger hspec hspec-discover HUnit
+         megaparsec messagepack mtl network optparse-applicative path
+         path-io prettyprinter prettyprinter-ansi-terminal QuickCheck
+         resourcet stm streaming-commons template-haskell text time
+         time-locale-compat transformers transformers-base typed-process
+         unliftio unliftio-core utf8-string vector
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "Haskell plugin backend for neovim";
+       license = lib.licenses.asl20;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "nvim-hs-contrib" = callPackage
···
      }) {};
 
   "optparse-declarative" = callPackage
-    ({ mkDerivation, base, mtl }:
+    ({ mkDerivation, base, exceptions, mtl }:
      mkDerivation {
        pname = "optparse-declarative";
-       version = "0.4.1";
-       sha256 = "0paa7r64y0nb9yv3x387pdid68lnc1gn2m28kcli55dvh1x4wwxr";
-       libraryHaskellDepends = [ base mtl ];
+       version = "0.4.2";
+       sha256 = "0a8b4aa5zvj36nj81kfylxcqfp9ahi5lnak61wvwv9bw68r2a2jn";
+       libraryHaskellDepends = [ base exceptions mtl ];
        description = "Declarative command line option parser";
        license = lib.licenses.mit;
      }) {};
···
        testHaskellDepends = [ base bytestring directory ];
        description = "Simple interface to optparse-applicative";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "optparse-simple_0_1_1_4" = callPackage
+    ({ mkDerivation, base, bytestring, directory, githash
+     , optparse-applicative, template-haskell, th-compat, transformers
+     }:
+     mkDerivation {
+       pname = "optparse-simple";
+       version = "0.1.1.4";
+       sha256 = "0y3qgab8csiwyv60cnpzpv65n3c0ikvdx5b5mfkfahkv8xfdh08x";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base githash optparse-applicative template-haskell th-compat
+         transformers
+       ];
+       testHaskellDepends = [ base bytestring directory ];
+       description = "Simple interface to optparse-applicative";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "optparse-text" = callPackage
···
        maintainers = with lib.maintainers; [ peti ];
      }) {};
 
+  "pandoc_2_14_0_3" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
+     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
+     , case-insensitive, citeproc, commonmark, commonmark-extensions
+     , commonmark-pandoc, connection, containers, data-default, deepseq
+     , Diff, directory, doclayout, doctemplates, emojis, exceptions
+     , file-embed, filepath, Glob, haddock-library, hslua
+     , hslua-module-path, hslua-module-system, hslua-module-text, HsYAML
+     , HTTP, http-client, http-client-tls, http-types, ipynb
+     , jira-wiki-markup, JuicyPixels, mtl, network, network-uri
+     , pandoc-types, parsec, process, QuickCheck, random, safe
+     , scientific, SHA, skylighting, skylighting-core, split, syb
+     , tagsoup, tasty, tasty-bench, tasty-golden, tasty-hunit, tasty-lua
+     , tasty-quickcheck, temporary, texmath, text, text-conversions
+     , time, unicode-collation, unicode-transforms, unix
+     , unordered-containers, xml, xml-conduit, zip-archive, zlib
+     }:
+     mkDerivation {
+       pname = "pandoc";
+       version = "2.14.0.3";
+       sha256 = "1pgd6125mrvzj2faxbsfmackb7kchzcr6bjkrwqbyn9hzxdzbqw2";
+       configureFlags = [ "-fhttps" "-f-trypandoc" ];
+       isLibrary = true;
+       isExecutable = true;
+       enableSeparateDataOutput = true;
+       libraryHaskellDepends = [
+  "jira-wiki-markup" = callPackage
+         blaze-html blaze-markup bytestring case-insensitive citeproc
+         commonmark commonmark-extensions commonmark-pandoc connection
+         containers data-default deepseq directory doclayout doctemplates
+         emojis exceptions file-embed filepath Glob haddock-library hslua
+         hslua-module-path hslua-module-system hslua-module-text HsYAML HTTP
+         http-client http-client-tls http-types ipynb jira-wiki-markup
+         JuicyPixels mtl network network-uri pandoc-types parsec process
+         random safe scientific SHA skylighting skylighting-core split syb
+         tagsoup temporary texmath text text-conversions time
+         unicode-collation unicode-transforms unix unordered-containers xml
+         xml-conduit zip-archive zlib
+       ];
+       executableHaskellDepends = [ base ];
+       testHaskellDepends = [
+         base bytestring containers Diff directory doctemplates exceptions
+         filepath Glob hslua mtl pandoc-types process QuickCheck tasty
+         tasty-golden tasty-hunit tasty-lua tasty-quickcheck text time xml
+         zip-archive
+       ];
+       benchmarkHaskellDepends = [
+         base bytestring containers deepseq mtl tasty-bench text time
+       ];
+       postInstall = ''
+         mkdir -p $out/share/man/man1
+         mv "man/"*.1 $out/share/man/man1/
+       '';
+       description = "Conversion between markup formats";
+       license = lib.licenses.gpl2Plus;
+       hydraPlatforms = lib.platforms.none;
+       maintainers = with lib.maintainers; [ peti ];
+     }) {};
+
   "pandoc-citeproc" = callPackage
     ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
      , Cabal, containers, data-default, directory, filepath, hs-bibutils
···
     ({ mkDerivation, base }:
      mkDerivation {
        pname = "parsec1";
-       version = "1.0.0.7";
-       sha256 = "1v9kq4g378v8pkj8ldpqwh9dwlng5idbxqqb8ywmzdjnglih34rf";
+       version = "1.0.0.8";
+       sha256 = "02zagbrn4w6gjl9awh4si5b6ia14p4rx22cssd03zx4ddb8kcwf7";
        libraryHaskellDepends = [ base ];
        description = "Portable monadic parser combinators";
        license = lib.licenses.bsd3;
···
        maintainers = with lib.maintainers; [ psibi ];
      }) {};
 
-  "persistent_2_13_0_3" = callPackage
+  "persistent_2_13_0_4" = callPackage
     ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
      , blaze-html, bytestring, conduit, containers, criterion, deepseq
      , fast-logger, file-embed, hspec, http-api-data, lift-type
···
      }:
      mkDerivation {
        pname = "persistent";
-       version = "2.13.0.3";
-       sha256 = "0jlrkyy10cz6rq47r75q9l5ycyrdjwxs810x7v5ijrimdd9cv24d";
+       version = "2.13.0.4";
+       sha256 = "04q4x50p2jpsp7fzrb61rs225hnrl8n1khmdvf0z6inkwq462w6a";
        libraryHaskellDepends = [
          aeson attoparsec base base64-bytestring blaze-html bytestring
          conduit containers fast-logger http-api-data lift-type monad-logger
···
        ];
        description = "run a subprocess, combining stdout and stderr";
        license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "plist" = callPackage
···
      }:
      mkDerivation {
        pname = "ploterific";
-       version = "0.2.1.2";
-       sha256 = "1ywg09amxngan23c5724c5s2s79yhynqha6c5xivg1ls58nc7yk5";
+       version = "0.2.1.3";
+       sha256 = "0ggi653hjg9s3v9zqsapm3ryb37hfdbw21pznhsvzhyy3n0fv7jv";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        hydraPlatforms = lib.platforms.none;
      }) {};
 
+  "polysemy-readline" = callPackage
+    ({ mkDerivation, base, exceptions, haskeline, polysemy
+     , polysemy-plugin
+     }:
+     mkDerivation {
+       pname = "polysemy-readline";
+       version = "0.1.0.0";
+       sha256 = "19nic0n5k3r5qbmhnrzwrkncj61ba43qmg86mx0y190mvx540yz1";
+       libraryHaskellDepends = [
+         base exceptions haskeline polysemy polysemy-plugin
+       ];
+       testHaskellDepends = [
+         base exceptions haskeline polysemy polysemy-plugin
+       ];
+       description = "Readline effect for polysemy";
+       license = lib.licenses.bsd2;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "polysemy-resume" = callPackage
     ({ mkDerivation, base, hedgehog, polysemy, polysemy-plugin
      , polysemy-test, relude, tasty, tasty-hedgehog, text, transformers
···
      , filepath, hashable, html-entities, http-conduit, HUnit
      , lifted-base, mmorph, mtl, network-uri, parsec, parsers
      , QuickCheck, safe, selective, tasty, tasty-hunit, tasty-quickcheck
-     , text, unordered-containers, xeno
+     , template-haskell, temporary, text, unordered-containers, xeno
      }:
      mkDerivation {
        pname = "rdf4h";
-       version = "4.0.2";
-       sha256 = "1gkz1i1v2509aa5c9jp2lgmsnnsr7d1314gq3xmcs21dfgf7xibw";
+       version = "5.0.1";
+       sha256 = "0i6sza600fzrk92pp9qc4ji361js5adg7ijf30hb9fdl854hjgk9";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
          algebraic-graphs attoparsec base binary bytestring containers
          deepseq exceptions filepath hashable html-entities http-conduit
-         lifted-base mmorph mtl network-uri parsec parsers selective text
-         unordered-containers xeno
+         lifted-base mmorph mtl network-uri parsec parsers selective
+         template-haskell text unordered-containers xeno
        ];
        executableHaskellDepends = [ base containers text ];
        testHaskellDepends = [
-         base containers directory filepath HUnit QuickCheck safe tasty
-         tasty-hunit tasty-quickcheck text
+         base bytestring containers directory filepath HUnit QuickCheck safe
+         tasty tasty-hunit tasty-quickcheck temporary text
        ];
        benchmarkHaskellDepends = [ base criterion deepseq text ];
        description = "A library for RDF processing in Haskell";
···
        description = "Robert Fischer's Common library";
        license = lib.licenses.bsd3;
        hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "rfc-env" = callPackage
···
      }:
      mkDerivation {
        pname = "rio-process-pool";
-       version = "1.0.0";
-       sha256 = "09v95wyrsa6yg5q5zaf9gqmn2xhh1i1q2mmxq52xhpc8pqwj93b9";
+       version = "1.0.1";
+       sha256 = "1r3w7p9yf2k2czdwm739y191x25ravbsn948wwgqxsqamsqs7l18";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        testToolDepends = [ hspec-discover ];
        description = "A family of combinators for defining webservices APIs";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "servant_0_18_3" = callPackage
+    ({ mkDerivation, aeson, attoparsec, base, base-compat, bifunctors
+     , bytestring, case-insensitive, deepseq, hspec, hspec-discover
+     , http-api-data, http-media, http-types, mmorph, mtl, network-uri
+     , QuickCheck, quickcheck-instances, singleton-bool, sop-core
+     , string-conversions, tagged, text, transformers, vault
+     }:
+     mkDerivation {
+       pname = "servant";
+       version = "0.18.3";
+       sha256 = "033ykm8l7a9bjcwb3v9d0ljglq1sxpjm1iss7nqakpyxljcg2sxp";
+       libraryHaskellDepends = [
+         aeson attoparsec base base-compat bifunctors bytestring
+         case-insensitive deepseq http-api-data http-media http-types mmorph
+         mtl network-uri QuickCheck singleton-bool sop-core
+         string-conversions tagged text transformers vault
+       ];
+       testHaskellDepends = [
+         aeson base base-compat bytestring hspec http-media mtl QuickCheck
+         quickcheck-instances string-conversions text transformers
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A family of combinators for defining webservices APIs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-JuicyPixels" = callPackage
···
      }:
      mkDerivation {
        pname = "servant-JuicyPixels";
-       version = "0.3.0.6";
-       sha256 = "16bdlgrz71h03lr2xcd2isclfzgr9h2xdl5lbnbs0v1czaxx7m6h";
+       version = "0.3.1.0";
+       sha256 = "1mi9b84myy3sg35xxrna5pwjwkn51v0xsd300ssvy8xaj4k96wjk";
        isLibrary = true;
        isExecutable = true;
        libraryHaskellDepends = [
···
        pname = "servant-auth";
        version = "0.4.0.0";
        sha256 = "0v2g80kakjwpws92bk3anzy4k8vgxq99y7g3ib4amc5x6kxcmjh1";
-       revision = "2";
-       editedCabalFile = "0mbx44l1jnvfvppv6diiixqx5rdkb68djxl36m5sd12qz6rqmcx0";
+       revision = "3";
+       editedCabalFile = "1hq0mz4fm2f6v57jzyahk5wfip285v3yh20dawvmwdh7wq6104zr";
        libraryHaskellDepends = [
          aeson base jose lens servant text unordered-containers
        ];
···
        pname = "servant-auth-client";
        version = "0.4.1.0";
        sha256 = "16rmwdrx0qyqa821ipayczzl3gv8gvqgx8k9q8qaw19w87hwkh83";
-       revision = "1";
-       editedCabalFile = "0q7bazq4ilijclpz23fshpjcspnrfalh7jhqi5gg03m00wwibn4n";
+       revision = "2";
+       editedCabalFile = "0mq9nhrlh44jxkngj06pasrrjzv5193lj6d2szprnncgrk36zi31";
        libraryHaskellDepends = [
          base bytestring containers servant servant-auth servant-client-core
        ];
···
        pname = "servant-auth-docs";
        version = "0.2.10.0";
        sha256 = "0j1ynnrb6plrhpb2vzs2p7a9jb41llp0j1jwgap7hjhkwhyc7wxd";
-       revision = "7";
-       editedCabalFile = "10178ahxq36l9mik7dcn1c1f97fpp8b4r7xiqwiv21llp95s7cqp";
+       revision = "8";
+       editedCabalFile = "01mb003lajxs1x82k20dbnxzdvxdla51vi4dh4f0a1xycvyhfpyi";
        setupHaskellDepends = [ base Cabal cabal-doctest ];
        libraryHaskellDepends = [
          base lens servant servant-auth servant-docs text
···
        pname = "servant-auth-server";
        version = "0.4.6.0";
        sha256 = "0isl9pzzhfbs8pgh3qr2vbgfp0bh741dfa59sq7n3cmbkc6ndpkk";
-       revision = "2";
-       editedCabalFile = "1vf0mnbq0wmwha3aa2fn593dwibaw00l4agspgvchx7574jyr5wp";
+       revision = "3";
+       editedCabalFile = "0iasfns12wab45hf4qkwm5bx1z63ass9n5sh926wnn82g1v6qdyw";
        libraryHaskellDepends = [
          aeson base base64-bytestring blaze-builder bytestring
          case-insensitive cookie data-default-class entropy http-types jose
···
        pname = "servant-auth-swagger";
        version = "0.2.10.1";
        sha256 = "029nvb4wxwl98ah26bgcq1b7izrnvssxwn1682liimvsh4a8bady";
-       revision = "2";
-       editedCabalFile = "0b8fawx2wv9zshn9i4abnwy4lgf3fkhbhm8bhfpgm9d867dx21y4";
+       revision = "3";
+       editedCabalFile = "1hkszdp7c7c34b2yp2gb7khzlzq8iw5ma066r30kq2nw5jj895k0";
        libraryHaskellDepends = [
          base lens servant servant-auth servant-swagger swagger2 text
        ];
···
        testToolDepends = [ hspec-discover markdown-unlit ];
        description = "Automatic derivation of querying functions for servant";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "servant-client_0_18_3" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, bytestring, containers
+     , deepseq, entropy, exceptions, hspec, hspec-discover
+     , http-api-data, http-client, http-media, http-types, HUnit
+     , kan-extensions, markdown-unlit, monad-control, mtl, network
+     , QuickCheck, semigroupoids, servant, servant-client-core
+     , servant-server, sop-core, stm, tdigest, text, time, transformers
+     , transformers-base, transformers-compat, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-client";
+       version = "0.18.3";
+       sha256 = "0ddn7x9z2znkkyn6l2x6a85vq673q4vppr0q9n56ibvl3k3saxj0";
+       libraryHaskellDepends = [
+         base base-compat bytestring containers deepseq exceptions
+         http-client http-media http-types kan-extensions monad-control mtl
+         semigroupoids servant servant-client-core stm text time
+         transformers transformers-base transformers-compat
+       ];
+       testHaskellDepends = [
+         aeson base base-compat bytestring entropy hspec http-api-data
+         http-client http-types HUnit kan-extensions markdown-unlit mtl
+         network QuickCheck servant servant-client-core servant-server
+         sop-core stm tdigest text transformers transformers-compat wai warp
+       ];
+       testToolDepends = [ hspec-discover markdown-unlit ];
+       description = "Automatic derivation of querying functions for servant";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-client-core" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-client-core_0_18_3" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, base64-bytestring
+     , bytestring, containers, deepseq, exceptions, free, hspec
+     , hspec-discover, http-media, http-types, network-uri, QuickCheck
+     , safe, servant, sop-core, template-haskell, text, transformers
+     }:
+     mkDerivation {
+       pname = "servant-client-core";
+       version = "0.18.3";
+       sha256 = "1iln4axymmmk3ib0wxmpzjgq16lip8nz7xich3ysgzx6g2n15xsd";
+       libraryHaskellDepends = [
+         aeson base base-compat base64-bytestring bytestring containers
+         deepseq exceptions free http-media http-types network-uri safe
+         servant sop-core template-haskell text transformers
+       ];
+       testHaskellDepends = [ base base-compat deepseq hspec QuickCheck ];
+       testToolDepends = [ hspec-discover ];
+       description = "Core functionality and class for client function generation for servant APIs";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-client-js" = callPackage
     ({ mkDerivation, base, binary, bytestring, case-insensitive
      , containers, exceptions, http-media, http-types, jsaddle
···
        pname = "servant-conduit";
        version = "0.15.1";
        sha256 = "1vy3ihypb0zm2yd16rq120qw3898i3c0mahh2jysssv65g0avdwp";
+       revision = "1";
+       editedCabalFile = "0j7jrwyj6vnfr8wyyzjjm6gakx401aylrq8shc2y9ciy0mhf8lrv";
        libraryHaskellDepends = [
          base bytestring conduit mtl resourcet servant unliftio-core
        ];
···
        ];
        description = "generate API docs for your servant webservice";
        license = lib.licenses.bsd3;
+     }) {};
+
+  "servant-docs_0_11_9" = callPackage
+    ({ mkDerivation, aeson, aeson-pretty, base, base-compat, bytestring
+     , case-insensitive, hashable, http-media, http-types, lens, servant
+     , string-conversions, tasty, tasty-golden, tasty-hunit, text
+     , transformers, universe-base, unordered-containers
+     }:
+     mkDerivation {
+       pname = "servant-docs";
+       version = "0.11.9";
+       sha256 = "0ynjyyxlzb2j5d92rryqqa97rp16582mbmvnv7syczha5ziq24nk";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         aeson aeson-pretty base base-compat bytestring case-insensitive
+         hashable http-media http-types lens servant string-conversions text
+         universe-base unordered-containers
+       ];
+       executableHaskellDepends = [
+         aeson base lens servant string-conversions text
+       ];
+       testHaskellDepends = [
+         aeson base base-compat lens servant string-conversions tasty
+         tasty-golden tasty-hunit transformers
+       ];
+       description = "generate API docs for your servant webservice";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "servant-docs-simple" = callPackage
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-foreign_0_15_4" = callPackage
+    ({ mkDerivation, base, base-compat, hspec, hspec-discover
+     , http-types, lens, servant, text
+     }:
+     mkDerivation {
+       pname = "servant-foreign";
+       version = "0.15.4";
+       sha256 = "0bznb73rbgfgkg7n4pxghkqsfca0yw9vak73c6w8sqvc2mjnc7mz";
+       libraryHaskellDepends = [
+         base base-compat http-types lens servant text
+       ];
+       testHaskellDepends = [ base hspec servant ];
+       testToolDepends = [ hspec-discover ];
+       description = "Helpers for generating clients for servant APIs in any programming language";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-gdp" = callPackage
     ({ mkDerivation, aeson, base, gdp, servant-server, text }:
      mkDerivation {
···
        broken = true;
      }) {};
 
+  "servant-http-streams_0_18_3" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, bytestring
+     , case-insensitive, containers, deepseq, entropy, exceptions, hspec
+     , hspec-discover, http-api-data, http-common, http-media
+     , http-streams, http-types, HUnit, io-streams, kan-extensions
+     , markdown-unlit, monad-control, mtl, network, QuickCheck
+     , semigroupoids, servant, servant-client-core, servant-server, stm
+     , tdigest, text, time, transformers, transformers-base
+     , transformers-compat, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-http-streams";
+       version = "0.18.3";
+       sha256 = "0cc4qmbzq4n1yp5yfg76w1skkksh13qlbza9i2pgsxa9sc39s5fa";
+       libraryHaskellDepends = [
+         base base-compat bytestring case-insensitive containers deepseq
+         exceptions http-common http-media http-streams http-types
+         io-streams kan-extensions monad-control mtl semigroupoids servant
+         servant-client-core text time transformers transformers-base
+         transformers-compat
+       ];
+       testHaskellDepends = [
+         aeson base base-compat bytestring deepseq entropy hspec
+         http-api-data http-streams http-types HUnit kan-extensions
+         markdown-unlit mtl network QuickCheck servant servant-client-core
+         servant-server stm tdigest text transformers transformers-compat
+         wai warp
+       ];
+       testToolDepends = [ hspec-discover markdown-unlit ];
+       description = "Automatic derivation of querying functions for servant";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
+     }) {};
+
   "servant-http2-client" = callPackage
     ({ mkDerivation, aeson, async, base, binary, bytestring
      , case-insensitive, containers, data-default-class, exceptions
···
        pname = "servant-machines";
        version = "0.15.1";
        sha256 = "0k8abcc72s5bzcf2vmjkxxjnhk45rww6hr3l93msm2510hi6gda4";
+       revision = "1";
+       editedCabalFile = "0zplgs1kqfmnnx8yv8ay594misiamgmvy41b8w1h3mr7n4vrgk8j";
        libraryHaskellDepends = [ base bytestring machines mtl servant ];
        testHaskellDepends = [
          base base-compat bytestring http-client http-media machines servant
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-pipes_0_15_3" = callPackage
+    ({ mkDerivation, base, base-compat, bytestring, http-client
+     , http-media, monad-control, mtl, pipes, pipes-bytestring
+     , pipes-safe, servant, servant-client, servant-server, wai, warp
+     }:
+     mkDerivation {
+       pname = "servant-pipes";
+       version = "0.15.3";
+       sha256 = "1sd01f95rkraa0zdqqg2vwx91zsih0i0hqqkz55nnw9bsbsqhq1n";
+       libraryHaskellDepends = [
+         base bytestring monad-control mtl pipes pipes-safe servant
+       ];
+       testHaskellDepends = [
+         base base-compat bytestring http-client http-media pipes
+         pipes-bytestring pipes-safe servant servant-client servant-server
+         wai warp
+       ];
+       description = "Servant Stream support for pipes";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-polysemy" = callPackage
     ({ mkDerivation, base, deepseq, http-client, http-client-tls, lens
      , mtl, polysemy, polysemy-plugin, polysemy-zoo, servant
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "servant-server_0_18_3" = callPackage
+    ({ mkDerivation, aeson, base, base-compat, base64-bytestring
+     , bytestring, containers, directory, exceptions, filepath, hspec
+     , hspec-discover, hspec-wai, http-api-data, http-media, http-types
+     , monad-control, mtl, network, network-uri, QuickCheck, resourcet
+     , safe, servant, should-not-typecheck, sop-core, string-conversions
+     , tagged, temporary, text, transformers, transformers-base
+     , transformers-compat, wai, wai-app-static, wai-extra, warp, word8
+     }:
+     mkDerivation {
+       pname = "servant-server";
+       version = "0.18.3";
+       sha256 = "1gng0in85as45aprwy19xaqlgmwfx0pkly150d2v96knhbcwsshk";
+       isLibrary = true;
+       isExecutable = true;
+       libraryHaskellDepends = [
+         base base-compat base64-bytestring bytestring containers exceptions
+         filepath http-api-data http-media http-types monad-control mtl
+         network network-uri resourcet servant sop-core string-conversions
+         tagged text transformers transformers-base wai wai-app-static word8
+       ];
+       executableHaskellDepends = [
+         aeson base base-compat servant text wai warp
+       ];
+       testHaskellDepends = [
+         aeson base base-compat base64-bytestring bytestring directory hspec
+         hspec-wai http-types mtl QuickCheck resourcet safe servant
+         should-not-typecheck sop-core string-conversions temporary text
+         transformers transformers-compat wai wai-extra
+       ];
+       testToolDepends = [ hspec-discover ];
+       description = "A family of combinators for defining webservices APIs and serving them";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "servant-server-namedargs" = callPackage
     ({ mkDerivation, base, bytestring, http-api-data, http-types, named
      , servant, servant-namedargs, servant-server, string-conversions
···
        license = lib.licenses.bsd3;
      }) {};
 
+  "streaming-bytestring_0_2_1" = callPackage
+    ({ mkDerivation, base, bytestring, deepseq, exceptions, ghc-prim
+     , mmorph, mtl, resourcet, smallcheck, streaming, tasty, tasty-hunit
+     , tasty-smallcheck, transformers, transformers-base
+     }:
+     mkDerivation {
+       pname = "streaming-bytestring";
+       version = "0.2.1";
+       sha256 = "1yri2g0wx2fila25ang04nsv4i12b4yhwqwcfkkpx1sz8fhzibxy";
+       libraryHaskellDepends = [
+         base bytestring deepseq exceptions ghc-prim mmorph mtl resourcet
+         streaming transformers transformers-base
+       ];
+       testHaskellDepends = [
+         base bytestring resourcet smallcheck streaming tasty tasty-hunit
+         tasty-smallcheck transformers
+       ];
+       description = "Fast, effectful byte streams";
+       license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "streaming-cassava" = callPackage
     ({ mkDerivation, base, bytestring, cassava, hspec, mtl, QuickCheck
      , quickcheck-instances, streaming, streaming-bytestring, text
···
      }:
      mkDerivation {
        pname = "stripeapi";
-       version = "0.1.0.2";
-       sha256 = "1zls2k2bzrkwcqav8s416gjsc4rp6glb4rv0ljkjab55ym3fkbqq";
+       version = "1.0.0.0";
+       sha256 = "0wg3b08gvkcqinc5r9jcrcfrgw0c3mh57ca5hzcrknddwd23flbj";
        libraryHaskellDepends = [
          aeson base bytestring ghc-prim http-client http-conduit http-types
          mtl scientific text time transformers unordered-containers vector
···
      }:
      mkDerivation {
        pname = "swiss-ephemeris";
-       version = "1.2.1.1";
-       sha256 = "1k584gv36xgj87qbrvcl5w9v8z2k7y4csmz737d5r2a8mvf8sf33";
+       version = "1.3.0.1";
+       sha256 = "1y30qx18ps412r28grlxpfxw3ikirbf3kkxmqwd75ydxp9apn52k";
        libraryHaskellDepends = [ base ];
        testHaskellDepends = [ base directory hspec QuickCheck ];
        testToolDepends = [ hspec-discover ];
        description = "Haskell bindings for the Swiss Ephemeris C library";
-       license = lib.licenses.gpl2Only;
+       license = lib.licenses.agpl3Only;
        hydraPlatforms = lib.platforms.none;
        broken = true;
      }) {};
···
        license = lib.licenses.mit;
      }) {};
 
+  "tasty-bench_0_3" = callPackage
+    ({ mkDerivation, base, containers, deepseq, tasty }:
+     mkDerivation {
+       pname = "tasty-bench";
+       version = "0.3";
+       sha256 = "06c7n1dslxr1m15m8kf35zfn544jm36vk8s3yfrf6h047gd1bs2k";
+       libraryHaskellDepends = [ base containers deepseq tasty ];
+       description = "Featherlight benchmark framework";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "tasty-checklist" = callPackage
     ({ mkDerivation, base, exceptions, parameterized-utils, tasty
      , tasty-expected-failure, tasty-hunit, text
···
        pname = "tasty-json";
        version = "0.1.0.0";
        sha256 = "0k6zzi2w675pghxfv5y6m67n2cv8bb22dq9zgb5yfwycfj3va4bp";
+       revision = "1";
+       editedCabalFile = "0jk27ld4l435nnzc80wg6b46ibmc0cmbb0k3hpp58yxbyldr6xdr";
        libraryHaskellDepends = [
          base bytestring containers stm tagged tasty text
        ];
···
        pname = "tasty-wai";
        version = "0.1.1.1";
        sha256 = "1bnq2mbgv1ksn9sq33dq1q91pzndy7gn61mlnkybk89k0bsw5i7y";
-       revision = "1";
-       editedCabalFile = "033s0aap50r7y3sbxc1jf60lpv66nljwyypc8smyccgiv5l8khzr";
+       revision = "2";
+       editedCabalFile = "13f0rmdyfd8wx9w9d6vj40akskq763gjj89p7dzy6zyaiyllgk64";
        libraryHaskellDepends = [
          base bytestring http-types HUnit tasty wai wai-extra
        ];
···
        license = lib.licenses.mit;
      }) {};
 
+  "template-haskell-compat-v0208_0_1_6" = callPackage
+    ({ mkDerivation, base, template-haskell }:
+     mkDerivation {
+       pname = "template-haskell-compat-v0208";
+       version = "0.1.6";
+       sha256 = "1s2ba86y2r9n4r1dwfg734y3nfqxak560s8srd04kbn623hnrkw8";
+       libraryHaskellDepends = [ base template-haskell ];
+       description = "A backwards compatibility layer for Template Haskell newer than 2.8";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "template-haskell-optics" = callPackage
     ({ mkDerivation, base, containers, optics-core, template-haskell }:
      mkDerivation {
···
        pname = "texrunner";
        version = "0.0.1.2";
        sha256 = "1fxyxwgvn0rxhkl1fs2msr88jqwx5wwfnjsjlcankrwcn7gyk7jy";
-       revision = "2";
-       editedCabalFile = "0zv8xp8z2gx9zjqn1f81hri4hn0bws7cq39g5i2g2axrkm9nwj5q";
+       revision = "3";
+       editedCabalFile = "1l3cpi7yx8jm3653rf3v7midf19i7khc6in75m7zz66124c6i350";
        libraryHaskellDepends = [
          attoparsec base bytestring directory filepath io-streams mtl
          process semigroups temporary
···
        license = lib.licenses.mit;
      }) {};
 
+  "ttc_1_1_0_1" = callPackage
+    ({ mkDerivation, base, bytestring, tasty, tasty-hunit
+     , template-haskell, text
+     }:
+     mkDerivation {
+       pname = "ttc";
+       version = "1.1.0.1";
+       sha256 = "0vngp6md5viz4r57q0qn3pf09ph6kpkzvdigsxmgqcic2ha1a4n1";
+       libraryHaskellDepends = [ base bytestring template-haskell text ];
+       testHaskellDepends = [
+         base bytestring tasty tasty-hunit template-haskell text
+       ];
+       description = "Textual Type Classes";
+       license = lib.licenses.mit;
+       hydraPlatforms = lib.platforms.none;
+     }) {};
+
   "ttl-hashtables" = callPackage
     ({ mkDerivation, base, clock, containers, data-default, failable
      , hashable, hashtables, hspec, mtl, transformers
···
        ];
        description = "An equational theorem prover";
        license = lib.licenses.bsd3;
+       hydraPlatforms = lib.platforms.none;
+       broken = true;
      }) {};
 
   "twee-lib" = callPackage
···
 
   "wai-cli" = callPackage
     ({ mkDerivation, ansi-terminal, base, http-types, iproute
-     , monads-tf, network, options, socket-activation, stm
-     , streaming-commons, unix, wai, wai-extra, warp, warp-tls
+     , monads-tf, network, options, stm, streaming-commons, transformers
+     , unix, wai, wai-extra, warp, warp-tls
      }:
      mkDerivation {
        pname = "wai-cli";
-       version = "0.2.1";
-       sha256 = "1r4lxbjzb5qzn7y0kanlgm8s9a3j1j93cvs74s2bmcc82ysc3x9f";
-       revision = "1";
-       editedCabalFile = "1h0ip8r0zdm0xzaprfiyfdm40286apyvn6psqnx7pif8acfhpq8m";
+       version = "0.2.3";
+       sha256 = "0fflvxfc9ibkrrgqdsr89gl77b0b706a8g7ylydaqqz6z089qbi3";
        libraryHaskellDepends = [
-         ansi-terminal base http-types iproute monads-tf network options
-         socket-activation stm streaming-commons unix wai wai-extra warp
-         warp-tls
+         ansi-terminal base http-types iproute monads-tf network options stm
+         streaming-commons transformers unix wai wai-extra warp warp-tls
        ];
        description = "Command line runner for Wai apps (using Warp) with TLS, CGI, socket activation & graceful shutdown";
        license = lib.licenses.publicDomain;
-       hydraPlatforms = lib.platforms.none;
      }) {};
 
   "wai-conduit" = callPackage
···
      }:
      mkDerivation {
        pname = "yaml-unscrambler";
-       version = "0.1.0.2";
-       sha256 = "03wvb5skx41kdmdc6zhydr7zddzyshy2cgk8zmwy26q70z3g01zf";
+       version = "0.1.0.3";
+       sha256 = "1n8q5dsvs6sh2gzs24m49cz5pg1pavn9sma4fk5jizrjrabik4sj";
        libraryHaskellDepends = [
          acc attoparsec attoparsec-data attoparsec-time base base64
          bytestring conduit containers foldl hashable libyaml mtl scientific
···
     ({ mkDerivation, base, hspec, Z-Data, Z-IO, zookeeper_mt }:
      mkDerivation {
        pname = "zoovisitor";
-       version = "0.1.1.1";
-       sha256 = "1mg3wz3drddxdrbr1b0yw5wayzqi99zfdlgiwvgcc5pxb98i6wk3";
+       version = "0.1.2.0";
+       sha256 = "0s0svxa7y7a35jg4f0qq6zdg187c2g1s0f3payd26vpwa6rp8f8k";
        libraryHaskellDepends = [ base Z-Data Z-IO ];
        librarySystemDepends = [ zookeeper_mt ];
        testHaskellDepends = [ base hspec ];

pkgs/servers/monitoring/grafana/default.nix

···
 
 buildGoModule rec {
   pname = "grafana";
-  version = "8.0.3";
+  version = "8.0.4";
 
   excludedPackages = [ "release_publisher" ];
 
···
     rev = "v${version}";
     owner = "grafana";
     repo = "grafana";
-    sha256 = "sha256-GGtmsz3c7Q6mEGCJ6cdz2CjOW0ovZZW8j6LMfFgrMZ4=";
+    sha256 = "sha256-I4TUPni2WDdpsV19nltsaF1PugB5SOtQ9Jb0YzWUwFg=";
   };
 
   srcStatic = fetchurl {
     url = "https://dl.grafana.com/oss/release/grafana-${version}.linux-amd64.tar.gz";
-    sha256 = "sha256-2x0FhKinrXAFenJcUDh4Q3RJNBrqixKBNZT7BZNNOj8=";
+    sha256 = "sha256-GUVnw2kKxVfztvfsNMwRLxPTqRYzbxXzoH2GkmZB2JE=";
   };
 
   vendorSha256 = "sha256-x7sSVIim/TOhMTbnRK/fpgxiSRSO8KwGILTE2i1gU3U=";

pkgs/tools/security/gopass/default.nix

···
 
 buildGoModule rec {
   pname = "gopass";
-  version = "1.12.6";
+  version = "1.12.7";
 
   nativeBuildInputs = [ installShellFiles makeWrapper ];
 
···
     owner = "gopasspw";
     repo = pname;
     rev = "v${version}";
-    sha256 = "17y9indpgqqx261bqvckfqq1q2zciahssaalaa5c5hb6bnw5ls52";
+    sha256 = "08mzm03vhc8pqyl17y8dkrcpgy3ckmb84x84b6ap3cja3y8gmj5x";
   };
 
-  vendorSha256 = "106rn0bkvzf2fw21f6wpiya88ysj8sfc2zkkm47iqr23d2202i4b";
+  vendorSha256 = "0ym6f1h51bj3qlzxs936fz3p47l63nad4xckl16m13iy0k7z5flg";
 
   subPackages = [ "." ];