Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

[インデックス 11851] ファイルの概要

このコミットは、Go言語の仕様書（doc/go_spec.html）における、型なし浮動小数点数（untyped floats）の実装に関する制約の記述を明確化するものです。特に、数値定数の精度、オーバーフロー時の挙動、および中間計算における丸め処理について、コンパイラの実装が満たすべき要件をより厳密に定義しています。これにより、Go言語の数値定数の振る舞いに関する曖昧さを解消し、異なるコンパイラ間での一貫性を高めることを目的としています。

コミット

commit 9126c6570ce293761a4e5eefd61427902f291263
Author: Ian Lance Taylor <iant@golang.org>
Date:   Mon Feb 13 11:25:56 2012 -0800

    spec: clarify implementation restrictions on untyped floats
    
    Drop reference to "machine type."  Specify that integer
    overflow must be an error.  Drop requirement that exponent
    must be 128 bits--that's a lot.  Clarify that floating point
    expressions may be rounded, including intermediate values.
    
    This is a reworking of https://golang.org/cl/5577068/ .
    
    Fixes #2789.
    
    R=r, rsc, r, gri, ken, ken, iant
    CC=golang-dev, remyoudompheng
    https://golang.org/cl/5655049

GitHub上でのコミットページへのリンク

https://github.com/golang/go/commit/9126c6570ce293761a4e5eefd61427902f291263

元コミット内容

このコミットの元々の内容は、Go言語の仕様書において、型なし浮動小数点数に関する実装上の制約を明確にすることです。具体的には、以下の点が変更されています。

  • 「マシンタイプ」への言及を削除。
  • 整数オーバーフローがエラーとなるべきであることを明記。
  • 指数部が128ビットであるという要件を削除（これは大きすぎるため）。
  • 浮動小数点数式の計算において、中間値を含めて丸めが行われる可能性があることを明確化。

この変更は、以前の変更セット https://golang.org/cl/5577068/ の再作業であり、Issue #2789 を修正するものです。

変更の背景

このコミットの背景には、Go言語の数値定数、特に型なし浮動小数点数の扱いに関する仕様の曖昧さがありました。Go言語では、数値定数はデフォルトで「型なし（untyped）」であり、その精度は「任意精度（arbitrary precision）」であるとされています。しかし、実際のコンパイラ実装では、無限の精度を扱うことは不可能です。そのため、コンパイラがどの程度の精度を保証し、どのような場合にエラーを報告すべきか、また丸め処理をどのように行うべきかについて、明確なガイドラインが必要でした。

特に、Fixes #2789 とあることから、このコミットはGo言語のIssue 2789を解決するために行われました。Issue 2789は、「math.MaxFloat64 のような定数式が、コンパイラによって異なる結果を生成する可能性がある」という問題提起でした。これは、コンパイラが内部的に使用する数値表現の精度や丸め処理の仕方が統一されていないために発生していました。このコミットは、これらの実装上の差異を減らし、Goプログラムの移植性と予測可能性を高めることを目的としています。

前提知識の解説

型なし定数 (Untyped Constants)

Go言語における定数は、特定の型を持たない「型なし定数」として宣言できます。例えば、const pi = 3.14159 のように宣言された pi は、最初は型を持ちません。この定数は、それが使用される文脈（例えば、float64 型の変数に代入される場合）に応じて、適切な型に変換されます。この「型なし」の性質により、定数はより柔軟に利用でき、コンパイラは計算時に可能な限り高い精度を維持できます。

任意精度 (Arbitrary Precision)

Go言語の仕様では、数値定数は「任意精度」を持つとされています。これは、理論上、定数の値が無限の精度で表現されることを意味します。しかし、実際のコンピュータシステムでは無限の精度を扱うことはできないため、コンパイラは内部的に有限の精度でこれらの定数を表現する必要があります。このコミットは、その「有限の精度」が満たすべき最低限の要件を定義しています。

浮動小数点数の表現 (Floating-Point Representation)

浮動小数点数は、通常、符号部、指数部（exponent）、仮数部（mantissa または significand）の3つの部分で構成されます。

  • 仮数部: 数値の有効数字を表します。仮数部のビット数が多いほど、表現できる数値の精度が高くなります。
  • 指数部: 小数点の位置を示し、数値の大きさを決定します。指数部のビット数が多いほど、表現できる数値の範囲（非常に小さい数から非常に大きい数まで）が広がります。

オーバーフロー (Overflow) と 丸め (Rounding)

  • オーバーフロー: 数値が、そのデータ型で表現できる最大値を超えた場合に発生します。例えば、int8 型の変数が 127 を超える値を保持しようとするとオーバーフローします。
  • 丸め: 浮動小数点数の計算結果が、そのデータ型で正確に表現できない場合に、最も近い表現可能な値に調整する処理です。丸めには様々な方法（例: 四捨五入、切り捨て、切り上げ）がありますが、Goの仕様では「最も近い表現可能な定数に丸める」ことが求められています。

コンパイラの実装制約 (Implementation Restrictions)

プログラミング言語の仕様では、言語の振る舞いを定義しますが、具体的な実装方法についてはコンパイラに一定の自由度を与えることがあります。しかし、その自由度があまりに大きいと、異なるコンパイラ間でプログラムの振る舞いが異なってしまう可能性があります。このコミットは、Goの数値定数に関するコンパイラの実装制約をより厳密に定義することで、この問題を解決しようとしています。

技術的詳細

このコミットは、Go言語の仕様書 doc/go_spec.html の「Constants」セクションと、浮動小数点数に関する「Implementation restriction」セクションを修正しています。

1. 数値定数の内部表現に関する制約の明確化

変更前は、「コンパイラは、任意の機械型（machine type）の2倍以上のビット数を持つ内部表現で数値定数を実装してもよい」とされていました。これは曖昧であり、特に「機械型」という用語が何を指すのか不明確でした。

変更後は、この記述がより具体的かつ厳密になっています。

  • 整数定数: 少なくとも256ビットで表現すること。
  • 浮動小数点定数（複素数定数の部分を含む）: 仮数部が少なくとも256ビット、符号付き指数部が少なくとも32ビットで表現すること。

これらの具体的なビット数要件は、コンパイラがGoの任意精度定数を扱う際に、十分な精度と範囲を保証するための最低限の基準を提供します。特に、指数部が128ビットという以前の（おそらく非公式な）要件が削除され、より現実的な32ビットに緩和されたことは、実装の負担を軽減しつつ、十分な範囲を確保するためのバランスの取れた変更と言えます。

2. エラー報告の要件の追加

以前の仕様では、オーバーフローや精度不足の場合にコンパイラがどのように振る舞うべきかについて、明確な指示がありませんでした。

変更後は、以下のエラー報告要件が追加されました。

  • 整数定数: 正確に表現できない場合はエラーを出すこと。
  • 浮動小数点数または複素数定数: オーバーフローにより表現できない場合はエラーを出すこと。
  • 浮動小数点数または複素数定数: 精度制限により表現できない場合は、最も近い表現可能な定数に丸めること。

これにより、コンパイラは数値定数の計算結果が表現範囲を超えたり、精度が失われたりした場合に、開発者に明確なフィードバックを提供することが義務付けられました。特に、丸め処理が許容されるケースと、エラーとして報告すべきケースが明確に区別されています。

3. 型なし浮動小数点数式の丸めに関する明確化

新しい段落が追加され、型なし浮動小数点数または複素数定数式の計算中に、コンパイラが丸めを使用する可能性があることが明記されました。

  • この丸めは、定数に関する実装制約（前述の「Constants」セクション）に従って行われます。
  • この丸めにより、無限精度で計算された場合には整数となるはずの浮動小数点数定数式が、整数コンテキストでは無効になる可能性があることが示されています。

これは、コンパイラが内部的に浮動小数点数計算を行う際に、中間結果を丸めることが許容されることを意味します。これにより、コンパイラの実装がより柔軟になり、パフォーマンスと精度のバランスを取ることが可能になります。同時に、開発者に対して、型なし浮動小数点数式の計算結果が、厳密な数学的精度とは異なる可能性があることを警告しています。

これらの変更は、Go言語の数値定数の振る舞いをより予測可能にし、異なるコンパイラ間での一貫性を高める上で非常に重要です。

コアとなるコードの変更箇所

--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -589,11 +589,33 @@ functions return and test for those values at run time.
 </p>
  
 <p>
-Implementation restriction: A compiler may implement numeric constants by choosing
-an internal representation with at least twice as many bits as any machine type;
-for floating-point values, both the mantissa and exponent must be twice as large.
+Implementation restriction: Although numeric constants have arbitrary
+precision in the language, a compiler may implement them using an
+internal representation with limited precision.  That said, every
+implementation must:
 </p>
+<ul>
+\t<li>Represent integer constants with at least 256 bits.</li>
+
+\t<li>Represent floating-point constants, including the parts of
+\t    a complex constant, with a mantissa of at least 256 bits
+\t    and a signed exponent of at least 32 bits.</li>
+
+\t<li>Give an error if unable to represent an integer constant
+\t    precisely.</li>
+
+\t<li>Give an error if unable to represent a floating-point or
+\t    complex constant due to overflow.</li>
+
+\t<li>Round to the nearest representable constant if unable to
+\t    represent a floating-point or complex constant due to limits
+\t    on precision.</li>
+</ul>
+<p>
+These requirements apply both to literal constants and to the result
+of evaluating <a href="#Constant_expressions">constant
+expressions</a>.
+</p>
  
 <h2 id="Types">Types</h2>
  
@@ -3574,6 +3596,16 @@ int8(^1)   // same as int8(-2)\n ^int8(1)   // same as -1 ^ int8(1) = -2\n </pre>\n \n+<p>\n+Implementation restriction: A compiler may use rounding while\n+computing untyped floating-point or complex constant expressions; see\n+the implementation restriction in the section\n+on <a href="#Constants">constants</a>.  This rounding may cause a\n+floating-point constant expression to be invalid in an integer\n+context, even if it would be integral when calculated using infinite\n+precision.\n+</p>\n+\n <!--\n <p>\n <span class=\"alert\">\n```

## コアとなるコードの解説

このコミットは、Go言語の仕様書 `doc/go_spec.html` の2つの主要なセクションを変更しています。

### 1. 数値定数の実装制約の更新 (行 589-621)

*   **削除された行 (`-` で始まる行):**
    ```html
    -Implementation restriction: A compiler may implement numeric constants by choosing
    -an internal representation with at least twice as many bits as any machine type;
    -for floating-point values, both the mantissa and exponent must be twice as large.
    ```
    この部分は、数値定数の内部表現に関する以前の曖昧な記述を削除しています。「機械型（machine type）」という用語が不明確であり、浮動小数点数の仮数部と指数部が「2倍」というのも具体的な基準に欠けていました。

*   **追加された行 (`+` で始まる行):**
    ```html
    +Implementation restriction: Although numeric constants have arbitrary
    +precision in the language, a compiler may implement them using an
    +internal representation with limited precision.  That said, every
    +implementation must:
    +</p>
    +<ul>
    +\t<li>Represent integer constants with at least 256 bits.</li>
    +
    +\t<li>Represent floating-point constants, including the parts of
    +\t    a complex constant, with a mantissa of at least 256 bits
    +\t    and a signed exponent of at least 32 bits.</li>
    +
    +\t<li>Give an error if unable to represent an integer constant
    +\t    precisely.</li>
    +
    +\t<li>Give an error if unable to represent a floating-point or
    +\t    complex constant due to overflow.</li>
    +
    +\t<li>Round to the nearest representable constant if unable to
    +\t    represent a floating-point or complex constant due to limits
    +\t    on precision.</li>
    +</ul>
    +<p>
    +These requirements apply both to literal constants and to the result
    +of evaluating <a href="#Constant_expressions">constant
    +expressions</a>.
    ```
    この新しい記述は、数値定数の内部表現に関するコンパイラの要件を大幅に明確化しています。
    *   Go言語の定数が「任意精度」であるという原則を再確認しつつ、コンパイラが「限られた精度」で実装できることを認めています。
    *   しかし、その上で、すべての実装が満たすべき具体的な要件を箇条書きで示しています。
        *   整数定数には最低256ビット。
        *   浮動小数点数定数（および複素数定数の部分）には、仮数部が最低256ビット、符号付き指数部が最低32ビット。これにより、十分な精度と範囲が保証されます。
        *   整数定数が正確に表現できない場合はエラーを出すこと。
        *   浮動小数点数または複素数定数がオーバーフローにより表現できない場合はエラーを出すこと。
        *   浮動小数点数または複素数定数が精度制限により表現できない場合は、最も近い表現可能な定数に丸めること。
    *   これらの要件が、リテラル定数と定数式の評価結果の両方に適用されることを明記しています。

### 2. 型なし浮動小数点数式の丸めに関する新しい制約の追加 (行 3596-3606)

*   **追加された行 (`+` で始まる行):**
    ```html
    +<p>
    +Implementation restriction: A compiler may use rounding while
    +computing untyped floating-point or complex constant expressions; see
    +the implementation restriction in the section
    +on <a href="#Constants">constants</a>.  This rounding may cause a
    +floating-point constant expression to be invalid in an integer
    +context, even if it would be integral when calculated using infinite
    +precision.
    +</p>
    ```
    この新しい段落は、コンパイラが型なし浮動小数点数または複素数定数式を計算する際に、丸め処理を使用する可能性があることを明確にしています。これは、前述の「Constants」セクションで定義された実装制約に従います。
    重要なのは、この丸め処理によって、無限精度で計算すれば整数になるはずの浮動小数点数定数式が、整数コンテキストでは無効になる可能性があるという警告です。これは、コンパイラが内部的に浮動小数点数演算を行う際の現実的な制約を開発者に伝えるものであり、予期せぬ挙動を防ぐための重要な情報です。

これらの変更により、Go言語の数値定数に関する仕様がより堅牢になり、コンパイラの実装者とGoプログラマの双方にとって、その振る舞いがより明確で予測可能になりました。

## 関連リンク

*   Go言語のコミットページ: [https://github.com/golang/go/commit/9126c6570ce293761a4e5eefd61427902f291263](https://github.com/golang/go/commit/9126c6570ce293761a4e5eefd61427902f291263)
*   Go言語の変更リスト (CL): [https://golang.org/cl/5655049](https://golang.org/cl/5655049)
*   関連するGo言語のIssue: [https://github.com/golang/go/issues/2789](https://github.com/golang/go/issues/2789)
*   以前の変更リスト (再作業元): [https://golang.org/cl/5577068/](https://golang.org/cl/5577068/)

## 参考にした情報源リンク

*   Go言語の公式ドキュメント (Constants): [https://go.dev/ref/spec#Constants](https://go.dev/ref/spec#Constants) (このコミットによって変更された内容が反映されています)
*   Go言語のIssue 2789: `https://github.com/golang/go/issues/2789` (このコミットが修正した問題の詳細)
*   浮動小数点数に関する一般的な情報 (Wikipediaなど): [https://ja.wikipedia.org/wiki/%E6%B5%AE%E5%8B%95%E5%B0%8F%E6%95%B0%E7%82%B9%E6%95%B0](https://ja.wikipedia.org/wiki/%E6%B5%AE%E5%8B%95%E5%B0%8F%E6%95%B0%E7%82%B9%E6%95%B0)
*   任意精度演算に関する一般的な情報 (Wikipediaなど): [https://ja.wikipedia.org/wiki/%E4%BB%A3%E6%84%8F%E7%B2%BE%E5%BA%A6%E6%BC%94%E7%AE%97](https://ja.wikipedia.org/wiki/%E4%BB%A3%E6%84%8F%E7%B2%BE%E5%BA%A6%E6%BC%94%E7%AE%97)
*   Go言語の型なし定数に関する解説記事 (例: Go by Example - Constants): [https://gobyexample.com/constants](https://gobyexample.com/constants) (一般的な概念理解のため)
*   Go言語の仕様書における「Implementation restriction」の概念に関する一般的な理解# [インデックス 11851] ファイルの概要

このコミットは、Go言語の仕様書（`doc/go_spec.html`）における、型なし浮動小数点数（untyped floats）の実装に関する制約の記述を明確化するものです。特に、数値定数の精度、オーバーフロー時の挙動、および中間計算における丸め処理について、コンパイラの実装が満たすべき要件をより厳密に定義しています。これにより、Go言語の数値定数の振る舞いに関する曖昧さを解消し、異なるコンパイラ間での一貫性を高めることを目的としています。

## コミット

commit 9126c6570ce293761a4e5eefd61427902f291263 Author: Ian Lance Taylor iant@golang.org Date: Mon Feb 13 11:25:56 2012 -0800

spec: clarify implementation restrictions on untyped floats

Drop reference to "machine type."  Specify that integer
overflow must be an error.  Drop requirement that exponent
must be 128 bits--that's a lot.  Clarify that floating point
expressions may be rounded, including intermediate values.

This is a reworking of https://golang.org/cl/5577068/ .

Fixes #2789.

R=r, rsc, r, gri, ken, ken, iant
CC=golang-dev, remyoudompheng
https://golang.org/cl/5655049


## GitHub上でのコミットページへのリンク

[https://github.com/golang/go/commit/9126c6570ce293761a4e5eefd61427902f291263](https://github.com/golang/go/commit/9126c6570ce293761a4e5eefd61427902f291263)

## 元コミット内容

このコミットの元々の内容は、Go言語の仕様書において、型なし浮動小数点数に関する実装上の制約を明確にすることです。具体的には、以下の点が変更されています。

*   「マシンタイプ」への言及を削除。
*   整数オーバーフローがエラーとなるべきであることを明記。
*   指数部が128ビットであるという要件を削除（これは大きすぎるため）。
*   浮動小数点数式の計算において、中間値を含めて丸めが行われる可能性があることを明確化。

この変更は、以前の変更セット `https://golang.org/cl/5577068/` の再作業であり、Issue `#2789` を修正するものです。

## 変更の背景

このコミットの背景には、Go言語の数値定数、特に型なし浮動小数点数の扱いに関する仕様の曖昧さがありました。Go言語では、数値定数はデフォルトで「型なし（untyped）」であり、その精度は「任意精度（arbitrary precision）」であるとされています。しかし、実際のコンパイラ実装では、無限の精度を扱うことは不可能です。そのため、コンパイラがどの程度の精度を保証し、どのような場合にエラーを報告すべきか、また丸め処理をどのように行うべきかについて、明確なガイドラインが必要でした。

特に、`Fixes #2789` とあることから、このコミットはGo言語のIssue 2789を解決するために行われました。Issue 2789は、「`math.MaxFloat64` のような定数式が、コンパイラによって異なる結果を生成する可能性がある」という問題提起でした。これは、コンパイラが内部的に使用する数値表現の精度や丸め処理の仕方が統一されていないために発生していました。このコミットは、これらの実装上の差異を減らし、Goプログラムの移植性と予測可能性を高めることを目的としています。

## 前提知識の解説

### 型なし定数 (Untyped Constants)

Go言語における定数は、特定の型を持たない「型なし定数」として宣言できます。例えば、`const pi = 3.14159` のように宣言された `pi` は、最初は型を持ちません。この定数は、それが使用される文脈（例えば、`float64` 型の変数に代入される場合）に応じて、適切な型に変換されます。この「型なし」の性質により、定数はより柔軟に利用でき、コンパイラは計算時に可能な限り高い精度を維持できます。

### 任意精度 (Arbitrary Precision)

Go言語の仕様では、数値定数は「任意精度」を持つとされています。これは、理論上、定数の値が無限の精度で表現されることを意味します。しかし、実際のコンピュータシステムでは無限の精度を扱うことはできないため、コンパイラは内部的に有限の精度でこれらの定数を表現する必要があります。このコミットは、その「有限の精度」が満たすべき最低限の要件を定義しています。

### 浮動小数点数の表現 (Floating-Point Representation)

浮動小数点数は、通常、符号部、指数部（exponent）、仮数部（mantissa または significand）の3つの部分で構成されます。
*   **仮数部**: 数値の有効数字を表します。仮数部のビット数が多いほど、表現できる数値の精度が高くなります。
*   **指数部**: 小数点の位置を示し、数値の大きさを決定します。指数部のビット数が多いほど、表現できる数値の範囲（非常に小さい数から非常に大きい数まで）が広がります。

### オーバーフロー (Overflow) と 丸め (Rounding)

*   **オーバーフロー**: 数値が、そのデータ型で表現できる最大値を超えた場合に発生します。例えば、`int8` 型の変数が `127` を超える値を保持しようとするとオーバーフローします。
*   **丸め**: 浮動小数点数の計算結果が、そのデータ型で正確に表現できない場合に、最も近い表現可能な値に調整する処理です。丸めには様々な方法（例: 四捨五入、切り捨て、切り上げ）がありますが、Goの仕様では「最も近い表現可能な定数に丸める」ことが求められています。

### コンパイラの実装制約 (Implementation Restrictions)

プログラミング言語の仕様では、言語の振る舞いを定義しますが、具体的な実装方法についてはコンパイラに一定の自由度を与えることがあります。しかし、その自由度があまりに大きいと、異なるコンパイラ間でプログラムの振る舞いが異なってしまう可能性があります。このコミットは、Goの数値定数に関するコンパイラの実装制約をより厳密に定義することで、この問題を解決しようとしています。

## 技術的詳細

このコミットは、Go言語の仕様書 `doc/go_spec.html` の「Constants」セクションと、浮動小数点数に関する「Implementation restriction」セクションを修正しています。

### 1. 数値定数の内部表現に関する制約の明確化

変更前は、「コンパイラは、任意の機械型（machine type）の2倍以上のビット数を持つ内部表現で数値定数を実装してもよい」とされていました。これは曖昧であり、特に「機械型」という用語が何を指すのか不明確でした。

変更後は、この記述がより具体的かつ厳密になっています。

*   **整数定数**: 少なくとも256ビットで表現すること。
*   **浮動小数点定数（複素数定数の部分を含む）**: 仮数部が少なくとも256ビット、符号付き指数部が少なくとも32ビットで表現すること。

これらの具体的なビット数要件は、コンパイラがGoの任意精度定数を扱う際に、十分な精度と範囲を保証するための最低限の基準を提供します。特に、指数部が128ビットという以前の（おそらく非公式な）要件が削除され、より現実的な32ビットに緩和されたことは、実装の負担を軽減しつつ、十分な範囲を確保するためのバランスの取れた変更と言えます。

### 2. エラー報告の要件の追加

以前の仕様では、オーバーフローや精度不足の場合にコンパイラがどのように振る舞うべきかについて、明確な指示がありませんでした。

変更後は、以下のエラー報告要件が追加されました。

*   **整数定数**: 正確に表現できない場合はエラーを出すこと。
*   **浮動小数点数または複素数定数**: オーバーフローにより表現できない場合はエラーを出すこと。
*   **浮動小数点数または複素数定数**: 精度制限により表現できない場合は、最も近い表現可能な定数に丸めること。

これにより、コンパイラは数値定数の計算結果が表現範囲を超えたり、精度が失われたりした場合に、開発者に明確なフィードバックを提供することが義務付けられました。特に、丸め処理が許容されるケースと、エラーとして報告すべきケースが明確に区別されています。

### 3. 型なし浮動小数点数式の丸めに関する明確化

新しい段落が追加され、型なし浮動小数点数または複素数定数式の計算中に、コンパイラが丸めを使用する可能性があることが明記されました。

*   この丸めは、定数に関する実装制約（前述の「Constants」セクション）に従って行われます。
*   この丸めにより、無限精度で計算された場合には整数となるはずの浮動小数点数定数式が、整数コンテキストでは無効になる可能性があることが示されています。

これは、コンパイラが内部的に浮動小数点数計算を行う際に、中間結果を丸めることが許容されることを意味します。これにより、コンパイラの実装がより柔軟になり、パフォーマンスと精度のバランスを取ることが可能になります。同時に、開発者に対して、型なし浮動小数点数式の計算結果が、厳密な数学的精度とは異なる可能性があることを警告しています。

これらの変更は、Go言語の数値定数の振る舞いをより予測可能にし、異なるコンパイラ間での一貫性を高める上で非常に重要です。

## コアとなるコードの変更箇所

```diff
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -589,11 +589,33 @@ functions return and test for those values at run time.
 </p>
  
 <p>
-Implementation restriction: A compiler may implement numeric constants by choosing
-an internal representation with at least twice as many bits as any machine type;
-for floating-point values, both the mantissa and exponent must be twice as large.
+Implementation restriction: Although numeric constants have arbitrary
+precision in the language, a compiler may implement them using an
+internal representation with limited precision.  That said, every
+implementation must:
 </p>
+<ul>
+\t<li>Represent integer constants with at least 256 bits.</li>
+
+\t<li>Represent floating-point constants, including the parts of
+\t    a complex constant, with a mantissa of at least 256 bits
+\t    and a signed exponent of at least 32 bits.</li>
+
+\t<li>Give an error if unable to represent an integer constant
+\t    precisely.</li>
+
+\t<li>Give an error if unable to represent a floating-point or
+\t    complex constant due to overflow.</li>
+
+\t<li>Round to the nearest representable constant if unable to
+\t    represent a floating-point or complex constant due to limits
+\t    on precision.</li>
+</ul>
+<p>
+These requirements apply both to literal constants and to the result
+of evaluating <a href="#Constant_expressions">constant
+expressions</a>.
+</p>
  
 <h2 id="Types">Types</h2>
  
@@ -3574,6 +3596,16 @@ int8(^1)   // same as int8(-2)\n ^int8(1)   // same as -1 ^ int8(1) = -2\n </pre>\n \n+<p>\n+Implementation restriction: A compiler may use rounding while\n+computing untyped floating-point or complex constant expressions; see\n+the implementation restriction in the section\n+on <a href="#Constants">constants</a>.  This rounding may cause a\n+floating-point constant expression to be invalid in an integer\n+context, even if it would be integral when calculated using infinite\n+precision.\n+</p>\n+\n <!--\n <p>\n <span class=\"alert\">\n```

## コアとなるコードの解説

このコミットは、Go言語の仕様書 `doc/go_spec.html` の2つの主要なセクションを変更しています。

### 1. 数値定数の実装制約の更新 (行 589-621)

*   **削除された行 (`-` で始まる行):**
    ```html
    -Implementation restriction: A compiler may implement numeric constants by choosing
    -an internal representation with at least twice as many bits as any machine type;
    -for floating-point values, both the mantissa and exponent must be twice as large.
    ```
    この部分は、数値定数の内部表現に関する以前の曖昧な記述を削除しています。「機械型（machine type）」という用語が不明確であり、浮動小数点数の仮数部と指数部が「2倍」というのも具体的な基準に欠けていました。

*   **追加された行 (`+` で始まる行):**
    ```html
    +Implementation restriction: Although numeric constants have arbitrary
    +precision in the language, a compiler may implement them using an
    +internal representation with limited precision.  That said, every
    +implementation must:
    +</p>
    +<ul>
    +\t<li>Represent integer constants with at least 256 bits.</li>
    +
    +\t<li>Represent floating-point constants, including the parts of
    +\t    a complex constant, with a mantissa of at least 256 bits
    +\t    and a signed exponent of at least 32 bits.</li>
    +
    +\t<li>Give an error if unable to represent an integer constant
    +\t    precisely.</li>
    +
    +\t<li>Give an error if unable to represent a floating-point or
    +\t    complex constant due to overflow.</li>
    +
    +\t<li>Round to the nearest representable constant if unable to
    +\t    represent a floating-point or complex constant due to limits
    +\t    on precision.</li>
    +</ul>
    +<p>
    +These requirements apply both to literal constants and to the result
    +of evaluating <a href="#Constant_expressions">constant
    +expressions</a>.
    ```
    この新しい記述は、数値定数の内部表現に関するコンパイラの要件を大幅に明確化しています。
    *   Go言語の定数が「任意精度」であるという原則を再確認しつつ、コンパイラが「限られた精度」で実装できることを認めています。
    *   しかし、その上で、すべての実装が満たすべき具体的な要件を箇条書きで示しています。
        *   整数定数には最低256ビット。
        *   浮動小数点数定数（および複素数定数の部分）には、仮数部が最低256ビット、符号付き指数部が最低32ビット。これにより、十分な精度と範囲が保証されます。
        *   整数定数が正確に表現できない場合はエラーを出すこと。
        *   浮動小数点数または複素数定数がオーバーフローにより表現できない場合はエラーを出すこと。
        *   浮動小数点数または複素数定数が精度制限により表現できない場合は、最も近い表現可能な定数に丸めること。
    *   これらの要件が、リテラル定数と定数式の評価結果の両方に適用されることを明記しています。

### 2. 型なし浮動小数点数式の丸めに関する新しい制約の追加 (行 3596-3606)

*   **追加された行 (`+` で始まる行):**
    ```html
    +<p>
    +Implementation restriction: A compiler may use rounding while
    +computing untyped floating-point or complex constant expressions; see
    +the implementation restriction in the section
    +on <a href="#Constants">constants</a>.  This rounding may cause a
    +floating-point constant expression to be invalid in an integer
    +context, even if it would be integral when calculated using infinite
    +precision.
    +</p>
    ```
    この新しい段落は、コンパイラが型なし浮動小数点数または複素数定数式を計算する際に、丸め処理を使用する可能性があることを明確にしています。これは、前述の「Constants」セクションで定義された実装制約に従います。
    重要なのは、この丸め処理によって、無限精度で計算すれば整数になるはずの浮動小数点数定数式が、整数コンテキストでは無効になる可能性があるという警告です。これは、コンパイラが内部的に浮動小数点数演算を行う際の現実的な制約を開発者に伝えるものであり、予期せぬ挙動を防ぐための重要な情報です。

これらの変更により、Go言語の数値定数に関する仕様がより堅牢になり、コンパイラの実装者とGoプログラマの双方にとって、その振る舞いがより明確で予測可能になりました。

## 関連リンク

*   Go言語のコミットページ: [https://github.com/golang/go/commit/9126c6570ce293761a4e5eefd61427902f291263](https://github.com/golang/go/commit/9126c6570ce293761a4e5eefd61427902f291263)
*   Go言語の変更リスト (CL): [https://golang.org/cl/5655049](https://golang.org/cl/5655049)
*   関連するGo言語のIssue: [https://github.com/golang/go/issues/2789](https://github.com/golang/go/issues/2789)
*   以前の変更リスト (再作業元): [https://golang.org/cl/5577068/](https://golang.org/cl/5577068/)

## 参考にした情報源リンク

*   Go言語の公式ドキュメント (Constants): [https://go.dev/ref/spec#Constants](https://go.dev/ref/spec#Constants) (このコミットによって変更された内容が反映されています)
*   Go言語のIssue 2789: `https://github.com/golang/go/issues/2789` (このコミットが修正した問題の詳細)
*   浮動小数点数に関する一般的な情報 (Wikipediaなど): [https://ja.wikipedia.org/wiki/%E6%B5%AE%E5%8B%95%E5%B0%8F%E6%95%B0%E7%82%B9%E6%95%B0](https://ja.wikipedia.org/wiki/%E6%B5%AE%E5%8B%95%E5%B0%8F%E6%95%B0%E7%82%B9%E6%95%B0)
*   任意精度演算に関する一般的な情報 (Wikipediaなど): [https://ja.wikipedia.org/wiki/%E4%BB%A3%E6%84%8F%E7%B2%BE%E5%BA%A6%E6%BC%94%E7%AE%97](https://ja.wikipedia.org/wiki/%E4%BB%A3%E6%84%8F%E7%B2%BE%E5%BA%A6%E6%BC%94%E7%AE%97)
*   Go言語の型なし定数に関する解説記事 (例: Go by Example - Constants): [https://gobyexample.com/constants](https://gobyexample.com/constants) (一般的な概念理解のため)
*   Go言語の仕様書における「Implementation restriction」の概念に関する一般的な理解