commit bc9313d088c0f698ef6d993e86c67403c59631e2 · pyrox.dev/nixpkgs

+140

doc/languages-frameworks/go.section.md

···

       1
       1
       +
       # Go {#sec-language-go}

     

       2
       2
       +
       

     

       3
       3
       +
       ## Go modules {#ssec-language-go}

     

       4
       4
       +
       

     

       5
       5
       +
       The function `buildGoModule` builds Go programs managed with Go modules. It builds a [Go Modules](https://github.com/golang/go/wiki/Modules) through a two phase build:

     

       6
       6
       +
       

     

       7
       7
       +
       - An intermediate fetcher derivation. This derivation will be used to fetch all of the dependencies of the Go module.

     

       8
       8
       +
       - A final derivation will use the output of the intermediate derivation to build the binaries and produce the final output.

     

       9
       9
       +
       

     

       10
       10
       +
       ### Example for `buildGoModule` {#ex-buildGoModule}

     

       11
       11
       +
       

     

       12
       12
       +
       In the following is an example expression using `buildGoModule`, the following arguments are of special significance to the function:

     

       13
       13
       +
       

     

       14
       14
       +
       - `vendorSha256`: is the hash of the output of the intermediate fetcher derivation. `vendorSha256` can also take `null` as an input. When `null` is used as a value, rather than fetching the dependencies and vendoring them, we use the vendoring included within the source repo. If you'd like to not have to update this field on dependency changes, run `go mod vendor` in your source repo and set `vendorSha256 = null;`

     

       15
       15
       +
       - `runVend`: runs the vend command to generate the vendor directory. This is useful if your code depends on c code and go mod tidy does not include the needed sources to build.

     

       16
       16
       +
       

     

       17
       17
       +
       ```nix

     

       18
       18
       +
       pet = buildGoModule rec {

     

       19
       19
       +
         pname = "pet";

     

       20
       20
       +
         version = "0.3.4";

     

       21
       21
       +
       

     

       22
       22
       +
         src = fetchFromGitHub {

     

       23
       23
       +
           owner = "knqyf263";

     

       24
       24
       +
           repo = "pet";

     

       25
       25
       +
           rev = "v${version}";

     

       26
       26
       +
           sha256 = "0m2fzpqxk7hrbxsgqplkg7h2p7gv6s1miymv3gvw0cz039skag0s";

     

       27
       27
       +
         };

     

       28
       28
       +
       

     

       29
       29
       +
         vendorSha256 = "1879j77k96684wi554rkjxydrj8g3hpp0kvxz03sd8dmwr3lh83j";

     

       30
       30
       +
       

     

       31
       31
       +
         runVend = true;

     

       32
       32
       +
       

     

       33
       33
       +
         meta = with lib; {

     

       34
       34
       +
           description = "Simple command-line snippet manager, written in Go";

     

       35
       35
       +
           homepage = "https://github.com/knqyf263/pet";

     

       36
       36
       +
           license = licenses.mit;

     

       37
       37
       +
           maintainers = with maintainers; [ kalbasit ];

     

       38
       38
       +
           platforms = platforms.linux ++ platforms.darwin;

     

       39
       39
       +
         };

     

       40
       40
       +
       }

     

       41
       41
       +
       ```

     

       42
       42
       +
       

     

       43
       43
       +
       ## `buildGoPackage` (legacy) {#ssec-go-legacy}

     

       44
       44
       +
       

     

       45
       45
       +
       The function `buildGoPackage` builds legacy Go programs, not supporting Go modules.

     

       46
       46
       +
       

     

       47
       47
       +
       ### Example for `buildGoPackage`

     

       48
       48
       +
       

     

       49
       49
       +
       In the following is an example expression using buildGoPackage, the following arguments are of special significance to the function:

     

       50
       50
       +
       

     

       51
       51
       +
       - `goPackagePath` specifies the package's canonical Go import path.

     

       52
       52
       +
       - `goDeps` is where the Go dependencies of a Go program are listed as a list of package source identified by Go import path. It could be imported as a separate `deps.nix` file for readability. The dependency data structure is described below.

     

       53
       53
       +
       

     

       54
       54
       +
       ```nix

     

       55
       55
       +
       deis = buildGoPackage rec {

     

       56
       56
       +
         pname = "deis";

     

       57
       57
       +
         version = "1.13.0";

     

       58
       58
       +
       

     

       59
       59
       +
         goPackagePath = "github.com/deis/deis";

     

       60
       60
       +
       

     

       61
       61
       +
         src = fetchFromGitHub {

     

       62
       62
       +
           owner = "deis";

     

       63
       63
       +
           repo = "deis";

     

       64
       64
       +
           rev = "v${version}";

     

       65
       65
       +
           sha256 = "1qv9lxqx7m18029lj8cw3k7jngvxs4iciwrypdy0gd2nnghc68sw";

     

       66
       66
       +
         };

     

       67
       67
       +
       

     

       68
       68
       +
         goDeps = ./deps.nix;

     

       69
       69
       +
       }

     

       70
       70
       +
       ```

     

       71
       71
       +
       

     

       72
       72
       +
       The `goDeps` attribute can be imported from a separate `nix` file that defines which Go libraries are needed and should be included in `GOPATH` for `buildPhase`:

     

       73
       73
       +
       

     

       74
       74
       +
       ```nix

     

       75
       75
       +
       # deps.nix

     

       76
       76
       +
       [ # goDeps is a list of Go dependencies.

     

       77
       77
       +
         {

     

       78
       78
       +
           # goPackagePath specifies Go package import path.

     

       79
       79
       +
           goPackagePath = "gopkg.in/yaml.v2";

     

       80
       80
       +
           fetch = {

     

       81
       81
       +
             # `fetch type` that needs to be used to get package source.

     

       82
       82
       +
             # If `git` is used there should be `url`, `rev` and `sha256` defined next to it.

     

       83
       83
       +
             type = "git";

     

       84
       84
       +
             url = "https://gopkg.in/yaml.v2";

     

       85
       85
       +
             rev = "a83829b6f1293c91addabc89d0571c246397bbf4";

     

       86
       86
       +
             sha256 = "1m4dsmk90sbi17571h6pld44zxz7jc4lrnl4f27dpd1l8g5xvjhh";

     

       87
       87
       +
           };

     

       88
       88
       +
         }

     

       89
       89
       +
         {

     

       90
       90
       +
           goPackagePath = "github.com/docopt/docopt-go";

     

       91
       91
       +
           fetch = {

     

       92
       92
       +
             type = "git";

     

       93
       93
       +
             url = "https://github.com/docopt/docopt-go";

     

       94
       94
       +
             rev = "784ddc588536785e7299f7272f39101f7faccc3f";

     

       95
       95
       +
             sha256 = "0wwz48jl9fvl1iknvn9dqr4gfy1qs03gxaikrxxp9gry6773v3sj";

     

       96
       96
       +
           };

     

       97
       97
       +
         }

     

       98
       98
       +
       ]

     

       99
       99
       +
       ```

     

       100
       100
       +
       

     

       101
       101
       +
       To extract dependency information from a Go package in automated way use [go2nix](https://github.com/kamilchm/go2nix). It can produce complete derivation and `goDeps` file for Go programs.

     

       102
       102
       +
       

     

       103
       103
       +
       You may use Go packages installed into the active Nix profiles by adding the following to your ~/.bashrc:

     

       104
       104
       +
       

     

       105
       105
       +
       ```bash

     

       106
       106
       +
       for p in $NIX_PROFILES; do

     

       107
       107
       +
           GOPATH="$p/share/go:$GOPATH"

     

       108
       108
       +
       done

     

       109
       109
       +
       ```

     

       110
       110
       +
       

     

       111
       111
       +
       ## Attributes used by the builders {#ssec-go-common-attributes}

     

       112
       112
       +
       

     

       113
       113
       +
       Both `buildGoModule` and `buildGoPackage` can be tweaked to behave slightly differently, if the following attributes are used:

     

       114
       114
       +
       

     

       115
       115
       +
       ### `buildFlagsArray` and `buildFlags`: {#ex-goBuildFlags-noarray}

     

       116
       116
       +
       

     

       117
       117
       +
       These attributes set build flags supported by `go build`. We recommend using `buildFlagsArray`. The most common use case of these attributes is to make the resulting executable aware of its own version. For example:

     

       118
       118
       +
       

     

       119
       119
       +
       ```nix

     

       120
       120
       +
         buildFlagsArray = [

     

       121
       121
       +
           # Note: single quotes are not needed.

     

       122
       122
       +
           "-ldflags=-X main.Version=${version} -X main.Commit=${version}"

     

       123
       123
       +
         ];

     

       124
       124
       +
       ```

     

       125
       125
       +
       

     

       126
       126
       +
       ```nix

     

       127
       127
       +
         buildFlagsArray = ''

     

       128
       128
       +
           -ldflags=

     

       129
       129
       +
           -X main.Version=${version}

     

       130
       130
       +
           -X main.Commit=${version}

     

       131
       131
       +
         '';

     

       132
       132
       +
       ```

     

       133
       133
       +
       

     

       134
       134
       +
       ### `deleteVendor` {#var-go-deleteVendor}

     

       135
       135
       +
       

     

       136
       136
       +
       Removes the pre-existing vendor directory. This should only be used if the dependencies included in the vendor folder are broken or incomplete.

     

       137
       137
       +
       

     

       138
       138
       +
       ### `subPackages` {#var-go-subPackages}

     

       139
       139
       +
       

     

       140
       140
       +
       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.

-248

doc/languages-frameworks/go.xml

···

       1
       1
       -
       <section xmlns="http://docbook.org/ns/docbook"

     

       2
       2
       -
                xmlns:xlink="http://www.w3.org/1999/xlink"

     

       3
       3
       -
                xml:id="sec-language-go">

     

       4
       4
       -
        <title>Go</title>

     

       5
       5
       -
       

     

       6
       6
       -
        <section xml:id="ssec-go-modules">

     

       7
       7
       -
         <title>Go modules</title>

     

       8
       8
       -
       

     

       9
       9
       -
         <para>

     

       10
       10
       -
          The function <varname> buildGoModule </varname> builds Go programs managed with Go modules. It builds a <link xlink:href="https://github.com/golang/go/wiki/Modules">Go modules</link> through a two phase build:

     

       11
       11
       -
          <itemizedlist>

     

       12
       12
       -
           <listitem>

     

       13
       13
       -
            <para>

     

       14
       14
       -
             An intermediate fetcher derivation. This derivation will be used to fetch all of the dependencies of the Go module.

     

       15
       15
       -
            </para>

     

       16
       16
       -
           </listitem>

     

       17
       17
       -
           <listitem>

     

       18
       18
       -
            <para>

     

       19
       19
       -
             A final derivation will use the output of the intermediate derivation to build the binaries and produce the final output.

     

       20
       20
       -
            </para>

     

       21
       21
       -
           </listitem>

     

       22
       22
       -
          </itemizedlist>

     

       23
       23
       -
         </para>

     

       24
       24
       -
       

     

       25
       25
       -
         <example xml:id='ex-buildGoModule'>

     

       26
       26
       -
          <title>buildGoModule</title>

     

       27
       27
       -
       <programlisting>

     

       28
       28
       -
       pet = buildGoModule rec {

     

       29
       29
       -
         pname = "pet";

     

       30
       30
       -
         version = "0.3.4";

     

       31
       31
       -
       

     

       32
       32
       -
         src = fetchFromGitHub {

     

       33
       33
       -
           owner = "knqyf263";

     

       34
       34
       -
           repo = "pet";

     

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

     

       36
       36
       -
           sha256 = "0m2fzpqxk7hrbxsgqplkg7h2p7gv6s1miymv3gvw0cz039skag0s";

     

       37
       37
       -
         };

     

       38
       38
       -
       

     

       39
       39
       -
         vendorSha256 = "1879j77k96684wi554rkjxydrj8g3hpp0kvxz03sd8dmwr3lh83j"; <co xml:id='ex-buildGoModule-1' />

     

       40
       40
       -
       

     

       41
       41
       -
         runVend = true; <co xml:id='ex-buildGoModule-2' />

     

       42
       42
       -
       

     

       43
       43
       -
         meta = with lib; {

     

       44
       44
       -
           description = "Simple command-line snippet manager, written in Go";

     

       45
       45
       -
           homepage = "https://github.com/knqyf263/pet";

     

       46
       46
       -
           license = licenses.mit;

     

       47
       47
       -
           maintainers = with maintainers; [ kalbasit ];

     

       48
       48
       -
           platforms = platforms.linux ++ platforms.darwin;

     

       49
       49
       -
         };

     

       50
       50
       -
       }

     

       51
       51
       -
       </programlisting>

     

       52
       52
       -
         </example>

     

       53
       53
       -
       

     

       54
       54
       -
         <para>

     

       55
       55
       -
          <xref linkend='ex-buildGoModule'/> is an example expression using buildGoModule, the following arguments are of special significance to the function:

     

       56
       56
       -
          <calloutlist>

     

       57
       57
       -
           <callout arearefs='ex-buildGoModule-1'>

     

       58
       58
       -
            <para>

     

       59
       59
       -
             <varname>vendorSha256</varname> is the hash of the output of the intermediate fetcher derivation.

     

       60
       60
       -
            </para>

     

       61
       61
       -
           </callout>

     

       62
       62
       -
           <callout arearefs='ex-buildGoModule-2'>

     

       63
       63
       -
            <para>

     

       64
       64
       -
             <varname>runVend</varname> runs the vend command to generate the vendor directory. This is useful if your code depends on c code and go mod tidy does not include the needed sources to build.

     

       65
       65
       -
            </para>

     

       66
       66
       -
           </callout>

     

       67
       67
       -
          </calloutlist>

     

       68
       68
       -
         </para>

     

       69
       69
       -
       

     

       70
       70
       -
         <para>

     

       71
       71
       -
          <varname>vendorSha256</varname> can also take <varname>null</varname> as an input. When `null` is used as a value, rather than fetching the dependencies and vendoring them, we use the vendoring included within the source repo. If you'd like to not have to update this field on dependency changes, run `go mod vendor` in your source repo and set 'vendorSha256 = null;'

     

       72
       72
       -
         </para>

     

       73
       73
       -
        </section>

     

       74
       74
       -
       

     

       75
       75
       -
        <section xml:id="ssec-go-legacy">

     

       76
       76
       -
         <title>Go legacy</title>

     

       77
       77
       -
       

     

       78
       78
       -
         <para>

     

       79
       79
       -
          The function <varname> buildGoPackage </varname> builds legacy Go programs, not supporting Go modules.

     

       80
       80
       -
         </para>

     

       81
       81
       -
       

     

       82
       82
       -
         <example xml:id='ex-buildGoPackage'>

     

       83
       83
       -
          <title>buildGoPackage</title>

     

       84
       84
       -
       <programlisting>

     

       85
       85
       -
       deis = buildGoPackage rec {

     

       86
       86
       -
         pname = "deis";

     

       87
       87
       -
         version = "1.13.0";

     

       88
       88
       -
       

     

       89
       89
       -
         goPackagePath = "github.com/deis/deis"; <co xml:id='ex-buildGoPackage-1' />

     

       90
       90
       -
       

     

       91
       91
       -
         src = fetchFromGitHub {

     

       92
       92
       -
           owner = "deis";

     

       93
       93
       -
           repo = "deis";

     

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

     

       95
       95
       -
           sha256 = "1qv9lxqx7m18029lj8cw3k7jngvxs4iciwrypdy0gd2nnghc68sw";

     

       96
       96
       -
         };

     

       97
       97
       -
       

     

       98
       98
       -
         goDeps = ./deps.nix; <co xml:id='ex-buildGoPackage-2' />

     

       99
       99
       -
       }

     

       100
       100
       -
       </programlisting>

     

       101
       101
       -
         </example>

     

       102
       102
       -
       

     

       103
       103
       -
         <para>

     

       104
       104
       -
          <xref linkend='ex-buildGoPackage'/> is an example expression using buildGoPackage, the following arguments are of special significance to the function:

     

       105
       105
       -
          <calloutlist>

     

       106
       106
       -
           <callout arearefs='ex-buildGoPackage-1'>

     

       107
       107
       -
            <para>

     

       108
       108
       -
             <varname>goPackagePath</varname> specifies the package's canonical Go import path.

     

       109
       109
       -
            </para>

     

       110
       110
       -
           </callout>

     

       111
       111
       -
           <callout arearefs='ex-buildGoPackage-2'>

     

       112
       112
       -
            <para>

     

       113
       113
       -
             <varname>goDeps</varname> is where the Go dependencies of a Go program are listed as a list of package source identified by Go import path. It could be imported as a separate <varname>deps.nix</varname> file for readability. The dependency data structure is described below.

     

       114
       114
       -
            </para>

     

       115
       115
       -
           </callout>

     

       116
       116
       -
          </calloutlist>

     

       117
       117
       -
         </para>

     

       118
       118
       -
       

     

       119
       119
       -
         <para>

     

       120
       120
       -
          The <varname>goDeps</varname> attribute can be imported from a separate <varname>nix</varname> file that defines which Go libraries are needed and should be included in <varname>GOPATH</varname> for <varname>buildPhase</varname>.

     

       121
       121
       -
         </para>

     

       122
       122
       -
       

     

       123
       123
       -
         <example xml:id='ex-goDeps'>

     

       124
       124
       -
          <title>deps.nix</title>

     

       125
       125
       -
       <programlisting>

     

       126
       126
       -
       [ <co xml:id='ex-goDeps-1' />

     

       127
       127
       -
         {

     

       128
       128
       -
           goPackagePath = "gopkg.in/yaml.v2"; <co xml:id='ex-goDeps-2' />

     

       129
       129
       -
           fetch = {

     

       130
       130
       -
             type = "git"; <co xml:id='ex-goDeps-3' />

     

       131
       131
       -
             url = "https://gopkg.in/yaml.v2";

     

       132
       132
       -
             rev = "a83829b6f1293c91addabc89d0571c246397bbf4";

     

       133
       133
       -
             sha256 = "1m4dsmk90sbi17571h6pld44zxz7jc4lrnl4f27dpd1l8g5xvjhh";

     

       134
       134
       -
           };

     

       135
       135
       -
         }

     

       136
       136
       -
         {

     

       137
       137
       -
           goPackagePath = "github.com/docopt/docopt-go";

     

       138
       138
       -
           fetch = {

     

       139
       139
       -
             type = "git";

     

       140
       140
       -
             url = "https://github.com/docopt/docopt-go";

     

       141
       141
       -
             rev = "784ddc588536785e7299f7272f39101f7faccc3f";

     

       142
       142
       -
             sha256 = "0wwz48jl9fvl1iknvn9dqr4gfy1qs03gxaikrxxp9gry6773v3sj";

     

       143
       143
       -
           };

     

       144
       144
       -
         }

     

       145
       145
       -
       ]

     

       146
       146
       -
       </programlisting>

     

       147
       147
       -
         </example>

     

       148
       148
       -
       

     

       149
       149
       -
         <para>

     

       150
       150
       -
          <calloutlist>

     

       151
       151
       -
           <callout arearefs='ex-goDeps-1'>

     

       152
       152
       -
            <para>

     

       153
       153
       -
             <varname>goDeps</varname> is a list of Go dependencies.

     

       154
       154
       -
            </para>

     

       155
       155
       -
           </callout>

     

       156
       156
       -
           <callout arearefs='ex-goDeps-2'>

     

       157
       157
       -
            <para>

     

       158
       158
       -
             <varname>goPackagePath</varname> specifies Go package import path.

     

       159
       159
       -
            </para>

     

       160
       160
       -
           </callout>

     

       161
       161
       -
           <callout arearefs='ex-goDeps-3'>

     

       162
       162
       -
            <para>

     

       163
       163
       -
             <varname>fetch type</varname> that needs to be used to get package source. If <varname>git</varname> is used there should be <varname>url</varname>, <varname>rev</varname> and <varname>sha256</varname> defined next to it.

     

       164
       164
       -
            </para>

     

       165
       165
       -
           </callout>

     

       166
       166
       -
          </calloutlist>

     

       167
       167
       -
         </para>

     

       168
       168
       -
       

     

       169
       169
       -
         <para>

     

       170
       170
       -
          To extract dependency information from a Go package in automated way use <link xlink:href="https://github.com/kamilchm/go2nix">go2nix</link>. It can produce complete derivation and <varname>goDeps</varname> file for Go programs.

     

       171
       171
       -
         </para>

     

       172
       172
       -
       

     

       173
       173
       -
         <para>

     

       174
       174
       -
          You may use Go packages installed into the active Nix profiles by adding the following to your ~/.bashrc:

     

       175
       175
       -
       <screen>

     

       176
       176
       -
       for p in $NIX_PROFILES; do

     

       177
       177
       -
           GOPATH="$p/share/go:$GOPATH"

     

       178
       178
       -
       done

     

       179
       179
       -
       </screen>

     

       180
       180
       -
         </para>

     

       181
       181
       -
        </section>

     

       182
       182
       -
       

     

       183
       183
       -
        <section xml:id="ssec-go-common-attributes">

     

       184
       184
       -
         <title>Attributes used by the builders</title>

     

       185
       185
       -
       

     

       186
       186
       -
         <para>

     

       187
       187
       -
          Both <link xlink:href="#ssec-go-modules"><varname>buildGoModule</varname></link> and <link xlink:href="#ssec-go-modules"><varname>buildGoPackage</varname></link> can be tweaked to behave slightly differently, if the following attributes are used:

     

       188
       188
       -
         </para>

     

       189
       189
       -
       

     

       190
       190
       -
         <variablelist>

     

       191
       191
       -
          <varlistentry xml:id="var-go-buildFlagsArray">

     

       192
       192
       -
           <term>

     

       193
       193
       -
            <varname>buildFlagsArray</varname> and <varname>buildFlags</varname>

     

       194
       194
       -
           </term>

     

       195
       195
       -
           <listitem>

     

       196
       196
       -
            <para>

     

       197
       197
       -
             These attributes set build flags supported by <varname>go build</varname>. We recommend using <varname>buildFlagsArray</varname>. The most common use case of these attributes is to make the resulting executable aware of its own version. For example:

     

       198
       198
       -
            </para>

     

       199
       199
       -
            <example xml:id='ex-goBuildFlags-nospaces'>

     

       200
       200
       -
             <title>buildFlagsArray</title>

     

       201
       201
       -
       <programlisting>

     

       202
       202
       -
         buildFlagsArray = [

     

       203
       203
       -
           "-ldflags=-X main.Version=${version} -X main.Commit=${version}" <co xml:id='ex-goBuildFlags-1' />

     

       204
       204
       -
         ];

     

       205
       205
       -
       </programlisting>

     

       206
       206
       -
            </example>

     

       207
       207
       -
            <calloutlist>

     

       208
       208
       -
             <callout arearefs='ex-goBuildFlags-1'>

     

       209
       209
       -
              <para>

     

       210
       210
       -
               Note: single quotes are not needed.

     

       211
       211
       -
              </para>

     

       212
       212
       -
             </callout>

     

       213
       213
       -
            </calloutlist>

     

       214
       214
       -
            <example xml:id='ex-goBuildFlags-noarray'>

     

       215
       215
       -
             <title>buildFlagsArray</title>

     

       216
       216
       -
       <programlisting>

     

       217
       217
       -
         buildFlagsArray = ''

     

       218
       218
       -
           -ldflags=

     

       219
       219
       -
           -X main.Version=${version}

     

       220
       220
       -
           -X main.Commit=${version}

     

       221
       221
       -
         '';

     

       222
       222
       -
       </programlisting>

     

       223
       223
       -
            </example>

     

       224
       224
       -
           </listitem>

     

       225
       225
       -
          </varlistentry>

     

       226
       226
       -
          <varlistentry xml:id="var-go-deleteVendor">

     

       227
       227
       -
           <term>

     

       228
       228
       -
            <varname>deleteVendor</varname>

     

       229
       229
       -
           </term>

     

       230
       230
       -
           <listitem>

     

       231
       231
       -
            <para>

     

       232
       232
       -
             Removes the pre-existing vendor directory. This should only be used if the dependencies included in the vendor folder are broken or incomplete.

     

       233
       233
       -
            </para>

     

       234
       234
       -
           </listitem>

     

       235
       235
       -
          </varlistentry>

     

       236
       236
       -
          <varlistentry xml:id="var-go-subPackages">

     

       237
       237
       -
           <term>

     

       238
       238
       -
            <varname>subPackages</varname>

     

       239
       239
       -
           </term>

     

       240
       240
       -
           <listitem>

     

       241
       241
       -
            <para>

     

       242
       242
       -
             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.

     

       243
       243
       -
            </para>

     

       244
       244
       -
           </listitem>

     

       245
       245
       -
          </varlistentry>

     

       246
       246
       -
         </variablelist>

     

       247
       247
       -
        </section>

     

       248
       248
       -
       </section>

+1 -1

doc/languages-frameworks/index.xml

···

       13
       13
        
        <xi:include href="crystal.section.xml" />

     

       14
       14
        
        <xi:include href="emscripten.section.xml" />

     

       15
       15
        
        <xi:include href="gnome.xml" />

     

       16
       16
       -
        <xi:include href="go.xml" />

     

       16
       16
       +
        <xi:include href="go.section.xml" />

     

       17
       17
        
        <xi:include href="haskell.section.xml" />

     

       18
       18
        
        <xi:include href="idris.section.xml" />

     

       19
       19
        
        <xi:include href="ios.section.xml" />