Numeric literal semantics

[zygoloid]

This proposal provides semantics for numeric literals.

• Numeric literals have a type derived from their value, and can be converted to any type that can represent that value.

• Simple operations such as arithmetic that involve only literals also produce values of literal types.

• Literals implicitly convert to types that can represent them.

• The Carbon prelude provides:

  • An arbitrary-precision integer type BigInt.
  • A rational number type Rational(T:! Type) with constraints on T not yet determined.
  • A family of integer literal types, IntLiteral(N:! BigInt).
  • A family of real literal types, RealLiteral(N:! Rational(BigInt)).

Examples:

42 has type IntLiteral(42 as BigInt).
5.2 has type RealLiteral(5.2 as Rational(BigInt)).

// This is OK: the initializer is of the integer literal type with value
// -2147483648 despite being written as a unary `-` applied to a literal.
var x: i32 = -2147483648;

// This initializes y to 2^60.
var y: i64 = 1 << 60;

// This forms a rational literal whose value is one third, and converts it to
// the nearest representable value of type `f64`.
var z: f64 = 1.0 / 3.0;

// This is an error: 300 cannot be represented in type `i8`.
var c: i8 = 300;

[davidstone]

I have more general thoughts, but I need to gather them and figure out exactly what to say. I'll probably do some discussing on Discord first and then post more comments here. Here are my thoughts so far:

My general direction is that I would want to consider fitting integer literals into a broader plan for integers in general. Some of the decisions we can make with how to handle integers makes some of these choices a bit more "obvious".

I have written a C++ integer library: https://bitbucket.org/davidstone/bounded_integer/ where the general idea is that users specify min and max values that the integer type can use (bounded::integer<0, 10> holds values between 0 and 10 inclusive). If we decide to go in that direction for integers, the "obvious" answer (but not the only answer) to integer literals is that they would be of type Integer<N, N> (for which my library provides an alias template bounded::constant_t<N> for types and bounded::constant<N> for values). These are unit types with no storage, much as outlined in this proposal.

[github-actions]

We triage inactive PRs and issues in order to make it easier to find active work. If this PR should remain active, please comment or remove the inactive label.
This PR is labeled inactive because the last activity was over 90 days ago. This PR will be closed and archived after 14 additional days without activity.

[github-actions]

We triage inactive PRs and issues in order to make it easier to find active work. If this PR should remain active or becomes active again, please reopen it.
This PR was closed and archived because there has been no new activity in the 14 days since the inactive label was added.

[chandlerc]

I'm generally happy with this direction. Mostly waiting for folks who've commented to have a chance to resolve comments based on updates to the document.

[jonmeow]

A couple more comments

(note, I think the - comment from before may be obsolete under the current doc)

[zygoloid]

I believe all review comments have been addressed.

[chandlerc]

LGTM!