···

       
125
       
125
       
 
       


     

       
126
       
126
       
 
       
## Writing Agda packages {#writing-agda-packages}

     

       
127
       
127
       
 
       


     

       
128
       
128
       
-
       
To write a nix derivation for an Agda library, first check that the library has a `*.agda-lib` file.

     

       
128
       
128
       
+
       
To write a nix derivation for an Agda library, first check that the library has a (single) `*.agda-lib` file.

     

       
129
       
129
       
 
       


     

       
130
       
130
       
 
       
A derivation can then be written using `agdaPackages.mkDerivation`. This has similar arguments to `stdenv.mkDerivation` with the following additions:

     

       
131
       
131
       
 
       


     

       
132
       
132
       
-
       
* `everythingFile` can be used to specify the location of the `Everything.agda` file, defaulting to `./Everything.agda`. If this file does not exist then either it should be patched in or the `buildPhase` should be overridden (see below).

     

       
133
       
132
       
 
       
* `libraryName` should be the name that appears in the `*.agda-lib` file, defaulting to `pname`.

     

       
134
       
133
       
 
       
* `libraryFile` should be the file name of the `*.agda-lib` file, defaulting to `${libraryName}.agda-lib`.

     

       
135
       
134
       
 
       


     
···

       
152
       
151
       
 
       


     

       
153
       
152
       
 
       
### Building Agda packages {#building-agda-packages}

     

       
154
       
153
       
 
       


     

       
155
       
155
       
-
       
The default build phase for `agdaPackages.mkDerivation` runs `agda` on the `Everything.agda` file.

     

       
154
       
154
       
+
       
The default build phase for `agdaPackages.mkDerivation` runs `agda --build-library`.

     

       
156
       
155
       
 
       
If something else is needed to build the package (e.g. `make`) then the `buildPhase` should be overridden.

     

       
157
       
157
       
-
       
Additionally, a `preBuild` or `configurePhase` can be used if there are steps that need to be done prior to checking the `Everything.agda` file.

     

       
156
       
156
       
+
       
Additionally, a `preBuild` or `configurePhase` can be used if there are steps that need to be done prior to checking the library.

     

       
158
       
157
       
 
       
`agda` and the Agda libraries contained in `buildInputs` are made available during the build phase.

     

       
159
       
158
       
 
       


     

       
160
       
159
       
 
       
### Installing Agda packages {#installing-agda-packages}

     
···

       
182
       
181
       
 
       


     

       
183
       
182
       
 
       
### Adding Agda packages to Nixpkgs {#adding-agda-packages-to-nixpkgs}

     

       
184
       
183
       
 
       


     

       
185
       
185
       
-
       
To add an Agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other Agda libraries, so the top line of the `default.nix` can look like:

     

       
184
       
184
       
+
       
To add an Agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/default.nix` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other Agda libraries, so the derivation could look like:

     

       
186
       
185
       
 
       


     

       
187
       
186
       
 
       
```nix

     

       
188
       
187
       
 
       
{

     
···

       
190
       
189
       
 
       
  standard-library,

     

       
191
       
190
       
 
       
  fetchFromGitHub,

     

       
192
       
191
       
 
       
}:

     

       
193
       
193
       
-
       
{ }

     

       
194
       
194
       
-
       
```

     

       
195
       
192
       
 
       


     

       
196
       
196
       
-
       
Note that the derivation function is called with `mkDerivation` set to `agdaPackages.mkDerivation`, therefore you

     

       
197
       
197
       
-
       
could use a similar set as in your `default.nix` from [Writing Agda Packages](#writing-agda-packages) with

     

       
198
       
198
       
-
       
`agdaPackages.mkDerivation` replaced with `mkDerivation`.

     

       
199
       
199
       
-
       


     

       
200
       
200
       
-
       
Here is an example skeleton derivation for iowa-stdlib:

     

       
201
       
201
       
-
       


     

       
202
       
202
       
-
       
```nix

     

       
203
       
193
       
 
       
mkDerivation {

     

       
204
       
204
       
-
       
  version = "1.5.0";

     

       
205
       
205
       
-
       
  pname = "iowa-stdlib";

     

       
206
       
206
       
-
       


     

       
194
       
194
       
+
       
  pname = "my-library";

     

       
195
       
195
       
+
       
  version = "1.0";

     

       
207
       
196
       
 
       
  src = <...>;

     

       
208
       
208
       
-
       


     

       
209
       
209
       
-
       
  libraryFile = "";

     

       
210
       
210
       
-
       
  libraryName = "IAL-1.3";

     

       
211
       
211
       
-
       


     

       
212
       
212
       
-
       
  buildPhase = ''

     

       
213
       
213
       
-
       
    runHook preBuild

     

       
214
       
214
       
-
       


     

       
215
       
215
       
-
       
    patchShebangs find-deps.sh

     

       
216
       
216
       
-
       
    make

     

       
217
       
217
       
-
       


     

       
218
       
218
       
-
       
    runHook postBuild

     

       
219
       
219
       
-
       
  '';

     

       
197
       
197
       
+
       
  buildInputs = [ standard-library ];

     

       
198
       
198
       
+
       
  meta = <...>;

     

       
220
       
199
       
 
       
}

     

       
221
       
200
       
 
       
```

     

       
222
       
201
       
 
       


     

       
223
       
223
       
-
       
This library has a file called `.agda-lib`, and so we give an empty string to `libraryFile` as nothing precedes `.agda-lib` in the filename. This file contains `name: IAL-1.3`, and so we let `libraryName =  "IAL-1.3"`. This library does not use an `Everything.agda` file and instead has a Makefile, so there is no need to set `everythingFile` and we set a custom `buildPhase`.

     

       
202
       
202
       
+
       
You can look at other files under `pkgs/development/libraries/agda/` for more inspiration.

     

       
203
       
203
       
+
       


     

       
204
       
204
       
+
       
Note that the derivation function is called with `mkDerivation` set to `agdaPackages.mkDerivation`, therefore you

     

       
205
       
205
       
+
       
could use a similar set as in your `default.nix` from [Writing Agda Packages](#writing-agda-packages) with

     

       
206
       
206
       
+
       
`agdaPackages.mkDerivation` replaced with `mkDerivation`.

     

       
224
       
207
       
 
       


     

       
225
       
208
       
 
       
When writing an Agda package it is essential to make sure that no `.agda-lib` file gets added to the store as a single file (for example by using `writeText`). This causes Agda to think that the nix store is a Agda library and it will attempt to write to it whenever it typechecks something. See [https://github.com/agda/agda/issues/4613](https://github.com/agda/agda/issues/4613).

     

       
226
       
209
       
 
       


     
···

       
228
       
211
       
 
       
you can test whether it builds correctly by writing in a comment:

     

       
229
       
212
       
 
       


     

       
230
       
213
       
 
       
```

     

       
231
       
231
       
-
       
@ofborg build agdaPackages.iowa-stdlib

     

       
214
       
214
       
+
       
@ofborg build agdaPackages.my-library

     

       
232
       
215
       
 
       
```

     

       
233
       
216
       
 
       


     

       
234
       
217
       
 
       
### Maintaining Agda packages {#agda-maintaining-packages}

     

···

       
90
       
90
       
 
       
      pname,

     

       
91
       
91
       
 
       
      meta,

     

       
92
       
92
       
 
       
      buildInputs ? [ ],

     

       
93
       
93
       
-
       
      everythingFile ? "./Everything.agda",

     

       
94
       
94
       
-
       
      includePaths ? [ ],

     

       
95
       
93
       
 
       
      libraryName ? pname,

     

       
96
       
94
       
 
       
      libraryFile ? "${libraryName}.agda-lib",

     

       
97
       
95
       
 
       
      buildPhase ? null,

     
···

       
100
       
98
       
 
       
      ...

     

       
101
       
99
       
 
       
    }:

     

       
102
       
100
       
 
       
    let

     

       
103
       
103
       
-
       
      agdaWithArgs = withPackages (filter (p: p ? isAgdaDerivation) buildInputs);

     

       
104
       
104
       
-
       
      includePathArgs = concatMapStrings (path: "-i" + path + " ") (

     

       
105
       
105
       
-
       
        includePaths ++ [ (dirOf everythingFile) ]

     

       
106
       
106
       
-
       
      );

     

       
101
       
101
       
+
       
      agdaWithPkgs = withPackages (filter (p: p ? isAgdaDerivation) buildInputs);

     

       
107
       
102
       
 
       
    in

     

       
108
       
103
       
 
       
    {

     

       
109
       
104
       
 
       
      inherit libraryName libraryFile;

     

       
110
       
105
       
 
       


     

       
111
       
106
       
 
       
      isAgdaDerivation = true;

     

       
112
       
107
       
 
       


     

       
113
       
113
       
-
       
      buildInputs = buildInputs ++ [ agdaWithArgs ];

     

       
108
       
108
       
+
       
      buildInputs = buildInputs ++ [ agdaWithPkgs ];

     

       
114
       
109
       
 
       


     

       
115
       
110
       
 
       
      buildPhase =

     

       
116
       
111
       
 
       
        if buildPhase != null then

     
···

       
118
       
113
       
 
       
        else

     

       
119
       
114
       
 
       
          ''

     

       
120
       
115
       
 
       
            runHook preBuild

     

       
121
       
121
       
-
       
            agda ${includePathArgs} ${everythingFile}

     

       
122
       
122
       
-
       
            rm ${everythingFile} ${lib.interfaceFile Agda.version everythingFile}

     

       
116
       
116
       
+
       
            agda --build-library

     

       
123
       
117
       
 
       
            runHook postBuild

     

       
124
       
118
       
 
       
          '';

     

       
125
       
119
       
 
       


     

···

       
6
       
6
       
 
       
    * The resulting path may not be normalized.

     

       
7
       
7
       
 
       
    *

     

       
8
       
8
       
 
       
    * Examples:

     

       
9
       
9
       
-
       
    * interfaceFile pkgs.agda.version "./Everything.agda" == "_build/2.6.4.3/agda/./Everything.agdai"

     

       
10
       
10
       
-
       
    * interfaceFile pkgs.agda.version "src/Everything.lagda.tex" == "_build/2.6.4.3/agda/src/Everything.agdai"

     

       
9
       
9
       
+
       
    * interfaceFile pkgs.agda.version "./Foo.agda" == "_build/AGDA_VERSION/agda/./Foo.agdai"

     

       
10
       
10
       
+
       
    * interfaceFile pkgs.agda.version "src/Foo.lagda.tex" == "_build/AGDA_VERSION/agda/src/Foo.agdai"

     

       
11
       
11
       
 
       
  */

     

       
12
       
12
       
 
       
  interfaceFile =

     

       
13
       
13
       
 
       
    agdaVersion: agdaFile:

     

···

       
1412
       
1412
       
 
       
    (overrideCabal { mainProgram = "agda"; })

     

       
1413
       
1413
       
 
       
    # Split outputs to reduce closure size

     

       
1414
       
1414
       
 
       
    enableSeparateBinOutput

     

       
1415
       
1415
       
+
       
    # Build the primitive library to generate its interface files.

     

       
1416
       
1416
       
+
       
    # These are needed in order to use Agda in Nix builds.

     

       
1417
       
1417
       
+
       
    (overrideCabal (drv: {

     

       
1418
       
1418
       
+
       
      postInstall =

     

       
1419
       
1419
       
+
       
        drv.postInstall or ""

     

       
1420
       
1420
       
+
       
        + ''

     

       
1421
       
1421
       
+
       
          agdaExe=''${bin:-$out}/bin/agda

     

       
1422
       
1422
       
+
       


     

       
1423
       
1423
       
+
       
          echo "Generating Agda core library interface files..."

     

       
1424
       
1424
       
+
       
          (cd "$("$agdaExe" --print-agda-data-dir)/lib/prim" && "$agdaExe" --build-library)

     

       
1425
       
1425
       
+
       
        '';

     

       
1426
       
1426
       
+
       
    }))

     

       
1415
       
1427
       
 
       
  ];

     

       
1416
       
1428
       
 
       


     

       
1417
       
1429
       
 
       
  # ats-format uses cli-setup in Setup.hs which is quite happy to write

     

···

       
6
       
6
       
 
       


     

       
7
       
7
       
 
       
mkDerivation rec {

     

       
8
       
8
       
 
       
  pname = "1lab";

     

       
9
       
9
       
-
       
  version = "unstable-2024-08-05";

     

       
9
       
9
       
+
       
  version = "unstable-2025-07-01";

     

       
10
       
10
       
 
       


     

       
11
       
11
       
 
       
  src = fetchFromGitHub {

     

       
12
       
12
       
 
       
    owner = "the1lab";

     

       
13
       
13
       
 
       
    repo = pname;

     

       
14
       
14
       
-
       
    rev = "7cc9bf7bbe90be5491e0d64da90a36afa29a540b";

     

       
15
       
15
       
-
       
    hash = "sha256-hOyf6ZzejDAFDRj6liFZsBc9bKdxV5bzTPP4kGXIhW0=";

     

       
14
       
14
       
+
       
    rev = "e9c2ad2b3ba9cefad36e72cb9d732117c68ac862";

     

       
15
       
15
       
+
       
    hash = "sha256-wKh77+xCdfMtnq9jMlpdnEptGO+/WVNlQFa1TDbdUGs=";

     

       
16
       
16
       
 
       
  };

     

       
17
       
17
       
 
       


     

       
18
       
18
       
 
       
  postPatch = ''

     
···

       
23
       
23
       
 
       
    shopt -s globstar extglob

     

       
24
       
24
       
 
       
    files=(src/**/*.@(agda|lagda.md))

     

       
25
       
25
       
 
       
    sed -Ei '/OPTIONS/s/ -v ?[^ #]+//g' "''${files[@]}"

     

       
26
       
26
       
-
       


     

       
27
       
27
       
-
       
    # Generate all-pages manually instead of building the build script.

     

       
28
       
28
       
-
       
    mkdir -p _build

     

       
29
       
29
       
-
       
    for f in "''${files[@]}"; do

     

       
30
       
30
       
-
       
      f=''${f#src/} f=''${f%%.*} f=''${f//\//.}

     

       
31
       
31
       
-
       
      echo "open import $f"

     

       
32
       
32
       
-
       
    done > _build/all-pages.agda

     

       
33
       
26
       
 
       
  '';

     

       
34
       
34
       
-
       


     

       
35
       
35
       
-
       
  libraryName = "1lab";

     

       
36
       
36
       
-
       
  libraryFile = "1lab.agda-lib";

     

       
37
       
37
       
-
       
  everythingFile = "_build/all-pages.agda";

     

       
38
       
27
       
 
       


     

       
39
       
28
       
 
       
  meta = with lib; {

     

       
40
       
29
       
 
       
    description = "A formalised, cross-linked reference resource for mathematics done in Homotopy Type Theory ";

     

···

       
24
       
24
       
 
       
    # version update of the stdlib, so we get rid of the version constraint

     

       
25
       
25
       
 
       
    # altogether.

     

       
26
       
26
       
 
       
    sed -Ei 's/standard-library-[0-9.]+/standard-library/' agda-categories.agda-lib

     

       
27
       
27
       
-
       


     

       
28
       
28
       
-
       
    # The Makefile of agda-categories uses git(1) instead of find(1) to

     

       
29
       
29
       
-
       
    # determine the list of source files. We cannot use git, as $PWD will not

     

       
30
       
30
       
-
       
    # be a valid Git working directory.

     

       
31
       
31
       
-
       
    find src -name '*.agda' | sed -e 's|^src/[/]*|import |' -e 's|/|.|g' -e 's/.agda//' -e '/import Everything/d' | LC_COLLATE='C' sort > Everything.agda

     

       
32
       
27
       
 
       
  '';

     

       
33
       
28
       
 
       


     

       
34
       
29
       
 
       
  buildInputs = [ standard-library ];

     

···

       
15
       
15
       
 
       
    hash = "sha256-ab+KojzRbkUTAFNH5OA78s0F5SUuXTbliai6badveg4=";

     

       
16
       
16
       
 
       
  };

     

       
17
       
17
       
 
       


     

       
18
       
18
       
-
       
  preConfigure = ''

     

       
19
       
19
       
-
       
    cd test

     

       
20
       
20
       
-
       
    make everything

     

       
21
       
21
       
-
       
    mv Everything.agda ..

     

       
22
       
22
       
-
       
    cd ..

     

       
23
       
23
       
-
       
  '';

     

       
24
       
24
       
-
       


     

       
25
       
18
       
 
       
  meta = with lib; {

     

       
26
       
19
       
 
       
    homepage = "https://github.com/UlfNorell/agda-prelude";

     

       
27
       
20
       
 
       
    description = "Programming library for Agda";

     

···

       
16
       
16
       
 
       
    sha256 = "02fqkycvicw6m2xsz8p01aq8n3gj2d2gyx8sgj15l46f8434fy0x";

     

       
17
       
17
       
 
       
  };

     

       
18
       
18
       
 
       


     

       
19
       
19
       
-
       
  everythingFile = "./index.agda";

     

       
20
       
20
       
-
       


     

       
21
       
21
       
-
       
  includePaths = [

     

       
22
       
22
       
-
       
    "src"

     

       
23
       
23
       
-
       
    "examples"

     

       
24
       
24
       
-
       
  ];

     

       
25
       
25
       
-
       


     

       
26
       
19
       
 
       
  buildInputs = [ standard-library ];

     

       
27
       
20
       
 
       


     

       
28
       
21
       
 
       
  meta = with lib; {

     

···

       
8
       
8
       
 
       


     

       
9
       
9
       
 
       
mkDerivation rec {

     

       
10
       
10
       
 
       
  pname = "cubical-mini";

     

       
11
       
11
       
-
       
  version = "nightly-20241214";

     

       
11
       
11
       
+
       
  version = "0.5-unstable-2025-06-13";

     

       
12
       
12
       
 
       


     

       
13
       
13
       
 
       
  src = fetchFromGitHub {

     

       
14
       
14
       
 
       
    repo = pname;

     

       
15
       
15
       
 
       
    owner = "cmcmA20";

     

       
16
       
16
       
-
       
    rev = "ab18320018ddc0055db60d4bb5560d31909c5b78";

     

       
17
       
17
       
-
       
    hash = "sha256-32qXY9KbProdPwqHxSkwO74Oqx65rTzoXtH2SpRB3OM=";

     

       
16
       
16
       
+
       
    rev = "1776874d13d0b811e6eeb70d0e5a52b4d2a978d2";

     

       
17
       
17
       
+
       
    hash = "sha256-UxWOS+uzP9aAaMdSueA2CAuzWkImGAoKxroarcgpk+w=";

     

       
18
       
18
       
 
       
  };

     

       
19
       
19
       
 
       


     

       
20
       
20
       
 
       
  nativeBuildInputs = [

     

···

       
2
       
2
       
 
       
  lib,

     

       
3
       
3
       
 
       
  mkDerivation,

     

       
4
       
4
       
 
       
  fetchFromGitHub,

     

       
5
       
5
       
-
       
  ghc,

     

       
6
       
5
       
 
       
}:

     

       
7
       
6
       
 
       


     

       
8
       
7
       
 
       
mkDerivation rec {

     
···

       
16
       
15
       
 
       
    hash = "sha256-KwwN2g2naEo4/rKTz2L/0Guh5LxymEYP53XQzJ6eMjM=";

     

       
17
       
16
       
 
       
  };

     

       
18
       
17
       
 
       


     

       
19
       
19
       
-
       
  # The cubical library has several `Everything.agda` files, which are

     

       
20
       
20
       
-
       
  # compiled through the make file they provide.

     

       
21
       
21
       
-
       
  nativeBuildInputs = [ ghc ];

     

       
22
       
22
       
-
       
  buildPhase = ''

     

       
23
       
23
       
-
       
    runHook preBuild

     

       
24
       
24
       
-
       
    make

     

       
25
       
25
       
-
       
    runHook postBuild

     

       
18
       
18
       
+
       
  postPatch = ''

     

       
19
       
19
       
+
       
    # This imports the Everything files, which we don't generate.

     

       
20
       
20
       
+
       
    # TODO: remove for the next release

     

       
21
       
21
       
+
       
    rm -rf Cubical/README.agda Cubical/Talks/EPA2020.agda

     

       
26
       
22
       
 
       
  '';

     

       
27
       
23
       
 
       


     

       
28
       
24
       
 
       
  meta = with lib; {

     

···

       
18
       
18
       
 
       
    sha256 = "sha256-3nme/eH4pY6bD0DkhL4Dj/Vp/WnZqkQtZTNk+n1oAyY=";

     

       
19
       
19
       
 
       
  };

     

       
20
       
20
       
 
       


     

       
21
       
21
       
-
       
  preConfigure = ''

     

       
22
       
22
       
-
       
    sh generate-everything.sh

     

       
23
       
23
       
-
       
  '';

     

       
24
       
24
       
-
       


     

       
25
       
21
       
 
       
  meta = with lib; {

     

       
26
       
22
       
 
       
    homepage = "https://github.com/ryanorendorff/functional-linear-algebra";

     

       
27
       
23
       
 
       
    description = ''

     

···

       
20
       
20
       
 
       
    standard-library

     

       
21
       
21
       
 
       
  ];

     

       
22
       
22
       
 
       


     

       
23
       
23
       
-
       
  # everythingFile = "./README.agda";

     

       
23
       
23
       
+
       
  # Agda expects a single .agda-lib file.

     

       
24
       
24
       
+
       
  preBuild = ''

     

       
25
       
25
       
+
       
    rm tests.agda-lib

     

       
26
       
26
       
+
       
  '';

     

       
24
       
27
       
 
       


     

       
25
       
28
       
 
       
  meta = with lib; {

     

       
26
       
29
       
 
       
    description = "Library for datatype-generic programming in Agda";

     

···

       
2
       
2
       
 
       
  lib,

     

       
3
       
3
       
 
       
  mkDerivation,

     

       
4
       
4
       
 
       
  fetchFromGitHub,

     

       
5
       
5
       
-
       
  ghcWithPackages,

     

       
6
       
5
       
 
       
  nixosTests,

     

       
7
       
6
       
 
       
}:

     

       
8
       
7
       
 
       


     

       
9
       
8
       
 
       
mkDerivation rec {

     

       
10
       
9
       
 
       
  pname = "standard-library";

     

       
11
       
11
       
-
       
  version = "2.2";

     

       
10
       
10
       
+
       
  version = "2.2-unstable-2025-07-03";

     

       
12
       
11
       
 
       


     

       
13
       
12
       
 
       
  src = fetchFromGitHub {

     

       
14
       
13
       
 
       
    repo = "agda-stdlib";

     

       
15
       
14
       
 
       
    owner = "agda";

     

       
16
       
16
       
-
       
    rev = "v${version}";

     

       
17
       
17
       
-
       
    hash = "sha256-/Fy5EOSbVNXt6Jq0yKSnlNPW4SYfn+eCTAYFnMZrbR0=";

     

       
15
       
15
       
+
       
    rev = "6f8af9452e7fac27bc3b3ad068793b538f07668e";

     

       
16
       
16
       
+
       
    hash = "sha256-LD6KasmQ9ZHRNQJ0N4wjyc6JiSkZpmyqQq9B0Wta1n0=";

     

       
18
       
17
       
 
       
  };

     

       
19
       
19
       
-
       


     

       
20
       
20
       
-
       
  nativeBuildInputs = [ (ghcWithPackages (self: [ self.filemanip ])) ];

     

       
21
       
21
       
-
       
  preConfigure = ''

     

       
22
       
22
       
-
       
    runhaskell GenerateEverything.hs --include-deprecated

     

       
23
       
23
       
-
       
    # We will only build/consider Everything.agda, in particular we don't want Everything*.agda

     

       
24
       
24
       
-
       
    # do be copied to the store.

     

       
25
       
25
       
-
       
    rm EverythingSafe.agda

     

       
26
       
26
       
-
       
  '';

     

       
27
       
18
       
 
       


     

       
28
       
19
       
 
       
  passthru.tests = { inherit (nixosTests) agda; };

     

       
29
       
20
       
 
       
  meta = with lib; {

     

···

       
28
       
28
       
 
       


     

       
29
       
29
       
 
       
      agda = withPackages [ ];

     

       
30
       
30
       
 
       


     

       
31
       
31
       
-
       
      standard-library = callPackage ../development/libraries/agda/standard-library {

     

       
32
       
32
       
-
       
        inherit (pkgs.haskellPackages) ghcWithPackages;

     

       
33
       
33
       
-
       
      };

     

       
31
       
31
       
+
       
      standard-library = callPackage ../development/libraries/agda/standard-library { };

     

       
34
       
32
       
 
       


     

       
35
       
33
       
 
       
      iowa-stdlib = callPackage ../development/libraries/agda/iowa-stdlib { };

     

       
36
       
34