On Monday, 16 May 2016 at 15:11:21 UTC, Daniel Murphy wrote:
On 16/05/2016 10:37 PM, Walter Bright wrote:
Some counter points:
1. Go uses 256 bit soft float for constant folding.
Then we should use 257 bit soft float!
Go uses at least 288 bits!!!!! (256 bits mantissa and 32 bits
exponent).
But Go has a completely different take on constant expressions,
and much better than the C family that D belongs to (but still
far from ideal). From https://golang.org/ref/spec:
«
Numeric constants represent exact values of arbitrary precision
and do not overflow. Consequently, there are no constants
denoting the IEEE-754 negative zero, infinity, and not-a-number
values.
Constants may be typed or untyped. Literal constants, true,
false, iota, and certain constant expressions containing only
untyped constant operands are untyped.
A constant may be given a type explicitly by a constant
declaration or conversion, or implicitly when used in a variable
declaration or an assignment or as an operand in an expression.
It is an error if the constant value cannot be represented as a
value of the respective type. For instance, 3.0 can be given any
integer or any floating-point type, while 2147483648.0 (equal to
1<<31) can be given the types float32, float64, or uint32 but not
int32 or string.
An untyped constant has a default type which is the type to which
the constant is implicitly converted in contexts where a typed
value is required, for instance, in a short variable declaration
such as i := 0 where there is no explicit type. The default type
of an untyped constant is bool, rune, int, float64, complex128 or
string respectively, depending on whether it is a boolean, rune,
integer, floating-point, complex, or string constant.
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:
Represent integer constants with at least 256 bits.
Represent floating-point constants, including the parts of a
complex constant, with a mantissa of at least 256 bits and a
signed exponent of at least 32 bits.
Give an error if unable to represent an integer constant
precisely.
Give an error if unable to represent a floating-point or complex
constant due to overflow.
Round to the nearest representable constant if unable to
represent a floating-point or complex constant due to limits on
precision.
These requirements apply both to literal constants and to the
result of evaluating constant expressions.
»
See also https://golang.org/ref/spec#Constant_expressions
