gusb: fixed build, updated to 0.2.4

(cherry picked from commit 0ca664e996)

.gitignore

@@ -10,9 +10,4 @@ result-*
 /doc/manual.pdf
 .version-suffix
 
-.DS_Store
-
-/pkgs/applications/kde-apps-*/tmp/
-/pkgs/development/libraries/kde-frameworks-*/tmp/
-/pkgs/development/libraries/qt-5/*/tmp/
-/pkgs/desktops/plasma-*/tmp/
+.DS_Store

.travis.yml

@@ -1,6 +1,5 @@
 language: python
 python: "3.4"
-sudo: required
 before_install: ./maintainers/scripts/travis-nox-review-pr.sh nix
 install: ./maintainers/scripts/travis-nox-review-pr.sh nox
 script: ./maintainers/scripts/travis-nox-review-pr.sh build

.version

@@ -1 +1 @@
-16.03
+14.12

CONTRIBUTING.md

@@ -1,12 +0,0 @@
-# How to contribute
-
-## Opening issues
-
-* Make sure you have a [GitHub account](https://github.com/signup/free)
-* [Submit an issue](https://github.com/NixOS/nixpkgs/issues) - assuming one does not already exist.
-  * Clearly describe the issue including steps to reproduce when it is a bug.
-  * Include information what version of nixpkgs and Nix are you using (nixos-version or git revision).
-
-## Submitting changes
-
-See the nixpkgs manual for details on how to [Submit changes to nixpkgs](http://hydra.nixos.org/job/nixpkgs/trunk/manual/latest/download-by-type/doc/manual#chap-submitting-changes).

README.md

@@ -1,44 +1,10 @@
-[<img src="http://nixos.org/logo/nixos-hires.png" width="500px" alt="logo" />](https://nixos.org/nixos)
-
-[![Build Status](https://travis-ci.org/NixOS/nixpkgs.svg?branch=master)](https://travis-ci.org/NixOS/nixpkgs)
-[![Issue Stats](http://www.issuestats.com/github/nixos/nixpkgs/badge/pr)](http://www.issuestats.com/github/nixos/nixpkgs)
-[![Issue Stats](http://www.issuestats.com/github/nixos/nixpkgs/badge/issue)](http://www.issuestats.com/github/nixos/nixpkgs)
-
-Nixpkgs is a collection of packages for the [Nix](https://nixos.org/nix/) package
-manager. It is periodically built and tested by the [hydra](http://hydra.nixos.org/)
-build daemon as so-called channels. To get channel information via git, add
-[nixpkgs-channels](https://github.com/NixOS/nixpkgs-channels.git) as a remote:
-
-```
-% git remote add channels git://github.com/NixOS/nixpkgs-channels.git
-```
-
-For stability and maximum binary package support, it is recommended to maintain
-custom changes on top of one of the channels, e.g. `nixos-14.12` for the latest
-release and `nixos-unstable` for the latest successful build of master:
-
-```
-% git remote update channels
-% git rebase channels/nixos-14.12
-```
-
-For pull-requests, please rebase onto nixpkgs `master`.
-
-[NixOS](https://nixos.org/nixos/) linux distribution source code is located inside
-`nixos/` folder.
+Nixpkgs is a collection of packages for [Nix](https://nixos.org/nix/) package
+manager. Nixpkgs also includes [NixOS](https://nixos.org/nixos/) linux distribution source code.
 
 * [NixOS installation instructions](https://nixos.org/nixos/manual/#ch-installation)
-* [Documentation (Nix Expression Language chapter)](https://nixos.org/nix/manual/#ch-expression-language)
 * [Manual (How to write packages for Nix)](https://nixos.org/nixpkgs/manual/)
 * [Manual (NixOS)](https://nixos.org/nixos/manual/)
-* [Continuous package builds for unstable/master](https://hydra.nixos.org/jobset/nixos/trunk-combined)
-* [Continuous package builds for 14.12 release](https://hydra.nixos.org/jobset/nixos/release-14.12)
-* [Continuous package builds for 15.09 release](https://hydra.nixos.org/jobset/nixos/release-15.09)
-* [Tests for unstable/master](https://hydra.nixos.org/job/nixos/trunk-combined/tested#tabs-constituents)
-* [Tests for 14.12 release](https://hydra.nixos.org/job/nixos/release-14.12/tested#tabs-constituents)
-* [Tests for 15.09 release](https://hydra.nixos.org/job/nixos/release-15.09/tested#tabs-constituents)
-
-Communication:
-
-* [Mailing list](http://lists.science.uu.nl/mailman/listinfo/nix-dev)
+* [Continuous build](https://hydra.nixos.org/jobset/nixos/trunk-combined)
+* [Tests](https://hydra.nixos.org/job/nixos/trunk-combined/tested#tabs-constituents)
+* [Mailing list](https://lists.science.uu.nl/mailman/listinfo/nix-dev)
 * [IRC - #nixos on freenode.net](irc://irc.freenode.net/#nixos)

default.nix

@@ -1,6 +1,6 @@
-if ! builtins ? nixVersion || builtins.compareVersions "1.8" builtins.nixVersion == 1 then
+if ! builtins ? nixVersion || builtins.compareVersions "1.7" builtins.nixVersion == 1 then
 
-  abort "This version of Nixpkgs requires Nix >= 1.8, please upgrade! See https://nixos.org/wiki/How_to_update_when_nix_is_too_old_to_evaluate_nixpkgs"
+  abort "This version of Nixpkgs requires Nix >= 1.7, please upgrade! See https://nixos.org/wiki/How_to_update_when_nix_is_too_old_to_evaluate_nixpkgs"
 
 else
 

doc/coding-conventions.xml

@@ -5,7 +5,7 @@
 <title>Coding conventions</title>
 
 
-<section xml:id="sec-syntax"><title>Syntax</title>
+<section><title>Syntax</title>
 
 <itemizedlist>
 
@@ -169,8 +169,8 @@ stdenv.mkDerivation { ...
 args: with args; <replaceable>...</replaceable>
 </programlisting>
 
-  or
-
+  or 
+  
 <programlisting>
 { stdenv, fetchurl, perl, ... }: <replaceable>...</replaceable>
 </programlisting>
@@ -207,7 +207,7 @@ args.stdenv.mkDerivation (args // {
 </section>
 
 
-<section xml:id="sec-package-naming"><title>Package naming</title>
+<section><title>Package naming</title>
 
 <para>In Nixpkgs, there are generally three different names associated with a package:
 
@@ -256,12 +256,6 @@ bound to the variable name <varname>e2fsprogs</varname> in
   a package named <literal>hello-svn</literal> by
   <command>nix-env</command>.</para></listitem>
 
-  <listitem><para>If package is fetched from git's commit then
-  the version part of the name <emphasis>must</emphasis> be the date of that 
-  (fetched) commit. The date must be in <literal>"YYYY-MM-DD"</literal> format.
-  Also add <literal>"git"</literal> to the name - e.g.,
-  <literal>"pkgname-git-2014-09-23"</literal>.</para></listitem>
-
   <listitem><para>Dashes in the package name should be preserved
   in new variable names, rather than converted to underscores
   (which was convention up to around 2013 and most names
@@ -292,7 +286,7 @@ dashes between words — not in camel case.  For instance, it should be
 <filename>allPackages.nix</filename> or
 <filename>AllPackages.nix</filename>.</para>
 
-<section xml:id="sec-hierarchy"><title>Hierarchy</title>
+<section><title>Hierarchy</title>
 
 <para>Each package should be stored in its own directory somewhere in
 the <filename>pkgs/</filename> tree, i.e. in
@@ -451,17 +445,12 @@ splitting up an existing category.</para>
     </listitem>
   </varlistentry>
   <varlistentry>
-    <term>If it’s a <emphasis>desktop environment</emphasis>:</term>
+    <term>If it’s a <emphasis>desktop environment</emphasis>
+    (including <emphasis>window managers</emphasis>):</term>
     <listitem>
       <para><filename>desktops</filename> (e.g. <filename>kde</filename>, <filename>gnome</filename>, <filename>enlightenment</filename>)</para>
     </listitem>
   </varlistentry>
-  <varlistentry>
-    <term>If it’s a <emphasis>window manager</emphasis>:</term>
-    <listitem>
-      <para><filename>applications/window-managers</filename> (e.g. <filename>awesome</filename>, <filename>compiz</filename>, <filename>stumpwm</filename>)</para>
-    </listitem>
-  </varlistentry>
   <varlistentry>
     <term>If it’s an <emphasis>application</emphasis>:</term>
     <listitem>
@@ -609,57 +598,6 @@ evaluate correctly.</para>
 </section>
 
 </section>
-<section xml:id="sec-sources"><title>Fetching Sources</title>
-  <para>There are multiple ways to fetch a package source in nixpkgs. The
-    general guidline is that you should package sources with a high degree of
-    availability. Right now there is only one fetcher which has mirroring
-    support and that is <literal>fetchurl</literal>. Note that you should also
-    prefer protocols which have a corresponding proxy environment variable.
-  </para>
-  <para>You can find many source fetch helpers in <literal>pkgs/build-support/fetch*</literal>.
-  </para>
-  <para>In the file <literal>pkgs/top-level/all-packages.nix</literal> you can
-    find fetch helpers, these have names on the form
-    <literal>fetchFrom*</literal>. The intention of these are to provide
-    snapshot fetches but using the same api as some of the version controlled
-    fetchers from <literal>pkgs/build-support/</literal>. As an example going
-    from bad to good:
-    <itemizedlist>
-      <listitem>
-        <para>Uses <literal>git://</literal> which won't be proxied.
-<programlisting>
-src = fetchgit {
-  url = "git://github.com/NixOS/nix.git";
-  rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
-  sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";
-}
-</programlisting>
-        </para>
-      </listitem>
-      <listitem>
-        <para>This is ok, but an archive fetch will still be faster.
-<programlisting>
-src = fetchgit {
-  url = "https://github.com/NixOS/nix.git";
-  rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
-  sha256 = "1cw5fszffl5pkpa6s6wjnkiv6lm5k618s32sp60kvmvpy7a2v9kg";
-}
-</programlisting>
-        </para>
-      </listitem>
-      <listitem>
-        <para>Fetches a snapshot archive and you get the rev you want.
-<programlisting>
-src = fetchFromGitHub {
-  owner = "NixOS";
-  repo = "nix";
-  rev = "1f795f9f44607cc5bec70d1300150bfefcef2aae";
-  sha256 = "04yri911rj9j19qqqn6m82266fl05pz98inasni0vxr1cf1gdgv9";
-}
-</programlisting>
-        </para>
-      </listitem>
-    </itemizedlist>
-  </para>
-</section>
+
+
 </chapter>

doc/contributing.xml

@@ -2,19 +2,18 @@
          xmlns:xlink="http://www.w3.org/1999/xlink"
          xml:id="chap-contributing">
 
-<title>Contributing to this documentation</title>
+<title>Contributing</title>
 
-<para>The DocBook sources of the Nixpkgs manual are in the <filename
-xlink:href="https://github.com/NixOS/nixpkgs/tree/master/doc">doc</filename>
-subdirectory of the Nixpkgs repository. If you make modifications to
-the manual, it's important to build it before committing. You can do that as follows:
+<para>If you make modifications to the manual, it's important to build the manual before contributing:</para>
 
-<screen>
-$ cd /path/to/nixpkgs
-$ nix-build doc
-</screen>
+<orderedlist>
 
-If the build succeeds, the manual will be in
-<filename>./result/share/doc/nixpkgs/manual.html</filename>.</para>
+  <listitem><para><command>$ git clone git://github.com/NixOS/nixpkgs.git</command></para></listitem>
+
+  <listitem><para><command>$ nix-build -A manual nixpkgs/pkgs/top-level/release.nix</command></para></listitem>
+  
+  <listitem><para>Inside the built derivation you shall see <literal>manual/index.html</literal> file.</para></listitem>
+
+</orderedlist>
 
 </chapter>

doc/default.nix

@@ -36,9 +36,6 @@ stdenv.mkDerivation {
 
     cp ${./style.css} $dst/style.css
 
-    mkdir -p $dst/images/callouts
-    cp ${docbook5_xsl}/xml/xsl/docbook/images/callouts/*.gif $dst/images/callouts/
-
     mkdir -p $out/nix-support
     echo "doc manual $dst manual.html" >> $out/nix-support/hydra-build-products
   '';

doc/functions.xml

@@ -1,273 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-	 xmlns:xlink="http://www.w3.org/1999/xlink"
-	 xml:id="chap-functions">
-
-<title>Functions reference</title>
-
-<para>
-  The nixpkgs repository has several utility functions to manipulate Nix expressions.
-</para>
-
-<section xml:id="sec-pkgs-overridePackages">
-  <title>pkgs.overridePackages</title>
-
-  <para>
-    This function inside the nixpkgs expression (<varname>pkgs</varname>)
-    can be used to override the set of packages itself.
-  </para>
-  <para>
-    Warning: this function is expensive and must not be used from within
-    the nixpkgs repository.
-  </para>
-  <para>
-    Example usage:
-
-    <programlisting>let
-  pkgs = import &lt;nixpkgs&gt; {};
-  newpkgs = pkgs.overridePackages (self: super: {
-    foo = super.foo.override { ... };
-  };
-in ...</programlisting>
-  </para>
-
-  <para>
-    The resulting <varname>newpkgs</varname> will have the new <varname>foo</varname>
-    expression, and all other expressions depending on <varname>foo</varname> will also
-    use the new <varname>foo</varname> expression.
-  </para>
-
-  <para>
-    The behavior of this function is similar to <link 
-    linkend="sec-modify-via-packageOverrides">config.packageOverrides</link>.
-  </para>
-
-  <para>
-    The <varname>self</varname> parameter refers to the final package set with the
-    applied overrides. Using this parameter may lead to infinite recursion if not
-    used consciously.
-  </para>
-
-  <para>
-    The <varname>super</varname> parameter refers to the old package set.
-    It's equivalent to <varname>pkgs</varname> in the above example.
-  </para>
-
-</section>
-
-<section xml:id="sec-pkg-override">
-  <title>&lt;pkg&gt;.override</title>
-
-  <para>
-    The function <varname>override</varname> is usually available for all the
-    derivations in the nixpkgs expression (<varname>pkgs</varname>).
-  </para>
-  <para>
-    It is used to override the arguments passed to a function.
-  </para>
-  <para>
-    Example usages:
-
-    <programlisting>pkgs.foo.override { arg1 = val1; arg2 = val2; ... }</programlisting>
-    <programlisting>pkgs.overridePackages (self: super: {
-  foo = super.foo.override { barSupport = true ; };
-})</programlisting>
-    <programlisting>mypkg = pkgs.callPackage ./mypkg.nix {
-  mydep = pkgs.mydep.override { ... };
-})</programlisting>
-  </para>
-
-  <para>
-    In the first example, <varname>pkgs.foo</varname> is the result of a function call
-    with some default arguments, usually a derivation.
-    Using <varname>pkgs.foo.override</varname> will call the same function with
-    the given new arguments.
-  </para>
-
-</section>
-
-<section xml:id="sec-pkg-overrideDerivation">
-  <title>&lt;pkg&gt;.overrideDerivation</title>
-
-  <para>
-    The function <varname>overrideDerivation</varname> is usually available for all the
-    derivations in the nixpkgs expression (<varname>pkgs</varname>).
-  </para> 
-  <para>
-    It is used to create a new derivation by overriding the attributes of
-    the original derivation according to the given function.
-  </para>
-
-  <para>
-    Example usage:
-
-    <programlisting>mySed = pkgs.gnused.overrideDerivation (oldAttrs: {
-  name = "sed-4.2.2-pre";
-  src = fetchurl {
-    url = ftp://alpha.gnu.org/gnu/sed/sed-4.2.2-pre.tar.bz2;
-    sha256 = "11nq06d131y4wmf3drm0yk502d2xc6n5qy82cg88rb9nqd2lj41k";
-  };
-  patches = [];
-});</programlisting>
-  </para>
-
-  <para>
-    In the above example, the name, src and patches of the derivation
-    will be overridden, while all other attributes will be retained from the
-    original derivation.
-  </para>
-
-  <para>
-    The argument <varname>oldAttrs</varname> is used to refer to the attribute set of
-    the original derivation.
-  </para>
-
-</section>
-
-<section xml:id="sec-lib-makeOverridable">
-  <title>lib.makeOverridable</title>
-
-  <para>
-    The function <varname>lib.makeOverridable</varname> is used make the result
-    of a function easily customizable. This utility only makes sense for functions
-    that accept an argument set and return an attribute set.
-  </para>
-
-  <para>
-    Example usage:
-
-    <programlisting>f = { a, b }: { result = a+b; }
-c = lib.makeOverridable f { a = 1; b = 2; }</programlisting>
-
-  </para>
-
-  <para>
-    The variable <varname>c</varname> is the value of the <varname>f</varname> function
-    applied with some default arguments. Hence the value of <varname>c.result</varname>
-    is <literal>3</literal>, in this example.
-  </para>
-
-  <para>
-    The variable <varname>c</varname> however also has some additional functions, like
-    <link linkend="sec-pkg-override">c.override</link> which can be used to
-    override the default arguments. In this example the value of
-    <varname>(c.override { a = 4; }).result</varname> is 6.
-  </para>
-
-</section>
-
-
-<section xml:id="sec-fhs-environments">
-  <title>buildFHSChrootEnv/buildFHSUserEnv</title>
-
-  <para>
-    <function>buildFHSChrootEnv</function> and
-    <function>buildFHSUserEnv</function> provide a way to build and run
-    FHS-compatible lightweight sandboxes. They get their own isolated root with
-    binded <filename>/nix/store</filename>, so their footprint in terms of disk
-    space needed is quite small. This allows one to run software which is hard or
-    unfeasible to patch for NixOS -- 3rd-party source trees with FHS assumptions,
-    games distributed as tarballs, software with integrity checking and/or external
-    self-updated binaries.
-  </para>
-
-  <para>
-    <function>buildFHSChrootEnv</function> allows to create persistent
-    environments, which can be constructed, deconstructed and entered by
-    multiple users at once. A downside is that it requires
-    <literal>root</literal> access for both those who create and destroy and
-    those who enter it. It can be useful to create environments for daemons that
-    one can enter and observe.
-  </para>
-
-  <para>
-    <function>buildFHSUserEnv</function> uses Linux namespaces feature to create
-    temporary lightweight environments which are destroyed after all child
-    processes exit. It does not require root access, and can be useful to create
-    sandboxes and wrap applications.
-  </para>
-
-  <para>
-    Those functions both rely on <function>buildFHSEnv</function>, which creates
-    an actual directory structure given a list of necessary packages and extra
-    build commands.
-    <function>buildFHSChrootEnv</function> and <function>buildFHSUserEnv</function>
-    both accept those arguments which are passed to
-    <function>buildFHSEnv</function>:
-  </para>
-
-  <variablelist>
-    <varlistentry>
-    <term><literal>name</literal></term>
-
-    <listitem><para>Environment name.</para></listitem>
-    </varlistentry>
-
-    <varlistentry>
-    <term><literal>targetPkgs</literal></term>
-
-    <listitem><para>Packages to be installed for the main host's architecture
-    (i.e. x86_64 on x86_64 installations).</para></listitem>
-    </varlistentry>
-
-    <varlistentry>
-    <term><literal>multiPkgs</literal></term>
-
-    <listitem><para>Packages to be installed for all architectures supported by
-    a host (i.e. i686 and x86_64 on x86_64 installations).</para></listitem>
-    </varlistentry>
-
-    <varlistentry>
-    <term><literal>extraBuildCommands</literal></term>
-
-    <listitem><para>Additional commands to be executed for finalizing the
-    directory structure.</para></listitem>
-    </varlistentry>
-
-    <varlistentry>
-    <term><literal>extraBuildCommandsMulti</literal></term>
-
-    <listitem><para>Like <literal>extraBuildCommandsMulti</literal>, but
-    executed only on multilib architectures.</para></listitem>
-    </varlistentry>
-  </variablelist>
-
-  <para>
-    Additionally, <function>buildFHSUserEnv</function> accepts
-    <literal>runScript</literal> parameter, which is a command that would be
-    executed inside the sandbox and passed all the command line arguments. It
-    default to <literal>bash</literal>.
-    One can create a simple environment using a <literal>shell.nix</literal>
-    like that:
-  </para>
-
-<programlisting><![CDATA[
-{ pkgs ? import <nixpkgs> {} }:
-
-(pkgs.buildFHSUserEnv {
-  name = "simple-x11-env";
-  targetPkgs = pkgs: (with pkgs;
-    [ udev
-      alsaLib
-    ]) ++ (with pkgs.xlibs;
-    [ libX11
-      libXcursor
-      libXrandr
-    ]);
-  multiPkgs = pkgs: (with pkgs;
-    [ udev
-      alsaLib
-    ]) ++ (with [];
-  runScript = "bash";
-}).env
-]]></programlisting>
-
-  <para>
-    Running <literal>nix-shell</literal> would then drop you into a shell with
-    these libraries and binaries available. You can use this to run
-    closed-source applications which expect FHS structure without hassles:
-    simply change <literal>runScript</literal> to the application path,
-    e.g. <filename>./bin/start.sh</filename> -- relative paths are supported.
-  </para>
-</section>
-
-</chapter>

doc/haskell-users-guide.xml

@@ -1,829 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="users-guide-to-the-haskell-infrastructure">
-
-<title>User's Guide to the Haskell Infrastructure</title>
-
-<section xml:id="how-to-install-haskell-packages">
-  <title>How to install Haskell packages</title>
-  <para>
-    Nixpkgs distributes build instructions for all Haskell packages
-    registered on
-    <link xlink:href="http://hackage.haskell.org/">Hackage</link>, but
-    strangely enough normal Nix package lookups don't seem to discover
-    any of them:
-  </para>
-  <programlisting>
-$ nix-env -qa cabal-install
-error: selector ‘cabal-install’ matches no derivations
-
-$ nix-env -i ghc
-error: selector ‘ghc’ matches no derivations
-</programlisting>
-  <para>
-    The Haskell package set is not registered in the top-level namespace
-    because it is <emphasis>huge</emphasis>. If all Haskell packages
-    were visible to these commands, then name-based search/install
-    operations would be much slower than they are now. We avoided that
-    by keeping all Haskell-related packages in a separate attribute set
-    called <literal>haskellPackages</literal>, which the following
-    command will list:
-  </para>
-  <programlisting>
-$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskellPackages
-haskellPackages.a50         a50-0.5
-haskellPackages.abacate     haskell-abacate-0.0.0.0
-haskellPackages.abcBridge   haskell-abcBridge-0.12
-haskellPackages.afv         afv-0.1.1
-haskellPackages.alex        alex-3.1.4
-haskellPackages.Allure      Allure-0.4.101.1
-haskellPackages.alms        alms-0.6.7
-[... some 8000 entries omitted  ...]
-</programlisting>
-  <para>
-    To install any of those packages into your profile, refer to them by
-    their attribute path (first column):
-  </para>
-  <programlisting>
-$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskellPackages.Allure ...
-</programlisting>
-  <para>
-    The attribute path of any Haskell packages corresponds to the name
-    of that particular package on Hackage: the package
-    <literal>cabal-install</literal> has the attribute
-    <literal>haskellPackages.cabal-install</literal>, and so on.
-    (Actually, this convention causes trouble with packages like
-    <literal>3dmodels</literal> and <literal>4Blocks</literal>, because
-    these names are invalid identifiers in the Nix language. The issue
-    of how to deal with these rare corner cases is currently
-    unresolved.)
-  </para>
-  <para>
-    Haskell packages who's Nix name (second column) begins with a
-    <literal>haskell-</literal> prefix are packages that provide a
-    library whereas packages without that prefix provide just
-    executables. Libraries may provide executables too, though: the
-    package <literal>haskell-pandoc</literal>, for example, installs
-    both a library and an application. You can install and use Haskell
-    executables just like any other program in Nixpkgs, but using
-    Haskell libraries for development is a bit trickier and we'll
-    address that subject in great detail in section
-    <link linkend="how-to-create-a-development-environment">How to
-    create a development environment</link>.
-  </para>
-  <para>
-    Attribute paths are deterministic inside of Nixpkgs, but the path
-    necessary to reach Nixpkgs varies from system to system. We dodged
-    that problem by giving <literal>nix-env</literal> an explicit
-    <literal>-f &quot;&lt;nixpkgs&gt;&quot;</literal> parameter, but if
-    you call <literal>nix-env</literal> without that flag, then chances
-    are the invocation fails:
-  </para>
-  <programlisting>
-$ nix-env -iA haskellPackages.cabal-install
-error: attribute ‘haskellPackages’ in selection path
-       ‘haskellPackages.cabal-install’ not found
-</programlisting>
-  <para>
-    On NixOS, for example, Nixpkgs does <emphasis>not</emphasis> exist
-    in the top-level namespace by default. To figure out the proper
-    attribute path, it's easiest to query for the path of a well-known
-    Nixpkgs package, i.e.:
-  </para>
-  <programlisting>
-$ nix-env -qaP coreutils
-nixos.coreutils  coreutils-8.23
-</programlisting>
-  <para>
-    If your system responds like that (most NixOS installations will),
-    then the attribute path to <literal>haskellPackages</literal> is
-    <literal>nixos.haskellPackages</literal>. Thus, if you want to
-    use <literal>nix-env</literal> without giving an explicit
-    <literal>-f</literal> flag, then that's the way to do it:
-  </para>
-  <programlisting>
-$ nix-env -qaP -A nixos.haskellPackages
-$ nix-env -iA nixos.haskellPackages.cabal-install
-</programlisting>
-  <para>
-    Our current default compiler is GHC 7.10.x and the
-    <literal>haskellPackages</literal> set contains packages built with
-    that particular version. Nixpkgs contains the latest major release
-    of every GHC since 6.10.4, however, and there is a whole family of
-    package sets available that defines Hackage packages built with each
-    of those compilers, too:
-  </para>
-  <programlisting>
-$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskell.packages.ghc6123
-$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskell.packages.ghc763
-</programlisting>
-  <para>
-    The name <literal>haskellPackages</literal> is really just a synonym
-    for <literal>haskell.packages.ghc7102</literal>, because we prefer
-    that package set internally and recommend it to our users as their
-    default choice, but ultimately you are free to compile your Haskell
-    packages with any GHC version you please. The following command
-    displays the complete list of available compilers:
-  </para>
-  <programlisting>
-$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskell.compiler
-haskell.compiler.ghc6104        ghc-6.10.4
-haskell.compiler.ghc6123        ghc-6.12.3
-haskell.compiler.ghc704         ghc-7.0.4
-haskell.compiler.ghc722         ghc-7.2.2
-haskell.compiler.ghc742         ghc-7.4.2
-haskell.compiler.ghc763         ghc-7.6.3
-haskell.compiler.ghc784         ghc-7.8.4
-haskell.compiler.ghc7102        ghc-7.10.2
-haskell.compiler.ghcHEAD        ghc-7.11.20150402
-haskell.compiler.ghcNokinds     ghc-nokinds-7.11.20150704
-haskell.compiler.ghcjs          ghcjs-0.1.0
-haskell.compiler.jhc            jhc-0.8.2
-haskell.compiler.uhc            uhc-1.1.9.0
-</programlisting>
-  <para>
-    We have no package sets for <literal>jhc</literal> or
-    <literal>uhc</literal> yet, unfortunately, but for every version of
-    GHC listed above, there exists a package set based on that compiler.
-    Also, the attributes <literal>haskell.compiler.ghcXYC</literal> and
-    <literal>haskell.packages.ghcXYC.ghc</literal> are synonymous for
-    the sake of convenience.
-  </para>
-</section>
-<section xml:id="how-to-create-a-development-environment">
-  <title>How to create a development environment</title>
-  <section xml:id="how-to-install-a-compiler">
-    <title>How to install a compiler</title>
-    <para>
-      A simple development environment consists of a Haskell compiler
-      and the tool <literal>cabal-install</literal>, and we saw in
-      section <link linkend="how-to-install-haskell-packages">How to
-      install Haskell packages</link> how you can install those programs
-      into your user profile:
-    </para>
-    <programlisting>
-$ nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskellPackages.ghc haskellPackages.cabal-install
-</programlisting>
-    <para>
-      Instead of the default package set
-      <literal>haskellPackages</literal>, you can also use the more
-      precise name <literal>haskell.compiler.ghc7102</literal>, which
-      has the advantage that it refers to the same GHC version
-      regardless of what Nixpkgs considers &quot;default&quot; at any
-      given time.
-    </para>
-    <para>
-      Once you've made those tools available in
-      <literal>$PATH</literal>, it's possible to build Hackage packages
-      the same way people without access to Nix do it all the time:
-    </para>
-    <programlisting>
-$ cabal get lens-4.11 &amp;&amp; cd lens-4.11
-$ cabal install -j --dependencies-only
-$ cabal configure
-$ cabal build
-</programlisting>
-    <para>
-      If you enjoy working with Cabal sandboxes, then that's entirely
-      possible too: just execute the command
-    </para>
-    <programlisting>
-$ cabal sandbox init
-</programlisting>
-    <para>
-      before installing the required dependencies.
-    </para>
-    <para>
-      The <literal>nix-shell</literal> utility makes it easy to switch
-      to a different compiler version; just enter the Nix shell
-      environment with the command
-    </para>
-    <programlisting>
-$ nix-shell -p haskell.compiler.ghc784
-</programlisting>
-    <para>
-      to bring GHC 7.8.4 into <literal>$PATH</literal>. Re-running
-      <literal>cabal configure</literal> switches your build to use that
-      compiler instead. If you're working on a project that doesn't
-      depend on any additional system libraries outside of GHC, then
-      it's sufficient even to run the <literal>cabal configure</literal>
-      command inside of the shell:
-    </para>
-    <programlisting>
-$ nix-shell -p haskell.compiler.ghc784 --command &quot;cabal configure&quot;
-</programlisting>
-    <para>
-      Afterwards, all other commands like <literal>cabal build</literal>
-      work just fine in any shell environment, because the configure
-      phase recorded the absolute paths to all required tools like GHC
-      in its build configuration inside of the <literal>dist/</literal>
-      directory. Please note, however, that
-      <literal>nix-collect-garbage</literal> can break such an
-      environment because the Nix store paths created by
-      <literal>nix-shell</literal> aren't &quot;alive&quot; anymore once
-      <literal>nix-shell</literal> has terminated. If you find that your
-      Haskell builds no longer work after garbage collection, then
-      you'll have to re-run <literal>cabal configure</literal> inside of
-      a new <literal>nix-shell</literal> environment.
-    </para>
-  </section>
-  <section xml:id="how-to-install-a-compiler-with-libraries">
-    <title>How to install a compiler with libraries</title>
-    <para>
-      GHC expects to find all installed libraries inside of its own
-      <literal>lib</literal> directory. This approach works fine on
-      traditional Unix systems, but it doesn't work for Nix, because
-      GHC's store path is immutable once it's built. We cannot install
-      additional libraries into that location. As a consequence, our
-      copies of GHC don't know any packages except their own core
-      libraries, like <literal>base</literal>,
-      <literal>containers</literal>, <literal>Cabal</literal>, etc.
-    </para>
-    <para>
-      We can register additional libraries to GHC, however, using a
-      special build function called <literal>ghcWithPackages</literal>.
-      That function expects one argument: a function that maps from an
-      attribute set of Haskell packages to a list of packages, which
-      determines the libraries known to that particular version of GHC.
-      For example, the Nix expression
-      <literal>ghcWithPackages (pkgs: [pkgs.mtl])</literal> generates a
-      copy of GHC that has the <literal>mtl</literal> library registered
-      in addition to its normal core packages:
-    </para>
-    <programlisting>
-$ nix-shell -p &quot;haskellPackages.ghcWithPackages (pkgs: [pkgs.mtl])&quot;
-
-[nix-shell:~]$ ghc-pkg list mtl
-/nix/store/zy79...-ghc-7.10.2/lib/ghc-7.10.2/package.conf.d:
-    mtl-2.2.1
-</programlisting>
-    <para>
-      This function allows users to define their own development
-      environment by means of an override. After adding the following
-      snippet to <literal>~/.nixpkgs/config.nix</literal>,
-    </para>
-    <programlisting>
-{
-  packageOverrides = super: let self = super.pkgs; in
-  {
-    myHaskellEnv = self.haskell.packages.ghc7102.ghcWithPackages
-                     (haskellPackages: with haskellPackages; [
-                       # libraries
-                       arrows async cgi criterion
-                       # tools
-                       cabal-install haskintex
-                     ]);
-  };
-}
-</programlisting>
-    <para>
-      it's possible to install that compiler with
-      <literal>nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA myHaskellEnv</literal>.
-      If you'd like to switch that development environment to a
-      different version of GHC, just replace the
-      <literal>ghc7102</literal> bit in the previous definition with the
-      appropriate name. Of course, it's also possible to define any
-      number of these development environments! (You can't install two
-      of them into the same profile at the same time, though, because
-      that would result in file conflicts.)
-    </para>
-    <para>
-      The generated <literal>ghc</literal> program is a wrapper script
-      that re-directs the real GHC executable to use a new
-      <literal>lib</literal> directory --- one that we specifically
-      constructed to contain all those packages the user requested:
-    </para>
-    <programlisting>
-$ cat $(type -p ghc)
-#! /nix/store/xlxj...-bash-4.3-p33/bin/bash -e
-export NIX_GHC=/nix/store/19sm...-ghc-7.10.2/bin/ghc
-export NIX_GHCPKG=/nix/store/19sm...-ghc-7.10.2/bin/ghc-pkg
-export NIX_GHC_DOCDIR=/nix/store/19sm...-ghc-7.10.2/share/doc/ghc/html
-export NIX_GHC_LIBDIR=/nix/store/19sm...-ghc-7.10.2/lib/ghc-7.10.2
-exec /nix/store/j50p...-ghc-7.10.2/bin/ghc &quot;-B$NIX_GHC_LIBDIR&quot; &quot;$@&quot;
-</programlisting>
-    <para>
-      The variables <literal>$NIX_GHC</literal>,
-      <literal>$NIX_GHCPKG</literal>, etc. point to the
-      <emphasis>new</emphasis> store path
-      <literal>ghcWithPackages</literal> constructed specifically for
-      this environment. The last line of the wrapper script then
-      executes the real <literal>ghc</literal>, but passes the path to
-      the new <literal>lib</literal> directory using GHC's
-      <literal>-B</literal> flag.
-    </para>
-    <para>
-      The purpose of those environment variables is to work around an
-      impurity in the popular
-      <link xlink:href="http://hackage.haskell.org/package/ghc-paths">ghc-paths</link>
-      library. That library promises to give its users access to GHC's
-      installation paths. Only, the library can't possible know that
-      path when it's compiled, because the path GHC considers its own is
-      determined only much later, when the user configures it through
-      <literal>ghcWithPackages</literal>. So we
-      <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/haskell-modules/ghc-paths-nix.patch">patched
-      ghc-paths</link> to return the paths found in those environment
-      variables at run-time rather than trying to guess them at
-      compile-time.
-    </para>
-    <para>
-      To make sure that mechanism works properly all the time, we
-      recommend that you set those variables to meaningful values in
-      your shell environment, too, i.e. by adding the following code to
-      your <literal>~/.bashrc</literal>:
-    </para>
-    <programlisting>
-if type &gt;/dev/null 2&gt;&amp;1 -p ghc; then
-  eval &quot;$(egrep ^export &quot;$(type -p ghc)&quot;)&quot;
-fi
-</programlisting>
-    <para>
-      If you are certain that you'll use only one GHC environment which
-      is located in your user profile, then you can use the following
-      code, too, which has the advantage that it doesn't contain any
-      paths from the Nix store, i.e. those settings always remain valid
-      even if a <literal>nix-env -u</literal> operation updates the GHC
-      environment in your profile:
-    </para>
-    <programlisting>
-if [ -e ~/.nix-profile/bin/ghc ]; then
-  export NIX_GHC=&quot;$HOME/.nix-profile/bin/ghc&quot;
-  export NIX_GHCPKG=&quot;$HOME/.nix-profile/bin/ghc-pkg&quot;
-  export NIX_GHC_DOCDIR=&quot;$HOME/.nix-profile/share/doc/ghc/html&quot;
-  export NIX_GHC_LIBDIR=&quot;$HOME/.nix-profile/lib/ghc-$($NIX_GHC --numeric-version)&quot;
-fi
-</programlisting>
-  </section>
-  <section xml:id="how-to-create-ad-hoc-environments-for-nix-shell">
-    <title>How to create ad hoc environments for
-    <literal>nix-shell</literal></title>
-    <para>
-      The easiest way to create an ad hoc development environment is to
-      run <literal>nix-shell</literal> with the appropriate GHC
-      environment given on the command-line:
-    </para>
-    <programlisting>
-nix-shell -p &quot;haskellPackages.ghcWithPackages (pkgs: with pkgs; [mtl pandoc])&quot;
-</programlisting>
-    <para>
-      For more sophisticated use-cases, however, it's more convenient to
-      save the desired configuration in a file called
-      <literal>shell.nix</literal> that looks like this:
-    </para>
-    <programlisting>
-{ nixpkgs ? import &lt;nixpkgs&gt; {}, compiler ? &quot;ghc7102&quot; }:
-let
-  inherit (nixpkgs) pkgs;
-  ghc = pkgs.haskell.packages.${compiler}.ghcWithPackages (ps: with ps; [
-          monad-par mtl
-        ]);
-in
-pkgs.stdenv.mkDerivation {
-  name = &quot;my-haskell-env-0&quot;;
-  buildInputs = [ ghc ];
-  shellHook = &quot;eval $(egrep ^export ${ghc}/bin/ghc)&quot;;
-}
-</programlisting>
-    <para>
-      Now run <literal>nix-shell</literal> --- or even
-      <literal>nix-shell --pure</literal> --- to enter a shell
-      environment that has the appropriate compiler in
-      <literal>$PATH</literal>. If you use <literal>--pure</literal>,
-      then add all other packages that your development environment
-      needs into the <literal>buildInputs</literal> attribute. If you'd
-      like to switch to a different compiler version, then pass an
-      appropriate <literal>compiler</literal> argument to the
-      expression, i.e.
-      <literal>nix-shell --argstr compiler ghc784</literal>.
-    </para>
-    <para>
-      If you need such an environment because you'd like to compile a
-      Hackage package outside of Nix --- i.e. because you're hacking on
-      the latest version from Git ---, then the package set provides
-      suitable nix-shell environments for you already! Every Haskell
-      package has an <literal>env</literal> attribute that provides a
-      shell environment suitable for compiling that particular package.
-      If you'd like to hack the <literal>lens</literal> library, for
-      example, then you just have to check out the source code and enter
-      the appropriate environment:
-    </para>
-    <programlisting>
-  $ cabal get lens-4.11 &amp;&amp; cd lens-4.11
-  Downloading lens-4.11...
-  Unpacking to lens-4.11/
-
-  $ nix-shell &quot;&lt;nixpkgs&gt;&quot; -A haskellPackages.lens.env
-  [nix-shell:/tmp/lens-4.11]$
-</programlisting>
-    <para>
-      At point, you can run <literal>cabal configure</literal>,
-      <literal>cabal build</literal>, and all the other development
-      commands. Note that you need <literal>cabal-install</literal>
-      installed in your <literal>$PATH</literal> already to use it here
-      --- the <literal>nix-shell</literal> environment does not provide
-      it.
-    </para>
-  </section>
-</section>
-<section xml:id="how-to-create-nix-builds-for-your-own-private-haskell-packages">
-  <title>How to create Nix builds for your own private Haskell
-  packages</title>
-  <para>
-    If your own Haskell packages have build instructions for Cabal, then
-    you can convert those automatically into build instructions for Nix
-    using the <literal>cabal2nix</literal> utility, which you can
-    install into your profile by running
-    <literal>nix-env -i cabal2nix</literal>.
-  </para>
-  <section xml:id="how-to-build-a-stand-alone-project">
-    <title>How to build a stand-alone project</title>
-    <para>
-      For example, let's assume that you're working on a private project
-      called <literal>foo</literal>. To generate a Nix build expression
-      for it, change into the project's top-level directory and run the
-      command:
-    </para>
-    <programlisting>
-$ cabal2nix . &gt;foo.nix
-</programlisting>
-    <para>
-      Then write the following snippet into a file called
-      <literal>default.nix</literal>:
-    </para>
-    <programlisting>
-{ nixpkgs ? import &lt;nixpkgs&gt; {}, compiler ? &quot;ghc7102&quot; }:
-nixpkgs.pkgs.haskell.packages.${compiler}.callPackage ./foo.nix { }
-</programlisting>
-    <para>
-      Finally, store the following code in a file called
-      <literal>shell.nix</literal>:
-    </para>
-    <programlisting>
-{ nixpkgs ? import &lt;nixpkgs&gt; {}, compiler ? &quot;ghc7102&quot; }:
-(import ./default.nix { inherit nixpkgs compiler; }).env
-</programlisting>
-    <para>
-      At this point, you can run <literal>nix-build</literal> to have
-      Nix compile your project and install it into a Nix store path. The
-      local directory will contain a symlink called
-      <literal>result</literal> after <literal>nix-build</literal>
-      returns that points into that location. Of course, passing the
-      flag <literal>--argstr compiler ghc763</literal> allows switching
-      the build to any version of GHC currently supported.
-    </para>
-    <para>
-      Furthermore, you can call <literal>nix-shell</literal> to enter an
-      interactive development environment in which you can use
-      <literal>cabal configure</literal> and
-      <literal>cabal build</literal> to develop your code. That
-      environment will automatically contain a proper GHC derivation
-      with all the required libraries registered as well as all the
-      system-level libraries your package might need.
-    </para>
-    <para>
-      If your package does not depend on any system-level libraries,
-      then it's sufficient to run
-    </para>
-    <programlisting>
-$ nix-shell --command &quot;cabal configure&quot;
-</programlisting>
-    <para>
-      once to set up your build. <literal>cabal-install</literal>
-      determines the absolute paths to all resources required for the
-      build and writes them into a config file in the
-      <literal>dist/</literal> directory. Once that's done, you can run
-      <literal>cabal build</literal> and any other command for that
-      project even outside of the <literal>nix-shell</literal>
-      environment. This feature is particularly nice for those of us who
-      like to edit their code with an IDE, like Emacs'
-      <literal>haskell-mode</literal>, because it's not necessary to
-      start Emacs inside of nix-shell just to make it find out the
-      necessary settings for building the project;
-      <literal>cabal-install</literal> has already done that for us.
-    </para>
-    <para>
-      If you want to do some quick-and-dirty hacking and don't want to
-      bother setting up a <literal>default.nix</literal> and
-      <literal>shell.nix</literal> file manually, then you can use the
-      <literal>--shell</literal> flag offered by
-      <literal>cabal2nix</literal> to have it generate a stand-alone
-      <literal>nix-shell</literal> environment for you. With that
-      feature, running
-    </para>
-    <programlisting>
-$ cabal2nix --shell . &gt;shell.nix
-$ nix-shell --command &quot;cabal configure&quot;
-</programlisting>
-    <para>
-      is usually enough to set up a build environment for any given
-      Haskell package. You can even use that generated file to run
-      <literal>nix-build</literal>, too:
-    </para>
-    <programlisting>
-$ nix-build shell.nix
-</programlisting>
-  </section>
-  <section xml:id="how-to-build-projects-that-depend-on-each-other">
-    <title>How to build projects that depend on each other</title>
-    <para>
-      If you have multiple private Haskell packages that depend on each
-      other, then you'll have to register those packages in the Nixpkgs
-      set to make them visible for the dependency resolution performed
-      by <literal>callPackage</literal>. First of all, change into each
-      of your projects top-level directories and generate a
-      <literal>default.nix</literal> file with
-      <literal>cabal2nix</literal>:
-    </para>
-    <programlisting>
-$ cd ~/src/foo &amp;&amp; cabal2nix . &gt;default.nix
-$ cd ~/src/bar &amp;&amp; cabal2nix . &gt;default.nix
-</programlisting>
-    <para>
-      Then edit your <literal>~/.nixpkgs/config.nix</literal> file to
-      register those builds in the default Haskell package set:
-    </para>
-    <programlisting>
-  {
-    packageOverrides = super: let self = super.pkgs; in
-    {
-      haskellPackages = super.haskellPackages.override {
-        overrides = self: super: {
-          foo = self.callPackage ../src/foo {};
-          bar = self.callPackage ../src/bar {};
-        };
-      };
-    };
-  }
-</programlisting>
-    <para>
-      Once that's accomplished,
-      <literal>nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qA haskellPackages</literal>
-      will show your packages like any other package from Hackage, and
-      you can build them
-    </para>
-    <programlisting>
-$ nix-build &quot;&lt;nixpkgs&gt;&quot; -A haskellPackages.foo
-</programlisting>
-    <para>
-      or enter an interactive shell environment suitable for building
-      them:
-    </para>
-    <programlisting>
-$ nix-shell &quot;&lt;nixpkgs&gt;&quot; -A haskellPackages.bar.env
-</programlisting>
-  </section>
-</section>
-<section xml:id="miscellaneous-topics">
-  <title>Miscellaneous Topics</title>
-  <section xml:id="how-to-build-with-profiling-enabled">
-    <title>How to build with profiling enabled</title>
-    <para>
-      Every Haskell package set takes a function called
-      <literal>overrides</literal> that you can use to manipulate the
-      package as much as you please. One useful application of this
-      feature is to replace the default <literal>mkDerivation</literal>
-      function with one that enables library profiling for all packages.
-      To accomplish that, add configure the following snippet in your
-      <literal>~/.nixpkgs/config.nix</literal> file:
-    </para>
-    <programlisting>
-{
-  packageOverrides = super: let self = super.pkgs; in
-  {
-    profiledHaskellPackages = self.haskellPackages.override {
-      overrides = self: super: {
-        mkDerivation = args: super.mkDerivation (args // {
-          enableLibraryProfiling = true;
-        });
-      };
-    };
-  };
-}
-</programlisting>
-    <para>
-        Then, replace instances of <literal>haskellPackages</literal> in the
-        <literal>cabal2nix</literal>-generated <literal>default.nix</literal>
-        or <literal>shell.nix</literal> files with
-        <literal>profiledHaskellPackages</literal>.
-    </para>
-  </section>
-  <section xml:id="how-to-override-package-versions-in-a-compiler-specific-package-set">
-    <title>How to override package versions in a compiler-specific
-    package set</title>
-    <para>
-      Nixpkgs provides the latest version of
-      <link xlink:href="http://hackage.haskell.org/package/ghc-events"><literal>ghc-events</literal></link>,
-      which is 0.4.4.0 at the time of this writing. This is fine for
-      users of GHC 7.10.x, but GHC 7.8.4 cannot compile that binary.
-      Now, one way to solve that problem is to register an older version
-      of <literal>ghc-events</literal> in the 7.8.x-specific package
-      set. The first step is to generate Nix build instructions with
-      <literal>cabal2nix</literal>:
-    </para>
-    <programlisting>
-$ cabal2nix cabal://ghc-events-0.4.3.0 &gt;~/.nixpkgs/ghc-events-0.4.3.0.nix
-</programlisting>
-    <para>
-      Then add the override in <literal>~/.nixpkgs/config.nix</literal>:
-    </para>
-    <programlisting>
-{
-  packageOverrides = super: let self = super.pkgs; in
-  {
-    haskell = super.haskell // {
-      packages = super.haskell.packages // {
-        ghc784 = super.haskell.packages.ghc784.override {
-          overrides = self: super: {
-            ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {};
-          };
-        };
-      };
-    };
-  };
-}
-</programlisting>
-    <para>
-      This code is a little crazy, no doubt, but it's necessary because
-      the intuitive version
-    </para>
-    <programlisting>
-haskell.packages.ghc784 = super.haskell.packages.ghc784.override {
-  overrides = self: super: {
-    ghc-events = self.callPackage ./ghc-events-0.4.3.0.nix {};
-  };
-};
-</programlisting>
-    <para>
-      doesn't do what we want it to: that code replaces the
-      <literal>haskell</literal> package set in Nixpkgs with one that
-      contains only one entry,<literal>packages</literal>, which
-      contains only one entry <literal>ghc784</literal>. This override
-      loses the <literal>haskell.compiler</literal> set, and it loses
-      the <literal>haskell.packages.ghcXYZ</literal> sets for all
-      compilers but GHC 7.8.4. To avoid that problem, we have to perform
-      the convoluted little dance from above, iterating over each step
-      in hierarchy.
-    </para>
-    <para>
-      Once it's accomplished, however, we can install a variant of
-      <literal>ghc-events</literal> that's compiled with GHC 7.8.4:
-    </para>
-    <programlisting>
-nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskell.packages.ghc784.ghc-events
-</programlisting>
-    <para>
-      Unfortunately, it turns out that this build fails again while
-      executing the test suite! Apparently, the release archive on
-      Hackage is missing some data files that the test suite requires,
-      so we cannot run it. We accomplish that by re-generating the Nix
-      expression with the <literal>--no-check</literal> flag:
-    </para>
-    <programlisting>
-$ cabal2nix --no-check cabal://ghc-events-0.4.3.0 &gt;~/.nixpkgs/ghc-events-0.4.3.0.nix
-</programlisting>
-    <para>
-      Now the builds succeeds.
-    </para>
-    <para>
-      Of course, in the concrete example of
-      <literal>ghc-events</literal> this whole exercise is not an ideal
-      solution, because <literal>ghc-events</literal> can analyze the
-      output emitted by any version of GHC later than 6.12 regardless of
-      the compiler version that was used to build the `ghc-events'
-      executable, so strictly speaking there's no reason to prefer one
-      built with GHC 7.8.x in the first place. However, for users who
-      cannot use GHC 7.10.x at all for some reason, the approach of
-      downgrading to an older version might be useful.
-    </para>
-  </section>
-  <section xml:id="how-to-recover-from-ghcs-infamous-non-deterministic-library-id-bug">
-    <title>How to recover from GHC's infamous non-deterministic library
-    ID bug</title>
-    <para>
-      GHC and distributed build farms don't get along well:
-    </para>
-    <programlisting>
-https://ghc.haskell.org/trac/ghc/ticket/4012
-</programlisting>
-    <para>
-      When you see an error like this one
-    </para>
-    <programlisting>
-package foo-0.7.1.0 is broken due to missing package
-text-1.2.0.4-98506efb1b9ada233bb5c2b2db516d91
-</programlisting>
-    <para>
-      then you have to download and re-install <literal>foo</literal>
-      and all its dependents from scratch:
-    </para>
-    <programlisting>
-# nix-store -q --referrers /nix/store/*-haskell-text-1.2.0.4 \
-  | xargs -L 1 nix-store --repair-path --option binary-caches http://hydra.nixos.org
-</programlisting>
-    <para>
-      If you're using additional Hydra servers other than
-      <literal>hydra.nixos.org</literal>, then it might be necessary to
-      purge the local caches that store data from those machines to
-      disable these binary channels for the duration of the previous
-      command, i.e. by running:
-    </para>
-    <programlisting>
-rm /nix/var/nix/binary-cache-v3.sqlite
-rm /nix/var/nix/manifests/*
-rm /nix/var/nix/channel-cache/*
-</programlisting>
-  </section>
-  <section xml:id="builds-on-darwin-fail-with-math.h-not-found">
-    <title>Builds on Darwin fail with <literal>math.h</literal> not
-    found</title>
-    <para>
-      Users of GHC on Darwin have occasionally reported that builds
-      fail, because the compiler complains about a missing include file:
-    </para>
-    <programlisting>
-fatal error: 'math.h' file not found
-</programlisting>
-    <para>
-      The issue has been discussed at length in
-      <link xlink:href="https://github.com/NixOS/nixpkgs/issues/6390">ticket
-      6390</link>, and so far no good solution has been proposed. As a
-      work-around, users who run into this problem can configure the
-      environment variables
-    </para>
-    <programlisting>
-export NIX_CFLAGS_COMPILE=&quot;-idirafter /usr/include&quot;
-export NIX_CFLAGS_LINK=&quot;-L/usr/lib&quot;
-</programlisting>
-    <para>
-      in their <literal>~/.bashrc</literal> file to avoid the compiler
-      error.
-    </para>
-  </section>
-</section>
-
-<section xml:id="other-resources">
-  <title>Other resources</title>
-  <itemizedlist>
-    <listitem>
-      <para>
-        The Youtube video
-        <link xlink:href="https://www.youtube.com/watch?v=BsBhi_r-OeE">Nix
-        Loves Haskell</link> provides an introduction into Haskell NG
-        aimed at beginners. The slides are available at
-        http://cryp.to/nixos-meetup-3-slides.pdf and also -- in a form
-        ready for cut &amp; paste -- at
-        https://github.com/NixOS/cabal2nix/blob/master/doc/nixos-meetup-3-slides.md.
-      </para>
-    </listitem>
-    <listitem>
-      <para>
-        Another Youtube video is
-        <link xlink:href="https://www.youtube.com/watch?v=mQd3s57n_2Y">Escaping
-        Cabal Hell with Nix</link>, which discusses the subject of
-        Haskell development with Nix but also provides a basic
-        introduction to Nix as well, i.e. it's suitable for viewers with
-        almost no prior Nix experience.
-      </para>
-    </listitem>
-    <listitem>
-      <para>
-        Oliver Charles wrote a very nice
-        <link xlink:href="http://wiki.ocharles.org.uk/Nix">Tutorial how to
-        develop Haskell packages with Nix</link>.
-      </para>
-    </listitem>
-    <listitem>
-      <para>
-        The <emphasis>Journey into the Haskell NG
-        infrastructure</emphasis> series of postings describe the new
-        Haskell infrastructure in great detail:
-      </para>
-      <itemizedlist>
-        <listitem>
-          <para>
-            <link xlink:href="http://lists.science.uu.nl/pipermail/nix-dev/2015-January/015591.html">Part
-            1</link> explains the differences between the old and the
-            new code and gives instructions how to migrate to the new
-            setup.
-          </para>
-        </listitem>
-        <listitem>
-          <para>
-            <link xlink:href="http://lists.science.uu.nl/pipermail/nix-dev/2015-January/015608.html">Part
-            2</link> looks in-depth at how to tweak and configure your
-            setup by means of overrides.
-          </para>
-        </listitem>
-        <listitem>
-          <para>
-            <link xlink:href="http://lists.science.uu.nl/pipermail/nix-dev/2015-April/016912.html">Part
-            3</link> describes the infrastructure that keeps the
-            Haskell package set in Nixpkgs up-to-date.
-          </para>
-        </listitem>
-      </itemizedlist>
-    </listitem>
-  </itemizedlist>
-</section>
-
-</chapter>

doc/language-support.xml

@@ -1,4 +1,3 @@
-
 <chapter xmlns="http://docbook.org/ns/docbook"
          xmlns:xlink="http://www.w3.org/1999/xlink"
          xml:id="chap-language-support">
@@ -14,7 +13,7 @@ in Nixpkgs to easily build packages for other programming languages,
 such as Perl or Haskell.  These are described in this chapter.</para>
 
 
-<section xml:id="sec-language-perl"><title>Perl</title>
+<section xml:id="ssec-language-perl"><title>Perl</title>
 
 <para>Nixpkgs provides a function <varname>buildPerlPackage</varname>,
 a generic package builder function for any Perl package that has a
@@ -152,7 +151,7 @@ ClassC3Componentised = buildPerlPackage rec {
 
 </para>
 
-<section xml:id="ssec-generation-from-CPAN"><title>Generation from CPAN</title>
+<section><title>Generation from CPAN</title>
 
 <para>Nix expressions for Perl packages can be generated (almost)
 automatically from CPAN.  This is done by the program
@@ -192,7 +191,7 @@ you need it.</para>
 </section>
 
 
-<section xml:id="sec-python"><title>Python</title>
+<section xml:id="python"><title>Python</title>
 
 <para>
   Currently supported interpreters are <varname>python26</varname>, <varname>python27</varname>,
@@ -246,62 +245,62 @@ are provided with all modules included.</para>
         Name of the folder in <literal>${python}/lib/</literal> for corresponding interpreter.
     </para></listitem>
   </varlistentry>
-
+  
   <varlistentry>
     <term><varname>interpreter</varname></term>
     <listitem><para>
         Alias for <literal>${python}/bin/${executable}.</literal>
     </para></listitem>
   </varlistentry>
-
+  
   <varlistentry>
     <term><varname>buildEnv</varname></term>
     <listitem><para>
         Function to build python interpreter environments with extra packages bundled together.
-        See <xref linkend="ssec-python-build-env" /> for usage and documentation.
+        See <xref linkend="python-build-env" /> for usage and documentation.
     </para></listitem>
   </varlistentry>
-
+  
   <varlistentry>
     <term><varname>sitePackages</varname></term>
     <listitem><para>
       Alias for <literal>lib/${libPrefix}/site-packages</literal>.
     </para></listitem>
   </varlistentry>
-
+  
   <varlistentry>
     <term><varname>executable</varname></term>
     <listitem><para>
       Name of the interpreter executable, ie <literal>python3.4</literal>.
     </para></listitem>
   </varlistentry>
-
+  
 </variablelist>
-<section xml:id="ssec-build-python-package"><title><varname>buildPythonPackage</varname> function</title>
-
+<section xml:id="build-python-package"><title><varname>buildPythonPackage</varname> function</title>
+  
   <para>
   The function is implemented in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/python-modules/generic/default.nix">
   <filename>pkgs/development/python-modules/generic/default.nix</filename></link>.
   Example usage:
-
-<programlisting language="nix">
-twisted = buildPythonPackage {
-  name = "twisted-8.1.0";
-
-  src = pkgs.fetchurl {
-    url = http://tmrc.mit.edu/mirror/twisted/Twisted/8.1/Twisted-8.1.0.tar.bz2;
-    sha256 = "0q25zbr4xzknaghha72mq57kh53qw1bf8csgp63pm9sfi72qhirl";
-  };
-
-  propagatedBuildInputs = [ self.ZopeInterface ];
-
-  meta = {
-    homepage = http://twistedmatrix.com/;
-    description = "Twisted, an event-driven networking engine written in Python";
-    license = stdenv.lib.licenses.mit;
-  };
-};
-</programlisting>
+  
+    <programlisting language="nix">
+      twisted = buildPythonPackage {
+        name = "twisted-8.1.0";
+      
+        src = pkgs.fetchurl {
+          url = http://tmrc.mit.edu/mirror/twisted/Twisted/8.1/Twisted-8.1.0.tar.bz2;
+          sha256 = "0q25zbr4xzknaghha72mq57kh53qw1bf8csgp63pm9sfi72qhirl";
+        };
+      
+        propagatedBuildInputs = [ self.ZopeInterface ];
+      
+        meta = {
+          homepage = http://twistedmatrix.com/;
+          description = "Twisted, an event-driven networking engine written in Python";
+          license = stdenv.lib.licenses.mit;
+        };
+      };
+    </programlisting>
 
   Most of Python packages that use <varname>buildPythonPackage</varname> are defined
   in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/top-level/python-packages.nix"><filename>pkgs/top-level/python-packages.nix</filename></link>
@@ -309,27 +308,27 @@ twisted = buildPythonPackage {
   <varname>python27Packages</varname>, <varname>python32Packages</varname>, <varname>python33Packages</varname>,
   <varname>python34Packages</varname> and <varname>pypyPackages</varname>.
   </para>
-
+  
   <para>
     <function>buildPythonPackage</function> mainly does four things:
-
+      
     <orderedlist>
       <listitem><para>
         In the <varname>configurePhase</varname>, it patches
         <literal>setup.py</literal> to always include setuptools before
         distutils for monkeypatching machinery to take place.
       </para></listitem>
-
+    
       <listitem><para>
-        In the <varname>buildPhase</varname>, it calls
+        In the <varname>buildPhase</varname>, it calls 
         <literal>${python.interpreter} setup.py build ...</literal>
       </para></listitem>
-
+      
       <listitem><para>
-        In the <varname>installPhase</varname>, it calls
+        In the <varname>installPhase</varname>, it calls 
         <literal>${python.interpreter} setup.py install ...</literal>
       </para></listitem>
-
+      
       <listitem><para>
         In the <varname>postFixup</varname> phase, <literal>wrapPythonPrograms</literal>
         bash function is called to wrap all programs in <filename>$out/bin/*</filename>
@@ -338,30 +337,23 @@ twisted = buildPythonPackage {
       </para></listitem>
     </orderedlist>
   </para>
-
-  <para>By default <varname>doCheck = true</varname> is set and tests are run with
+  
+  <para>By default <varname>doCheck = true</varname> is set and tests are run with 
   <literal>${python.interpreter} setup.py test</literal> command in <varname>checkPhase</varname>.</para>
-
-  <para>
-    As in Perl, dependencies on other Python packages can be specified in the
-    <varname>buildInputs</varname> and
-    <varname>propagatedBuildInputs</varname> attributes.  If something is
-    exclusively a build-time dependency, use
-    <varname>buildInputs</varname>; if it’s (also) a runtime dependency,
-    use <varname>propagatedBuildInputs</varname>.
-  </para>
-
+  
+  <para><varname>propagatedBuildInputs</varname> packages are propagated to user environment.</para>
+    
   <para>
     By default <varname>meta.platforms</varname> is set to the same value
     as the interpreter unless overriden otherwise.
   </para>
-
+  
   <variablelist>
     <title>
       <varname>buildPythonPackage</varname> parameters
       (all parameters from <varname>mkDerivation</varname> function are still supported)
     </title>
-
+  
     <varlistentry>
       <term><varname>namePrefix</varname></term>
       <listitem><para>
@@ -371,7 +363,7 @@ twisted = buildPythonPackage {
         if you're packaging an application or a command line tool.
       </para></listitem>
     </varlistentry>
-
+  
     <varlistentry>
       <term><varname>disabled</varname></term>
       <listitem><para>
@@ -381,21 +373,21 @@ twisted = buildPythonPackage {
         for examples.
       </para></listitem>
     </varlistentry>
-
+      
     <varlistentry>
       <term><varname>setupPyInstallFlags</varname></term>
       <listitem><para>
         List of flags passed to <command>setup.py install</command> command.
       </para></listitem>
     </varlistentry>
-
+     
     <varlistentry>
       <term><varname>setupPyBuildFlags</varname></term>
       <listitem><para>
         List of flags passed to <command>setup.py build</command> command.
       </para></listitem>
     </varlistentry>
-
+     
     <varlistentry>
       <term><varname>pythonPath</varname></term>
       <listitem><para>
@@ -404,21 +396,21 @@ twisted = buildPythonPackage {
         (contrary to <varname>propagatedBuildInputs</varname>).
       </para></listitem>
     </varlistentry>
-
+     
     <varlistentry>
       <term><varname>preShellHook</varname></term>
       <listitem><para>
         Hook to execute commands before <varname>shellHook</varname>.
       </para></listitem>
     </varlistentry>
-
+    
     <varlistentry>
       <term><varname>postShellHook</varname></term>
       <listitem><para>
         Hook to execute commands after <varname>shellHook</varname>.
       </para></listitem>
     </varlistentry>
-
+    
     <varlistentry>
       <term><varname>distutilsExtraCfg</varname></term>
       <listitem><para>
@@ -427,83 +419,50 @@ twisted = buildPythonPackage {
         configuration).
       </para></listitem>
     </varlistentry>
-
-    <varlistentry>
-      <term><varname>makeWrapperArgs</varname></term>
-      <listitem><para>
-        A list of strings. Arguments to be passed to
-        <varname>makeWrapper</varname>, which wraps generated binaries. By
-        default, the arguments to <varname>makeWrapper</varname> set
-        <varname>PATH</varname> and <varname>PYTHONPATH</varname> environment
-        variables before calling the binary. Additional arguments here can
-        allow a developer to set environment variables which will be
-        available when the binary is run. For example,
-        <varname>makeWrapperArgs = ["--set FOO BAR" "--set BAZ QUX"]</varname>.
-      </para></listitem>
-    </varlistentry>
-
+  
   </variablelist>
-
+  
 </section>
 
-<section xml:id="ssec-python-build-env"><title><function>python.buildEnv</function> function</title>
+<section xml:id="python-build-env"><title><function>python.buildEnv</function> function</title>
   <para>
     Create Python environments using low-level <function>pkgs.buildEnv</function> function. Example <filename>default.nix</filename>:
-
-<programlisting language="nix">
-<![CDATA[with import <nixpkgs> {};
-
-python.buildEnv.override {
-  extraLibs = [ pkgs.pythonPackages.pyramid ];
-  ignoreCollisions = true;
-}]]>
-</programlisting>
-
+    
+    <programlisting language="nix">
+    <![CDATA[
+      with import <nixpkgs> {};
+      
+      python.buildEnv.override {
+        extraLibs = [ pkgs.pythonPackages.pyramid ];
+        ignoreCollisions = true;
+      }
+    ]]>
+    </programlisting>
+    
     Running <command>nix-build</command> will create
     <filename>/nix/store/cf1xhjwzmdki7fasgr4kz6di72ykicl5-python-2.7.8-env</filename>
     with wrapped binaries in <filename>bin/</filename>.
   </para>
-
-  <para>
-  You can also use <varname>env</varname> attribute to create local
-  environments with needed packages installed (somewhat comparable to
-  <literal>virtualenv</literal>). For example, with the following
-  <filename>shell.nix</filename>:
-
-<programlisting language="nix">
-<![CDATA[with import <nixpkgs> {};
-
-(python3.buildEnv.override {
-  extraLibs = with python3Packages;
-    [ numpy
-      requests
-    ];
-}).env]]>
-</programlisting>
-
-  Running <command>nix-shell</command> will drop you into a shell where
-  <command>python</command> will have specified packages in its path.
-  </para>
-
+  
   <variablelist>
     <title>
       <function>python.buildEnv</function> arguments
     </title>
-
+  
     <varlistentry>
       <term><varname>extraLibs</varname></term>
       <listitem><para>
         List of packages installed inside the environment.
       </para></listitem>
     </varlistentry>
-
+    
     <varlistentry>
       <term><varname>postBuild</varname></term>
       <listitem><para>
         Shell command executed after the build of environment.
       </para></listitem>
     </varlistentry>
-
+    
     <varlistentry>
       <term><varname>ignoreCollisions</varname></term>
       <listitem><para>
@@ -513,7 +472,7 @@ python.buildEnv.override {
   </variablelist>
 </section>
 
-<section xml:id="ssec-python-tools"><title>Tools</title>
+<section xml:id="python-tools"><title>Tools</title>
 
 <para>Packages inside nixpkgs are written by hand. However many tools
 exist in community to help save time. No tool is preferred at the moment.
@@ -540,43 +499,42 @@ exist in community to help save time. No tool is preferred at the moment.
 
 </section>
 
-<section xml:id="ssec-python-development"><title>Development</title>
+<section xml:id="python-development"><title>Development</title>
 
   <para>
-    To develop Python packages <function>buildPythonPackage</function> has
+    To develop Python packages <function>bulidPythonPackage</function> has
     additional logic inside <varname>shellPhase</varname> to run
     <command>${python.interpreter} setup.py develop</command> for the package.
   </para>
-
-  <warning><para><varname>shellPhase</varname> is executed only if <filename>setup.py</filename>
-  exists.</para></warning>
-
+  
   <para>
     Given a <filename>default.nix</filename>:
-
-<programlisting language="nix">
-<![CDATA[with import <nixpkgs> {};
-
-buildPythonPackage {
-  name = "myproject";
-
-  buildInputs = with pkgs.pythonPackages; [ pyramid ];
-
-  src = ./.;
-}]]>
-</programlisting>
-
+    
+    <programlisting language="nix">
+    <![CDATA[
+      with import <nixpkgs> {};
+      
+      buildPythonPackage {
+        name = "myproject";
+      
+        buildInputs = with pkgs.pythonPackages; [ pyramid ];
+      
+        src = ./.;
+      }
+    ]]>
+    </programlisting>
+    
     Running <command>nix-shell</command> with no arguments should give you
     the environment in which the package would be build with
     <command>nix-build</command>.
   </para>
-
+  
   <para>
     Shortcut to setup environments with C headers/libraries and python packages:
-
+    
     <programlisting language="bash">$ nix-shell -p pythonPackages.pyramid zlib libjpeg git</programlisting>
   </para>
-
+  
   <note><para>
     There is a boolean value <varname>lib.inNixShell</varname> set to
     <varname>true</varname> if nix-shell is invoked.
@@ -584,7 +542,7 @@ buildPythonPackage {
 
 </section>
 
-<section xml:id="ssec-python-faq"><title>FAQ</title>
+<section xml:id="python-faq"><title>FAQ</title>
 
 <variablelist>
 
@@ -605,18 +563,18 @@ buildPythonPackage {
       Known bug in setuptools <varname>install_data</varname> does not respect --prefix</link>. Example of
       such package using the feature is <filename>pkgs/tools/X11/xpra/default.nix</filename>. As workaround
       install it as an extra <varname>preInstall</varname> step:
-
+      
       <programlisting>${python.interpreter} setup.py install_data --install-dir=$out --root=$out
 sed -i '/ = data_files/d' setup.py</programlisting>
     </para></listitem>
   </varlistentry>
-
+  
   <varlistentry>
     <term>Rationale of non-existent global site-packages</term>
     <listitem><para>
       There is no need to have global site-packages in Nix. Each package has isolated
       dependency tree and installing any python package will only populate <varname>$PATH</varname>
-      inside user environment. See <xref linkend="ssec-python-build-env" /> to create self-contained
+      inside user environment. See <xref linkend="python-build-env" /> to create self-contained
       interpreter with a set of packages.
     </para></listitem>
   </varlistentry>
@@ -626,7 +584,7 @@ sed -i '/ = data_files/d' setup.py</programlisting>
 </section>
 
 
-<section xml:id="ssec-python-contrib"><title>Contributing guidelines</title>
+<section xml:id="python-contrib"><title>Contributing guidelines</title>
 <para>
   Following rules are desired to be respected:
 </para>
@@ -654,169 +612,23 @@ sed -i '/ = data_files/d' setup.py</programlisting>
 </section>
 
 
-<section xml:id="sec-language-ruby"><title>Ruby</title>
-  <para>There currently is support to bundle applications that are packaged as Ruby gems. The utility "bundix" allows you to write a <filename>Gemfile</filename>, let bundler create a <filename>Gemfile.lock</filename>, and then convert
-  this into a nix expression that contains all Gem dependencies automatically.</para>
-
-  <para>For example, to package sensu, we did:</para>
-
-<screen>
-<![CDATA[$ cd pkgs/servers/monitoring
-$ mkdir sensu
-$ cat > Gemfile
-source 'https://rubygems.org'
-gem 'sensu'
-$ bundler package --path /tmp/vendor/bundle
-$ $(nix-build '<nixpkgs>' -A bundix)/bin/bundix
-$ cat > default.nix
-{ lib, bundlerEnv, ruby }:
-
-bundlerEnv {
-  name = "sensu-0.17.1";
-
-  inherit ruby;
-  gemfile = ./Gemfile;
-  lockfile = ./Gemfile.lock;
-  gemset = ./gemset.nix;
-
-  meta = with lib; {
-    description = "A monitoring framework that aims to be simple, malleable,
-and scalable.";
-    homepage    = http://sensuapp.org/;
-    license     = with licenses; mit;
-    maintainers = with maintainers; [ theuni ];
-    platforms   = platforms.unix;
-  };
-}]]>
-</screen>
-
-<para>Please check in the <filename>Gemfile</filename>, <filename>Gemfile.lock</filename> and the <filename>gemset.nix</filename> so future updates can be run easily.
-</para>
-
+<section xml:id="ssec-language-ruby"><title>Ruby</title>
+  <para>For example, to package yajl-ruby package, use gem-nix:</para>
+  
+  <screen>
+    $ nix-env -i gem-nix
+    $ gem-nix --no-user-install --nix-file=pkgs/development/interpreters/ruby/generated.nix yajl-ruby
+    $ nix-build -A rubyLibs.yajl-ruby
+  </screen>
 </section>
 
-<section xml:id="sec-language-go"><title>Go</title>
-
-<para>The function <varname>buildGoPackage</varname> builds
-standard Go packages.
-</para>
-
-<example xml:id='ex-buildGoPackage'><title>buildGoPackage</title>
-<programlisting>
-net = buildGoPackage rec {
-  name = "go.net-${rev}";
-  goPackagePath = "golang.org/x/net"; <co xml:id='ex-buildGoPackage-1' />
-  subPackages = [ "ipv4" "ipv6" ]; <co xml:id='ex-buildGoPackage-2' />
-  rev = "e0403b4e005";
-  src = fetchFromGitHub {
-    inherit rev;
-    owner = "golang";
-    repo = "net";
-    sha256 = "1g7cjzw4g4301a3yqpbk8n1d4s97sfby2aysl275x04g0zh8jxqp";
-  };
-  goPackageAliases = [ "code.google.com/p/go.net" ]; <co xml:id='ex-buildGoPackage-3' />
-  propagatedBuildInputs = [ goPackages.text ]; <co xml:id='ex-buildGoPackage-4' />
-  buildFlags = "--tags release"; <co xml:id='ex-buildGoPackage-5' />
-  disabled = isGo13;<co xml:id='ex-buildGoPackage-6' />
-};
-</programlisting>
-</example>
-
-<para><xref linkend='ex-buildGoPackage'/> is an example expression using buildGoPackage,
-the following arguments are of special significance to the function:
-
-<calloutlist>
-
-  <callout arearefs='ex-buildGoPackage-1'>
-    <para>
-      <varname>goPackagePath</varname> specifies the package's canonical Go import path.
-    </para>
-  </callout>
-
-  <callout arearefs='ex-buildGoPackage-2'>
-    <para>
-      <varname>subPackages</varname> limits the builder from building child packages that
-      have not been listed. If <varname>subPackages</varname> is not specified, all child
-      packages will be built.
-    </para>
-    <para>
-      In this example only <literal>code.google.com/p/go.net/ipv4</literal> and
-      <literal>code.google.com/p/go.net/ipv4</literal> will be built.
-    </para>
-  </callout>
-
-  <callout arearefs='ex-buildGoPackage-3'>
-    <para>
-      <varname>goPackageAliases</varname> is a list of alternative import paths
-      that are valid for this library.
-      Packages that depend on this library will automatically rename
-      import paths that match any of the aliases to <literal>goPackagePath</literal>.
-    </para>
-    <para>
-      In this example imports will be renamed from
-      <literal>code.google.com/p/go.net</literal> to
-      <literal>golang.org/x/net</literal> in every package that depend on the
-      <literal>go.net</literal> library.
-    </para>
-  </callout>
-
-  <callout arearefs='ex-buildGoPackage-4'>
-    <para>
-      <varname>propagatedBuildInputs</varname> is where the dependencies of a Go library are
-      listed. Only libraries should list <varname>propagatedBuildInputs</varname>. If a standalone
-      program is being build instead, use <varname>buildInputs</varname>. If a library's tests require
-      additional dependencies that are not propagated, they should be listed in <varname>buildInputs</varname>.
-    </para>
-  </callout>
-
-  <callout arearefs='ex-buildGoPackage-5'>
-    <para>
-      <varname>buildFlags</varname> is a list of flags passed to the go build command.
-    </para>
-  </callout>
-
-  <callout arearefs='ex-buildGoPackage-6'>
-    <para>
-      If <varname>disabled</varname> is <literal>true</literal>,
-      nix will refuse to build this package.
-    </para>
-    <para>
-      In this example the package will not be built for go 1.3. The <literal>isGo13</literal>
-      is an utility function that returns <literal>true</literal> if go used to build the
-      package has version 1.3.x.
-    </para>
-  </callout>
-
-</calloutlist>
-
-</para>
-
-<para>
-Reusable Go libraries may be found in the <varname>goPackages</varname> set. You can test
-build a Go package as follows:
-
-<screen>
-$ nix-build -A goPackages.net
-</screen>
-
-</para>
-
-<para>
-You may use Go packages installed into the active Nix profiles by adding
-the following to your ~/.bashrc:
-
-<screen>
-for p in $NIX_PROFILES; do
-    GOPATH="$p/share/go:$GOPATH"
-done
-</screen>
-</para>
 
+<section xml:id="ssec-language-go"><title>Go</title>
   <para>To extract dependency information from a Go package in automated way use <link xlink:href="https://github.com/cstrahan/go2nix">go2nix</link>.</para>
 </section>
 
 
-<section xml:id="sec-language-java"><title>Java</title>
+<section xml:id="ssec-language-java"><title>Java</title>
 
 <para>Ant-based Java packages are typically built from source as follows:
 
@@ -897,7 +709,7 @@ Runtime) instead of the OpenJRE.</para>
 </section>
 
 
-<section xml:id="sec-language-lua"><title>Lua</title>
+<section xml:id="ssec-language-lua"><title>Lua</title>
 
 <para>
   Lua packages are built by the <varname>buildLuaPackage</varname> function.  This function is
@@ -905,7 +717,7 @@ Runtime) instead of the OpenJRE.</para>
   in <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/lua-modules/generic/default.nix">
   <filename>pkgs/development/lua-modules/generic/default.nix</filename></link>
   and works similarly to <varname>buildPerlPackage</varname>. (See
-  <xref linkend="sec-language-perl"/> for details.)
+  <xref linkend="ssec-language-perl"/> for details.)
 </para>
 
 <para>
@@ -919,7 +731,7 @@ fileSystem = buildLuaPackage {
   src = fetchurl {
     url = "https://github.com/keplerproject/luafilesystem/archive/v1_6_2.tar.gz";
     sha256 = "1n8qdwa20ypbrny99vhkmx8q04zd2jjycdb5196xdhgvqzk10abz";
-  };
+  };  
   meta = {
     homepage = "https://github.com/keplerproject/luafilesystem";
     hydraPlatforms = stdenv.lib.platforms.linux;
@@ -930,7 +742,7 @@ fileSystem = buildLuaPackage {
 </para>
 
 <para>
-  Though, more complicated package should be placed in a seperate file in
+  Though, more complicated package should be placed in a seperate file in 
   <link
   xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/development/lua-modules"><filename>pkgs/development/lua-modules</filename></link>.
 </para>
@@ -944,7 +756,7 @@ fileSystem = buildLuaPackage {
 
 </section>
 
-<section xml:id="sec-language-coq"><title>Coq</title>
+<section xml:id="ssec-language-coq"><title>Coq</title>
   <para>
     Coq libraries should be installed in
     <literal>$(out)/lib/coq/${coq.coq-version}/user-contrib/</literal>.

doc/manual.xml

@@ -12,14 +12,10 @@
   <xi:include href="introduction.xml" />
   <xi:include href="quick-start.xml" />
   <xi:include href="stdenv.xml" />
-  <xi:include href="packageconfig.xml" />
-  <xi:include href="functions.xml" />
   <xi:include href="meta.xml" />
   <xi:include href="language-support.xml" />
   <xi:include href="package-notes.xml" />
   <xi:include href="coding-conventions.xml" />
-  <xi:include href="submitting-changes.xml" />
-  <xi:include href="haskell-users-guide.xml" />
   <xi:include href="contributing.xml" />
 
 </book>

doc/meta.xml

@@ -82,8 +82,7 @@ hello-2.3  A program that produces a familiar, friendly greeting
 </para>
 
 
-<section xml:id="sec-standard-meta-attributes"><title>Standard
-meta-attributes</title>
+<section><title>Standard meta-attributes</title>
 
 <para>It is expected that each meta-attribute is one of the following:</para>
 
@@ -138,39 +137,12 @@ meta-attributes</title>
 
   <varlistentry>
     <term><varname>license</varname></term>
-    <listitem>
-      <para>
-        The license, or licenses, for the package. One from the attribute set
-        defined in <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/lib/licenses.nix">
-          <filename>nixpkgs/lib/licenses.nix</filename></link>. At this moment
-        using both a list of licenses and a single license is valid. If the
-        license field is in the form of a list representation, then it means
-        that parts of the package are licensed differently.  Each license
-        should preferably be referenced by their attribute. The non-list
-        attribute value can also be a space delimited string representation of
-        the contained attribute shortNames or spdxIds. The following are all valid
-        examples:
-        <itemizedlist>
-          <listitem><para>Single license referenced by attribute (preferred)
-              <literal>stdenv.lib.licenses.gpl3</literal>.
-          </para></listitem>
-          <listitem><para>Single license referenced by its attribute shortName (frowned upon)
-              <literal>"gpl3"</literal>.
-          </para></listitem>
-          <listitem><para>Single license referenced by its attribute spdxId (frowned upon)
-              <literal>"GPL-3.0"</literal>.
-          </para></listitem>
-          <listitem><para>Multiple licenses referenced by attribute (preferred)
-              <literal>with stdenv.lib.licenses; [ asl20 free ofl ]</literal>.
-          </para></listitem>
-          <listitem><para>Multiple licenses referenced as a space delimited string of attribute shortNames (frowned upon)
-              <literal>"asl20 free ofl"</literal>.
-          </para></listitem>
-        </itemizedlist>
-        For details, see <xref linkend='sec-meta-license'/>.
-      </para>
-    </listitem>
+    <listitem><para>The license for the package. One from the
+    attribute set defined in <link
+    xlink:href="https://github.com/NixOS/nixpkgs/blob/master/lib/licenses.nix">
+    <filename>nixpkgs/lib/licenses.nix</filename></link>.  Example:
+    <literal>stdenv.lib.licenses.gpl3</literal>. For details, see
+    <xref linkend='sec-meta-license'/>.</para></listitem>
   </varlistentry>
 
   <varlistentry>

doc/old/cross.txt

@@ -184,10 +184,10 @@ if test "$noSysDirs" = "1"; then
     if test "$noSysDirs" = "1"; then
         # Figure out what extra flags to pass to the gcc compilers
         # being generated to make sure that they use our glibc.
-        if test -e $NIX_CC/nix-support/orig-glibc; then
-            glibc=$(cat $NIX_CC/nix-support/orig-glibc)
+        if test -e $NIX_GCC/nix-support/orig-glibc; then
+            glibc=$(cat $NIX_GCC/nix-support/orig-glibc)
             # Ugh.  Copied from gcc-wrapper/builder.sh.  We can't just
-            # source in $NIX_CC/nix-support/add-flags, since that
+            # source in $NIX_GCC/nix-support/add-flags, since that
             # would cause *this* GCC to be linked against the
             # *previous* GCC.  Need some more modularity there.
             extraCFlags="-B$glibc/lib -isystem $glibc/include"

doc/package-notes.xml

@@ -141,7 +141,7 @@ $ make menuconfig ARCH=<replaceable>arch</replaceable></screen>
 
 <!--============================================================-->
 
-<section xml:id="sec-xorg">
+<section>
 
 <title>X.org</title>
 
@@ -219,151 +219,5 @@ you should modify
 </section>
 -->
 
-<!--============================================================-->
-
-<section xml:id="sec-eclipse">
-
-  <title>Eclipse</title>
-
-  <para>
-    The Nix expressions related to the Eclipse platform and IDE are in
-    <link xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/editors/eclipse"><filename>pkgs/applications/editors/eclipse</filename></link>.
-  </para>
-
-  <para>
-    Nixpkgs provides a number of packages that will install Eclipse in
-    its various forms, these range from the bare-bones Eclipse
-    Platform to the more fully featured Eclipse SDK or Scala-IDE
-    packages and multiple version are often available. It is possible
-    to list available Eclipse packages by issuing the command:
-
-<screen>
-$ nix-env -f '&lt;nixpkgs&gt;' -qaP -A eclipses --description
-</screen>
-
-    Once an Eclipse variant is installed it can be run using the
-    <command>eclipse</command> command, as expected. From within
-    Eclipse it is then possible to install plugins in the usual manner
-    by either manually specifying an Eclipse update site or by
-    installing the Marketplace Client plugin and using it to discover
-    and install other plugins. This installation method provides an
-    Eclipse installation that closely resemble a manually installed
-    Eclipse.
-  </para>
-
-  <para>
-    If you prefer to install plugins in a more declarative manner then
-    Nixpkgs also offer a number of Eclipse plugins that can be
-    installed in an <emphasis>Eclipse environment</emphasis>. This
-    type of environment is created using the function
-    <varname>eclipseWithPlugins</varname> found inside the
-    <varname>nixpkgs.eclipses</varname> attribute set. This function
-    takes as argument <literal>{ eclipse, plugins ? [], jvmArgs ? []
-    }</literal> where <varname>eclipse</varname> is a one of the
-    Eclipse packages described above, <varname>plugins</varname> is a
-    list of plugin derivations, and <varname>jvmArgs</varname> is a
-    list of arguments given to the JVM running the Eclipse. For
-    example, say you wish to install the latest Eclipse Platform with
-    the popular Eclipse Color Theme plugin and also allow Eclipse to
-    use more RAM. You could then add
-
-<screen>
-packageOverrides = pkgs: {
-  myEclipse = with pkgs.eclipses; eclipseWithPlugins {
-    eclipse = eclipse-platform;
-    jvmArgs = [ "-Xmx2048m" ];
-    plugins = [ plugins.color-theme ];
-  };
-}
-</screen>
-
-    to your Nixpkgs configuration
-    (<filename>~/.nixpkgs/config.nix</filename>) and install it by
-    running <command>nix-env -f '&lt;nixpkgs&gt;' -iA
-    myEclipse</command> and afterward run Eclipse as usual. It is
-    possible to find out which plugins are available for installation
-    using <varname>eclipseWithPlugins</varname> by running
-
-<screen>
-$ nix-env -f '&lt;nixpkgs&gt;' -qaP -A eclipses.plugins --description
-</screen>
-  </para>
-
-  <para>
-    If there is a need to install plugins that are not available in
-    Nixpkgs then it may be possible to define these plugins outside
-    Nixpkgs using the <varname>buildEclipseUpdateSite</varname> and
-    <varname>buildEclipsePlugin</varname> functions found in the
-    <varname>nixpkgs.eclipses.plugins</varname> attribute set. Use the
-    <varname>buildEclipseUpdateSite</varname> function to install a
-    plugin distributed as an Eclipse update site. This function takes
-    <literal>{ name, src }</literal> as argument where
-    <literal>src</literal> indicates the Eclipse update site archive.
-    All Eclipse features and plugins within the downloaded update site
-    will be installed. When an update site archive is not available
-    then the <varname>buildEclipsePlugin</varname> function can be
-    used to install a plugin that consists of a pair of feature and
-    plugin JARs. This function takes an argument <literal>{ name,
-    srcFeature, srcPlugin }</literal> where
-    <literal>srcFeature</literal> and <literal>srcPlugin</literal> are
-    the feature and plugin JARs, respectively.
-  </para>
-
-  <para>
-    Expanding the previous example with two plugins using the above
-    functions we have
-<screen>
-packageOverrides = pkgs: {
-  myEclipse = with pkgs.eclipses; eclipseWithPlugins {
-    eclipse = eclipse-platform;
-    jvmArgs = [ "-Xmx2048m" ];
-    plugins = [
-      plugins.color-theme
-      (plugins.buildEclipsePlugin {
-        name = "myplugin1-1.0";
-        srcFeature = fetchurl {
-          url = "http://…/features/myplugin1.jar";
-          sha256 = "123…";
-        };
-        srcPlugin = fetchurl {
-          url = "http://…/plugins/myplugin1.jar";
-          sha256 = "123…";
-        };
-      });
-      (plugins.buildEclipseUpdateSite {
-        name = "myplugin2-1.0";
-        src = fetchurl {
-          stripRoot = false;
-          url = "http://…/myplugin2.zip";
-          sha256 = "123…";
-        };
-      });
-    ];
-  };
-}
-</screen>
-  </para>
-
-</section>
-
-<section xml:id="sec-elm">
-
-<title>Elm</title>
-
-<para>
-The Nix expressions for Elm reside in
-<filename>pkgs/development/compilers/elm</filename>. They are generated
-automatically by <command>update-elm.rb</command> script. One should
-specify versions of Elm packages inside the script, clear the
-<filename>packages</filename> directory and run the script from inside it.
-<literal>elm-reactor</literal> is special because it also has Elm package
-dependencies. The process is not automated very much for now -- you should
-get the <literal>elm-reactor</literal> source tree (e.g. with
-<command>nix-shell</command>) and run <command>elm2nix.rb</command> inside
-it. Place the resulting <filename>package.nix</filename> file into
-<filename>packages/elm-reactor-elm.nix</filename>.
-</para>
-
-</section>
 
 </chapter>

doc/packageconfig.xml

@@ -1,88 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-	 xmlns:xlink="http://www.w3.org/1999/xlink"
-	 xml:id="chap-packageconfig">
-
-<title><filename>~/.nixpkgs/config.nix</filename>: global configuration</title>
-
-    <para>
-      Nix packages can be configured to allow or deny certain options.
-    </para>
-
-    <para>
-	To apply the configuration edit <filename>~/.nixpkgs/config.nix</filename>
-	and set it like
-<programlisting>{
-  allowUnfree = true;
-}</programlisting>
-	and will allow the Nix package manager to install unfree licensed packages.
-
-	The configuration as listed also applies to NixOS under <option>nixpkgs.config</option> set.
-    </para>
-
-    <itemizedlist>
-	<listitem>
-	    <para>
-		Allow installing of packages that are distributed under unfree license by setting
-		<programlisting>allowUnfree = true;</programlisting>
-		or deny them by setting it to <literal>false</literal>.
-	    </para>
-	    <para>
-		Same can be achieved by setting the environment variable:
-		<programlisting>$ export NIXPKGS_ALLOW_UNFREE=1</programlisting>
-	    </para>
-	</listitem>
-
-	<listitem>
-	    <para>
-		Whenever unfree packages are not allowed, single packages can
-		still be allowed by a predicate function that accepts package
-		as an argument and should return a boolean:
-		<programlisting>allowUnfreePredicate = (pkg: ...);</programlisting>
-
-		Example to allow flash player only:
-		<programlisting>allowUnfreePredicate = (pkg: pkgs.lib.hasPrefix "flashplayer-" pkg.name);</programlisting>
-	    </para>
-	</listitem>
-
-	<listitem>
-	    <para>
-		Whenever unfree packages are not allowed, packages can still be
-		whitelisted by their license:
-		<programlisting>whitelistedLicenses = with stdenv.lib.licenses; [ amd wtfpl ];</programlisting>
-	    </para>
-	</listitem>
-
-	<listitem>
-	    <para>
-		In addition to whitelisting licenses which are denied by the
-		<literal>allowUnfree</literal> setting, you can also explicitely
-		deny installation of packages which have a certain license:
-		<programlisting>blacklistedLicenses = with stdenv.lib.licenses; [ agpl3 gpl3 ];</programlisting>
-	    </para>
-	</listitem>
-    </itemizedlist>
-
-    <para>
-	A complete list of licenses can be found in the file
-	<filename>lib/licenses.nix</filename> of the nix package tree.
-    </para>
-
-<section xml:id="sec-modify-via-packageOverrides"><title>Modify
-packages via <literal>packageOverrides</literal></title>
-
-<para>
-
-  You can define a function called <varname>packageOverrides</varname>
-  in your local <filename>~/.nixpkgs/config</filename> to overide nix
-  packages.  It must be a function that takes pkgs as an argument and
-  return modified set of packages.
-
-  <programlisting>{
-  packageOverrides = pkgs: rec {
-    foo = pkgs.foo.override { ... };
-  };
-}</programlisting>
-</para>
-</section>
-
-</chapter>

doc/quick-start.xml

@@ -55,18 +55,18 @@ $ git add pkgs/development/libraries/libfoo/default.nix</screen>
       <itemizedlist>
 
         <listitem>
-          <para>GNU Hello: <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/hello/ex-2/default.nix"><filename>pkgs/applications/misc/hello/ex-2/default.nix</filename></link>.
-          Trivial package, which specifies some <varname>meta</varname>
-          attributes which is good practice.</para>
+          <para>GNU cpio: <link
+          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/tools/archivers/cpio/default.nix"><filename>pkgs/tools/archivers/cpio/default.nix</filename></link>.
+          The simplest possible package.  The generic builder in
+          <varname>stdenv</varname> does everything for you.  It has
+          no dependencies beyond <varname>stdenv</varname>.</para>
         </listitem>
 
         <listitem>
-          <para>GNU cpio: <link
-          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/tools/archivers/cpio/default.nix"><filename>pkgs/tools/archivers/cpio/default.nix</filename></link>.
-          Also a simple package. The generic builder in
-          <varname>stdenv</varname> does everything for you. It has
-          no dependencies beyond <varname>stdenv</varname>.</para>
+          <para>GNU Hello: <link
+          xlink:href="https://github.com/NixOS/nixpkgs/blob/master/pkgs/applications/misc/hello/ex-2/default.nix"><filename>pkgs/applications/misc/hello/ex-2/default.nix</filename></link>.
+          Also trivial, but it specifies some <varname>meta</varname>
+          attributes which is good practice.</para>
         </listitem>
 
         <listitem>

doc/stdenv.xml

@@ -15,8 +15,7 @@ environment does everything automatically.  If
 can easily customise or override the various build phases.</para>
 
 
-<section xml:id="sec-using-stdenv"><title>Using
-<literal>stdenv</literal></title>
+<section><title>Using <literal>stdenv</literal></title>
 
 <para>To build a package with the standard environment, you use the
 function <varname>stdenv.mkDerivation</varname>, instead of the
@@ -59,7 +58,7 @@ build.  To make this easier, the standard environment breaks the
 package build into a number of <emphasis>phases</emphasis>, all of
 which can be overridden or modified individually: unpacking the
 sources, applying patches, configuring, building, and installing.
-(There are some others; see <xref linkend="sec-stdenv-phases"/>.)
+(There are some others; see <xref linkend="ssec-stdenv-phases"/>.)
 For instance, a package that doesn’t supply a makefile but instead has
 to be compiled “manually” could be handled like this:
 
@@ -125,8 +124,7 @@ genericBuild
 </section>
 
 
-<section xml:id="sec-tools-of-stdenv"><title>Tools provided by
-<literal>stdenv</literal></title>
+<section><title>Tools provided by <literal>stdenv</literal></title>
 
 <para>The standard environment provides the following packages:
 
@@ -227,7 +225,7 @@ genericBuild
 </section>
 
 
-<section xml:id="sec-stdenv-phases"><title>Phases</title>
+<section xml:id="ssec-stdenv-phases"><title>Phases</title>
 
 <para>The generic builder has a number of <emphasis>phases</emphasis>.
 Package builds are split into phases to make it easier to override
@@ -245,8 +243,7 @@ is convenient to override a phase from the derivation, while the
 latter is convenient from a build script.</para>
 
 
-<section xml:id="ssec-controlling-phases"><title>Controlling
-phases</title>
+<section><title>Controlling phases</title>
 
 <para>There are a number of variables that control what phases are
 executed and in what order:
@@ -330,7 +327,7 @@ executed and in what order:
 </section>
 
 
-<section xml:id="ssec-unpack-phase"><title>The unpack phase</title>
+<section><title>The unpack phase</title>
 
 <para>The unpack phase is responsible for unpacking the source code of
 the package.  The default implementation of
@@ -437,7 +434,7 @@ Additional file types can be supported by setting the
 </section>
 
 
-<section xml:id="ssec-patch-phase"><title>The patch phase</title>
+<section><title>The patch phase</title>
 
 <para>The patch phase applies the list of patches defined in the
 <varname>patches</varname> variable.</para>
@@ -480,7 +477,7 @@ Additional file types can be supported by setting the
 </section>
 
 
-<section xml:id="ssec-configure-phase"><title>The configure phase</title>
+<section><title>The configure phase</title>
 
 <para>The configure phase prepares the source tree for building.  The
 default <function>configurePhase</function> runs
@@ -516,8 +513,8 @@ script) if it exists.</para>
     <term><varname>dontAddPrefix</varname></term>
     <listitem><para>By default, the flag
     <literal>--prefix=$prefix</literal> is added to the configure
-    flags.  If this is undesirable, set this variable to
-    true.</para></listitem>
+    flags.  If this is undesirable, set this variable to a non-empty
+    value.</para></listitem>
   </varlistentry>
 
   <varlistentry>
@@ -533,7 +530,8 @@ script) if it exists.</para>
     <listitem><para>By default, the flag
     <literal>--disable-dependency-tracking</literal> is added to the
     configure flags to speed up Automake-based builds.  If this is
-    undesirable, set this variable to true.</para></listitem>
+    undesirable, set this variable to a non-empty
+    value.</para></listitem>
   </varlistentry>
 
   <varlistentry>
@@ -546,16 +544,7 @@ script) if it exists.</para>
     variables in the Libtool script to prevent Libtool from using
     libraries in <filename>/usr/lib</filename> and
     such.</para></footnote>.  If this is undesirable, set this
-    variable to true.</para></listitem>
-  </varlistentry>
-
-  <varlistentry>
-    <term><varname>dontDisableStatic</varname></term>
-    <listitem><para>By default, when the configure script has
-    <option>--enable-static</option>, the option
-    <option>--disable-static</option> is added to the configure flags.</para>
-    <para>If this is undesirable, set this variable to
-    true.</para></listitem>
+    variable to a non-empty value.</para></listitem>
   </varlistentry>
 
   <varlistentry>
@@ -576,7 +565,7 @@ script) if it exists.</para>
 </section>
 
 
-<section xml:id="build-phase"><title>The build phase</title>
+<section><title>The build phase</title>
 
 <para>The build phase is responsible for actually building the package
 (e.g. compiling it).  The default <function>buildPhase</function>
@@ -660,7 +649,7 @@ called, respectively.</para>
 </section>
 
 
-<section xml:id="ssec-check-phase"><title>The check phase</title>
+<section><title>The check phase</title>
 
 <para>The check phase checks whether the package was built correctly
 by running its test suite.  The default
@@ -720,7 +709,7 @@ doCheck = true;</programlisting>
 </section>
 
 
-<section xml:id="ssec-install-phase"><title>The install phase</title>
+<section><title>The install phase</title>
 
 <para>The install phase is responsible for installing the package in
 the Nix store under <envar>out</envar>.  The default
@@ -729,7 +718,7 @@ the Nix store under <envar>out</envar>.  The default
 install</command>.</para>
 
 <variablelist>
-  <title>Variables controlling the install phase</title>
+  <title>Variables controlling the check phase</title>
 
   <varlistentry>
     <term><varname>makeFlags</varname> /
@@ -775,7 +764,7 @@ installTargets = "install-bin install-doc";</programlisting>
 </section>
 
 
-<section xml:id="ssec-fixup-phase"><title>The fixup phase</title>
+<section><title>The fixup phase</title>
 
 <para>The fixup phase performs some (Nix-specific) post-processing
 actions on the files installed under <filename>$out</filename> by the
@@ -808,7 +797,7 @@ following:
 </para>
 
 <variablelist>
-  <title>Variables controlling the fixup phase</title>
+  <title>Variables controlling the check phase</title>
 
   <varlistentry>
     <term><varname>dontStrip</varname></term>
@@ -816,12 +805,6 @@ following:
     stripped.  By default, they are.</para></listitem>
   </varlistentry>
 
-  <varlistentry>
-    <term><varname>dontMoveSbin</varname></term>
-    <listitem><para>If set, files in <filename>$out/sbin</filename> are not moved
-    to <filename>$out/bin</filename>. By default, they are.</para></listitem>
-  </varlistentry>
-
   <varlistentry>
     <term><varname>stripAllList</varname></term>
     <listitem><para>List of directories to search for libraries and
@@ -904,8 +887,7 @@ following:
 </section>
 
 
-<section xml:id="ssec-distribution-phase"><title>The distribution
-phase</title>
+<section><title>The distribution phase</title>
 
 <para>The distribution phase is intended to produce a source
 distribution of the package.  The default
@@ -1209,7 +1191,7 @@ echo @foo@
 </section>
 
 
-<section xml:id="sec-purity-in-nixpkgs"><title>Purity in Nixpkgs</title>
+<section><title>Purity in Nixpkgs</title>
 
 <para>[measures taken to prevent dependencies on packages outside the
 store, and what you can do to prevent them]</para>

doc/submitting-changes.xml

@@ -1,283 +0,0 @@
-<chapter xmlns="http://docbook.org/ns/docbook"
-         xmlns:xlink="http://www.w3.org/1999/xlink"
-         xml:id="chap-submitting-changes">
-
-<title>Submitting changes</title>
-
-<section>
-<title>Making patches</title>
-
-<itemizedlist>
-<listitem>
-<para>Read <link xlink:href="https://nixos.org/nixpkgs/manual/">Manual (How to write packages for Nix)</link>.</para>
-</listitem>
-
-<listitem>
-<para>Fork the repository on GitHub.</para>
-</listitem>
-
-<listitem>
-<para>Create a branch for your future fix.
-
-<itemizedlist>
-<listitem>
-<para>You can make branch from a commit of your local <command>nixos-version</command>. That will help you to avoid additional local compilations. Because you will receive packages from binary cache.
-
-<itemizedlist>
-<listitem>
-<para>For example: <command>nixos-version</command> returns <command>15.05.git.0998212 (Dingo)</command>. So you can do:</para>
-</listitem>
-</itemizedlist>
-
-<screen>
-$ git checkout 0998212
-$ git checkout -b 'fix/pkg-name-update'
-</screen>
-</para>
-</listitem>
-
-<listitem>
-<para>Please avoid working directly on the <command>master</command> branch.</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-
-<listitem>
-<para>Make commits of logical units.
-
-<itemizedlist>
-<listitem>
-<para>If you removed pkgs, made some major NixOS changes etc., write about them in <command>nixos/doc/manual/release-notes/rl-unstable.xml</command>.</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-
-<listitem>
-<para>Check for unnecessary whitespace with <command>git diff --check</command> before committing.</para>
-</listitem>
-
-<listitem>
-<para>Format the commit in a following way:</para>
-<programlisting>
-(pkg-name | service-name): (from -> to | init at version | refactor | etc)
-Additional information.
-</programlisting>
-
-<itemizedlist>
-<listitem>
-<para>Examples:
-
-<itemizedlist>
-<listitem>
-<para>
-<command>nginx: init at 2.0.1</command>
-</para>
-</listitem>
-
-<listitem>
-<para>
-<command>firefox: 3.0 -> 3.1.1</command>
-</para>
-</listitem>
-
-<listitem>
-<para>
-<command>hydra service: add bazBaz option</command>
-</para>
-</listitem>
-
-<listitem>
-<para>
-<command>nginx service: refactor config generation</command>
-</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-</itemizedlist>
-</listitem>
-
-<listitem>
-<para>Test your changes. If you work with
-
-<itemizedlist>
-<listitem>
-<para>nixpkgs:
-
-<itemizedlist>
-<listitem>
-<para>update pkg ->
-
-<itemizedlist>
-<listitem>
-<para>
-<command>nix-env -i pkg-name -f &lt;path to your local nixpkgs folder&gt;</command>
-</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-
-<listitem>
-<para>add pkg ->
-
-<itemizedlist>
-<listitem>
-<para>Make sure it's in <command>pkgs/top-level/all-packages.nix</command>
-</para>
-</listitem>
-
-<listitem>
-<para>
-<command>nix-env -i pkg-name -f &lt;path to your local nixpkgs folder&gt;</command>
-</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-
-<listitem>
-<para>
-<emphasis>If you don't want to install pkg in you profile</emphasis>.
-
-<itemizedlist>
-<listitem>
-<para>
-<command>nix-build -A pkg-attribute-name &lt;path to your local nixpkgs folder&gt;/default.nix</command> and check results in the folder <command>result</command>. It will appear in the same directory where you did <command>nix-build</command>.</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-
-<listitem>
-<para>If you did <command>nix-env -i pkg-name</command> you can do <command>nix-env -e pkg-name</command> to uninstall it from your system.</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-
-<listitem>
-<para>NixOS and its modules:
-
-<itemizedlist>
-<listitem>
-<para>You can add new module to your NixOS configuration file (usually it's <command>/etc/nixos/configuration.nix</command>).
-            And do <command>sudo nixos-rebuild test -I nixpkgs=&lt;path to your local nixpkgs folder&gt; --fast</command>.</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-
-<listitem>
-<para>If you have commits <command>pkg-name: oh, forgot to insert whitespace</command>: squash commits in this case. Use <command>git rebase -i</command>.</para>
-</listitem>
-
-<listitem>
-<para>Rebase you branch against current <command>master</command>.</para>
-</listitem>
-</itemizedlist>
-</section>
-
-<section>
-<title>Submitting changes</title>
-
-<itemizedlist>
-<listitem>
-<para>Push your changes to your fork of nixpkgs.</para>
-</listitem>
-
-<listitem>
-<para>Create pull request:
-
-<itemizedlist>
-<listitem>
-<para>Write the title in format <command>(pkg-name | service): improvement</command>.
-
-<itemizedlist>
-<listitem>
-<para>If you update the pkg, write versions <command>from -> to</command>.</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-
-<listitem>
-<para>Write in comment if you have tested your patch. Do not rely much on <command>TravisCI</command>.</para>
-</listitem>
-
-<listitem>
-<para>If you make an improvement, write about your motivation.</para>
-</listitem>
-
-<listitem>
-<para>Notify maintainers of the package. For example add to the message: <command>cc @jagajaga @domenkozar</command>.</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-</itemizedlist>
-</section>
-
-<section>
-<title>Hotfixing pull requests</title>
-
-<itemizedlist>
-<listitem>
-<para>Make the appropriate changes in you branch.</para>
-</listitem>
-
-<listitem>
-<para>Don't create additional commits, do
-
-<itemizedlist>
-<listitem>
-<para><command>git rebase -i</command></para>
-</listitem>
-<listitem>
-<para>
-<command>git push --force</command> to your branch.</para>
-</listitem>
-</itemizedlist>
-</para>
-</listitem>
-
-</itemizedlist>
-</section>
-
-<section>
-<title>Commit policy</title>
-
-<itemizedlist>
-<listitem>
-<para>Commits must be sufficiently tested before being merged, both for the master and staging branches.</para>
-</listitem>
-
-<listitem>
-<para>Hydra builds for master and staging should not be used as testing platform, it's a build farm for changes that have been already tested.</para>
-</listitem>
-
-<listitem>
-<para>Master should only see non-breaking commits that do not cause mass rebuilds.</para>
-</listitem>
-
-<listitem>
-<para>Staging should only see non-breaking mass-rebuild commits. That means it's not to be used for testing, and changes must have been well tested already. <link xlink:href="http://comments.gmane.org/gmane.linux.distributions.nixos/13447">Read policy here</link>.</para>
-</listitem>
-
-<listitem>
-<para>If staging is already in a broken state, please refrain from adding extra new breakages. Stabilize it for a few days, merge into master, then resume development on staging. <link xlink:href="http://hydra.nixos.org/jobset/nixpkgs/staging#tabs-evaluations">Keep an eye on the staging evaluations here</link>.</para>
-</listitem>
-
-<listitem>
-<para>When changing the bootloader installation process, extra care must be taken. Grub installations cannot be rolled back, hence changes may break people's installations forever. For any non-trivial change to the bootloader please file a PR asking for review, especially from @edolstra.</para>
-</listitem>
-</itemizedlist>
-
-</section>
-</chapter>
-

lib/attrsets.nix

@@ -1,11 +1,12 @@
 # Operations on attribute sets.
 
 with {
-  inherit (builtins) head tail length;
+  inherit (builtins) head tail;
   inherit (import ./trivial.nix) or;
   inherit (import ./default.nix) fold;
   inherit (import ./strings.nix) concatStringsSep;
   inherit (import ./lists.nix) concatMap concatLists all deepSeqList;
+  inherit (import ./misc.nix) maybeAttr;
 };
 
 rec {
@@ -75,7 +76,7 @@ rec {
        => { foo = 1; }
   */
   filterAttrs = pred: set:
-    listToAttrs (concatMap (name: let v = set.${name}; in if pred name v then [(nameValuePair name v)] else []) (attrNames set));
+    listToAttrs (fold (n: ys: let v = set.${n}; in if pred n v then [(nameValuePair n v)] ++ ys else ys) [] (attrNames set));
 
 
   /* foldAttrs: apply fold functions to values grouped by key. Eg accumulate values as list:
@@ -85,7 +86,7 @@ rec {
   foldAttrs = op: nul: list_of_attrs:
     fold (n: a:
         fold (name: o:
-          o // (listToAttrs [{inherit name; value = op n.${name} (a.${name} or nul); }])
+          o // (listToAttrs [{inherit name; value = op n.${name} (maybeAttr name nul a); }])
         ) a (attrNames n)
     ) {} list_of_attrs;
 

lib/customisation.nix

@@ -1,8 +1,6 @@
 let
-
   lib = import ./default.nix;
   inherit (builtins) attrNames isFunction;
-
 in
 
 rec {
@@ -31,8 +29,8 @@ rec {
 
      For another application, see build-support/vm, where this
      function is used to build arbitrary derivations inside a QEMU
-     virtual machine.
-  */
+     virtual machine. */
+     
   overrideDerivation = drv: f:
     let
       newDrv = derivation (drv.drvAttrs // (f drv));
@@ -51,23 +49,29 @@ rec {
        else { }));
 
 
+  # usage: (you can use override multiple times)
+  # let d = makeOverridable stdenv.mkDerivation { name = ..; buildInputs; }
+  #     noBuildInputs = d.override { buildInputs = []; }
+  #     additionalBuildInputs = d.override ( args : args // { buildInputs = args.buildInputs ++ [ additional ]; } )
   makeOverridable = f: origArgs:
     let
       ff = f origArgs;
-      overrideWith = newArgs: origArgs // (if builtins.isFunction newArgs then newArgs origArgs else newArgs);
     in
       if builtins.isAttrs ff then (ff //
-        { override = newArgs: makeOverridable f (overrideWith newArgs);
+        { override = newArgs:
+            makeOverridable f (origArgs // (if builtins.isFunction newArgs then newArgs origArgs else newArgs));
+          deepOverride = newArgs:
+            makeOverridable f (lib.overrideExisting (lib.mapAttrs (deepOverrider newArgs) origArgs) newArgs);
           overrideDerivation = fdrv:
             makeOverridable (args: overrideDerivation (f args) fdrv) origArgs;
         })
-      else if builtins.isFunction ff then
-        { override = newArgs: makeOverridable f (overrideWith newArgs);
-          __functor = self: ff;
-          overrideDerivation = throw "overrideDerivation not yet supported for functors";
-        }
       else ff;
 
+  deepOverrider = newArgs: name: x: if builtins.isAttrs x then (
+    if x ? deepOverride then (x.deepOverride newArgs) else
+    if x ? override then (x.override newArgs) else
+    x) else x;
+
 
   /* Call the package function in the file `fn' with the required
     arguments automatically.  The function is called with the
@@ -91,29 +95,10 @@ rec {
       };
   */
   callPackageWith = autoArgs: fn: args:
-    let
-      f = if builtins.isFunction fn then fn else import fn;
-      auto = builtins.intersectAttrs (builtins.functionArgs f) autoArgs;
-    in makeOverridable f (auto // args);
+    let f = if builtins.isFunction fn then fn else import fn; in
+    makeOverridable f ((builtins.intersectAttrs (builtins.functionArgs f) autoArgs) // args);
 
-
-  /* Like callPackage, but for a function that returns an attribute
-     set of derivations. The override function is added to the
-     individual attributes. */
-  callPackagesWith = autoArgs: fn: args:
-    let
-      f = if builtins.isFunction fn then fn else import fn;
-      auto = builtins.intersectAttrs (builtins.functionArgs f) autoArgs;
-      finalArgs = auto // args;
-      pkgs = f finalArgs;
-      mkAttrOverridable = name: pkg: pkg // {
-        override = newArgs: mkAttrOverridable name (f (finalArgs // newArgs)).${name};
-      };
-    in lib.mapAttrs mkAttrOverridable pkgs;
-
-
-  /* Add attributes to each output of a derivation without changing
-     the derivation itself. */
+  /* Add attributes to each output of a derivation without changing the derivation itself */
   addPassthru = drv: passthru:
     let
       outputs = drv.outputs or [ "out" ];
@@ -130,38 +115,4 @@ rec {
 
       outputsList = map outputToAttrListElement outputs;
   in commonAttrs.${drv.outputName};
-
-
-  /* Strip a derivation of all non-essential attributes, returning
-     only those needed by hydra-eval-jobs. Also strictly evaluate the
-     result to ensure that there are no thunks kept alive to prevent
-     garbage collection. */
-  hydraJob = drv:
-    let
-      outputs = drv.outputs or ["out"];
-
-      commonAttrs =
-        { inherit (drv) name system meta; inherit outputs; }
-        // lib.optionalAttrs (drv._hydraAggregate or false) {
-          _hydraAggregate = true;
-          constituents = map hydraJob (lib.flatten drv.constituents);
-        }
-        // (lib.listToAttrs outputsList);
-
-      makeOutput = outputName:
-        let output = drv.${outputName}; in
-        { name = outputName;
-          value = commonAttrs // {
-            outPath = output.outPath;
-            drvPath = output.drvPath;
-            type = "derivation";
-            inherit outputName;
-          };
-        };
-
-      outputsList = map makeOutput outputs;
-
-      drv' = (lib.head outputsList).value;
-    in lib.deepSeq drv' drv';
-
 }

lib/debug.nix

@@ -13,11 +13,10 @@ rec {
 
   addErrorContextToAttrs = lib.mapAttrs (a: v: lib.addErrorContext "while evaluating ${a}" v);
 
-  traceIf = p: msg: x: if p then trace msg x else x;
 
-  traceVal = x: trace x x;
-  traceXMLVal = x: trace (builtins.toXML x) x;
-  traceXMLValMarked = str: x: trace (str + builtins.toXML x) x;
+  traceVal = x: builtins.trace x x;
+  traceXMLVal = x: builtins.trace (builtins.toXML x) x;
+  traceXMLValMarked = str: x: builtins.trace (str + builtins.toXML x) x;
 
   # this can help debug your code as well - designed to not produce thousands of lines
   traceShowVal = x : trace (showVal x) x;
@@ -43,7 +42,6 @@ rec {
   traceCall2 = n : f : a : b : let t = n2 : x : traceShowValMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a) (t "arg 2" b));
   traceCall3 = n : f : a : b : c : let t = n2 : x : traceShowValMarked "${n} ${n2}:" x; in t "result" (f (t "arg 1" a) (t "arg 2" b) (t "arg 3" c));
 
-  # FIXME: rename this?
   traceValIfNot = c: x:
     if c x then true else trace (showVal x) false;
 
@@ -108,6 +106,6 @@ rec {
             )
           else
             let r = strict expr;
-            in trace "${str}\n result:\n${builtins.toXML r}" r
+            in builtins.trace "${str}\n result:\n${builtins.toXML r}" r
       );
 }

lib/default.nix

@@ -11,7 +11,7 @@ let
   types = import ./types.nix;
   meta = import ./meta.nix;
   debug = import ./debug.nix;
-  misc = import ./deprecated.nix;
+  misc = import ./misc.nix;
   maintainers = import ./maintainers.nix;
   platforms = import ./platforms.nix;
   systems = import ./systems.nix;

lib/deprecated.nix

@@ -1,423 +0,0 @@
-let lib = import ./default.nix;
-    inherit (builtins) isFunction head tail isList isAttrs isInt attrNames;
-
-in
-
-with import ./lists.nix;
-with import ./attrsets.nix;
-with import ./strings.nix;
-
-rec {
-
-  # returns default if env var is not set
-  maybeEnv = name: default:
-    let value = builtins.getEnv name; in
-    if value == "" then default else value;
-
-  defaultMergeArg = x : y: if builtins.isAttrs y then
-    y
-  else 
-    (y x);
-  defaultMerge = x: y: x // (defaultMergeArg x y);
-  foldArgs = merger: f: init: x: 
-    let arg=(merger init (defaultMergeArg init x));
-      # now add the function with composed args already applied to the final attrs
-        base = (setAttrMerge "passthru" {} (f arg) 
-                        ( z : z // rec { 
-                          function = foldArgs merger f arg; 
-			  args = (lib.attrByPath ["passthru" "args"] {} z) // x;
-                          } ));
-	withStdOverrides = base // {
-	   override = base.passthru.function;
-	   } ;
-        in
-	withStdOverrides;
-    
-
-  # predecessors: proposed replacement for applyAndFun (which has a bug cause it merges twice)
-  # the naming "overridableDelayableArgs" tries to express that you can
-  # - override attr values which have been supplied earlier
-  # - use attr values before they have been supplied by accessing the fix point
-  #   name "fixed"
-  # f: the (delayed overridden) arguments are applied to this
-  #
-  # initial: initial attrs arguments and settings. see defaultOverridableDelayableArgs
-  #
-  # returns: f applied to the arguments // special attributes attrs
-  #     a) merge: merge applied args with new args. Wether an argument is overridden depends on the merge settings
-  #     b) replace: this let's you replace and remove names no matter which merge function has been set
-  #
-  # examples: see test cases "res" below;
-  overridableDelayableArgs =
-          f :        # the function applied to the arguments
-          initial :  # you pass attrs, the functions below are passing a function taking the fix argument
-    let
-        takeFixed = if isFunction initial then initial else (fixed : initial); # transform initial to an expression always taking the fixed argument
-        tidy = args : 
-            let # apply all functions given in "applyPreTidy" in sequence
-                applyPreTidyFun = fold ( n : a : x : n ( a x ) ) lib.id (maybeAttr "applyPreTidy" [] args);
-            in removeAttrs (applyPreTidyFun args) ( ["applyPreTidy"] ++ (maybeAttr  "removeAttrs" [] args) ); # tidy up args before applying them
-        fun = n : x :
-             let newArgs = fixed :
-                     let args = takeFixed fixed; 
-                         mergeFun = args.${n};
-                     in if isAttrs x then (mergeFun args x)
-                        else assert isFunction x;
-                             mergeFun args (x ( args // { inherit fixed; }));
-             in overridableDelayableArgs f newArgs;
-    in
-    (f (tidy (lib.fix takeFixed))) // {
-      merge   = fun "mergeFun";
-      replace = fun "keepFun";
-    };
-  defaultOverridableDelayableArgs = f : 
-      let defaults = {
-            mergeFun = mergeAttrByFunc; # default merge function. merge strategie (concatenate lists, strings) is given by mergeAttrBy
-            keepFun = a : b : { inherit (a) removeAttrs mergeFun keepFun mergeAttrBy; } // b; # even when using replace preserve these values
-            applyPreTidy = []; # list of functions applied to args before args are tidied up (usage case : prepareDerivationArgs)
-            mergeAttrBy = mergeAttrBy // {
-              applyPreTidy = a : b : a ++ b;
-              removeAttrs = a : b: a ++ b;
-            };
-            removeAttrs = ["mergeFun" "keepFun" "mergeAttrBy" "removeAttrs" "fixed" ]; # before applying the arguments to the function make sure these names are gone
-          };
-      in (overridableDelayableArgs f defaults).merge;
-
-
-
-  # rec { # an example of how composedArgsAndFun can be used
-  #  a  = composedArgsAndFun (x : x) { a = ["2"]; meta = { d = "bar";}; };
-  #  # meta.d will be lost ! It's your task to preserve it (eg using a merge function)
-  #  b  = a.passthru.function { a = [ "3" ]; meta = { d2 = "bar2";}; };
-  #  # instead of passing/ overriding values you can use a merge function:
-  #  c  = b.passthru.function ( x: { a = x.a  ++ ["4"]; }); # consider using (maybeAttr "a" [] x)
-  # }
-  # result:
-  # {
-  #   a = { a = ["2"];     meta = { d = "bar"; }; passthru = { function = .. }; };
-  #   b = { a = ["3"];     meta = { d2 = "bar2"; }; passthru = { function = .. }; };
-  #   c = { a = ["3" "4"]; meta = { d2 = "bar2"; }; passthru = { function = .. }; };
-  #   # c2 is equal to c
-  # }
-  composedArgsAndFun = f: foldArgs defaultMerge f {};
-
-
-  # shortcut for attrByPath ["name"] default attrs
-  maybeAttrNullable = maybeAttr;
-
-  # shortcut for attrByPath ["name"] default attrs
-  maybeAttr = name: default: attrs: attrs.${name} or default;
-
-
-  # Return the second argument if the first one is true or the empty version
-  # of the second argument.
-  ifEnable = cond: val:
-    if cond then val
-    else if builtins.isList val then []
-    else if builtins.isAttrs val then {}
-    # else if builtins.isString val then ""
-    else if val == true || val == false then false
-    else null;
-
-    
-  # Return true only if there is an attribute and it is true.
-  checkFlag = attrSet: name:
-        if name == "true" then true else
-        if name == "false" then false else
-        if (elem name (attrByPath ["flags"] [] attrSet)) then true else
-        attrByPath [name] false attrSet ;
-
-
-  # Input : attrSet, [ [name default] ... ], name
-  # Output : its value or default.
-  getValue = attrSet: argList: name:
-  ( attrByPath [name] (if checkFlag attrSet name then true else
-        if argList == [] then null else
-        let x = builtins.head argList; in
-                if (head x) == name then 
-                        (head (tail x))
-                else (getValue attrSet 
-                        (tail argList) name)) attrSet );
-
-                        
-  # Input : attrSet, [[name default] ...], [ [flagname reqs..] ... ]
-  # Output : are reqs satisfied? It's asserted.
-  checkReqs = attrSet : argList : condList :
-  (
-    fold lib.and true 
-      (map (x: let name = (head x) ; in
-        
-        ((checkFlag attrSet name) -> 
-        (fold lib.and true
-        (map (y: let val=(getValue attrSet argList y); in
-                (val!=null) && (val!=false)) 
-        (tail x))))) condList)) ;
-        
-
-  # This function has O(n^2) performance.
-  uniqList = {inputList, acc ? []} :
-    let go = xs : acc :
-             if xs == []
-             then []
-             else let x = head xs;
-                      y = if elem x acc then [] else [x];
-                  in y ++ go (tail xs) (y ++ acc);
-    in go inputList acc;
-
-  uniqListExt = {inputList, outputList ? [],
-    getter ? (x : x), compare ? (x: y: x==y)}:
-        if inputList == [] then outputList else
-        let x=head inputList; 
-        isX = y: (compare (getter y) (getter x));
-        newOutputList = outputList ++
-         (if any isX outputList then [] else [x]);
-        in uniqListExt {outputList=newOutputList; 
-                inputList = (tail inputList);
-                inherit getter compare;
-                };
-
-
-                
-  condConcat = name: list: checker:
-        if list == [] then name else
-        if checker (head list) then 
-                condConcat 
-                        (name + (head (tail list))) 
-                        (tail (tail list)) 
-                        checker
-        else condConcat
-                name (tail (tail list)) checker;
-
-  lazyGenericClosure = {startSet, operator}:
-    let
-      work = list: doneKeys: result:
-        if list == [] then
-          result
-        else
-          let x = head list; key = x.key; in
-          if elem key doneKeys then
-            work (tail list) doneKeys result
-          else
-            work (tail list ++ operator x) ([key] ++ doneKeys) ([x] ++ result);
-    in
-      work startSet [] [];
-
-  innerModifySumArgs = f: x: a: b: if b == null then (f a b) // x else 
-        innerModifySumArgs f x (a // b);
-  modifySumArgs = f: x: innerModifySumArgs f x {};
-
-
-  innerClosePropagation = acc : xs :
-    if xs == []
-    then acc
-    else let y  = head xs;
-             ys = tail xs;
-         in if ! isAttrs y
-            then innerClosePropagation acc ys
-            else let acc' = [y] ++ acc;
-                 in innerClosePropagation
-                      acc'
-                      (uniqList { inputList = (maybeAttrNullable "propagatedBuildInputs" [] y)
-                                           ++ (maybeAttrNullable "propagatedNativeBuildInputs" [] y)
-                                           ++ ys;
-                                  acc = acc';
-                                }
-                      );
-
-  closePropagation = list: (uniqList {inputList = (innerClosePropagation [] list);});
-
-  # calls a function (f attr value ) for each record item. returns a list
-  mapAttrsFlatten = f : r : map (attr: f attr r.${attr}) (attrNames r);
-
-  # attribute set containing one attribute
-  nvs = name : value : listToAttrs [ (nameValuePair name value) ];
-  # adds / replaces an attribute of an attribute set
-  setAttr = set : name : v : set // (nvs name v);
-
-  # setAttrMerge (similar to mergeAttrsWithFunc but only merges the values of a particular name)
-  # setAttrMerge "a" [] { a = [2];} (x : x ++ [3]) -> { a = [2 3]; } 
-  # setAttrMerge "a" [] {         } (x : x ++ [3]) -> { a = [  3]; }
-  setAttrMerge = name : default : attrs : f :
-    setAttr attrs name (f (maybeAttr name default attrs));
-
-  # Using f = a : b = b the result is similar to //
-  # merge attributes with custom function handling the case that the attribute
-  # exists in both sets
-  mergeAttrsWithFunc = f : set1 : set2 :
-    fold (n: set : if set ? ${n}
-                        then setAttr set n (f set.${n} set2.${n})
-                        else set )
-           (set2 // set1) (attrNames set2);
-
-  # merging two attribute set concatenating the values of same attribute names
-  # eg { a = 7; } {  a = [ 2 3 ]; } becomes { a = [ 7 2 3 ]; }
-  mergeAttrsConcatenateValues = mergeAttrsWithFunc ( a : b : (toList a) ++ (toList b) );
-
-  # merges attributes using //, if a name exisits in both attributes
-  # an error will be triggered unless its listed in mergeLists
-  # so you can mergeAttrsNoOverride { buildInputs = [a]; } { buildInputs = [a]; } {} to get
-  # { buildInputs = [a b]; }
-  # merging buildPhase does'nt really make sense. The cases will be rare where appending /prefixing will fit your needs?
-  # in these cases the first buildPhase will override the second one
-  # ! deprecated, use mergeAttrByFunc instead
-  mergeAttrsNoOverride = { mergeLists ? ["buildInputs" "propagatedBuildInputs"],
-                           overrideSnd ? [ "buildPhase" ]
-                         } : attrs1 : attrs2 :
-    fold (n: set : 
-        setAttr set n ( if set ? ${n}
-            then # merge 
-              if elem n mergeLists # attribute contains list, merge them by concatenating
-                then attrs2.${n} ++ attrs1.${n}
-              else if elem n overrideSnd
-                then attrs1.${n}
-              else throw "error mergeAttrsNoOverride, attribute ${n} given in both attributes - no merge func defined"
-            else attrs2.${n} # add attribute not existing in attr1
-           )) attrs1 (attrNames attrs2);
-
-
-  # example usage:
-  # mergeAttrByFunc  {
-  #   inherit mergeAttrBy; # defined below
-  #   buildInputs = [ a b ];
-  # } {
-  #  buildInputs = [ c d ];
-  # };
-  # will result in
-  # { mergeAttrsBy = [...]; buildInputs = [ a b c d ]; }
-  # is used by prepareDerivationArgs, defaultOverridableDelayableArgs and can be used when composing using
-  # foldArgs, composedArgsAndFun or applyAndFun. Example: composableDerivation in all-packages.nix
-  mergeAttrByFunc = x : y :
-    let
-          mergeAttrBy2 = { mergeAttrBy=lib.mergeAttrs; }
-                      // (maybeAttr "mergeAttrBy" {} x)
-                      // (maybeAttr "mergeAttrBy" {} y); in
-    fold lib.mergeAttrs {} [
-      x y
-      (mapAttrs ( a : v : # merge special names using given functions
-          if x ? ${a}
-             then if y ? ${a}
-               then v x.${a} y.${a} # both have attr, use merge func
-               else x.${a} # only x has attr
-             else y.${a} # only y has attr)
-          ) (removeAttrs mergeAttrBy2
-                         # don't merge attrs which are neither in x nor y
-                         (filter (a: ! x ? ${a} && ! y ? ${a})
-                                 (attrNames mergeAttrBy2))
-            )
-      )
-    ];
-  mergeAttrsByFuncDefaults = foldl mergeAttrByFunc { inherit mergeAttrBy; };
-  mergeAttrsByFuncDefaultsClean = list: removeAttrs (mergeAttrsByFuncDefaults list) ["mergeAttrBy"];
-
-  # merge attrs based on version key into mkDerivation args, see mergeAttrBy to learn about smart merge defaults
-  #
-  # This function is best explained by an example:
-  #
-  #     {version ? "2.x"} :
-  #
-  #     mkDerivation (mergeAttrsByVersion "package-name" version 
-  #       { # version specific settings
-  #         "git" = { src = ..; preConfigre = "autogen.sh"; buildInputs = [automake autoconf libtool];  };
-  #         "2.x" = { src = ..; };
-  #       }
-  #       {  // shared settings
-  #          buildInputs = [ common build inputs ];
-  #          meta = { .. }
-  #       }
-  #     )
-  #
-  # Please note that e.g. Eelco Dolstra usually prefers having one file for
-  # each version. On the other hand there are valuable additional design goals
-  #  - readability
-  #  - do it once only
-  #  - try to avoid duplication
-  #
-  # Marc Weber and Michael Raskin sometimes prefer keeping older
-  # versions around for testing and regression tests - as long as its cheap to
-  # do so.
-  #
-  # Very often it just happens that the "shared" code is the bigger part.
-  # Then using this function might be appropriate.
-  #
-  # Be aware that its easy to cause recompilations in all versions when using
-  # this function - also if derivations get too complex splitting into multiple
-  # files is the way to go.
-  #
-  # See misc.nix -> versionedDerivation
-  # discussion: nixpkgs: pull/310
-  mergeAttrsByVersion = name: version: attrsByVersion: base:
-    mergeAttrsByFuncDefaultsClean [ { name = "${name}-${version}"; } base (maybeAttr version (throw "bad version ${version} for ${name}") attrsByVersion)];
-
-  # sane defaults (same name as attr name so that inherit can be used)
-  mergeAttrBy = # { buildInputs = concatList; [...]; passthru = mergeAttr; [..]; }
-    listToAttrs (map (n : nameValuePair n lib.concat)
-      [ "nativeBuildInputs" "buildInputs" "propagatedBuildInputs" "configureFlags" "prePhases" "postAll" "patches" ])
-    // listToAttrs (map (n : nameValuePair n lib.mergeAttrs) [ "passthru" "meta" "cfg" "flags" ])
-    // listToAttrs (map (n : nameValuePair n (a: b: "${a}\n${b}") ) [ "preConfigure" "postInstall" ])
-  ;
-
-  # prepareDerivationArgs tries to make writing configurable derivations easier
-  # example:
-  #  prepareDerivationArgs {
-  #    mergeAttrBy = {
-  #       myScript = x : y : x ++ "\n" ++ y;
-  #    };
-  #    cfg = {
-  #      readlineSupport = true;
-  #    };
-  #    flags = {
-  #      readline = {
-  #        set = {
-  #           configureFlags = [ "--with-compiler=${compiler}" ];
-  #           buildInputs = [ compiler ];
-  #           pass = { inherit compiler; READLINE=1; };
-  #           assertion = compiler.dllSupport;
-  #           myScript = "foo";
-  #        };
-  #        unset = { configureFlags = ["--without-compiler"]; };
-  #      };
-  #    };
-  #    src = ...
-  #    buildPhase = '' ... '';
-  #    name = ...
-  #    myScript = "bar";
-  #  };
-  # if you don't have need for unset you can omit the surrounding set = { .. } attr
-  # all attrs except flags cfg and mergeAttrBy will be merged with the
-  # additional data from flags depending on config settings
-  # It's used in composableDerivation in all-packages.nix. It's also used
-  # heavily in the new python and libs implementation
-  #
-  # should we check for misspelled cfg options?
-  # TODO use args.mergeFun here as well?
-  prepareDerivationArgs = args:
-    let args2 = { cfg = {}; flags = {}; } // args;
-        flagName = name : "${name}Support";
-        cfgWithDefaults = (listToAttrs (map (n : nameValuePair (flagName n) false) (attrNames args2.flags)))
-                          // args2.cfg;
-        opts = attrValues (mapAttrs (a : v :
-                let v2 = if v ? set || v ? unset then v else { set = v; };
-                    n = if cfgWithDefaults.${flagName a} then "set" else "unset";
-                    attr = maybeAttr n {} v2; in
-                if (maybeAttr "assertion" true attr)
-                  then attr
-                  else throw "assertion of flag ${a} of derivation ${args.name} failed"
-               ) args2.flags );
-    in removeAttrs
-      (mergeAttrsByFuncDefaults ([args] ++ opts ++ [{ passthru = cfgWithDefaults; }]))
-      ["flags" "cfg" "mergeAttrBy" ];
-
-
-  nixType = x:
-      if isAttrs x then
-          if x ? outPath then "derivation"
-          else "aattrs"
-      else if isFunction x then "function"
-      else if isList x then "list"
-      else if x == true then "bool"
-      else if x == false then "bool"
-      else if x == null then "null"
-      else if isInt x then "int"
-      else "string";
-
-}

lib/licenses.nix

@@ -85,11 +85,6 @@ lib.mapAttrs (n: v: v // { shortName = n; }) rec {
     fullName = "Creative Commons Zero v1.0 Universal";
   };
 
-  cc-by-sa-25 = spdx {
-    spdxId = "CC-BY-SA-2.5";
-    fullName = "Creative Commons Attribution Share Alike 2.5";
-  };
-
   cc-by-30 = spdx {
     spdxId = "CC-BY-3.0";
     fullName = "Creative Commons Attribution 3.0";
@@ -105,11 +100,6 @@ lib.mapAttrs (n: v: v // { shortName = n; }) rec {
     fullName = "Creative Commons Attribution 4.0";
   };
 
-  cc-by-sa-40 = spdx {
-    spdxId = "CC-BY-SA-4.0";
-    fullName = "Creative Commons Attribution Share Alike 4.0";
-  };
-
   cddl = spdx {
     spdxId = "CDDL-1.0";
     fullName = "Common Development and Distribution License 1.0";
@@ -135,26 +125,11 @@ lib.mapAttrs (n: v: v // { shortName = n; }) rec {
     fullName = "Common Public License 1.0";
   };
 
-  efl10 = spdx {
-    spdxId = "EFL-1.0";
-    fullName = "Eiffel Forum License v1.0";
-  };
-
-  efl20 = spdx {
-    spdxId = "EFL-2.0";
-    fullName = "Eiffel Forum License v2.0";
-  };
-
   epl10 = spdx {
     spdxId = "EPL-1.0";
     fullName = "Eclipse Public License 1.0";
   };
 
-  fdl12 = spdx {
-    spdxId = "GFDL-1.2";
-    fullName = "GNU Free Documentation License v1.2";
-  };
-
   free = {
     fullName = "Unspecified free software license";
   };
@@ -210,11 +185,6 @@ lib.mapAttrs (n: v: v // { shortName = n; }) rec {
     url = http://www.calculate-linux.org/packages/licenses/iASL;
   };
 
-  ijg = spdx {
-    spdxId = "IJG";
-    fullName = "Independent JPEG Group License";
-  };
-
   inria = {
     fullName  = "INRIA Non-Commercial License Agreement";
     url       = "http://compcert.inria.fr/doc/LICENSE";
@@ -285,11 +255,6 @@ lib.mapAttrs (n: v: v // { shortName = n; }) rec {
     fullName = "LaTeX Project Public License v1.2";
   };
 
-  lppl13c = spdx {
-    spdxId = "LPPL-1.3c";
-    fullName = "LaTeX Project Public License v1.3c";
-  };
-
   lpl-102 = spdx {
     spdxId = "LPL-1.02";
     fullName = "Lucent Public License v1.02";
@@ -302,11 +267,6 @@ lib.mapAttrs (n: v: v // { shortName = n; }) rec {
     fullName = "MIT License";
   };
 
-  mpl10 = spdx {
-    spdxId = "MPL-1.0";
-    fullName = "Mozilla Public License 1.0";
-  };
-
   mpl11 = spdx {
     spdxId = "MPL-1.1";
     fullName = "Mozilla Public License 1.1";
@@ -327,21 +287,11 @@ lib.mapAttrs (n: v: v // { shortName = n; }) rec {
     fullName  = "University of Illinois/NCSA Open Source License";
   };
 
-  notion_lgpl = {
-    url = "https://raw.githubusercontent.com/raboof/notion/master/LICENSE";
-    fullName = "Notion modified LGPL";
-  };
-  
   ofl = spdx {
     spdxId = "OFL-1.1";
     fullName = "SIL Open Font License 1.1";
   };
 
-  openldap = spdx {
-    spdxId = "OLDAP-2.8";
-    fullName = "Open LDAP Public License v2.8";
-  };
-
   openssl = spdx {
     spdxId = "OpenSSL";
     fullName = "OpenSSL License";
@@ -418,11 +368,6 @@ lib.mapAttrs (n: v: v // { shortName = n; }) rec {
     fullName = "The Unlicense";
   };
 
-  vim = spdx {
-    spdxId = "Vim";
-    fullName = "Vim License";
-  };
-
   vsl10 = spdx {
     spdxId = "VSL-1.0";
     fullName = "Vovida Software License v1.0";

lib/lists.nix

@@ -4,7 +4,7 @@ with import ./trivial.nix;
 
 rec {
 
-  inherit (builtins) head tail length isList elemAt concatLists filter elem genList;
+  inherit (builtins) head tail length isList elemAt concatLists filter elem;
 
 
   # Create a list consisting of a single element.  `singleton x' is
@@ -38,24 +38,16 @@ rec {
     in foldl' (length list - 1);
 
 
-  # Strict version of foldl.
-  foldl' = builtins.foldl' or foldl;
-
-
-  # Map with index: `imap (i: v: "${v}-${toString i}") ["a" "b"] ==
-  # ["a-1" "b-2"]'. FIXME: why does this start to count at 1?
-  imap =
-    if builtins ? genList then
-      f: list: genList (n: f (n + 1) (elemAt list n)) (length list)
-    else
-      f: list:
-      let
-        len = length list;
-        imap' = n:
-          if n == len
-            then []
-            else [ (f (n + 1) (elemAt list n)) ] ++ imap' (n + 1);
-      in imap' 0;
+  # map with index: `imap (i: v: "${v}-${toString i}") ["a" "b"] ==
+  # ["a-1" "b-2"]'
+  imap = f: list:
+    let
+      len = length list;
+      imap' = n:
+        if n == len
+          then []
+          else [ (f (n + 1) (elemAt list n)) ] ++ imap' (n + 1);
+    in imap' 0;
 
 
   # Map and concatenate the result.
@@ -67,7 +59,7 @@ rec {
   # == [1 2 3 4 5]' and `flatten 1 == [1]'.
   flatten = x:
     if isList x
-    then foldl' (x: y: x ++ (flatten y)) [] x
+    then fold (x: y: (flatten x) ++ y) [] x
     else [x];
 
 
@@ -94,17 +86,17 @@ rec {
 
   # Return true iff function `pred' returns true for at least element
   # of `list'.
-  any = builtins.any or (pred: fold (x: y: if pred x then true else y) false);
+  any = pred: fold (x: y: if pred x then true else y) false;
 
 
   # Return true iff function `pred' returns true for all elements of
   # `list'.
-  all = builtins.all or (pred: fold (x: y: if pred x then y else false) true);
+  all = pred: fold (x: y: if pred x then y else false) true;
 
 
   # Count how many times function `pred' returns true for the elements
   # of `list'.
-  count = pred: foldl' (c: x: if pred x then c + 1 else c) 0;
+  count = pred: fold (x: c: if pred x then c + 1 else c) 0;
 
 
   # Return a singleton list or an empty list, depending on a boolean
@@ -124,17 +116,10 @@ rec {
 
 
   # Return a list of integers from `first' up to and including `last'.
-  range =
-    if builtins ? genList then
-      first: last:
-        if first > last
-        then []
-        else genList (n: first + n) (last - first + 1)
-    else
-      first: last:
-        if last < first
-        then []
-        else [first] ++ range (first + 1) last;
+  range = first: last:
+    if last < first
+    then []
+    else [first] ++ range (first + 1) last;
 
 
   # Partition the elements of a list in two lists, `right' and
@@ -147,37 +132,30 @@ rec {
     ) { right = []; wrong = []; };
 
 
-  zipListsWith =
-    if builtins ? genList then
-      f: fst: snd: genList (n: f (elemAt fst n) (elemAt snd n)) (min (length fst) (length snd))
-    else
-      f: fst: snd:
-      let
-        len = min (length fst) (length snd);
-        zipListsWith' = n:
-          if n != len then
-            [ (f (elemAt fst n) (elemAt snd n)) ]
-            ++ zipListsWith' (n + 1)
-          else [];
-      in zipListsWith' 0;
+  zipListsWith = f: fst: snd:
+    let
+      len1 = length fst;
+      len2 = length snd;
+      len = if len1 < len2 then len1 else len2;
+      zipListsWith' = n:
+        if n != len then
+          [ (f (elemAt fst n) (elemAt snd n)) ]
+          ++ zipListsWith' (n + 1)
+        else [];
+    in zipListsWith' 0;
 
   zipLists = zipListsWith (fst: snd: { inherit fst snd; });
 
 
-  # Reverse the order of the elements of a list.
-  reverseList =
-    if builtins ? genList then
-      xs: let l = length xs; in genList (n: elemAt xs (l - n - 1)) l
-    else
-      fold (e: acc: acc ++ [ e ]) [];
+  # Reverse the order of the elements of a list.  FIXME: O(n^2)!
+  reverseList = fold (e: acc: acc ++ [ e ]) [];
 
 
   # Sort a list based on a comparator function which compares two
   # elements and returns true if the first argument is strictly below
   # the second argument.  The returned list is sorted in an increasing
   # order.  The implementation does a quick-sort.
-  sort = builtins.sort or (
-    strictLess: list:
+  sort = strictLess: list:
     let
       len = length list;
       first = head list;
@@ -191,50 +169,31 @@ rec {
       pivot = pivot' 1 { left = []; right = []; };
     in
       if len < 2 then list
-      else (sort strictLess pivot.left) ++  [ first ] ++  (sort strictLess pivot.right));
+      else (sort strictLess pivot.left) ++  [ first ] ++  (sort strictLess pivot.right);
 
 
   # Return the first (at most) N elements of a list.
-  take =
-    if builtins ? genList then
-      count: sublist 0 count
-    else
-      count: list:
-        let
-          len = length list;
-          take' = n:
-            if n == len || n == count
-              then []
-            else
-              [ (elemAt list n) ] ++ take' (n + 1);
-        in take' 0;
+  take = count: list:
+    let
+      len = length list;
+      take' = n:
+        if n == len || n == count
+          then []
+        else
+          [ (elemAt list n) ] ++ take' (n + 1);
+    in take' 0;
 
 
   # Remove the first (at most) N elements of a list.
-  drop =
-    if builtins ? genList then
-      count: list: sublist count (length list) list
-    else
-      count: list:
-        let
-          len = length list;
-          drop' = n:
-            if n == -1 || n < count
-              then []
-            else
-              drop' (n - 1) ++ [ (elemAt list n) ];
-        in drop' (len - 1);
-
-
-  # Return a list consisting of at most ‘count’ elements of ‘list’,
-  # starting at index ‘start’.
-  sublist = start: count: list:
-    let len = length list; in
-    genList
-      (n: elemAt list (n + start))
-      (if start >= len then 0
-       else if start + count > len then len - start
-       else count);
+  drop = count: list:
+    let
+      len = length list;
+      drop' = n:
+        if n == -1 || n < count
+          then []
+        else
+          drop' (n - 1) ++ [ (elemAt list n) ];
+    in drop' (len - 1);
 
 
   # Return the last element of a list.
@@ -246,13 +205,25 @@ rec {
   init = list: assert list != []; take (length list - 1) list;
 
 
-  deepSeqList = xs: y: if any (x: deepSeq x false) xs then y else y;
+  # Zip two lists together.
+  zipTwoLists = xs: ys:
+    let
+      len1 = length xs;
+      len2 = length ys;
+      len = if len1 < len2 then len1 else len2;
+      zipTwoLists' = n:
+        if n != len then
+          [ { first = elemAt xs n; second = elemAt ys n; } ]
+          ++ zipTwoLists' (n + 1)
+        else [];
+    in zipTwoLists' 0;
 
 
+  deepSeqList = xs: y: if any (x: deepSeq x false) xs then y else y;
+
   crossLists = f: foldl (fs: args: concatMap (f: map f args) fs) [f];
 
-
-  # Remove duplicate elements from the list. O(n^2) complexity.
+  # Remove duplicate elements from the list
   unique = list:
     if list == [] then
       []
@@ -262,12 +233,4 @@ rec {
         xs = unique (drop 1 list);
       in [x] ++ remove x xs;
 
-
-  # Intersects list 'e' and another list. O(nm) complexity.
-  intersectLists = e: filter (x: elem x e);
-
-
-  # Subtracts list 'e' from another list. O(nm) complexity.
-  subtractLists = e: filter (x: !(elem x e));
-
 }

lib/maintainers.nix

@@ -1,30 +1,21 @@
 /* -*- coding: utf-8; -*- */
 
 {
-  /* Add your name and email address here.
-     Keep the list alphabetically sorted.
-     Prefer the same attrname as your github username, please,
-     so it's easy to ping a package @maintainer.
-  */
+  /* Add your name and email address here.  Keep the list
+     alphabetically sorted.  */
 
-  a1russell = "Adam Russell <adamlr6+pub@gmail.com>";
-  abaldeau = "Andreas Baldeau <andreas@baldeau.net>";
+  _1126 = "Christian Lask <mail@elfsechsundzwanzig.de>";
   abbradar = "Nikolay Amiantov <ab@fmap.me>";
-  adev	   = "Adrien Devresse <adev@adev.name>";
   aforemny = "Alexander Foremny <alexanderforemny@googlemail.com>";
-  aflatter = "Alexander Flatter <flatter@fastmail.fm>";
   aherrmann = "Andreas Herrmann <andreash87@gmx.ch>";
   ak = "Alexander Kjeldaas <ak@formalprivacy.com>";
-  akaWolf = "Artjom Vejsel <akawolf0@gmail.com>";
   akc = "Anders Claesson <akc@akc.is>";
   algorith = "Dries Van Daele <dries_van_daele@telenet.be>";
   all = "Nix Committers <nix-commits@lists.science.uu.nl>";
   amiddelk = "Arie Middelkoop <amiddelk@gmail.com>";
   amorsillo = "Andrew Morsillo <andrew.morsillo@gmail.com>";
   AndersonTorres = "Anderson Torres <torres.anderson.85@gmail.com>";
-  anderspapitto = "Anders Papitto <anderspapitto@gmail.com>";
   andres = "Andres Loeh <ksnixos@andres-loeh.de>";
-  andrewrk = "Andrew Kelley <superjoe30@gmail.com>";
   antono = "Antono Vasiljev <self@antono.info>";
   ardumont = "Antoine R. Dumont <eniotna.t@gmail.com>";
   aristid = "Aristid Breitkreuz <aristidb@gmail.com>";
@@ -33,16 +24,10 @@
   astsmtl = "Alexander Tsamutali <astsmtl@yandex.ru>";
   aszlig = "aszlig <aszlig@redmoonstudios.org>";
   auntie = "Jonathan Glines <auntieNeo@gmail.com>";
-  avnik = "Alexander V. Nikolaev <avn@avnik.info>";
   aycanirican = "Aycan iRiCAN <iricanaycan@gmail.com>";
-  badi = "Badi' Abdul-Wahid <abdulwahidc@gmail.com>";
   balajisivaraman = "Balaji Sivaraman<sivaraman.balaji@gmail.com>";
   bbenoist = "Baptist BENOIST <return_0@live.com>";
-  bcarrell = "Brandon Carrell <brandoncarrell@gmail.com>";
-  bcdarwin = "Ben Darwin <bcdarwin@gmail.com>";
-  bdimcheff = "Brandon Dimcheff <brandon@dimcheff.com>";
   bennofs = "Benno Fünfstück <benno.fuenfstueck@gmail.com>";
-  benley = "Benjamin Staffin <benley@gmail.com>";
   berdario = "Dario Bertini <berdario@gmail.com>";
   bergey = "Daniel Bergey <bergey@teallabs.org>";
   bjg = "Brian Gough <bjg@gnu.org>";
@@ -50,37 +35,24 @@
   bluescreen303 = "Mathijs Kwik <mathijs@bluescreen303.nl>";
   bobvanderlinden = "Bob van der Linden <bobvanderlinden@gmail.com>";
   bodil = "Bodil Stokke <nix@bodil.org>";
-  boothead = "Ben Ford <ben@perurbis.com>";
   bosu = "Boris Sukholitko <boriss@gmail.com>";
-  bramd = "Bram Duvigneau <bram@bramd.nl>";
-  bstrik = "Berno Strik <dutchman55@gmx.com>";
-  c0dehero = "CodeHero <codehero@nerdpol.ch>";
   calrama = "Moritz Maxeiner <moritz@ucworks.org>";
   campadrenalin = "Philip Horger <campadrenalin@gmail.com>";
   cdepillabout = "Dennis Gosnell <cdep.illabout@gmail.com>";
   cfouche = "Chaddaï Fouché <chaddai.fouche@gmail.com>";
   chaoflow = "Florian Friesdorf <flo@chaoflow.net>";
-  chattered = "Phil Scott <me@philscotted.com>";
   christopherpoole = "Christopher Mark Poole <mail@christopherpoole.net>";
   coconnor = "Corey O'Connor <coreyoconnor@gmail.com>";
   codyopel = "Cody Opel <codyopel@gmail.com>";
   copumpkin = "Dan Peebles <pumpkingod@gmail.com>";
   coroa = "Jonas Hörsch <jonas@chaoflow.net>";
-  couchemar = "Andrey Pavlov <couchemar@yandex.ru>";
   cstrahan = "Charles Strahan <charles.c.strahan@gmail.com>";
-  cwoac = "Oliver Matthews <oliver@codersoffortune.net>";
-  DamienCassou = "Damien Cassou <damien@cassou.me>";
+  DamienCassou = "Damien Cassou <damien.cassou@gmail.com>";
   davidrusu = "David Rusu <davidrusu.me@gmail.com>";
   dbohdan = "Danyil Bohdan <danyil.bohdan@gmail.com>";
   DerGuteMoritz = "Moritz Heidkamp <moritz@twoticketsplease.de>";
-  deepfire = "Kosyrev Serge <_deepfire@feelingofgreen.ru>";
-  desiderius = "Didier J. Devroye <didier@devroye.name>";
-  devhell = "devhell <\"^\"@regexmail.net>";
-  dezgeg = "Tuomas Tynkkynen <tuomas.tynkkynen@iki.fi>";
-  dfoxfranke = "Daniel Fox Franke <dfoxfranke@gmail.com>";
   dmalikov = "Dmitry Malikov <malikov.d.y@gmail.com>";
   doublec = "Chris Double <chris.double@double.co.nz>";
-  ebzzry = "Rommel Martinez <ebzzry@gmail.com>";
   ederoyd46 = "Matthew Brown <matt@ederoyd.co.uk>";
   eduarrrd = "Eduard Bachmakov <e.bachmakov@gmail.com>";
   edwtjo = "Edward Tjörnhammar <ed@cflags.cc>";
@@ -88,183 +60,108 @@
   eikek = "Eike Kettner <eike.kettner@posteo.de>";
   ellis = "Ellis Whitehead <nixos@ellisw.net>";
   emery = "Emery Hemingway <emery@vfemail.net>";
-  epitrochoid = "Mabry Cervin <mpcervin@uncg.edu>";
-  ericbmerritt = "Eric Merritt <eric@afiniate.com>";
   ertes = "Ertugrul Söylemez <ertesx@gmx.de>";
   exlevan = "Alexey Levan <exlevan@gmail.com>";
   falsifian = "James Cook <james.cook@utoronto.ca>";
   flosse = "Markus Kohlhase <mail@markus-kohlhase.de>";
   fluffynukeit = "Daniel Austin <dan@fluffynukeit.com>";
-  forkk = "Andrew Okin <forkk@forkk.net>";
   fpletz = "Franz Pletz <fpletz@fnordicwalking.de>";
-  fridh = "Frederik Rietdijk <fridh@fridh.nl>";
-  fro_ozen = "fro_ozen <fro_ozen@gmx.de>";
   ftrvxmtrx = "Siarhei Zirukin <ftrvxmtrx@gmail.com>";
   funfunctor = "Edward O'Callaghan <eocallaghan@alterapraxis.com>";
   fuuzetsu = "Mateusz Kowalczyk <fuuzetsu@fuuzetsu.co.uk>";
   gal_bolle = "Florent Becker <florent.becker@ens-lyon.org>";
   garbas = "Rok Garbas <rok@garbas.si>";
-  garrison = "Jim Garrison <jim@garrison.cc>";
   gavin = "Gavin Rogers <gavin@praxeology.co.uk>";
-  gebner = "Gabriel Ebner <gebner@gebner.org>";
-  gfxmonk = "Tim Cuthbertson <tim@gfxmonk.net>";
-  giogadi = "Luis G. Torres <lgtorres42@gmail.com>";
-  globin = "Robin Gloster <robin@glob.in>";
   goibhniu = "Cillian de Róiste <cillian.deroiste@gmail.com>";
-  gridaphobe = "Eric Seidel <eric@seidel.io>";
   guibert = "David Guibert <david.guibert@gmail.com>";
-  havvy = "Ryan Scheel <ryan.havvy@gmail.com>";
-  hbunke = "Hendrik Bunke <bunke.hendrik@gmail.com>";
   henrytill = "Henry Till <henrytill@gmail.com>";
-  hiberno = "Christian Lask <mail@elfsechsundzwanzig.de>";
   hinton = "Tom Hinton <t@larkery.com>";
   hrdinka = "Christoph Hrdinka <c.nix@hrdinka.at>";
-  iand675 = "Ian Duncan <ian@iankduncan.com>";
   ianwookim = "Ian-Woo Kim <ianwookim@gmail.com>";
   iElectric = "Domen Kozar <domen@dev.si>";
-  ikervagyok = "Balázs Lengyel <ikervagyok@gmail.com>";
   iyzsong = "Song Wenwu <iyzsong@gmail.com>";
-  j-keck = "Jürgen Keck <jhyphenkeck@gmail.com>";
   jagajaga = "Arseniy Seroka <ars.seroka@gmail.com>";
-  jb55 = "William Casarin <bill@casarin.me>";
   jcumming = "Jack Cummings <jack@mudshark.org>";
-  jefdaj = "Jeffrey David Johnson <jefdaj@gmail.com>";
-  jfb = "James Felix Black <james@yamtime.com>";
   jgeerds = "Jascha Geerds <jg@ekby.de>";
   jirkamarsik = "Jirka Marsik <jiri.marsik89@gmail.com>";
   joachifm = "Joachim Fasting <joachifm@fastmail.fm>";
   joamaki = "Jussi Maki <joamaki@gmail.com>";
-  joelmo = "Joel Moberg <joel.moberg@gmail.com>";
   joelteon = "Joel Taylor <me@joelt.io>";
   jpbernardy = "Jean-Philippe Bernardy <jeanphilippe.bernardy@gmail.com>";
   jwiegley = "John Wiegley <johnw@newartisans.com>";
-  jwilberding = "Jordan Wilberding <jwilberding@afiniate.com>";
   jzellner = "Jeff Zellner <jeffz@eml.cc>";
-  kamilchm = "Kamil Chmielewski <kamil.chm@gmail.com>";
-  khumba = "Bryan Gardiner <bog@khumba.net>";
   kkallio = "Karn Kallio <tierpluspluslists@gmail.com>";
   koral = "Koral <koral@mailoo.org>";
-  kovirobi = "Kovacsics Robert <kovirobi@gmail.com>";
   kragniz = "Louis Taylor <kragniz@gmail.com>";
   ktosiek = "Tomasz Kontusz <tomasz.kontusz@gmail.com>";
-  lassulus = "Lassulus <lassulus@gmail.com>";
-  layus = "Guillaume Maudoux <layus.on@gmail.com>";
-  lebastr = "Alexander Lebedev <lebastr@gmail.com>";
-  leonardoce = "Leonardo Cecchi <leonardo.cecchi@gmail.com>";
   lethalman = "Luca Bruno <lucabru@src.gnome.org>";
   lhvwb = "Nathaniel Baxter <nathaniel.baxter@gmail.com>";
-  lihop = "Leroy Hopson <nixos@leroy.geek.nz>";
   linquize = "Linquize <linquize@yahoo.com.hk>";
-  linus = "Linus Arver <linusarver@gmail.com>";
-  lnl7 = "Daiderd Jordan <daiderd@gmail.com>";
   lovek323 = "Jason O'Conal <jason@oconal.id.au>";
-  lowfatcomputing = "Andreas Wagner <andreas.wagner@lowfatcomputing.org>";
-  lsix = "Lancelot SIX <lsix@lancelotsix.com>";
   ludo = "Ludovic Courtès <ludo@gnu.org>";
   madjar = "Georges Dubus <georges.dubus@compiletoi.net>";
   magnetophon = "Bart Brouns <bart@magnetophon.nl>";
-  mahe = "Matthias Herrmann <matthias.mh.herrmann@gmail.com>";
-  makefu = "Felix Richter <makefu@syntax-fehler.de>";
-  malyn = "Michael Alyn Miller <malyn@strangeGizmo.com>";
   manveru = "Michael Fellinger <m.fellinger@gmail.com>";
   marcweber = "Marc Weber <marco-oweber@gmx.de>";
-  maurer = "Matthew Maurer <matthew.r.maurer+nix@gmail.com>";
   matejc = "Matej Cotman <cotman.matej@gmail.com>";
-  mathnerd314 = "Mathnerd314 <mathnerd314.gph+hs@gmail.com>";
-  matthiasbeyer = "Matthias Beyer <mail@beyermatthias.de>";
-  mbakke = "Marius Bakke <ymse@tuta.io>";
-  meditans = "Carlo Nucera <meditans@gmail.com>";
   meisternu = "Matt Miemiec <meister@krutt.org>";
   michelk = "Michel Kuhlmann <michel@kuhlmanns.info>";
-  mirdhyn = "Merlin Gaillard <mirdhyn@gmail.com>";
-  mschristiansen = "Mikkel Christiansen <mikkel@rheosystems.com>";
   modulistic = "Pablo Costa <modulistic@gmail.com>";
   mornfall = "Petr Ročkai <me@mornfall.net>";
   MP2E = "Cray Elliott <MP2E@archlinux.us>";
   msackman = "Matthew Sackman <matthew@wellquite.org>";
-  mtreskin = "Max Treskin <zerthurd@gmail.com>";
-  mudri = "James Wood <lamudri@gmail.com>";
   muflax = "Stefan Dorn <mail@muflax.com>";
   nathan-gs = "Nathan Bijnens <nathan@nathan.gs>";
   nckx = "Tobias Geerinckx-Rice <tobias.geerinckx.rice@gmail.com>";
   notthemessiah = "Brian Cohen <brian.cohen.88@gmail.com>";
   np = "Nicolas Pouillard <np.nix@nicolaspouillard.fr>";
   nslqqq = "Nikita Mikhailov <nslqqq@gmail.com>";
-  obadz = "obadz <dav-nixos@odav.org>";
   ocharles = "Oliver Charles <ollie@ocharles.org.uk>";
-  odi = "Oliver Dunkl <oliver.dunkl@gmail.com>";
   offline = "Jaka Hudoklin <jakahudoklin@gmail.com>";
   olcai = "Erik Timan <dev@timan.info>";
   orbitz = "Malcolm Matalka <mmatalka@gmail.com>";
-  osener = "Ozan Sener <ozan@ozansener.com>";
   page = "Carles Pagès <page@cubata.homelinux.net>";
-  paholg = "Paho Lurie-Gregg <paho@paholg.com>";
-  pakhfn = "Fedor Pakhomov <pakhfn@gmail.com>";
   pashev = "Igor Pashev <pashev.igor@gmail.com>";
-  pesterhazy = "Paulus Esterhazy <pesterhazy@gmail.com>";
-  phausmann = "Philipp Hausmann <nix@314.ch>";
-  philandstuff = "Philip Potter <philip.g.potter@gmail.com>";
   phreedom = "Evgeny Egorochkin <phreedom@yandex.ru>";
   pierron = "Nicolas B. Pierron <nixos@nbp.name>";
   piotr = "Piotr Pietraszkiewicz <ppietrasa@gmail.com>";
-  pjones = "Peter Jones <pjones@devalot.com>";
   pkmx = "Chih-Mao Chen <pkmx.tw@gmail.com>";
   plcplc = "Philip Lykke Carlsen <plcplc@gmail.com>";
-  pmahoney = "Patrick Mahoney <pat@polycrystal.org>";
-  pmiddend = "Philipp Middendorf <pmidden@secure.mailbox.org>";
   prikhi = "Pavan Rikhi <pavan.rikhi@gmail.com>";
-  psibi = "Sibi <sibi@psibi.in>";
   pSub = "Pascal Wittmann <mail@pascal-wittmann.de>";
   puffnfresh = "Brian McKenna <brian@brianmckenna.org>";
   qknight = "Joachim Schiele <js@lastlog.de>";
-  ragge = "Ragnar Dahlen <r.dahlen@gmail.com>";
   raskin = "Michael Raskin <7c6f434c@mail.ru>";
   redbaron = "Maxim Ivanov <ivanov.maxim@gmail.com>";
   refnil = "Martin Lavoie <broemartino@gmail.com>";
   relrod = "Ricky Elrod <ricky@elrod.me>";
-  renzo = "Renzo Carbonara <renzocarbonara@gmail.com>";
-  rick68 = "Wei-Ming Yang <rick68@gmail.com>";
   rickynils = "Rickard Nilsson <rickynils@gmail.com>";
   rob = "Rob Vermaas <rob.vermaas@gmail.com>";
   robberer = "Longrin Wischnewski <robberer@freakmail.de>";
-  robbinch = "Robbin C. <robbinch33@gmail.com>";
   roconnor = "Russell O'Connor <roconnor@theorem.ca>";
   roelof = "Roelof Wobben <rwobben@hotmail.com>";
   romildo = "José Romildo Malaquias <malaquias@gmail.com>";
   rszibele = "Richard Szibele <richard_szibele@hotmail.com>";
-  rushmorem = "Rushmore Mushambi <rushmore@webenchanter.com>";
   rycee = "Robert Helgesson <robert@rycee.net>";
-  samuelrivas = "Samuel Rivas <samuelrivas@gmail.com>";
   sander = "Sander van der Burg <s.vanderburg@tudelft.nl>";
-  schmitthenner = "Fabian Schmitthenner <development@schmitthenner.eu>";
   schristo = "Scott Christopher <schristopher@konputa.com>";
   sepi = "Raffael Mancini <raffael@mancini.lu>";
-  sheganinans = "Aistis Raulinaitis <sheganinans@gmail.com>";
   shell = "Shell Turner <cam.turn@gmail.com>";
   shlevy = "Shea Levy <shea@shealevy.com>";
   simons = "Peter Simons <simons@cryp.to>";
-  simonvandel = "Simon Vandel Sillesen <simon.vandel@gmail.com>";
-  sjagoe = "Simon Jagoe <simon@simonjagoe.com>";
   sjmackenzie = "Stewart Mackenzie <setori88@gmail.com>";
   skeidel = "Sven Keidel <svenkeidel@gmail.com>";
   smironov = "Sergey Mironov <ierton@gmail.com>";
-  spacefrogg = "Michael Raitza <spacefrogg-nixos@meterriblecrew.net>";
   sprock = "Roger Mason <rmason@mun.ca>";
   spwhitt = "Spencer Whitt <sw@swhitt.me>";
   stephenmw = "Stephen Weinberg <stephen@q5comm.com>";
-  szczyp = "Szczyp <qb@szczyp.com>";
   sztupi = "Attila Sztupak <attila.sztupak@gmail.com>";
   tailhook = "Paul Colomiets <paul@colomiets.name>";
-  taktoa = "Remy Goldschmidt <taktoa@gmail.com>";
-  telotortium = "Robert Irelan <rirelan@gmail.com>";
   thammers = "Tobias Hammerschmidt <jawr@gmx.de>";
   the-kenny = "Moritz Ulrich <moritz@tarn-vedra.de>";
-  theuni = "Christian Theune <ct@flyingcircus.io>";
   thoughtpolice = "Austin Seipp <aseipp@pobox.com>";
   titanous = "Jonathan Rudenberg <jonathan@titanous.com>";
   tomberek = "Thomas Bereknyei <tomberek@gmail.com>";
-  travisbhartwell = "Travis B. Hartwell <nafai@travishartwell.net>";
-  trino = "Hubert Mühlhans <muehlhans.hubert@ekodia.de>";
   tstrobel = "Thomas Strobel <ts468@cam.ac.uk>";
   ttuegel = "Thomas Tuegel <ttuegel@gmail.com>";
   tv = "Tomislav Viljetić <tv@shackspace.de>";
@@ -277,12 +174,10 @@
   viric = "Lluís Batlle i Rossell <viric@viric.name>";
   vizanto = "Danny Wilson <danny@prime.vc>";
   vlstill = "Vladimír Štill <xstill@fi.muni.cz>";
-  vmandela = "Venkateswara Rao Mandela <venkat.mandela@gmail.com>";
   vozz = "Oliver Hunt <oliver.huntuk@gmail.com>";
   winden = "Antonio Vargas Gonzalez <windenntw@gmail.com>";
   wizeman = "Ricardo M. Correia <rcorreia@wizy.org>";
   wjlroe = "William Roe <willroe@gmail.com>";
-  womfoo = "Kranium Gikos Mendoza <kranium@gikos.net>";
   wkennington = "William A. Kennington III <william@wkennington.com>";
   wmertens = "Wout Mertens <Wout.Mertens@gmail.com>";
   wscott = "Wayne Scott <wsc9tt@gmail.com>";

lib/misc.nix

@@ -0,0 +1,426 @@
+let lib = import ./default.nix;
+    inherit (builtins) isFunction head tail isList isAttrs isInt attrNames;
+
+in
+
+with import ./lists.nix;
+with import ./attrsets.nix;
+with import ./strings.nix;
+
+rec {
+
+  # returns default if env var is not set
+  maybeEnv = name: default:
+    let value = builtins.getEnv name; in
+    if value == "" then default else value;
+
+  defaultMergeArg = x : y: if builtins.isAttrs y then
+    y
+  else 
+    (y x);
+  defaultMerge = x: y: x // (defaultMergeArg x y);
+  foldArgs = merger: f: init: x: 
+    let arg=(merger init (defaultMergeArg init x));
+      # now add the function with composed args already applied to the final attrs
+        base = (setAttrMerge "passthru" {} (f arg) 
+                        ( z : z // rec { 
+                          function = foldArgs merger f arg; 
+			  args = (lib.attrByPath ["passthru" "args"] {} z) // x;
+                          } ));
+	withStdOverrides = base // {
+	   override = base.passthru.function;
+	   deepOverride = a : (base.passthru.function ((lib.mapAttrs (lib.deepOverrider a) base.passthru.args) // a));
+	   } ;
+        in
+	withStdOverrides;
+    
+
+  # predecessors: proposed replacement for applyAndFun (which has a bug cause it merges twice)
+  # the naming "overridableDelayableArgs" tries to express that you can
+  # - override attr values which have been supplied earlier
+  # - use attr values before they have been supplied by accessing the fix point
+  #   name "fixed"
+  # f: the (delayed overridden) arguments are applied to this
+  #
+  # initial: initial attrs arguments and settings. see defaultOverridableDelayableArgs
+  #
+  # returns: f applied to the arguments // special attributes attrs
+  #     a) merge: merge applied args with new args. Wether an argument is overridden depends on the merge settings
+  #     b) replace: this let's you replace and remove names no matter which merge function has been set
+  #
+  # examples: see test cases "res" below;
+  overridableDelayableArgs =
+          f :        # the function applied to the arguments
+          initial :  # you pass attrs, the functions below are passing a function taking the fix argument
+    let
+        takeFixed = if isFunction initial then initial else (fixed : initial); # transform initial to an expression always taking the fixed argument
+        tidy = args : 
+            let # apply all functions given in "applyPreTidy" in sequence
+                applyPreTidyFun = fold ( n : a : x : n ( a x ) ) lib.id (maybeAttr "applyPreTidy" [] args);
+            in removeAttrs (applyPreTidyFun args) ( ["applyPreTidy"] ++ (maybeAttr  "removeAttrs" [] args) ); # tidy up args before applying them
+        fun = n : x :
+             let newArgs = fixed :
+                     let args = takeFixed fixed; 
+                         mergeFun = args.${n};
+                     in if isAttrs x then (mergeFun args x)
+                        else assert isFunction x;
+                             mergeFun args (x ( args // { inherit fixed; }));
+             in overridableDelayableArgs f newArgs;
+    in
+    (f (tidy (lib.fix takeFixed))) // {
+      merge   = fun "mergeFun";
+      replace = fun "keepFun";
+    };
+  defaultOverridableDelayableArgs = f : 
+      let defaults = {
+            mergeFun = mergeAttrByFunc; # default merge function. merge strategie (concatenate lists, strings) is given by mergeAttrBy
+            keepFun = a : b : { inherit (a) removeAttrs mergeFun keepFun mergeAttrBy; } // b; # even when using replace preserve these values
+            applyPreTidy = []; # list of functions applied to args before args are tidied up (usage case : prepareDerivationArgs)
+            mergeAttrBy = mergeAttrBy // {
+              applyPreTidy = a : b : a ++ b;
+              removeAttrs = a : b: a ++ b;
+            };
+            removeAttrs = ["mergeFun" "keepFun" "mergeAttrBy" "removeAttrs" "fixed" ]; # before applying the arguments to the function make sure these names are gone
+          };
+      in (overridableDelayableArgs f defaults).merge;
+
+
+
+  # rec { # an example of how composedArgsAndFun can be used
+  #  a  = composedArgsAndFun (x : x) { a = ["2"]; meta = { d = "bar";}; };
+  #  # meta.d will be lost ! It's your task to preserve it (eg using a merge function)
+  #  b  = a.passthru.function { a = [ "3" ]; meta = { d2 = "bar2";}; };
+  #  # instead of passing/ overriding values you can use a merge function:
+  #  c  = b.passthru.function ( x: { a = x.a  ++ ["4"]; }); # consider using (maybeAttr "a" [] x)
+  # }
+  # result:
+  # {
+  #   a = { a = ["2"];     meta = { d = "bar"; }; passthru = { function = .. }; };
+  #   b = { a = ["3"];     meta = { d2 = "bar2"; }; passthru = { function = .. }; };
+  #   c = { a = ["3" "4"]; meta = { d2 = "bar2"; }; passthru = { function = .. }; };
+  #   # c2 is equal to c
+  # }
+  composedArgsAndFun = f: foldArgs defaultMerge f {};
+
+
+  # shortcut for attrByPath ["name"] default attrs
+  maybeAttrNullable = maybeAttr;
+
+  # shortcut for attrByPath ["name"] default attrs
+  maybeAttr = name: default: attrs: attrs.${name} or default;
+
+
+  # Return the second argument if the first one is true or the empty version
+  # of the second argument.
+  ifEnable = cond: val:
+    if cond then val
+    else if builtins.isList val then []
+    else if builtins.isAttrs val then {}
+    # else if builtins.isString val then ""
+    else if val == true || val == false then false
+    else null;
+
+    
+  # Return true only if there is an attribute and it is true.
+  checkFlag = attrSet: name:
+        if name == "true" then true else
+        if name == "false" then false else
+        if (elem name (attrByPath ["flags"] [] attrSet)) then true else
+        attrByPath [name] false attrSet ;
+
+
+  # Input : attrSet, [ [name default] ... ], name
+  # Output : its value or default.
+  getValue = attrSet: argList: name:
+  ( attrByPath [name] (if checkFlag attrSet name then true else
+        if argList == [] then null else
+        let x = builtins.head argList; in
+                if (head x) == name then 
+                        (head (tail x))
+                else (getValue attrSet 
+                        (tail argList) name)) attrSet );
+
+                        
+  # Input : attrSet, [[name default] ...], [ [flagname reqs..] ... ]
+  # Output : are reqs satisfied? It's asserted.
+  checkReqs = attrSet : argList : condList :
+  (
+    fold lib.and true 
+      (map (x: let name = (head x) ; in
+        
+        ((checkFlag attrSet name) -> 
+        (fold lib.and true
+        (map (y: let val=(getValue attrSet argList y); in
+                (val!=null) && (val!=false)) 
+        (tail x))))) condList)) ;
+        
+
+  # This function has O(n^2) performance.
+  uniqList = {inputList, acc ? []} :
+    let go = xs : acc :
+             if xs == []
+             then []
+             else let x = head xs;
+                      y = if elem x acc then [] else [x];
+                  in y ++ go (tail xs) (y ++ acc);
+    in go inputList acc;
+
+  uniqListExt = {inputList, outputList ? [],
+    getter ? (x : x), compare ? (x: y: x==y)}:
+        if inputList == [] then outputList else
+        let x=head inputList; 
+        isX = y: (compare (getter y) (getter x));
+        newOutputList = outputList ++
+         (if any isX outputList then [] else [x]);
+        in uniqListExt {outputList=newOutputList; 
+                inputList = (tail inputList);
+                inherit getter compare;
+                };
+
+
+                
+  condConcat = name: list: checker:
+        if list == [] then name else
+        if checker (head list) then 
+                condConcat 
+                        (name + (head (tail list))) 
+                        (tail (tail list)) 
+                        checker
+        else condConcat
+                name (tail (tail list)) checker;
+
+  lazyGenericClosure = {startSet, operator}:
+    let
+      work = list: doneKeys: result:
+        if list == [] then
+          result
+        else
+          let x = head list; key = x.key; in
+          if elem key doneKeys then
+            work (tail list) doneKeys result
+          else
+            work (tail list ++ operator x) ([key] ++ doneKeys) ([x] ++ result);
+    in
+      work startSet [] [];
+
+  genericClosure = builtins.genericClosure or lazyGenericClosure;
+
+  innerModifySumArgs = f: x: a: b: if b == null then (f a b) // x else 
+        innerModifySumArgs f x (a // b);
+  modifySumArgs = f: x: innerModifySumArgs f x {};
+
+
+  innerClosePropagation = acc : xs :
+    if xs == []
+    then acc
+    else let y  = head xs;
+             ys = tail xs;
+         in if ! isAttrs y
+            then innerClosePropagation acc ys
+            else let acc' = [y] ++ acc;
+                 in innerClosePropagation
+                      acc'
+                      (uniqList { inputList = (maybeAttrNullable "propagatedBuildInputs" [] y)
+                                           ++ (maybeAttrNullable "propagatedNativeBuildInputs" [] y)
+                                           ++ ys;
+                                  acc = acc';
+                                }
+                      );
+
+  closePropagation = list: (uniqList {inputList = (innerClosePropagation [] list);});
+
+  # calls a function (f attr value ) for each record item. returns a list
+  mapAttrsFlatten = f : r : map (attr: f attr r.${attr}) (attrNames r);
+
+  # attribute set containing one attribute
+  nvs = name : value : listToAttrs [ (nameValuePair name value) ];
+  # adds / replaces an attribute of an attribute set
+  setAttr = set : name : v : set // (nvs name v);
+
+  # setAttrMerge (similar to mergeAttrsWithFunc but only merges the values of a particular name)
+  # setAttrMerge "a" [] { a = [2];} (x : x ++ [3]) -> { a = [2 3]; } 
+  # setAttrMerge "a" [] {         } (x : x ++ [3]) -> { a = [  3]; }
+  setAttrMerge = name : default : attrs : f :
+    setAttr attrs name (f (maybeAttr name default attrs));
+
+  # Using f = a : b = b the result is similar to //
+  # merge attributes with custom function handling the case that the attribute
+  # exists in both sets
+  mergeAttrsWithFunc = f : set1 : set2 :
+    fold (n: set : if set ? ${n}
+                        then setAttr set n (f set.${n} set2.${n})
+                        else set )
+           (set2 // set1) (attrNames set2);
+
+  # merging two attribute set concatenating the values of same attribute names
+  # eg { a = 7; } {  a = [ 2 3 ]; } becomes { a = [ 7 2 3 ]; }
+  mergeAttrsConcatenateValues = mergeAttrsWithFunc ( a : b : (toList a) ++ (toList b) );
+
+  # merges attributes using //, if a name exisits in both attributes
+  # an error will be triggered unless its listed in mergeLists
+  # so you can mergeAttrsNoOverride { buildInputs = [a]; } { buildInputs = [a]; } {} to get
+  # { buildInputs = [a b]; }
+  # merging buildPhase does'nt really make sense. The cases will be rare where appending /prefixing will fit your needs?
+  # in these cases the first buildPhase will override the second one
+  # ! deprecated, use mergeAttrByFunc instead
+  mergeAttrsNoOverride = { mergeLists ? ["buildInputs" "propagatedBuildInputs"],
+                           overrideSnd ? [ "buildPhase" ]
+                         } : attrs1 : attrs2 :
+    fold (n: set : 
+        setAttr set n ( if set ? ${n}
+            then # merge 
+              if elem n mergeLists # attribute contains list, merge them by concatenating
+                then attrs2.${n} ++ attrs1.${n}
+              else if elem n overrideSnd
+                then attrs1.${n}
+              else throw "error mergeAttrsNoOverride, attribute ${n} given in both attributes - no merge func defined"
+            else attrs2.${n} # add attribute not existing in attr1
+           )) attrs1 (attrNames attrs2);
+
+
+  # example usage:
+  # mergeAttrByFunc  {
+  #   inherit mergeAttrBy; # defined below
+  #   buildInputs = [ a b ];
+  # } {
+  #  buildInputs = [ c d ];
+  # };
+  # will result in
+  # { mergeAttrsBy = [...]; buildInputs = [ a b c d ]; }
+  # is used by prepareDerivationArgs, defaultOverridableDelayableArgs and can be used when composing using
+  # foldArgs, composedArgsAndFun or applyAndFun. Example: composableDerivation in all-packages.nix
+  mergeAttrByFunc = x : y :
+    let
+          mergeAttrBy2 = { mergeAttrBy=lib.mergeAttrs; }
+                      // (maybeAttr "mergeAttrBy" {} x)
+                      // (maybeAttr "mergeAttrBy" {} y); in
+    fold lib.mergeAttrs {} [
+      x y
+      (mapAttrs ( a : v : # merge special names using given functions
+          if x ? ${a}
+             then if y ? ${a}
+               then v x.${a} y.${a} # both have attr, use merge func
+               else x.${a} # only x has attr
+             else y.${a} # only y has attr)
+          ) (removeAttrs mergeAttrBy2
+                         # don't merge attrs which are neither in x nor y
+                         (filter (a: ! x ? ${a} && ! y ? ${a})
+                                 (attrNames mergeAttrBy2))
+            )
+      )
+    ];
+  mergeAttrsByFuncDefaults = foldl mergeAttrByFunc { inherit mergeAttrBy; };
+  mergeAttrsByFuncDefaultsClean = list: removeAttrs (mergeAttrsByFuncDefaults list) ["mergeAttrBy"];
+
+  # merge attrs based on version key into mkDerivation args, see mergeAttrBy to learn about smart merge defaults
+  #
+  # This function is best explained by an example:
+  #
+  #     {version ? "2.x"} :
+  #
+  #     mkDerivation (mergeAttrsByVersion "package-name" version 
+  #       { # version specific settings
+  #         "git" = { src = ..; preConfigre = "autogen.sh"; buildInputs = [automake autoconf libtool];  };
+  #         "2.x" = { src = ..; };
+  #       }
+  #       {  // shared settings
+  #          buildInputs = [ common build inputs ];
+  #          meta = { .. }
+  #       }
+  #     )
+  #
+  # Please note that e.g. Eelco Dolstra usually prefers having one file for
+  # each version. On the other hand there are valuable additional design goals
+  #  - readability
+  #  - do it once only
+  #  - try to avoid duplication
+  #
+  # Marc Weber and Michael Raskin sometimes prefer keeping older
+  # versions around for testing and regression tests - as long as its cheap to
+  # do so.
+  #
+  # Very often it just happens that the "shared" code is the bigger part.
+  # Then using this function might be appropriate.
+  #
+  # Be aware that its easy to cause recompilations in all versions when using
+  # this function - also if derivations get too complex splitting into multiple
+  # files is the way to go.
+  #
+  # See misc.nix -> versionedDerivation
+  # discussion: nixpkgs: pull/310
+  mergeAttrsByVersion = name: version: attrsByVersion: base:
+    mergeAttrsByFuncDefaultsClean [ { name = "${name}-${version}"; } base (maybeAttr version (throw "bad version ${version} for ${name}") attrsByVersion)];
+
+  # sane defaults (same name as attr name so that inherit can be used)
+  mergeAttrBy = # { buildInputs = concatList; [...]; passthru = mergeAttr; [..]; }
+    listToAttrs (map (n : nameValuePair n lib.concat)
+      [ "nativeBuildInputs" "buildInputs" "propagatedBuildInputs" "configureFlags" "prePhases" "postAll" "patches" ])
+    // listToAttrs (map (n : nameValuePair n lib.mergeAttrs) [ "passthru" "meta" "cfg" "flags" ])
+    // listToAttrs (map (n : nameValuePair n (a: b: "${a}\n${b}") ) [ "preConfigure" "postInstall" ])
+  ;
+
+  # prepareDerivationArgs tries to make writing configurable derivations easier
+  # example:
+  #  prepareDerivationArgs {
+  #    mergeAttrBy = {
+  #       myScript = x : y : x ++ "\n" ++ y;
+  #    };
+  #    cfg = {
+  #      readlineSupport = true;
+  #    };
+  #    flags = {
+  #      readline = {
+  #        set = {
+  #           configureFlags = [ "--with-compiler=${compiler}" ];
+  #           buildInputs = [ compiler ];
+  #           pass = { inherit compiler; READLINE=1; };
+  #           assertion = compiler.dllSupport;
+  #           myScript = "foo";
+  #        };
+  #        unset = { configureFlags = ["--without-compiler"]; };
+  #      };
+  #    };
+  #    src = ...
+  #    buildPhase = '' ... '';
+  #    name = ...
+  #    myScript = "bar";
+  #  };
+  # if you don't have need for unset you can omit the surrounding set = { .. } attr
+  # all attrs except flags cfg and mergeAttrBy will be merged with the
+  # additional data from flags depending on config settings
+  # It's used in composableDerivation in all-packages.nix. It's also used
+  # heavily in the new python and libs implementation
+  #
+  # should we check for misspelled cfg options?
+  # TODO use args.mergeFun here as well?
+  prepareDerivationArgs = args:
+    let args2 = { cfg = {}; flags = {}; } // args;
+        flagName = name : "${name}Support";
+        cfgWithDefaults = (listToAttrs (map (n : nameValuePair (flagName n) false) (attrNames args2.flags)))
+                          // args2.cfg;
+        opts = attrValues (mapAttrs (a : v :
+                let v2 = if v ? set || v ? unset then v else { set = v; };
+                    n = if cfgWithDefaults.${flagName a} then "set" else "unset";
+                    attr = maybeAttr n {} v2; in
+                if (maybeAttr "assertion" true attr)
+                  then attr
+                  else throw "assertion of flag ${a} of derivation ${args.name} failed"
+               ) args2.flags );
+    in removeAttrs
+      (mergeAttrsByFuncDefaults ([args] ++ opts ++ [{ passthru = cfgWithDefaults; }]))
+      ["flags" "cfg" "mergeAttrBy" ];
+
+
+  nixType = x:
+      if isAttrs x then
+          if x ? outPath then "derivation"
+          else "aattrs"
+      else if isFunction x then "function"
+      else if isList x then "list"
+      else if x == true then "bool"
+      else if x == false then "bool"
+      else if x == null then "null"
+      else if isInt x then "int"
+      else "string";
+
+}

lib/modules.nix

@@ -9,75 +9,27 @@ rec {
 
   /* Evaluate a set of modules.  The result is a set of two
      attributes: ‘options’: the nested set of all option declarations,
-     and ‘config’: the nested set of all option values.
-     !!! Please think twice before adding to this argument list! The more
-     that is specified here instead of in the modules themselves the harder
-     it is to transparently move a set of modules to be a submodule of another
-     config (as the proper arguments need to be replicated at each call to
-     evalModules) and the less declarative the module set is. */
-  evalModules = { modules
-                , prefix ? []
-                , # This should only be used for special arguments that need to be evaluated
-                  # when resolving module structure (like in imports). For everything else,
-                  # there's _module.args.
-                  specialArgs ? {}
-                , # This would be remove in the future, Prefer _module.args option instead.
-                  args ? {}
-                , # This would be remove in the future, Prefer _module.check option instead.
-                  check ? true
-                }:
+     and ‘config’: the nested set of all option values. */
+  evalModules = { modules, prefix ? [], args ? {}, check ? true }:
     let
-      # This internal module declare internal options under the `_module'
-      # attribute.  These options are fragile, as they are used by the
-      # module system to change the interpretation of modules.
-      internalModule = rec {
-        _file = ./modules.nix;
-
-        key = _file;
-
-        options = {
-          _module.args = mkOption {
-            type = types.attrsOf types.unspecified;
-            internal = true;
-            description = "Arguments passed to each module.";
-          };
-
-          _module.check = mkOption {
-            type = types.bool;
-            internal = true;
-            default = check;
-            description = "Whether to check whether all option definitions have matching declarations.";
-          };
-        };
-
-        config = {
-          _module.args = args;
-        };
-      };
-
-      closed = closeModules (modules ++ [ internalModule ]) ({ inherit config options; lib = import ./.; } // specialArgs);
-
+      args' = args // { lib = import ./.; } // result;
+      closed = closeModules modules args';
       # Note: the list of modules is reversed to maintain backward
       # compatibility with the old module system.  Not sure if this is
       # the most sensible policy.
       options = mergeModules prefix (reverseList closed);
-
       # Traverse options and extract the option values into the final
       # config set.  At the same time, check whether all option
       # definitions have matching declarations.
-      # !!! _module.check's value can't depend on any other config values
-      # without an infinite recursion. One way around this is to make the
-      # 'config' passed around to the modules be unconditionally unchecked,
-      # and only do the check in 'result'.
       config = yieldConfig prefix options;
       yieldConfig = prefix: set:
         let res = removeAttrs (mapAttrs (n: v:
           if isOption v then v.value
           else yieldConfig (prefix ++ [n]) v) set) ["_definedNames"];
         in
-        if options._module.check.value && set ? _definedNames then
-          foldl' (res: m:
-            foldl' (res: name:
+        if check && set ? _definedNames then
+          fold (m: res:
+            fold (name: res:
               if set ? ${name} then res else throw "The option `${showOption (prefix ++ [name])}' defined in `${m.file}' does not exist.")
               res m.names)
             res set._definedNames
@@ -91,11 +43,9 @@ rec {
     let
       toClosureList = file: parentKey: imap (n: x:
         if isAttrs x || isFunction x then
-          let key = "${parentKey}:anon-${toString n}"; in
-          unifyModuleSyntax file key (unpackSubmodule (applyIfFunction key) x args)
+          unifyModuleSyntax file "${parentKey}:anon-${toString n}" (applyIfFunction x args)
         else
-          let file = toString x; key = toString x; in
-          unifyModuleSyntax file key (applyIfFunction key (import x) args));
+          unifyModuleSyntax (toString x) (toString x) (applyIfFunction (import x) args));
     in
       builtins.genericClosure {
         startSet = toClosureList unknownModule "" modules;
@@ -124,46 +74,7 @@ rec {
         config = removeAttrs m ["key" "_file" "require" "imports"];
       };
 
-  applyIfFunction = key: f: args@{ config, options, lib, ... }: if isFunction f then
-    let
-      # Module arguments are resolved in a strict manner when attribute set
-      # deconstruction is used.  As the arguments are now defined with the
-      # config._module.args option, the strictness used on the attribute
-      # set argument would cause an infinite loop, if the result of the
-      # option is given as argument.
-      #
-      # To work-around the strictness issue on the deconstruction of the
-      # attributes set argument, we create a new attribute set which is
-      # constructed to satisfy the expected set of attributes.  Thus calling
-      # a module will resolve strictly the attributes used as argument but
-      # not their values.  The values are forwarding the result of the
-      # evaluation of the option.
-      requiredArgs = builtins.attrNames (builtins.functionArgs f);
-      context = name: ''while evaluating the module argument `${name}' in "${key}":'';
-      extraArgs = builtins.listToAttrs (map (name: {
-        inherit name;
-        value = addErrorContext (context name)
-          (args.${name} or config._module.args.${name});
-      }) requiredArgs);
-
-      # Note: we append in the opposite order such that we can add an error
-      # context on the explicited arguments of "args" too. This update
-      # operator is used to make the "args@{ ... }: with args.lib;" notation
-      # works.
-    in f (args // extraArgs)
-  else
-    f;
-
-  /* We have to pack and unpack submodules. We cannot wrap the expected
-     result of the function as we would no longer be able to list the arguments
-     of the submodule. (see applyIfFunction) */
-  unpackSubmodule = unpack: m: args:
-    if isType "submodule" m then
-      { _file = m.file; } // (unpack m.submodule args)
-    else unpack m args;
-
-  packSubmodule = file: m:
-    { _type = "submodule"; file = file; submodule = m; };
+  applyIfFunction = f: arg: if isFunction f then f arg else f;
 
   /* Merge a list of modules.  This will recurse over the option
      declarations in all modules, combining them into a single set.
@@ -182,22 +93,25 @@ rec {
         let
           loc = prefix ++ [name];
           # Get all submodules that declare ‘name’.
-          decls = concatMap (m:
+          decls = concatLists (map (m:
             if m.options ? ${name}
               then [ { inherit (m) file; options = m.options.${name}; } ]
               else []
-            ) options;
+            ) options);
           # Get all submodules that define ‘name’.
-          defns = concatMap (m:
+          defns = concatLists (map (m:
             if m.config ? ${name}
               then map (config: { inherit (m) file; inherit config; })
                 (pushDownProperties m.config.${name})
               else []
-            ) configs;
+            ) configs);
           nrOptions = count (m: isOption m.options) decls;
-          # Extract the definitions for this loc
-          defns' = map (m: { inherit (m) file; value = m.config.${name}; })
-            (filter (m: m.config ? ${name}) configs);
+          # Process mkMerge and mkIf properties.
+          defns' = concatMap (m:
+            if m.config ? ${name}
+              then map (m': { inherit (m) file; value = m'; }) (dischargeProperties m.config.${name})
+              else []
+            ) configs;
         in
           if nrOptions == length decls then
             let opt = fixupOptionType loc (mergeOptionDecls loc decls);
@@ -225,7 +139,7 @@ rec {
      'opts' is a list of modules.  Each module has an options attribute which
      correspond to the definition of 'loc' in 'opt.file'. */
   mergeOptionDecls = loc: opts:
-    foldl' (res: opt:
+    fold (opt: res:
       if opt.options ? default && res ? default ||
          opt.options ? example && res ? example ||
          opt.options ? description && res ? description ||
@@ -242,16 +156,19 @@ rec {
              current option declaration as the file use for the submodule.  If the
              submodule defines any filename, then we ignore the enclosing option file. */
           options' = toList opt.options.options;
+          addModuleFile = m:
+            if isFunction m then args: { _file = opt.file; } // (m args)
+            else { _file = opt.file; } // m;
           coerceOption = file: opt:
-            if isFunction opt then packSubmodule file opt
-            else packSubmodule file { options = opt; };
+            if isFunction opt then args: { _file = file; } // (opt args)
+            else { _file = file; options = opt; };
           getSubModules = opt.options.type.getSubModules or null;
           submodules =
-            if getSubModules != null then map (packSubmodule opt.file) getSubModules ++ res.options
+            if getSubModules != null then map addModuleFile getSubModules ++ res.options
             else if opt.options ? options then map (coerceOption opt.file) options' ++ res.options
             else res.options;
         in opt.options // res //
-          { declarations = res.declarations ++ [opt.file];
+          { declarations = [opt.file] ++ res.declarations;
             options = submodules;
           }
     ) { inherit loc; declarations = []; options = []; } opts;
@@ -260,69 +177,38 @@ rec {
      config value. */
   evalOptionValue = loc: opt: defs:
     let
-      # Add in the default value for this option, if any.
-      defs' =
-          (optional (opt ? default)
-            { file = head opt.declarations; value = mkOptionDefault opt.default; }) ++ defs;
-
-      # Handle properties, check types, and merge everything together.
-      res =
-        if opt.readOnly or false && length defs' > 1 then
-          throw "The option `${showOption loc}' is read-only, but it's set multiple times."
-        else
-          mergeDefinitions loc opt.type defs';
-
-      # Check whether the option is defined, and apply the ‘apply’
-      # function to the merged value.  This allows options to yield a
-      # value computed from the definitions.
-      value =
-        if !res.isDefined then
+      # Process mkOverride properties, adding in the default
+      # value specified in the option declaration (if any).
+      defsFinal' = filterOverrides
+        ((if opt ? default then [{ file = head opt.declarations; value = mkOptionDefault opt.default; }] else []) ++ defs);
+      # Sort mkOrder properties.
+      defsFinal =
+        # Avoid sorting if we don't have to.
+        if any (def: def.value._type or "" == "order") defsFinal'
+        then sortProperties defsFinal'
+        else defsFinal';
+      files = map (def: def.file) defsFinal;
+      # Type-check the remaining definitions, and merge them if
+      # possible.
+      merged =
+        if defsFinal == [] then
           throw "The option `${showOption loc}' is used but not defined."
-        else if opt ? apply then
-          opt.apply res.mergedValue
         else
-          res.mergedValue;
-
+          fold (def: res:
+            if opt.type.check def.value then res
+            else throw "The option value `${showOption loc}' in `${def.file}' is not a ${opt.type.name}.")
+            (opt.type.merge loc defsFinal) defsFinal;
+      # Finally, apply the ‘apply’ function to the merged
+      # value.  This allows options to yield a value computed
+      # from the definitions.
+      value = (opt.apply or id) merged;
     in opt //
       { value = addErrorContext "while evaluating the option `${showOption loc}':" value;
-        definitions = map (def: def.value) res.defsFinal;
-        files = map (def: def.file) res.defsFinal;
-        inherit (res) isDefined;
+        definitions = map (def: def.value) defsFinal;
+        isDefined = defsFinal != [];
+        inherit files;
       };
 
-  # Merge definitions of a value of a given type.
-  mergeDefinitions = loc: type: defs: rec {
-    defsFinal =
-      let
-        # Process mkMerge and mkIf properties.
-        defs' = concatMap (m:
-          map (value: { inherit (m) file; inherit value; }) (dischargeProperties m.value)
-        ) defs;
-
-        # Process mkOverride properties.
-        defs'' = filterOverrides defs';
-
-        # Sort mkOrder properties.
-        defs''' =
-          # Avoid sorting if we don't have to.
-          if any (def: def.value._type or "" == "order") defs''
-          then sortProperties defs''
-          else defs'';
-      in defs''';
-
-    # Type-check the remaining definitions, and merge them.
-    mergedValue = foldl' (res: def:
-      if type.check def.value then res
-      else throw "The option value `${showOption loc}' in `${def.file}' is not a ${type.name}.")
-      (type.merge loc defsFinal) defsFinal;
-
-    isDefined = defsFinal != [];
-
-    optionalValue =
-      if isDefined then { value = mergedValue; }
-      else {};
-  };
-
   /* Given a config set, expand mkMerge properties, and push down the
      other properties into the children.  The result is a list of
      config sets that do not have properties at top-level.  For
@@ -392,7 +278,8 @@ rec {
     let
       defaultPrio = 100;
       getPrio = def: if def.value._type or "" == "override" then def.value.priority else defaultPrio;
-      highestPrio = foldl' (prio: def: min (getPrio def) prio) 9999 defs;
+      min = x: y: if x < y then x else y;
+      highestPrio = fold (def: prio: min (getPrio def) prio) 9999 defs;
       strip = def: if def.value._type or "" == "override" then def // { value = def.value.content; } else def;
     in concatMap (def: if getPrio def == highestPrio then [(strip def)] else []) defs;
 
@@ -469,31 +356,6 @@ rec {
   mkBefore = mkOrder 500;
   mkAfter = mkOrder 1500;
 
-  # Convenient property used to transfer all definitions and their
-  # properties from one option to another. This property is useful for
-  # renaming options, and also for including properties from another module
-  # system, including sub-modules.
-  #
-  #   { config, options, ... }:
-  #
-  #   {
-  #     # 'bar' might not always be defined in the current module-set.
-  #     config.foo.enable = mkAliasDefinitions (options.bar.enable or {});
-  #
-  #     # 'barbaz' has to be defined in the current module-set.
-  #     config.foobar.paths = mkAliasDefinitions options.barbaz.paths;
-  #   }
-  #
-  # Note, this is different than taking the value of the option and using it
-  # as a definition, as the new definition will not keep the mkOverride /
-  # mkDefault properties of the previous option.
-  #
-  mkAliasDefinitions = mkAliasAndWrapDefinitions id;
-  mkAliasAndWrapDefinitions = wrap: option:
-    mkMerge
-      (optional (isOption option && option.isDefined)
-        (wrap (mkMerge option.definitions)));
-
 
   /* Compatibility. */
   fixMergeModules = modules: args: evalModules { inherit modules args; check = false; };

lib/options.nix

@@ -4,6 +4,7 @@ let lib = import ./default.nix; in
 
 with import ./trivial.nix;
 with import ./lists.nix;
+with import ./misc.nix;
 with import ./attrsets.nix;
 with import ./strings.nix;
 
@@ -19,7 +20,6 @@ rec {
     , apply ? null # Function that converts the option value to something else.
     , internal ? null # Whether the option is for NixOS developers only.
     , visible ? null # Whether the option shows up in the manual.
-    , readOnly ? null # Whether the option can be set only once
     , options ? null # Obsolete, used by types.optionSet.
     } @ attrs:
     attrs // { _type = "option"; };
@@ -31,49 +31,37 @@ rec {
     type = lib.types.bool;
   };
 
-  # This option accept anything, but it does not produce any result.  This
-  # is useful for sharing a module across different module sets without
-  # having to implement similar features as long as the value of the options
-  # are not expected.
-  mkSinkUndeclaredOptions = attrs: mkOption ({
-    internal = true;
-    visible = false;
-    default = false;
-    description = "Sink for option definitions.";
-    type = mkOptionType {
-      name = "sink";
-      check = x: true;
-      merge = loc: defs: false;
-    };
-    apply = x: throw "Option value is not readable because the option is not declared.";
-  } // attrs);
-
   mergeDefaultOption = loc: defs:
     let list = getValues defs; in
     if length list == 1 then head list
     else if all isFunction list then x: mergeDefaultOption loc (map (f: f x) list)
     else if all isList list then concatLists list
-    else if all isAttrs list then foldl' lib.mergeAttrs {} list
-    else if all isBool list then foldl' lib.or false list
+    else if all isAttrs list then fold lib.mergeAttrs {} list
+    else if all isBool list then fold lib.or false list
     else if all isString list then lib.concatStrings list
     else if all isInt list && all (x: x == head list) list then head list
     else throw "Cannot merge definitions of `${showOption loc}' given in ${showFiles (getFiles defs)}.";
 
+  /* Obsolete, will remove soon.  Specify an option type or apply
+     function instead.  */
+  mergeTypedOption = typeName: predicate: merge: loc: list:
+    let list' = map (x: x.value) list; in
+    if all predicate list then merge list'
+    else throw "Expected a ${typeName}.";
+
+  mergeEnableOption = mergeTypedOption "boolean"
+    (x: true == x || false == x) (fold lib.or false);
+
+  mergeListOption = mergeTypedOption "list" isList concatLists;
+
+  mergeStringOption = mergeTypedOption "string" isString lib.concatStrings;
+
   mergeOneOption = loc: defs:
     if defs == [] then abort "This case should never happen."
     else if length defs != 1 then
       throw "The unique option `${showOption loc}' is defined multiple times, in ${showFiles (getFiles defs)}."
     else (head defs).value;
 
-  /* "Merge" option definitions by checking that they all have the same value. */
-  mergeEqualOption = loc: defs:
-    if defs == [] then abort "This case should never happen."
-    else foldl' (val: def:
-      if def.value != val then
-        throw "The option `${showOption loc}' has conflicting definitions, in ${showFiles (getFiles defs)}."
-      else
-        val) (head defs).value defs;
-
   getValues = map (x: x.value);
   getFiles = map (x: x.file);
 
@@ -83,7 +71,7 @@ rec {
   optionAttrSetToDocList = optionAttrSetToDocList' [];
 
   optionAttrSetToDocList' = prefix: options:
-    concatMap (opt:
+    fold (opt: rest:
       let
         docOption = rec {
           name = showOption opt.loc;
@@ -91,7 +79,6 @@ rec {
           declarations = filter (x: x != unknownModule) opt.declarations;
           internal = opt.internal or false;
           visible = opt.visible or true;
-          readOnly = opt.readOnly or false;
           type = opt.type.name or null;
         }
         // (if opt ? example then { example = scrubOptionValue opt.example; } else {})
@@ -102,7 +89,8 @@ rec {
           let ss = opt.type.getSubOptions opt.loc;
           in if ss != {} then optionAttrSetToDocList' opt.loc ss else [];
       in
-        [ docOption ] ++ subOptions) (collect isOption options);
+        # FIXME: expensive, O(n^2)
+        [ docOption ] ++ subOptions ++ rest) [] (collect isOption options);
 
 
   /* This function recursively removes all derivation attributes from

lib/platforms.nix

@@ -13,8 +13,4 @@ rec {
   none = [];
   allBut = platforms: lists.filter (x: !(builtins.elem x platforms)) all;
   mesaPlatforms = ["i686-linux" "x86_64-linux" "x86_64-darwin" "armv5tel-linux" "armv6l-linux"];
-  x86_64 = ["x86_64-linux" "x86_64-darwin" "x86_64-freebsd" "x86_64-openbsd" "x86_64-netbsd" "x86_64-cygwin"];
-  i686 = ["i686-linux" "i686-freebsd" "i686-netbsd" "i686-cygwin"];
-  arm = ["armv5tel-linux" "armv6l-linux" "armv7l-linux" ];
-  mips = [ "mips64el-linux" ];
 }

lib/strings.nix

@@ -8,15 +8,11 @@ in
 
 rec {
 
-  inherit (builtins) stringLength substring head tail isString replaceStrings;
+  inherit (builtins) stringLength substring head tail isString;
 
 
   # Concatenate a list of strings.
-  concatStrings =
-    if builtins ? concatStringsSep then
-      builtins.concatStringsSep ""
-    else
-      lib.foldl' (x: y: x + y) "";
+  concatStrings = lib.fold (x: y: x + y) "";
 
 
   # Map a function over a list and concatenate the resulting strings.
@@ -29,13 +25,14 @@ rec {
   intersperse = separator: list:
     if list == [] || length list == 1
     then list
-    else tail (lib.concatMap (x: [separator x]) list);
+    else [(head list) separator]
+         ++ (intersperse separator (tail list));
 
 
   # Concatenate a list of strings with a separator between each element, e.g.
   # concatStringsSep " " ["foo" "bar" "xyzzy"] == "foo bar xyzzy"
-  concatStringsSep = builtins.concatStringsSep or (separator: list:
-    concatStrings (intersperse separator list));
+  concatStringsSep = separator: list:
+    concatStrings (intersperse separator list);
 
   concatMapStringsSep = sep: f: list: concatStringsSep sep (map f list);
   concatImapStringsSep = sep: f: list: concatStringsSep sep (lib.imap f list);
@@ -64,13 +61,13 @@ rec {
 
   # Determine whether a string has given prefix/suffix.
   hasPrefix = pref: str:
-    substring 0 (stringLength pref) str == pref;
+    eqStrings (substring 0 (stringLength pref) str) pref;
   hasSuffix = suff: str:
     let
       lenStr = stringLength str;
       lenSuff = stringLength suff;
     in lenStr >= lenSuff &&
-       substring (lenStr - lenSuff) lenStr str == suff;
+       eqStrings (substring (lenStr - lenSuff) lenStr str) suff;
 
 
   # Convert a string to a list of characters (i.e. singleton strings).
@@ -79,57 +76,63 @@ rec {
   # will likely be horribly inefficient; Nix is not a general purpose
   # programming language.  Complex string manipulations should, if
   # appropriate, be done in a derivation.
-  stringToCharacters = s:
-    map (p: substring p 1 s) (lib.range 0 (stringLength s - 1));
+  stringToCharacters = s: let l = stringLength s; in
+    if l == 0
+    then []
+    else map (p: substring p 1 s) (lib.range 0 (l - 1));
 
 
-  # Manipulate a string charactter by character and replace them by
-  # strings before concatenating the results.
+  # Manipulate a string charcater by character and replace them by strings
+  # before concatenating the results.
   stringAsChars = f: s:
     concatStrings (
       map f (stringToCharacters s)
     );
 
 
-  # Escape occurrence of the elements of ‘list’ in ‘string’ by
-  # prefixing it with a backslash. For example, ‘escape ["(" ")"]
-  # "(foo)"’ returns the string ‘\(foo\)’.
-  escape = list: replaceChars list (map (c: "\\${c}") list);
+  # same as vim escape function.
+  # Each character contained in list is prefixed by "\"
+  escape = list : string :
+    stringAsChars (c: if lib.elem c list then "\\${c}" else c) string;
 
 
-  # Escape all characters that have special meaning in the Bourne shell.
+  # still ugly slow. But more correct now
+  # [] for zsh
   escapeShellArg = lib.escape (stringToCharacters "\\ ';$`()|<>\t*[]");
 
 
-  # Obsolete - use replaceStrings instead.
-  replaceChars = builtins.replaceStrings or (
-    del: new: s:
+  # replace characters by their substitutes.  This function is equivalent to
+  # the `tr' command except that one character can be replace by multiple
+  # ones.  e.g.,
+  # replaceChars ["<" ">"] ["&lt;" "&gt;"] "<foo>" returns "&lt;foo&gt;".
+  replaceChars = del: new: s:
     let
-      substList = lib.zipLists del new;
       subst = c:
-        let found = lib.findFirst (sub: sub.fst == c) null substList; in
-        if found == null then
-          c
-        else
-          found.snd;
+        (lib.fold
+          (sub: res: if sub.fst == c then sub else res)
+          {fst = c; snd = c;} (lib.zipLists del new)
+        ).snd;
     in
-      stringAsChars subst s);
+      stringAsChars subst s;
 
 
-  # Case conversion utilities.
+  # Case conversion utilities
   lowerChars = stringToCharacters "abcdefghijklmnopqrstuvwxyz";
   upperChars = stringToCharacters "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   toLower = replaceChars upperChars lowerChars;
   toUpper = replaceChars lowerChars upperChars;
 
-
-  # Appends string context from another string.
+  # Appends string context from another string
   addContextFrom = a: b: substring 0 0 a + b;
 
+  # Compares strings not requiring context equality
+  # Obviously, a workaround but works on all Nix versions
+  eqStrings = a: b: addContextFrom b a == addContextFrom a b;
 
-  # Cut a string with a separator and produces a list of strings which
-  # were separated by this separator; e.g., `splitString "."
-  # "foo.bar.baz"' returns ["foo" "bar" "baz"].
+
+  # Cut a string with a separator and produces a list of strings which were
+  # separated by this separator. e.g.,
+  # `splitString "." "foo.bar.baz"' returns ["foo" "bar" "baz"].
   splitString = _sep: _s:
     let
       sep = addContextFrom _s _sep;
@@ -172,7 +175,7 @@ rec {
       sufLen = stringLength suf;
       sLen = stringLength s;
     in
-      if sufLen <= sLen && suf == substring (sLen - sufLen) sufLen s then
+      if sufLen <= sLen && eqStrings suf (substring (sLen - sufLen) sufLen s) then
         substring 0 (sLen - sufLen) s
       else
         s;
@@ -191,13 +194,14 @@ rec {
 
 
   # Extract name with version from URL. Ask for separator which is
-  # supposed to start extension.
-  nameFromURL = url: sep:
-    let
-      components = splitString "/" url;
-      filename = lib.last components;
-      name = builtins.head (splitString sep filename);
-    in assert name !=  filename; name;
+  # supposed to start extension
+  nameFromURL = url: sep: let
+    components = splitString "/" url;
+    filename = lib.last components;
+    name = builtins.head (splitString sep filename);
+  in
+  assert ! eqStrings name filename;
+  name;
 
 
   # Create an --{enable,disable}-<feat> string that can be passed to
@@ -205,22 +209,7 @@ rec {
   enableFeature = enable: feat: "--${if enable then "enable" else "disable"}-${feat}";
 
 
-  # Create a fixed width string with additional prefix to match
-  # required width.
-  fixedWidthString = width: filler: str:
-    let
-      strw = lib.stringLength str;
-      reqWidth = width - (lib.stringLength filler);
-    in
-      assert strw <= width;
-      if strw == width then str else filler + fixedWidthString reqWidth filler str;
-
-
-  # Format a number adding leading zeroes up to fixed width.
-  fixedWidthNumber = width: n: fixedWidthString width "0" (toString n);
-
-
   # Check whether a value is a store path.
-  isStorePath = x: builtins.substring 0 1 (toString x) == "/" && dirOf (builtins.toPath x) == builtins.storeDir;
+  isStorePath = x: builtins.substring 0 1 (toString x) == "/" && dirOf (builtins.toPath x) == (builtins.storeDir or "/nix/store");
 
 }

lib/tests/modules.sh

@@ -1,127 +0,0 @@
-#!/bin/sh
-#
-# This script is used to test that the module system is working as expected.
-# By default it test the version of nixpkgs which is defined in the NIX_PATH.
-
-cd ./modules
-
-pass=0
-fail=0
-
-evalConfig() {
-    local attr=$1
-    shift;
-    local script="import ./default.nix { modules = [ $@ ];}"
-    nix-instantiate --timeout 1 -E "$script" -A "$attr" --eval-only --show-trace
-}
-
-reportFailure() {
-    local attr=$1
-    shift;
-    local script="import ./default.nix { modules = [ $@ ];}"
-    echo 2>&1 "$ nix-instantiate -E '$script' -A '$attr' --eval-only"
-    evalConfig "$attr" "$@"
-    fail=$((fail + 1))
-}
-
-checkConfigOutput() {
-    local outputContains=$1
-    shift;
-    if evalConfig "$@" 2>/dev/null | grep --silent "$outputContains" ; then
-        pass=$((pass + 1))
-        return 0;
-    else
-        echo 2>&1 "error: Expected result matching '$outputContains', while evaluating"
-        reportFailure "$@"
-        return 1
-    fi
-}
-
-checkConfigError() {
-    local errorContains=$1
-    local err=""
-    shift;
-    if err==$(evalConfig "$@" 2>&1 >/dev/null); then
-        echo 2>&1 "error: Expected error code, got exit code 0, while evaluating"
-        reportFailure "$@"
-        return 1
-    else
-        if echo "$err" | grep --silent "$errorContains" ; then
-            pass=$((pass + 1))
-            return 0;
-        else
-            echo 2>&1 "error: Expected error matching '$errorContains', while evaluating"
-            reportFailure "$@"
-            return 1
-        fi
-    fi
-}
-
-# Check boolean option.
-checkConfigOutput "false" config.enable ./declare-enable.nix
-checkConfigError 'The option .* defined in .* does not exist.' config.enable ./define-enable.nix
-
-# Check mkForce without submodules.
-set -- config.enable ./declare-enable.nix ./define-enable.nix
-checkConfigOutput "true" "$@"
-checkConfigOutput "false" "$@" ./define-force-enable.nix
-checkConfigOutput "false" "$@" ./define-enable-force.nix
-
-# Check mkForce with option and submodules.
-checkConfigError 'attribute .*foo.* .* not found' config.loaOfSub.foo.enable ./declare-loaOfSub-any-enable.nix
-checkConfigOutput 'false' config.loaOfSub.foo.enable ./declare-loaOfSub-any-enable.nix ./define-loaOfSub-foo.nix
-set -- config.loaOfSub.foo.enable ./declare-loaOfSub-any-enable.nix ./define-loaOfSub-foo-enable.nix
-checkConfigOutput 'true' "$@"
-checkConfigOutput 'false' "$@" ./define-force-loaOfSub-foo-enable.nix
-checkConfigOutput 'false' "$@" ./define-loaOfSub-force-foo-enable.nix
-checkConfigOutput 'false' "$@" ./define-loaOfSub-foo-force-enable.nix
-checkConfigOutput 'false' "$@" ./define-loaOfSub-foo-enable-force.nix
-
-# Check overriding effect of mkForce on submodule definitions.
-checkConfigError 'attribute .*bar.* .* not found' config.loaOfSub.bar.enable ./declare-loaOfSub-any-enable.nix ./define-loaOfSub-foo.nix
-checkConfigOutput 'false' config.loaOfSub.bar.enable ./declare-loaOfSub-any-enable.nix ./define-loaOfSub-foo.nix ./define-loaOfSub-bar.nix
-set -- config.loaOfSub.bar.enable ./declare-loaOfSub-any-enable.nix ./define-loaOfSub-foo.nix ./define-loaOfSub-bar-enable.nix
-checkConfigOutput 'true' "$@"
-checkConfigError 'attribute .*bar.* .* not found' "$@" ./define-force-loaOfSub-foo-enable.nix
-checkConfigError 'attribute .*bar.* .* not found' "$@" ./define-loaOfSub-force-foo-enable.nix
-checkConfigOutput 'true' "$@" ./define-loaOfSub-foo-force-enable.nix
-checkConfigOutput 'true' "$@" ./define-loaOfSub-foo-enable-force.nix
-
-# Check mkIf with submodules.
-checkConfigError 'attribute .*foo.* .* not found' config.loaOfSub.foo.enable ./declare-enable.nix ./declare-loaOfSub-any-enable.nix
-set -- config.loaOfSub.foo.enable ./declare-enable.nix ./declare-loaOfSub-any-enable.nix
-checkConfigError 'attribute .*foo.* .* not found' "$@" ./define-if-loaOfSub-foo-enable.nix
-checkConfigError 'attribute .*foo.* .* not found' "$@" ./define-loaOfSub-if-foo-enable.nix
-checkConfigError 'attribute .*foo.* .* not found' "$@" ./define-loaOfSub-foo-if-enable.nix
-checkConfigOutput 'false' "$@" ./define-loaOfSub-foo-enable-if.nix
-checkConfigOutput 'true' "$@" ./define-enable.nix ./define-if-loaOfSub-foo-enable.nix
-checkConfigOutput 'true' "$@" ./define-enable.nix ./define-loaOfSub-if-foo-enable.nix
-checkConfigOutput 'true' "$@" ./define-enable.nix ./define-loaOfSub-foo-if-enable.nix
-checkConfigOutput 'true' "$@" ./define-enable.nix ./define-loaOfSub-foo-enable-if.nix
-
-# Check _module.args.
-set -- config.enable ./declare-enable.nix ./define-enable-with-custom-arg.nix
-checkConfigError 'while evaluating the module argument .*custom.* in .*define-enable-with-custom-arg.nix.*:' "$@"
-checkConfigOutput "true" "$@" ./define-_module-args-custom.nix
-
-# Check that using _module.args on imports cause infinite recursions, with
-# the proper error context.
-set -- "$@" ./define-_module-args-custom.nix ./import-custom-arg.nix
-checkConfigError 'while evaluating the module argument .*custom.* in .*import-custom-arg.nix.*:' "$@"
-checkConfigError 'infinite recursion encountered' "$@"
-
-# Check _module.check.
-set -- config.enable ./declare-enable.nix ./define-enable.nix ./define-loaOfSub-foo.nix
-checkConfigError 'The option .* defined in .* does not exist.' "$@"
-checkConfigOutput "true" "$@" ./define-module-check.nix
-
-cat <<EOF
-====== module tests ======
-$pass Pass
-$fail Fail
-EOF
-
-if test $fail -ne 0; then
-    exit 1
-fi
-exit 0

lib/tests/modules/declare-enable.nix

@@ -1,14 +0,0 @@
-{ lib, ... }:
-
-{
-  options = {
-    enable = lib.mkOption {
-      default = false;
-      example = true;
-      type = lib.types.bool;
-      description = ''
-        Some descriptive text
-      '';
-    };
-  };
-}

lib/tests/modules/declare-loaOfSub-any-enable.nix

@@ -1,29 +0,0 @@
-{ lib, ... }:
-
-let
-  submod = { ... }: {
-    options = {
-      enable = lib.mkOption {
-        default = false;
-        example = true;
-        type = lib.types.bool;
-        description = ''
-          Some descriptive text
-        '';
-      };
-    };
-  };
-in
-
-{
-  options = {
-    loaOfSub = lib.mkOption {
-      default = {};
-      example = {};
-      type = lib.types.loaOf (lib.types.submodule [ submod ]);
-      description = ''
-        Some descriptive text
-      '';
-    };
-  };
-}

lib/tests/modules/default.nix

@@ -1,7 +0,0 @@
-{ lib ? import <nixpkgs/lib>, modules ? [] }:
-
-{
-  inherit (lib.evalModules {
-    inherit modules;
-  }) config options;
-}

lib/tests/modules/define-_module-args-custom.nix

@@ -1,7 +0,0 @@
-{ lib, ... }:
-
-{
-  config = {
-    _module.args.custom = true;
-  };
-}

lib/tests/modules/define-enable-force.nix

@@ -1,5 +0,0 @@
-{ lib, ... }:
-
-{
-  enable = lib.mkForce false;
-}

lib/tests/modules/define-enable-with-custom-arg.nix

@@ -1,7 +0,0 @@
-{ lib, custom, ... }:
-
-{
-  config = {
-    enable = custom;
-  };
-}

lib/tests/modules/define-enable.nix

@@ -1,3 +0,0 @@
-{
-  enable = true;
-}

lib/tests/modules/define-force-enable.nix

@@ -1,5 +0,0 @@
-{ lib, ... }:
-
-lib.mkForce {
-  enable = false;
-}

lib/tests/modules/define-force-loaOfSub-foo-enable.nix

@@ -1,5 +0,0 @@
-{ lib, ... }:
-
-lib.mkForce {
-  loaOfSub.foo.enable = false;
-}

lib/tests/modules/define-if-loaOfSub-foo-enable.nix

@@ -1,5 +0,0 @@
-{ config, lib, ... }:
-
-lib.mkIf config.enable {
-  loaOfSub.foo.enable = true;
-}

lib/tests/modules/define-loaOfSub-bar-enable.nix

@@ -1,3 +0,0 @@
-{
-  loaOfSub.bar.enable = true;
-}

lib/tests/modules/define-loaOfSub-bar.nix

@@ -1,3 +0,0 @@
-{
-  loaOfSub.bar = {};
-}

lib/tests/modules/define-loaOfSub-foo-enable-force.nix

@@ -1,5 +0,0 @@
-{ lib, ... }:
-
-{
-  loaOfSub.foo.enable = lib.mkForce false;
-}

lib/tests/modules/define-loaOfSub-foo-enable-if.nix

@@ -1,5 +0,0 @@
-{ config, lib, ... }:
-
-{
-  loaOfSub.foo.enable = lib.mkIf config.enable true;
-}

lib/tests/modules/define-loaOfSub-foo-enable.nix

@@ -1,3 +0,0 @@
-{
-  loaOfSub.foo.enable = true;
-}

lib/tests/modules/define-loaOfSub-foo-force-enable.nix

@@ -1,7 +0,0 @@
-{ lib, ... }:
-
-{
-  loaOfSub.foo = lib.mkForce {
-    enable = false;
-  };
-}

lib/tests/modules/define-loaOfSub-foo-if-enable.nix

@@ -1,7 +0,0 @@
-{ config, lib, ... }:
-
-{
-  loaOfSub.foo = lib.mkIf config.enable {
-    enable = true;
-  };
-}

lib/tests/modules/define-loaOfSub-foo.nix

@@ -1,3 +0,0 @@
-{
-  loaOfSub.foo = {};
-}

lib/tests/modules/define-loaOfSub-force-foo-enable.nix

@@ -1,7 +0,0 @@
-{ lib, ... }:
-
-{
-  loaOfSub = lib.mkForce {
-    foo.enable = false;
-  };
-}

lib/tests/modules/define-loaOfSub-if-foo-enable.nix

@@ -1,7 +0,0 @@
-{ config, lib, ... }:
-
-{
-  loaOfSub = lib.mkIf config.enable {
-    foo.enable = true;
-  };
-}

lib/tests/modules/define-module-check.nix

@@ -1,3 +0,0 @@
-{
-  _module.check = false;
-}

lib/tests/modules/import-custom-arg.nix

@@ -1,6 +0,0 @@
-{ lib, custom, ... }:
-
-{
-  imports = []
-  ++ lib.optional custom ./define-enable-force.nix;
-}

lib/tests/release.nix

@@ -1,31 +0,0 @@
-{ nixpkgs }:
-
-with import ./../.. { };
-with lib;
-
-stdenv.mkDerivation {
-  name = "nixpkgs-lib-tests";
-  buildInputs = [ nix ];
-  NIX_PATH="nixpkgs=${nixpkgs}";
-
-  buildCommand = ''
-    datadir="${nix}/share"
-    export TEST_ROOT=$(pwd)/test-tmp
-    export NIX_STORE_DIR=$TEST_ROOT/store
-    export NIX_LOCALSTATE_DIR=$TEST_ROOT/var
-    export NIX_LOG_DIR=$TEST_ROOT/var/log/nix
-    export NIX_STATE_DIR=$TEST_ROOT/var/nix
-    export NIX_DB_DIR=$TEST_ROOT/db
-    export NIX_CONF_DIR=$TEST_ROOT/etc
-    export NIX_MANIFESTS_DIR=$TEST_ROOT/var/nix/manifests
-    export NIX_BUILD_HOOK=
-    export PAGER=cat
-    cacheDir=$TEST_ROOT/binary-cache
-    nix-store --init
-
-    cd ${nixpkgs}/lib/tests
-    ./modules.sh
-
-    touch $out
-  '';
-}

lib/trivial.nix

@@ -1,3 +1,8 @@
+with {
+  inherit (import ./lists.nix) deepSeqList;
+  inherit (import ./attrsets.nix) deepSeqAttrs;
+};
+
 rec {
 
   # Identity function.
@@ -18,11 +23,23 @@ rec {
   # Flip the order of the arguments of a binary function.
   flip = f: a: b: f b a;
 
+  # `seq x y' evaluates x, then returns y.  That is, it forces strict
+  # evaluation of its first argument.
+  seq = x: y: if x == null then y else y;
+
+  # Like `seq', but recurses into lists and attribute sets to force evaluation
+  # of all list elements/attributes.
+  deepSeq = x: y:
+    if builtins.isList x
+      then deepSeqList x y
+    else if builtins.isAttrs x
+      then deepSeqAttrs x y
+      else seq x y;
+
   # Pull in some builtins not included elsewhere.
   inherit (builtins)
     pathExists readFile isBool isFunction
-    isInt add sub lessThan
-    seq deepSeq genericClosure;
+    isInt add sub lessThan;
 
   # Return the Nixpkgs version number.
   nixpkgsVersion =
@@ -30,11 +47,7 @@ rec {
     readFile ../.version
     + (if pathExists suffixFile then readFile suffixFile else "pre-git");
 
-  # Whether we're being called by nix-shell.
+  # Whether we're being called by nix-shell.  This is useful to  
   inNixShell = builtins.getEnv "IN_NIX_SHELL" == "1";
 
-  # Return minimum/maximum of two numbers.
-  min = x: y: if x < y then x else y;
-  max = x: y: if x > y then x else y;
-
 }

lib/types.nix

@@ -6,7 +6,6 @@ with import ./attrsets.nix;
 with import ./options.nix;
 with import ./trivial.nix;
 with import ./strings.nix;
-with {inherit (import ./modules.nix) mergeDefinitions; };
 
 rec {
 
@@ -54,7 +53,7 @@ rec {
     bool = mkOptionType {
       name = "boolean";
       check = isBool;
-      merge = mergeEqualOption;
+      merge = loc: fold (x: y: x.value || y) false;
     };
 
     int = mkOptionType {
@@ -88,7 +87,7 @@ rec {
     attrs = mkOptionType {
       name = "attribute set";
       check = isAttrs;
-      merge = loc: foldl' (res: def: mergeAttrs res def.value) {};
+      merge = loc: fold (def: mergeAttrs def.value) {};
     };
 
     # derivation is a reserved keyword.
@@ -103,7 +102,7 @@ rec {
     path = mkOptionType {
       name = "path";
       # Hacky: there is no ‘isPath’ primop.
-      check = x: builtins.substring 0 1 (toString x) == "/";
+      check = x: builtins.unsafeDiscardStringContext (builtins.substring 0 1 (toString x)) == "/";
       merge = mergeOneOption;
     };
 
@@ -112,15 +111,11 @@ rec {
 
     listOf = elemType: mkOptionType {
       name = "list of ${elemType.name}s";
-      check = isList;
+      check = value: isList value && all elemType.check value;
       merge = loc: defs:
-        map (x: x.value) (filter (x: x ? value) (concatLists (imap (n: def: imap (m: def':
-            (mergeDefinitions
-              (loc ++ ["[definition ${toString n}-entry ${toString m}]"])
-              elemType
-              [{ inherit (def) file; value = def'; }]
-            ).optionalValue
-          ) def.value) defs)));
+        concatLists (imap (n: def: imap (m: def':
+          elemType.merge (loc ++ ["[${toString n}-${toString m}]"])
+            [{ inherit (def) file; value = def'; }]) def.value) defs);
       getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["*"]);
       getSubModules = elemType.getSubModules;
       substSubModules = m: listOf (elemType.substSubModules m);
@@ -128,14 +123,12 @@ rec {
 
     attrsOf = elemType: mkOptionType {
       name = "attribute set of ${elemType.name}s";
-      check = isAttrs;
+      check = x: isAttrs x && all elemType.check (attrValues x);
       merge = loc: defs:
-        mapAttrs (n: v: v.value) (filterAttrs (n: v: v ? value) (zipAttrsWith (name: defs:
-            (mergeDefinitions (loc ++ [name]) elemType defs).optionalValue
-          )
+        zipAttrsWith (name: elemType.merge (loc ++ [name]))
           # Push down position info.
           (map (def: listToAttrs (mapAttrsToList (n: def':
-            { name = n; value = { inherit (def) file; value = def'; }; }) def.value)) defs)));
+            { name = n; value = { inherit (def) file; value = def'; }; }) def.value)) defs);
       getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name>"]);
       getSubModules = elemType.getSubModules;
       substSubModules = m: attrsOf (elemType.substSubModules m);
@@ -159,7 +152,10 @@ rec {
         attrOnly = attrsOf elemType;
       in mkOptionType {
         name = "list or attribute set of ${elemType.name}s";
-        check = x: isList x || isAttrs x;
+        check = x:
+          if isList x       then listOnly.check x
+          else if isAttrs x then attrOnly.check x
+          else false;
         merge = loc: defs: attrOnly.merge loc (imap convertIfList defs);
         getSubOptions = prefix: elemType.getSubOptions (prefix ++ ["<name?>"]);
         getSubModules = elemType.getSubModules;
@@ -200,11 +196,7 @@ rec {
           let
             coerce = def: if isFunction def then def else { config = def; };
             modules = opts' ++ map (def: { _file = def.file; imports = [(coerce def.value)]; }) defs;
-          in (evalModules {
-            inherit modules;
-            args.name = last loc;
-            prefix = loc;
-          }).config;
+          in (evalModules { inherit modules; args.name = last loc; prefix = loc; }).config;
         getSubOptions = prefix: (evalModules
           { modules = opts'; inherit prefix;
             # FIXME: hack to get shit to evaluate.

maintainers/scripts/gnome-latest.sh

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/bin/sh
 
 GNOME_FTP="ftp.gnome.org/pub/GNOME/sources"
 

maintainers/scripts/hydra_eval_check

@@ -6,7 +6,6 @@ hydra_eval_jobs \
   --argstr system i686-linux \
   --argstr system x86_64-darwin \
   --argstr system i686-cygwin \
-  --argstr system x86_64-cygwin \
   --argstr system i686-freebsd \
   --arg officialRelease false \
   --arg nixpkgs "{ outPath = builtins.storePath ./. ; rev = 1234; }" \

maintainers/scripts/patchelf-hints.sh

@@ -62,7 +62,7 @@ for bin in $(find $binaryDist -executable -type f) :; do
         )
 
         if test "$names" = "glibc"; then names="stdenv.glibc"; fi
-        if echo $names | grep -c "gcc" &> /dev/null; then names="stdenv.cc.cc"; fi
+        if echo $names | grep -c "gcc" &> /dev/null; then names="stdenv.gcc.gcc"; fi
 
         if test $lib != $libPath; then
             interpreter="--interpreter \${$names}/lib/$lib"

maintainers/scripts/travis-nox-review-pr.sh

@@ -28,21 +28,12 @@ elif [[ $1 == build ]]; then
     source $HOME/.nix-profile/etc/profile.d/nix.sh
 
     if [[ $TRAVIS_PULL_REQUEST == false ]]; then
-        echo "=== Not a pull request"
+        echo "===> Not a pull request, checking evaluation"
+        nix-build pkgs/top-level/release.nix -A tarball
     else
         echo "=== Checking PR"
-
-        if ! nox-review pr ${TRAVIS_PULL_REQUEST}; then
-            if sudo dmesg | egrep 'Out of memory|Killed process' > /tmp/oom-log; then
-                echo "=== The build failed due to running out of memory:"
-                cat /tmp/oom-log
-                echo "=== Please disregard the result of this Travis build."
-            fi
-            exit 1
-        fi
+        nox-review pr ${TRAVIS_PULL_REQUEST}
     fi
-    # echo "=== Checking tarball creation"
-    # nix-build pkgs/top-level/release.nix -A tarball
 else
     echo "$0: Unknown option $1" >&2
     false

maintainers/scripts/update-channel-branches.sh

@@ -1,112 +0,0 @@
-#!/bin/sh
-set -e
-
-: ${NIXOS_CHANNELS:=https://nixos.org/channels/}
-: ${CHANNELS_NAMESPACE:=refs/heads/channels/}
-
-# List all channels which are currently in the repository which we would
-# have to remove if they are not found again.
-deadChannels=$(git for-each-ref --format="%(refname)" "$CHANNELS_NAMESPACE")
-
-updateRef() {
-    local channelName=$1
-    local newRev=$2
-
-    # if the inputs are not valid, then we do not update any branch.
-    test -z "$newRev" -o -z "$channelName" && return;
-
-    # Update the local refs/heads/channels/* branches to be in-sync with the
-    # channel references.
-    local branch=$CHANNELS_NAMESPACE$channelName
-    oldRev=$(git rev-parse --short "$branch" 2>/dev/null || true)
-    if test "$oldRev" != "$newRev"; then
-        if git update-ref "$branch" "$newRev" 2>/dev/null; then
-            if test -z "$oldRev"; then
-                echo " * [new branch]      $newRev           -> ${branch#refs/heads/}"
-            else
-                echo "                     $oldRev..$newRev  -> ${branch#refs/heads/}"
-            fi
-        else
-            if test -z "$oldRev"; then
-                echo " * [missing rev]     $newRev           -> ${branch#refs/heads/}"
-            else
-                echo "   [missing rev]     $oldRev..$newRev  -> ${branch#refs/heads/}"
-            fi
-        fi
-    fi
-
-    # Filter out the current channel from the list of dead channels.
-    deadChannels=$(grep -v "$CHANNELS_NAMESPACE$channelName" <<EOF
-$deadChannels
-EOF
-) ||true
-}
-
-# Find the name of all channels which are listed in the directory.
-echo "Fetching channels from $NIXOS_CHANNELS:"
-for channelName in : $(curl -s "$NIXOS_CHANNELS" | sed -n '/folder/ { s,.*href=",,; s,/".*,,; p }'); do
-    test "$channelName" = : && continue;
-
-    # Do not follow redirections, such that we can extract the
-    # short-changeset from the name of the directory where we are
-    # redirected to.
-    sha1=$(curl -sI "$NIXOS_CHANNELS$channelName" | sed -n '/Location/ { s,.*\.\([a-f0-9]*\)[ \r]*$,\1,; p; }')
-
-    updateRef "remotes/$channelName" "$sha1"
-done
-
-echo "Fetching channels from nixos-version:"
-if currentSystem=$(nixos-version 2>/dev/null); then
-    # If the system is entirely build from a custom nixpkgs version,
-    # then the version is not annotated in git version. This sed
-    # expression is basically matching that the expressions end with
-    # ".<sha1> (Name)" to extract the sha1.
-    sha1=$(echo "$currentSystem" | sed -n 's,^.*\.\([a-f0-9]*\) *(.*)$,\1,; T skip; p; :skip;')
-
-    updateRef current-system "$sha1"
-fi
-
-echo "Fetching channels from $HOME/.nix-defexpr:"
-for revFile in : $(find -L "$HOME/.nix-defexpr/" -maxdepth 4 -name svn-revision); do
-    test "$revFile" = : && continue;
-
-    # Deconstruct a path such as, into:
-    #
-    #   /home/luke/.nix-defexpr/channels_root/nixos/nixpkgs/svn-revision
-    #     channelName = root/nixos
-    #
-    #   /home/luke/.nix-defexpr/channels/nixpkgs/svn-revision
-    #     channelName = nixpkgs
-    #
-    user=${revFile#*.nix-defexpr/channels}
-    repo=${user#*/}
-    repo=${repo%%/*}
-    user=${user%%/*}
-    user=${user#_}
-    test -z "$user" && user=$USER
-    channelName="$user${user:+/}$repo"
-
-    sha1=$(sed -n 's,^.*\.\([a-f0-9]*\)$,\1,; T skip; p; :skip;' "$revFile")
-
-    updateRef "$channelName" "$sha1"
-done
-
-# Suggest to remove channel branches which are no longer found by this
-# script. This is to handle the cases where a local/remote channel
-# disappear. We should not attempt to remove manually any branches, as they
-# might be user branches.
-if test -n "$deadChannels"; then
-
-    echo "
-Some old channel branches are still in your repository, if you
-want to remove them, run the following command(s):
-"
-
-    while read branch; do
-        echo "    git update-ref -d $branch"
-    done <<EOF
-$deadChannels
-EOF
-
-    echo
-fi

maintainers/scripts/vanity-manual-equalities.txt

@@ -4,4 +4,3 @@ Pjotr Prins	pjotr.public05@thebird.nl
 Wouter den Breejen	wbreejen
 MarcWeber	marcweber
 Ricardo Correia	Ricardo M. Correia
-ertesx@gmx.de	ertes

maintainers/scripts/vanity.sh

@@ -47,11 +47,11 @@ fetchGithubName () {
 
 # For RDF
 normalize_name () {
-	sed -e 's/%/%25/g; s/ /%20/g; s/'\''/%27/g; s/"/%22/g; s/`/%60/g; s/\^/%5e/g; '
+	sed -e 's/%/%25/g; s/ /%20/g; s/'\''/%27/g; s/"/%22/g; s/`/%60/g'
 }
 
 denormalize_name () {
-	sed -e 's/%20/ /g; s/%27/'\''/g; s/%22/"/g; s/%60/`/g; s/%5e/^/g; s/%25/%/g;';
+	sed -e 's/%20/ /g; s/%27/'\''/g; s/%22/"/g; s/%60/`/g; s/%25/%/g;';
 }
 
 n3="$(mktemp --suffix .n3)"

nixos/doc/manual/administration/declarative-containers.xml

@@ -49,8 +49,4 @@ on container networking.)</para>
 switch</literal>. Note that this will not delete the root directory of
 the container in <literal>/var/lib/containers</literal>.</para>
 
-<para>Declarative containers can be started and stopped using the
-corresponding systemd service, e.g. <literal>systemctl start
-container@database</literal>.</para>
-
-</section>
+</section>

nixos/doc/manual/configuration/ad-hoc-packages.xml

@@ -11,7 +11,7 @@ uninstall packages from the command line.  For instance, to install
 Mozilla Thunderbird:
 
 <screen>
-$ nix-env -iA nixos.thunderbird</screen>
+$ nix-env -iA nixos.pkgs.thunderbird</screen>
 
 If you invoke this as root, the package is installed in the Nix
 profile <filename>/nix/var/nix/profiles/default</filename> and visible

nixos/doc/manual/configuration/config-file.xml

@@ -68,7 +68,7 @@ instance, if you try to define an option that doesn’t exist (that is,
 doesn’t have a corresponding <emphasis>option declaration</emphasis>),
 <command>nixos-rebuild</command> will give an error like:
 <screen>
-The option `services.httpd.enable' defined in `/etc/nixos/configuration.nix' does not exist.
+The option `services.httpd.enabl' defined in `/etc/nixos/configuration.nix' does not exist.
 </screen>
 Likewise, values in option definitions must have a correct type.  For
 instance, <option>services.httpd.enable</option> must be a Boolean

nixos/doc/manual/configuration/declarative-packages.xml

@@ -23,13 +23,13 @@ Nixpkgs will be built or downloaded as part of the system when you run
 <para>You can get a list of the available packages as follows:
 <screen>
 $ nix-env -qaP '*' --description
-nixos.firefox   firefox-23.0   Mozilla Firefox - the browser, reloaded
+nixos.pkgs.firefox   firefox-23.0   Mozilla Firefox - the browser, reloaded
 <replaceable>...</replaceable>
 </screen>
 
 The first column in the output is the <emphasis>attribute
 name</emphasis>, such as
-<literal>nixos.thunderbird</literal>. (The
+<literal>nixos.pkgs.thunderbird</literal>. (The
 <literal>nixos</literal> prefix allows distinguishing between
 different channels that you might have.)</para>
 

nixos/doc/manual/configuration/summary.xml

@@ -60,7 +60,7 @@ manual</link> for the rest.</para>
         <entry>A nested set, equivalent to <literal>{ foo = { bar = 1; }; }</literal></entry>
       </row>
       <row>
-        <entry><literal>rec { x = "foo"; y = x + "bar"; }</literal></entry>
+        <entry><literal>rec { x = "bla"; y = x + "bar"; }</literal></entry>
         <entry>A recursive set, equivalent to <literal>{ x = "foo"; y = "foobar"; }</literal></entry>
       </row>
       <row>

nixos/doc/manual/configuration/x-windows.xml

@@ -61,12 +61,6 @@ by default because it’s not free software.  You can enable it as follows:
 <programlisting>
 services.xserver.videoDrivers = [ "nvidia" ];
 </programlisting>
-Or if you have an older card, you may have to use one of the legacy drivers:
-<programlisting>
-services.xserver.videoDrivers = [ "nvidiaLegacy340" ];
-services.xserver.videoDrivers = [ "nvidiaLegacy304" ];
-services.xserver.videoDrivers = [ "nvidiaLegacy173" ];
-</programlisting>
 You may need to reboot after enabling this driver to prevent a clash
 with other kernel modules.</para>
 

nixos/doc/manual/default.nix

@@ -61,16 +61,6 @@ let
       echo "${version}" > version
     '';
 
-  toc = builtins.toFile "toc.xml"
-    ''
-      <toc role="chunk-toc">
-        <d:tocentry xmlns:d="http://docbook.org/ns/docbook" linkend="book-nixos-manual"><?dbhtml filename="index.html"?>
-          <d:tocentry linkend="ch-options"><?dbhtml filename="options.html"?></d:tocentry>
-          <d:tocentry linkend="ch-release-notes"><?dbhtml filename="release-notes.html"?></d:tocentry>
-        </d:tocentry>
-      </toc>
-    '';
-
 in rec {
 
   # The NixOS options in JSON format.
@@ -123,10 +113,9 @@ in rec {
         --param chunk.section.depth 0 \
         --param chunk.first.sections 1 \
         --param use.id.as.filename 1 \
-        --stringparam generate.toc "book toc appendix toc" \
-        --stringparam chunk.toc ${toc} \
+        --stringparam generate.toc "book toc chapter toc appendix toc" \
         --nonet --xinclude --output $dst/ \
-        ${docbook5_xsl}/xml/xsl/docbook/xhtml/chunktoc.xsl ./manual.xml
+        ${docbook5_xsl}/xml/xsl/docbook/xhtml/chunkfast.xsl ./manual.xml
 
       mkdir -p $dst/images/callouts
       cp ${docbook5_xsl}/xml/xsl/docbook/images/callouts/*.gif $dst/images/callouts/

nixos/doc/manual/development/development.xml

@@ -15,7 +15,6 @@ NixOS.</para>
 <xi:include href="writing-modules.xml" />
 <xi:include href="building-parts.xml" />
 <xi:include href="building-nixos.xml" />
-<xi:include href="nixos-tests.xml" />
 <xi:include href="testing-installer.xml" />
 
 </part>

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

@@ -15,6 +15,5 @@ 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" />
 
-</chapter>
+</chapter>

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

@@ -1,43 +0,0 @@
-<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 interactively</title>
-
-<para>The test itself can be run interactively.  This is
-particularly useful when developing or debugging a test:
-
-<screen>
-$ nix-build nixos/tests/login.nix -A driver
-$ ./result/bin/nixos-test-driver
-starting VDE switch for network 1
-&gt;
-</screen>
-
-You can then take any Perl statement, e.g.
-
-<screen>
-&gt; startAll
-&gt; testScript
-&gt; $machine->succeed("touch /tmp/foo")
-</screen>
-
-The function <command>testScript</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>
-$ nix-build nixos/tests/login.nix -A driver
-$ ./result/bin/nixos-run-vms
-</screen>
-
-The script <command>nixos-run-vms</command> starts the virtual
-machines defined by test.  The root file system of the VMs is created
-on the fly and kept across VM restarts in
-<filename>./</filename><varname>hostname</varname><filename>.qcow2</filename>.</para>
-
-</section>

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

@@ -2,7 +2,7 @@
         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">
+        xml:id="sec-running-nixos-tests">
 
 <title>Running Tests</title>
 
@@ -38,4 +38,42 @@ $ firefox result/log.html
 </screen>
 
 </para>
+
+<title>Running Tests interactively</title>
+
+<para>The test itself can be run interactively.  This is
+particularly useful when developing or debugging a test:
+
+<screen>
+$ nix-build nixos/tests/login.nix -A driver
+$ ./result/bin/nixos-test-driver
+starting VDE switch for network 1
+&gt;
+</screen>
+
+You can then take any Perl statement, e.g.
+
+<screen>
+&gt; startAll
+&gt; testScript
+&gt; $machine->succeed("touch /tmp/foo")
+</screen>
+
+The function <command>testScript</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>
+$ nix-build nixos/tests/login.nix -A driver
+$ ./result/bin/nixos-run-vms
+</screen>
+
+The script <command>nixos-run-vms</command> starts the virtual
+machines defined by test.  The root file system of the VMs is created
+on the fly and kept across VM restarts in
+<filename>./</filename><varname>hostname</varname><filename>.qcow2</filename>.</para>
+
 </section>

nixos/doc/manual/development/sources.xml

@@ -24,9 +24,6 @@ $ mkdir -p <replaceable>/my/sources</replaceable>
 $ cd <replaceable>/my/sources</replaceable>
 $ nix-env -i git
 $ git clone git://github.com/NixOS/nixpkgs.git
-$ cd nixpkgs
-$ git remote add channels git://github.com/NixOS/nixpkgs-channels.git
-$ git remote update channels
 </screen>
 
 This will check out the latest NixOS sources to
@@ -34,12 +31,7 @@ This will check out the latest NixOS sources to
 and the Nixpkgs sources to
 <filename><replaceable>/my/sources</replaceable>/nixpkgs</filename>.
 (The NixOS source tree lives in a subdirectory of the Nixpkgs
-repository.) The remote <literal>channels</literal> refers to a
-read-only repository that tracks the Nixpkgs/NixOS channels (see <xref
-linkend="sec-upgrading"/> for more information about channels). Thus,
-the Git branch <literal>channels/nixos-14.12</literal> will contain
-the latest built and tested version available in the
-<literal>nixos-14.12</literal> channel.</para>
+repository.)</para>
 
 <para>It’s often inconvenient to develop directly on the master
 branch, since if somebody has just committed (say) a change to GCC,
@@ -54,26 +46,20 @@ $ nixos-version
 $ git checkout -b local ea1952b
 </screen>
 
-Or, to base your local branch on the latest version available in a
+Or, to base your local branch on the latest version available in the
 NixOS channel:
 
 <screen>
-$ git remote update channels
-$ git checkout -b local channels/nixos-14.12
+$ curl -sI https://nixos.org/channels/nixos-unstable/ | grep Location
+Location: https://releases.nixos.org/nixos/unstable/nixos-14.10pre43986.acaf4a6/
+
+$ git checkout -b local acaf4a6
 </screen>
 
-(Replace <literal>nixos-14.12</literal> with the name of the channel
-you want to use.) You can use <command>git merge</command> or
-<command>git rebase</command> to keep your local branch in sync with
-the channel, e.g.
-
-<screen>
-$ git remote update channels
-$ git merge channels/nixos-14.12
-</screen>
-
-You can use <command>git cherry-pick</command> to copy commits from
-your local branch to the upstream branch.</para>
+You can then use <command>git rebase</command> to sync your local
+branch with the upstream branch, and use <command>git
+cherry-pick</command> to copy commits from your local branch to the
+upstream branch.</para>
 
 <para>If you want to rebuild your system using your (modified)
 sources, you need to tell <command>nixos-rebuild</command> about them

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

@@ -158,7 +158,7 @@ let locatedb = "/var/cache/locatedb"; in
         script =
           ''
             mkdir -m 0755 -p $(dirname ${locatedb})
-            exec updatedb --localuser=nobody --output=${locatedb} --prunepaths='/tmp /var/tmp /run'
+            exec updatedb --localuser=nobody --output=${locatedb} --prunepaths='/tmp /var/tmp /media /run'
           '';
       };
 
@@ -172,4 +172,4 @@ let locatedb = "/var/cache/locatedb"; in
 <xi:include href="option-declarations.xml" />
 <xi:include href="option-def.xml" />
 
-</chapter>
+</chapter>

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

@@ -154,15 +154,6 @@ startAll;
     log.</para></listitem>
   </varlistentry>
 
-  <varlistentry>
-    <term><methodname>getScreenText</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>sendMonitorCommand</methodname></term>
     <listitem><para>Send a command to the QEMU monitor. This is rarely
@@ -246,15 +237,6 @@ startAll;
     connections.</para></listitem>
   </varlistentry>
 
-  <varlistentry>
-    <term><methodname>waitForText</methodname></term>
-    <listitem><para>Wait until the supplied regular expressions matches
-    the textual contents of the screen by using optical character recognition
-    (see <methodname>getScreenText</methodname>).</para>
-    <note><para>This requires passing <option>enableOCR</option> to the test
-    attribute set.</para></note></listitem>
-  </varlistentry>
-
   <varlistentry>
     <term><methodname>waitForWindow</methodname></term>
     <listitem><para>Wait until an X11 window has appeared whose name

nixos/doc/manual/installation/installing-uefi.xml

@@ -41,6 +41,10 @@ changes:
     <option>boot.loader.efi</option> and <option>boot.loader.gummiboot</option>
     as well.</para>
   </listitem>
+  <listitem>
+    <para>To see console messages during early boot, add <literal>"fbcon"</literal>
+    to your <option>boot.initrd.kernelModules</option>.</para>
+  </listitem>
 </itemizedlist>
 </para>
 

nixos/doc/manual/installation/installing-usb.xml

@@ -6,8 +6,8 @@
 
 <title>Booting from a USB Drive</title>
 
-<para>For systems without CD drive, the NixOS live CD can be booted from
-a USB stick. For non-UEFI installations,
+<para>For systems without CD drive, the NixOS livecd can be booted from
+a usb stick. For non-UEFI installations,
 <link xlink:href="http://unetbootin.sourceforge.net/">unetbootin</link>
 will work. For UEFI installations, you should mount the ISO, copy its contents
 verbatim to your drive, then either:

nixos/doc/manual/installation/installing.xml

@@ -120,11 +120,7 @@ $ nixos-generate-config --root /mnt</screen>
 $ nano /mnt/etc/nixos/configuration.nix
 </screen>
 
-    If you’re using the graphical ISO image, other editors may be
-    available (such as <command>vim</command>). If you have network
-    access, you can also install other editors — for instance, you can
-    install Emacs by running <literal>nix-env -i
-    emacs</literal>.</para>
+    The <command>vim</command> text editor is also available.</para>
 
     <para>You <emphasis>must</emphasis> set the option
     <option>boot.loader.grub.device</option> to specify on which disk
@@ -193,13 +189,11 @@ $ reboot</screen>
 
   <listitem>
 
-    <para>You should now be able to boot into the installed NixOS. The
-    GRUB boot menu shows a list of <emphasis>available
-    configurations</emphasis> (initially just one). Every time you
-    change the NixOS configuration (see <link
-    linkend="sec-changing-config">Changing Configuration</link> ), a
-    new item is added to the menu. This allows you to easily roll back
-    to a previous configuration if something goes wrong.</para>
+    <para>You should now be able to boot into the installed NixOS. The GRUB boot menu shows a list
+                of <emphasis>available configurations</emphasis> (initially just one). Every time
+                you change the NixOS configuration (see<link linkend="sec-changing-config">Changing
+                    Configuration</link> ), a new item appears in the menu. This allows you to
+                easily roll back to another configuration if something goes wrong.</para>
 
     <para>You should log in and change the <literal>root</literal>
     password with <command>passwd</command>.</para>

nixos/doc/manual/installation/obtaining.xml

@@ -8,7 +8,7 @@
 
 <para>NixOS ISO images can be downloaded from the <link
 xlink:href="http://nixos.org/nixos/download.html">NixOS
-download page</link>.  There are a number of installation options.  If
+homepage</link>.  There are a number of installation options.  If
 you happen to have an optical drive and a spare CD, burning the
 image to CD and booting from that is probably the easiest option.
 Most people will need to prepare a USB stick to boot from.
@@ -27,7 +27,7 @@ running NixOS system through several other means:
     <para>Using virtual appliances in Open Virtualization Format (OVF)
     that can be imported into VirtualBox.  These are available from
     the <link xlink:href="http://nixos.org/nixos/download.html">NixOS
-    download page</link>.</para>
+    homepage</link>.</para>
   </listitem>
   <listitem>
     <para>Using AMIs for Amazon’s EC2.  To find one for your region

nixos/doc/manual/installation/upgrading.xml

@@ -107,30 +107,4 @@ newer Nix version, which may involve an upgrade of Nix’s database
 schema.  This cannot be undone easily, so in that case you will not be
 able to go back to your original channel.</para></warning>
 
-
-<section><title>Automatic Upgrades</title>
-
-<para>You can keep a NixOS system up-to-date automatically by adding
-the following to <filename>configuration.nix</filename>:
-
-<programlisting>
-system.autoUpgrade.enable = true;
-</programlisting>
-
-This enables a periodically executed systemd service named
-<literal>nixos-upgrade.service</literal>. It runs
-<command>nixos-rebuild switch --upgrade</command> to upgrade NixOS to
-the latest version in the current channel. (To see when the service
-runs, see <command>systemctl list-timers</command>.)  You can also
-specify a channel explicitly, e.g.
-
-<programlisting>
-system.autoUpgrade.channel = https://nixos.org/channels/nixos-15.09;
-</programlisting>
-
-</para>
-
-</section>
-
-
 </chapter>

nixos/doc/manual/man-nixos-install.xml

@@ -25,22 +25,6 @@
       <arg choice='plain'><option>--root</option></arg>
       <replaceable>root</replaceable>
     </arg>
-    <arg>
-      <group choice='req'>
-        <arg choice='plain'><option>--max-jobs</option></arg>
-        <arg choice='plain'><option>-j</option></arg>
-      </group>
-      <replaceable>number</replaceable>
-    </arg>
-    <arg>
-      <option>--cores</option>
-      <replaceable>number</replaceable>
-    </arg>
-    <arg>
-      <option>--option</option>
-      <replaceable>name</replaceable>
-      <replaceable>value</replaceable>
-    </arg>
     <arg>
       <arg choice='plain'><option>--show-trace</option></arg>
     </arg>
@@ -112,37 +96,6 @@ it.</para>
     </listitem>
   </varlistentry>
 
-  <varlistentry><term><option>--max-jobs</option></term>
-    <term><option>-j</option></term>
-  
-    <listitem><para>Sets the maximum number of build jobs that Nix will
-    perform in parallel to the specified number. The default is <literal>1</literal>.
-    A higher value is useful on SMP systems or to exploit I/O latency.</para></listitem>
-  
-  </varlistentry>
-  
-  
-  <varlistentry><term><option>--cores</option></term>
-  
-    <listitem><para>Sets the value of the <envar>NIX_BUILD_CORES</envar>
-    environment variable in the invocation of builders.  Builders can
-    use this variable at their discretion to control the maximum amount
-    of parallelism.  For instance, in Nixpkgs, if the derivation
-    attribute <varname>enableParallelBuilding</varname> is set to
-    <literal>true</literal>, the builder passes the
-    <option>-j<replaceable>N</replaceable></option> flag to GNU Make.
-    The value <literal>0</literal> means that the builder should use all
-    available CPU cores in the system.</para></listitem>
-  
-  </varlistentry>
-
-  <varlistentry><term><option>--option</option> <replaceable>name</replaceable> <replaceable>value</replaceable></term>
-
-    <listitem><para>Set the Nix configuration option
-    <replaceable>name</replaceable> to <replaceable>value</replaceable>.</para></listitem>
-
-  </varlistentry>
-
   <varlistentry>
     <term><option>--show-trace</option></term>
     <listitem>

nixos/doc/manual/manual.xml

@@ -2,7 +2,7 @@
       xmlns:xlink="http://www.w3.org/1999/xlink"
       xmlns:xi="http://www.w3.org/2001/XInclude"
       version="5.0"
-      xml:id="book-nixos-manual">
+      xml:id="NixOSManual">
   
   <info>
     <title>NixOS Manual</title>
@@ -33,12 +33,11 @@
   <xi:include href="administration/running.xml" />
   <!-- <xi:include href="userconfiguration.xml" /> -->
   <xi:include href="development/development.xml" />
+  <xi:include href="release-notes/release-notes.xml" />
 
   <appendix xml:id="ch-options">
     <title>Configuration Options</title>
     <xi:include href="options-db.xml" />
   </appendix>
 
-  <xi:include href="release-notes/release-notes.xml" />
-
 </book>

nixos/doc/manual/options-to-docbook.xsl

@@ -25,65 +25,61 @@
               <option>
                 <xsl:value-of select="attr[@name = 'name']/string/@value" />
               </option>
-            </term>
+             </term>
 
-            <listitem>
+             <listitem>
 
-              <para>
-                <xsl:value-of disable-output-escaping="yes"
-                              select="attr[@name = 'description']/string/@value" />
-              </para>
+               <para>
+                 <xsl:value-of disable-output-escaping="yes"
+                               select="attr[@name = 'description']/string/@value" />
+               </para>
 
-              <xsl:if test="attr[@name = 'type']">
-                <para>
-                  <emphasis>Type:</emphasis>
-                  <xsl:text> </xsl:text>
-                  <xsl:value-of select="attr[@name = 'type']/string/@value"/>
-                  <xsl:if test="attr[@name = 'readOnly']/bool/@value = 'true'">
-                    <xsl:text> </xsl:text>
-                    <emphasis>(read only)</emphasis>
-                  </xsl:if>
-                </para>
-              </xsl:if>
+               <xsl:if test="attr[@name = 'type']">
+                 <para>
+                   <emphasis>Type:</emphasis>
+                   <xsl:text> </xsl:text>
+                   <xsl:apply-templates select="attr[@name = 'type']" mode="top" />
+                 </para>
+               </xsl:if>
 
-              <xsl:if test="attr[@name = 'default']">
-                <para>
-                  <emphasis>Default:</emphasis>
-                  <xsl:text> </xsl:text>
-                  <xsl:apply-templates select="attr[@name = 'default']" mode="top" />
-                </para>
-              </xsl:if>
+               <xsl:if test="attr[@name = 'default']">
+                 <para>
+                   <emphasis>Default:</emphasis>
+                   <xsl:text> </xsl:text>
+                   <xsl:apply-templates select="attr[@name = 'default']" mode="top" />
+                 </para>
+               </xsl:if>
 
-              <xsl:if test="attr[@name = 'example']">
-                <para>
-                  <emphasis>Example:</emphasis>
-                  <xsl:text> </xsl:text>
-                  <xsl:choose>
-                    <xsl:when test="attr[@name = 'example']/attrs[attr[@name = '_type' and string[@value = 'literalExample']]]">
-                      <programlisting><xsl:value-of select="attr[@name = 'example']/attrs/attr[@name = 'text']/string/@value" /></programlisting>
-                    </xsl:when>
-                    <xsl:otherwise>
-                      <xsl:apply-templates select="attr[@name = 'example']" mode="top" />
-                    </xsl:otherwise>
-                  </xsl:choose>
-                </para>
-              </xsl:if>
+               <xsl:if test="attr[@name = 'example']">
+                 <para>
+                   <emphasis>Example:</emphasis>
+                   <xsl:text> </xsl:text>
+                   <xsl:choose>
+                     <xsl:when test="attr[@name = 'example']/attrs[attr[@name = '_type' and string[@value = 'literalExample']]]">
+                       <programlisting><xsl:value-of select="attr[@name = 'example']/attrs/attr[@name = 'text']/string/@value" /></programlisting>
+                     </xsl:when>
+                     <xsl:otherwise>
+                       <xsl:apply-templates select="attr[@name = 'example']" mode="top" />
+                     </xsl:otherwise>
+                   </xsl:choose>
+                 </para>
+               </xsl:if>
 
-              <xsl:if test="count(attr[@name = 'declarations']/list/*) != 0">
-                <para>
-                  <emphasis>Declared by:</emphasis>
-                </para>
-                <xsl:apply-templates select="attr[@name = 'declarations']" />
-              </xsl:if>
+               <xsl:if test="count(attr[@name = 'declarations']/list/*) != 0">
+                 <para>
+                   <emphasis>Declared by:</emphasis>
+                 </para>
+                 <xsl:apply-templates select="attr[@name = 'declarations']" />
+               </xsl:if>
 
-              <xsl:if test="count(attr[@name = 'definitions']/list/*) != 0">
-                <para>
-                  <emphasis>Defined by:</emphasis>
-                </para>
-                <xsl:apply-templates select="attr[@name = 'definitions']" />
-              </xsl:if>
+               <xsl:if test="count(attr[@name = 'definitions']/list/*) != 0">
+                 <para>
+                   <emphasis>Defined by:</emphasis>
+                 </para>
+                 <xsl:apply-templates select="attr[@name = 'definitions']" />
+               </xsl:if>
 
-            </listitem>
+             </listitem>
 
           </varlistentry>
 

nixos/doc/manual/release-notes/release-notes.xml

@@ -1,18 +1,17 @@
-<appendix 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="ch-release-notes">
+<part   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="ch-release-notes">
 
 <title>Release Notes</title>
 
-<para>This section lists the release notes for each stable version of NixOS
-and current unstable revision.</para>
+<partintro>
+<para>This section lists the release notes for each stable version of NixOS.</para>
+</partintro>
 
-<xi:include href="rl-unstable.xml" />
-<xi:include href="rl-1509.xml" />
 <xi:include href="rl-1412.xml" />
 <xi:include href="rl-1404.xml" />
 <xi:include href="rl-1310.xml" />
 
-</appendix>
+</part>

nixos/doc/manual/release-notes/rl-1310.xml

@@ -1,11 +1,11 @@
-<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-release-13.10">
+<chapter 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-release-13.10">
 
 <title>Release 13.10 (“Aardvark”, 2013/10/31)</title>
 
 <para>This is the first stable release branch of NixOS.</para>
 
-</section>
+</chapter>

nixos/doc/manual/release-notes/rl-1404.xml

@@ -1,8 +1,8 @@
-<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-release-14.04">
+<chapter 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-release-14.04">
 
 <title>Release 14.04 (“Baboon”, 2014/04/30)</title>
 
@@ -157,4 +157,4 @@ networking.firewall.enable = false;
 
 </para>
 
-</section>
+</chapter>

nixos/doc/manual/release-notes/rl-1412.xml

@@ -1,8 +1,8 @@
-<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-release-14.12">
+<chapter 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-release-14.12">
 
 <title>Release 14.12 (“Caterpillar”, 2014/12/30)</title>
 
@@ -174,4 +174,4 @@ now.</para></listitem>
 
 </para>
 
-</section>
+</chapter>

nixos/doc/manual/release-notes/rl-1509.xml

@@ -1,231 +0,0 @@
-<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-release-15.09">
-
-<title>Release 15.09 (“Dingo”, 2015/09/??)</title>
-
-<para>In addition to numerous new and upgraded packages, this release has the following highlights:
-
-  <itemizedlist>
-    <listitem>
-      <para>
-        The Haskell packages infrastructure has been re-designed from the ground up.
-        NixOS now distributes the latest version of every single package registered on
-        <link xlink:href="http://hackage.haskell.org/">Hackage</link>, i.e. well over
-        8000 Haskell packages. Further information and usage instructions for the
-        improved infrastructure are available at <link
-        xlink:href="https://nixos.org/wiki/Haskell">https://nixos.org/wiki/Haskell</link>.
-        Users migrating from an earlier release will find also find helpful information
-        below, in the list of backwards-incompatible changes.
-      </para>
-    </listitem>
-
-    <listitem>
-      <para>
-        Users running an SSH server who worry about the quality of their
-        <literal>/etc/ssh/moduli</literal> file with respect to the <link
-        xlink:href="https://stribika.github.io/2015/01/04/secure-secure-shell.html">vulnerabilities
-        discovered in the Diffie-Hellman key exchange</link> can now replace OpenSSH's
-        default version with one they generated themselves using the new
-        <literal>services.openssh.moduliFile</literal> option.
-      </para>
-    </listitem>
-  </itemizedlist>
-
-</para>
-
-
-<para>When upgrading from a previous release, please be aware of the
-following incompatible changes:
-
-<itemizedlist>
-
-<listitem><para><command>sshd</command> no longer supports DSA and ECDSA
-host keys by default. If you have existing systems with such host keys
-and want to continue to use them, please set
-
-<programlisting>
-system.stateVersion = "14.12";
-</programlisting>
-
-(The new option <option>system.stateVersion</option> ensures that
-certain configuration changes that could break existing systems (such
-as the <command>sshd</command> host key setting) will maintain
-compatibility with the specified NixOS release.)</para></listitem>
-
-<listitem><para><command>cron</command> is no longer enabled by
-default, unless you have a non-empty
-<option>services.cron.systemCronJobs</option>. To force
-<command>cron</command> to be enabled, set
-<option>services.cron.enable = true</option>.</para></listitem>
-
-<listitem><para>Nix now requires binary caches to be cryptographically
-signed. If you have unsigned binary caches that you want to continue
-to use, you should set <option>nix.requireSignedBinaryCaches =
-false</option>.</para></listitem>
-
-<listitem><para>Steam now doesn't need root rights to work. Instead of using
-<literal>*-steam-chrootenv</literal>, you should now just run <literal>steam</literal>.
-<literal>steamChrootEnv</literal> package was renamed to <literal>steam</literal>,
-and old <literal>steam</literal> package -- to <literal>steamOriginal</literal>.
-</para></listitem>
-
-<listitem><para>CMPlayer has been renamed to bomi upstream. Package <literal>cmplayer</literal>
-was accordingly renamed to <literal>bomi</literal>
-</para></listitem>
-
-<listitem><para>Atom Shell has been renamed to Electron upstream.  Package <literal>atom-shell</literal>
-was accordingly renamed to <literal>electron</literal>
-</para></listitem>
-
-<listitem><para>Elm is not released on Hackage anymore. You should now use <literal>elmPackages.elm</literal>
-which contains the latest Elm platform.</para></listitem>
-
-<listitem>
-  <para>
-	The CUPS printing service has been updated to version <literal>2.0.2</literal>.
-	Furthermore its systemd service has been renamed to <literal>cups.service</literal>.
-  </para>
-  <para>
-	Local printers are no longer shared or advertised by default. This behavior
-	can be changed by enabling <literal>services.printing.defaultShared</literal>
-	or <literal>services.printing.browsing</literal> respectively.
-  </para>
-</listitem>
-
-<listitem>
-  <para>
-    The VirtualBox host and guest options have been moved/renamed more
-    consistently and less confusing to be now found in
-    <literal>virtualisation.virtualbox.host.*</literal> instead of
-    <literal>services.virtualboxHost.*</literal> and
-    <literal>virtualisation.virtualbox.guest.*</literal> instead of
-    <literal>services.virtualboxGuest.*</literal>.
-  </para>
-</listitem>
-
-<listitem>
-  <para>
-    Haskell packages can no longer be found by name, i.e. the commands
-    <literal>nix-env -qa cabal-install</literal> and <literal>nix-env -i
-    ghc</literal> will fail, even though we <emphasis>do</emphasis> ship
-    both <literal>cabal-install</literal> and <literal>ghc</literal>.
-    The reason for this inconvenience is the sheer size of the Haskell
-    package set: name-based lookups such as these would become much
-    slower than they are today if we'd add the entire Hackage database
-    into the top level attribute set. Instead, the list of Haskell
-    packages can be displayed by
-  </para>
-  <programlisting>
-nix-env -f &quot;&lt;nixpkgs&gt;&quot; -qaP -A haskellPackages
-</programlisting>
-  <para>
-    and packages can be installed with:
-  </para>
-  <programlisting>
-nix-env -f &quot;&lt;nixpkgs&gt;&quot; -iA haskellPackages.cabal-install
-</programlisting>
-</listitem>
-
-<listitem>
-  <para>
-    Previous versions of NixOS came with a feature called
-    <literal>ghc-wrapper</literal>, a small wrapper script that allows
-    GHC to transparently pick up on libraries installed in the user's
-    profile. This feature has been deprecated;
-    <literal>ghc-wrapper</literal> was removed from the distribution.
-    The proper way to register Haskell libraries with the compiler now
-    is the <literal>haskellPackages.ghcWithPackages</literal>
-    function.
-    <link xlink:href="https://nixos.org/wiki/Haskell">https://nixos.org/wiki/Haskell</link>
-    provides much information about this subject.
-  </para>
-</listitem>
-
-<listitem>
-  <para>
-    All Haskell builds that have been generated with version 1.x of
-    the <literal>cabal2nix</literal> utility are now invalid and need
-    to be re-generated with a current version of
-    <literal>cabal2nix</literal> to function. The most recent version
-    of this tool can be installed by running
-    <literal>nix-env -i cabal2nix</literal>.
-  </para>
-</listitem>
-
-<listitem>
-  <para>
-    The <literal>haskellPackages</literal> set in Nixpkgs used to have a
-    function attribute called <literal>extension</literal> that users
-    could override in their <literal>~/.nixpkgs/config.nix</literal>
-    files to configure additional attributes, etc. That function still
-    exists, but it's now called <literal>overrides</literal>.
-  </para>
-</listitem>
-
-<listitem>
-  <para>
-    The OpenBLAS library has been updated to version
-    <literal>0.2.14</literal>. Support for the
-    <literal>x86_64-darwin</literal> platform was added. Dynamic
-    architecture detection was enabled; OpenBLAS now selects
-    microarchitecture-optimized routines at runtime, so optimal
-    performance is achieved without the need to rebuild OpenBLAS
-    locally. OpenBLAS has replaced ATLAS in most packages which use an
-    optimized BLAS or LAPACK implementation.
- </para>
-</listitem>
-
-<listitem>
-  <para>
-    The <literal>phpfpm</literal> is now using the default PHP version
-    (<literal>pkgs.php</literal>) instead of PHP 5.4 (<literal>pkgs.php54</literal>).
-  </para>
-</listitem>
-
-<listitem>
-  <para>
-    The <literal>locate</literal> service no longer indexes the Nix store
-    by default, preventing packages with potentially numerous versions from
-    cluttering the output. Indexing the store can be activated by setting
-    <literal>services.locate.includeStore = true</literal>.
-  </para>
-</listitem>
-
-<listitem>
-  <para>
-    The Nix expression search path (<envar>NIX_PATH</envar>) no longer
-    contains <filename>/etc/nixos/nixpkgs</filename> by default. You
-    can override <envar>NIX_PATH</envar> by setting
-    <option>nix.nixPath</option>.
-  </para>
-</listitem>
-
-</itemizedlist>
-</para>
-
-
-<para>The following new services were added since the last release:
-
-<itemizedlist>
-<listitem><para><literal>brltty</literal></para></listitem>
-<listitem><para><literal>marathon</literal></para></listitem>
-<listitem><para><literal>tvheadend</literal></para></listitem>
-</itemizedlist>
-</para>
-
-
-<para>Other notable improvements:
-
-<itemizedlist>
-  <listitem><para>The nixos and nixpkgs channels were unified,
-    so one <emphasis>can</emphasis> use <literal>nix-env -iA nixos.bash</literal>
-    instead of <literal>nix-env -iA nixos.pkgs.bash</literal>.
-    See <link xlink:href="https://github.com/NixOS/nixpkgs/commit/2cd7c1f198">the commit</link> for details.
-  </para></listitem>
-</itemizedlist>
-</para>
-
-</section>

nixos/doc/manual/release-notes/rl-unstable.xml

@@ -1,27 +0,0 @@
-<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-release-unstable">
-
-<title>Unstable</title>
-
-<para>When upgrading from a previous release, please be aware of the
-  following incompatible changes:
-
-  <itemizedlist>
-    <listitem><para>
-        <command>wmiiSnap</command> has been replaced with
-        <command>wmii_hg</command>, but
-        <command>services.xserver.windowManager.wmii.enable</command>
-        has been updated respectively so this only affects you if you
-        have explicitly installed <command>wmiiSnap</command>.
-    </para></listitem>
-    <listitem><para>
-        <command>wmiimenu</command> is removed, as it has been removed by
-        the developers upstream. Use <command>wimenu</command> from the
-        <command>wmii-hg</command> package.
-    </para></listitem>
-  </itemizedlist>
-</para>
-</section>

nixos/gui/README

@@ -0,0 +1,16 @@
+This file should become a nix expression. (see modules/installer/tools/tools.nix)
+
+you need to:
+- download the latest jQuery from and copy it to chrome/content:
+    http://code.jquery.com/jquery-1.5.2.js
+
+- install 'xulrunner' with nix:
+    nix-env -Ai nixpkgs_sys.firefox40Pkgs.xulrunner
+
+- make sure nixos-option in your path
+
+- have /etc/nixos/nixpkgs
+- have /etc/nixos/nixos
+
+run it:
+- xulrunner /etc/nixos/nixos/gui/application.ini -jsconsole

nixos/gui/application.ini

@@ -0,0 +1,36 @@
+[App]
+;
+; This field specifies your organization's name.  This field is recommended,
+; but optional.
+Vendor=NixOS
+;
+; This field specifies your application's name.  This field is required.
+Name=NixOS-gui
+;
+; This field specifies your application's version.  This field is optional.
+Version=0.1
+;
+; This field specifies your application's build ID (timestamp).  This field is
+; required.
+BuildID=20110424
+;
+; This field specifies a compact copyright notice for your application.  This
+; field is optional.
+;Copyright=
+
+;
+; This ID is just an example.  Every XUL app ought to have it's own unique ID.
+; You can use the microsoft "guidgen" or "uuidgen" tools, or go on
+; irc.mozilla.org and /msg botbot uuid.  This field is optional.
+;ID=
+
+[Gecko]
+;
+; This field is required.  It specifies the minimum Gecko version that this
+; application requires.
+MinVersion=1.9a5
+;
+; This field is optional.  It specifies the maximum Gecko version that this
+; application requires.  It should be specified if your application uses
+; unfrozen interfaces.
+MaxVersion=2.*

nixos/gui/chrome.manifest

@@ -0,0 +1 @@
+manifest chrome/chrome.manifest

nixos/gui/chrome/chrome.manifest

@@ -0,0 +1 @@
+content nixos-gui content/

nixos/gui/chrome/content/io.js

@@ -0,0 +1,137 @@
+
+function inspect(obj, maxLevels, level)
+{
+  var str = '', type, msg;
+
+    // Start Input Validations
+    // Don't touch, we start iterating at level zero
+    if(level == null)  level = 0;
+
+    // At least you want to show the first level
+    if(maxLevels == null) maxLevels = 1;
+    if(maxLevels < 1)
+        return '<font color="red">Error: Levels number must be > 0</font>';
+
+    // We start with a non null object
+    if(obj == null)
+    return '<font color="red">Error: Object <b>NULL</b></font>';
+    // End Input Validations
+
+    // Each Iteration must be indented
+    str += '<ul>';
+
+    // Start iterations for all objects in obj
+    for(property in obj)
+    {
+      try
+      {
+          // Show "property" and "type property"
+          type =  typeof(obj[property]);
+          str += '<li>(' + type + ') ' + property +
+                 ( (obj[property]==null)?(': <b>null</b>'):('')) + '</li>';
+
+          // We keep iterating if this property is an Object, non null
+          // and we are inside the required number of levels
+          if((type == 'object') && (obj[property] != null) && (level+1 < maxLevels))
+          str += inspect(obj[property], maxLevels, level+1);
+      }
+      catch(err)
+      {
+        // Is there some properties in obj we can't access? Print it red.
+        if(typeof(err) == 'string') msg = err;
+        else if(err.message)        msg = err.message;
+        else if(err.description)    msg = err.description;
+        else                        msg = 'Unknown';
+
+        str += '<li><font color="red">(Error) ' + property + ': ' + msg +'</font></li>';
+      }
+    }
+
+      // Close indent
+      str += '</ul>';
+
+    return str;
+}
+
+// Run xulrunner application.ini -jsconsole -console, to see messages.
+function log(str)
+{
+  Components.classes['@mozilla.org/consoleservice;1']
+    .getService(Components.interfaces.nsIConsoleService)
+    .logStringMessage(str);
+}
+
+function makeTempFile(prefix)
+{
+  var file = Components.classes["@mozilla.org/file/directory_service;1"]
+                       .getService(Components.interfaces.nsIProperties)
+                       .get("TmpD", Components.interfaces.nsIFile);
+  file.append(prefix || "xulrunner");
+  file.createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, 0664);
+  return file;
+}
+
+function writeToFile(file, data)
+{
+  // file is nsIFile, data is a string
+  var foStream = Components.classes["@mozilla.org/network/file-output-stream;1"]
+                           .createInstance(Components.interfaces.nsIFileOutputStream);
+
+  // use 0x02 | 0x10 to open file for appending.
+  foStream.init(file, 0x02 | 0x08 | 0x20, 0664, 0); // write, create, truncate
+  foStream.write(data, data.length);
+  foStream.close();
+}
+
+function readFromFile(file)
+{
+  // |file| is nsIFile
+  var data = "";
+  var fstream = Components.classes["@mozilla.org/network/file-input-stream;1"]
+                          .createInstance(Components.interfaces.nsIFileInputStream);
+  var sstream = Components.classes["@mozilla.org/scriptableinputstream;1"]
+                          .createInstance(Components.interfaces.nsIScriptableInputStream);
+  fstream.init(file, -1, 0, 0);
+  sstream.init(fstream);
+
+  var str = sstream.read(4096);
+  while (str.length > 0) {
+    data += str;
+    str = sstream.read(4096);
+  }
+
+  sstream.close();
+  fstream.close();
+
+  return data;
+}
+
+function runProgram(commandLine)
+{
+  // create an nsILocalFile for the executable
+  var file = Components.classes["@mozilla.org/file/local;1"]
+                       .createInstance(Components.interfaces.nsILocalFile);
+  file.initWithPath("/bin/sh");
+
+  // create an nsIProcess
+  var process = Components.classes["@mozilla.org/process/util;1"]
+                          .createInstance(Components.interfaces.nsIProcess);
+  process.init(file);
+
+  // Run the process.
+  // If first param is true, calling thread will be blocked until
+  // called process terminates.
+  // Second and third params are used to pass command-line arguments
+  // to the process.
+  var args = ["-c", commandLine];
+  process.run(true, args, args.length);
+}
+
+// only for testing...
+function testIO()
+{
+  var f = makeTempFile();
+  writeToFile(f, "essai\ntest");
+  alert(readFromFile(f));
+  runProgram("zenity --info");
+}

nixos/gui/chrome/content/main.js

@@ -0,0 +1,70 @@
+// global variables.
+var gNixOS;
+var gOptionView;
+
+/*
+var gProgressBar;
+function setProgress(current, max)
+{
+  if (gProgressBar) {
+    gProgressBar.value = 100 * current / max;
+    log("progress: " + gProgressBar.value + "%");
+  }
+  else
+    log("unknow progress bar");
+}
+*/
+
+function updateTextbox(id, value)
+{
+  // setting the height cause an overflow which resize the textbox to its
+  // content due to its onoverflow attribute.
+  $(id).attr("value", value).attr("height", 1);
+};
+
+function updatePanel(options)
+{
+  log("updatePanel: " + options.length);
+  if (options.length == 0)
+    return;
+  // FIXME: ignore the rest of the selection for now.
+  var o = options[0];
+  $("#name").attr("label", o.path);
+
+  if (o.typename != null)
+    $("#typename").attr("label", o.typename);
+  else
+    $("#typename").attr("label", "");
+
+  $("#desc").text(o.description);
+
+  if (o.value != null)
+    updateTextbox("#val", o.value);
+  else
+    updateTextbox("#val", "");
+
+  if (o.defaultValue != null)
+    updateTextbox("#def", o.defaultValue);
+  else
+    updateTextbox("#def", "");
+
+  if (o.example != null)
+    updateTextbox("#exp", o.example);
+  else
+    updateTextbox("#exp", "");
+
+  updateTextbox("#decls", o.declarations.join("\n"));
+  updateTextbox("#defs", o.definitions.join("\n"));
+}
+
+
+function onload()
+{
+  var optionTree = document.getElementById("option-tree");
+  // gProgressBar = document.getElementById("progress-bar");
+  // setProgress(0, 1);
+
+  gNixOS = new NixOS();
+  gOptionView = new OptionView(gNixOS.option, updatePanel);
+  optionTree.view = gOptionView;
+}