Share your experiences writing in Cpp2!

[JohelEGP]

From short thoughts to long articles hosted elsewhere.

[JohelEGP]

I have a group of modules layered like the STL,
which I intend to use in games or simulations.
At the lowest level, it has number concepts.
On top of that are quantities, represented with the quantity template.
Then I wrap those in geometries.

Here is the central piece, quantity, in Cpp1,
as it was before I rewrote it in Cpp2.

Cpp1 quantity

export template<const auto& R, number N> requires quantity_reference<std::remove_cvref_t<decltype(R)>> struct quantity {
  using number_type = N;

  N number;
  static constexpr const auto& reference = R;

  template<std::constructible_from<const N&> N2>
  [[nodiscard]] constexpr explicit(not std::convertible_to<const N&, N2>) operator quantity<R, N2>() const {
    return {convert_to<N2>(number)};
  }
  template<std::equality_comparable_with<N> N2>
  [[nodiscard]] constexpr bool operator==(const quantity<R, N2>& r) const {
    return number == r.number;
  }
  template<std::three_way_comparable_with<N> N2>
  [[nodiscard]] constexpr std::compare_three_way_result_t<N, N2> operator<=>(const quantity<R, N2>& r) const {
    return number <=> r.number;
  }

  constexpr quantity& operator++() & requires number_line<N> { return void(++number), *this; }
  constexpr quantity& operator--() & requires number_line<N> { return void(--number), *this; }
  [[nodiscard]] constexpr quantity operator++(int) & requires number_line<N> { return {number++}; }
  [[nodiscard]] constexpr quantity operator--(int) & requires number_line<N> { return {number--}; }

  template<compound_relative_quantity_for<N> N2> constexpr quantity& operator+=(const quantity<R, N2>& r) & {
    return void(number += r.number), *this;
  }
  template<compound_relative_quantity_for<N> N2> constexpr quantity& operator-=(const quantity<R, N2>& r) & {
    return void(number -= r.number), *this;
  }

  template<relative_quantity_for<N> N2>
  [[nodiscard]] constexpr quantity<R, decltype(N{} + N2{})> operator+(const quantity<R, N2>& r) const {
    return {number + r.number};
  }
  template<relative_quantity_for<N> N2>
  [[nodiscard]] constexpr quantity<R, decltype(N{} - N2{})> operator-(const quantity<R, N2>& r) const {
    return {number - r.number};
  }

  template<negatable_number N2 = N> [[nodiscard]] constexpr quantity<R, decltype(-N2{})> operator-() const {
    return {-number};
  }

  constexpr quantity& operator*=(const compound_scalar_for<N> auto& s) & { return void(number *= s), *this; }
  constexpr quantity& operator/=(const compound_scalar_for<N> auto& s) & { return void(number /= s), *this; }
  constexpr quantity& operator%=(const compound_modulus_for<N> auto& d) & { return void(number %= d), *this; }
  template<compound_modulus_for<N> N2> constexpr quantity& operator%=(const quantity<R, N2>& r) & {
    return void(number %= r.number), *this;
  }

  [[nodiscard]] friend constexpr auto operator*(const quantity& q, const scalar_for<N> auto& s)
    -> quantity<R, decltype(N{} * s)> {
    return {q.number * s};
  }
  [[nodiscard]] friend constexpr auto operator*(const scalar_for<N> auto& s, const quantity& q)
    -> quantity<R, decltype(s * N{})> {
    return {s * q.number};
  }

  [[nodiscard]] constexpr auto operator/(const scalar_for<N> auto& s) const -> quantity<R, decltype(N{} / s)> {
    return {number / s};
  }
  template<std::common_with<N> N2>
  [[nodiscard]] constexpr decltype(N{} / N2{}) operator/(const quantity<R, N2>& r) const {
    return number / r.number;
  }

  [[nodiscard]] constexpr auto operator%(const modulus_for<N> auto& m) const -> quantity<R, decltype(N{} % m)> {
    return {number % m};
  }
  template<modulus_for<N> N2>
  [[nodiscard]] constexpr quantity<R, decltype(N{} % N2{})> operator%(const quantity<R, N2>& m) const {
    return {number % m.number};
  }
};

I rewrote quantity from scratch in Cpp2,
trying to improve the design along the way.
Here is what I currently have.

Cpp2 quantity

export quantity: @struct <Name, Unit, Number: type> type
  requires qty::name<Name> && qty::unit<Unit> && number<Number> = {
  name_type: type   == Name;
  unit_type: type   == Unit;
  number_type: type == Number;

  name: QTY_NAME_MEM_TYPE;
  number: number_type;
  unit: QTY_UNIT_MEM_TYPE;

  unsafe_rename: <NewName> (this, new_name: NewName) -> quantity<NewName, Unit, Number>
    requires NewName::specializes<Name>::value || std::same_as<Name, qty::dimensionless> = (new_name, number, unit);
  renumber: <NewNumber> (this) -> quantity<Name, Unit, NewNumber> requires std::convertible_to<Number, NewNumber> =
    (name, number as NewNumber, unit);
  unsafe_renumber: <NewNumber> (this) -> quantity<Name, Unit, NewNumber>
    requires std::constructible_from<NewNumber, Number> = (name, cpp2::unsafe_narrow<NewNumber>(number), unit);
  reunit: <NewUnit> (this, new_unit: NewUnit) -> quantity<Name, NewUnit, Number> = (name, number, new_unit);

  from: <Origin> (this, o: Origin) -> qty::point<Origin, Name, Unit, Number> = (o, this);

  operator<=>: (this, that) -> _;

  operator++: (inout this) -> forward quantity requires number_line<Number> = {
    _ = number++;
    return this;
  }
  operator--: (inout this) -> forward quantity requires number_line<Number> = {
    _ = number--;
    return this;
  }
  operator++: (inout this, _: int) -> quantity requires number_line<Number> = {
    res := this;
    _ = this++;
    return res;
  }
  operator--: (inout this, _: int) -> quantity requires number_line<Number> = {
    res := this;
    _ = this--;
    return res;
  }

  operator+=: <OtherNumber> (inout this, r: quantity<Name, Unit, OtherNumber>) -> forward quantity
    requires compound_relative_quantity_for<OtherNumber, Number> = {
    number += r.number;
    return this;
  }
  operator-=: <OtherNumber> (inout this, r: quantity<Name, Unit, OtherNumber>) -> forward quantity
    requires compound_relative_quantity_for<OtherNumber, Number> = {
    number -= r.number;
    return this;
  }

  operator+: <OtherNumber> (this, r: quantity<Name, Unit, OtherNumber>) -> _
    requires relative_quantity_for<OtherNumber, Number> = :quantity = (name, number + r.number, unit);
  operator-: <OtherNumber> (this, r: quantity<Name, Unit, OtherNumber>) -> _
    requires relative_quantity_for<OtherNumber, Number> = :quantity = (name, number - r.number, unit);

  operator-: (this) -> _ requires negatable_number<Number> = :quantity = (name, -number, unit);

  operator*=: <OtherNumber> (inout this, r: OtherNumber) -> forward quantity
    requires compound_scalar_for<OtherNumber, Number> = {
    number *= r;
    return this;
  }
  operator/=: <OtherNumber> (inout this, r: OtherNumber) -> forward quantity
    requires compound_scalar_for<OtherNumber, Number> = {
    number /= r;
    return this;
  }
  operator%=: <OtherNumber> (inout this, r: OtherNumber) -> forward quantity
    requires compound_modulus_for<OtherNumber, Number> = {
    number %= r;
    return this;
  }
  operator%=: <OtherNumber> (inout this, r: quantity<Name, Unit, OtherNumber>) -> forward quantity
    requires compound_modulus_for<OtherNumber, Number> = this % r.number;

  operator/: <OtherNumber> (this, r: quantity<Name, Unit, OtherNumber>) -> qty::one::quantity<decltype(
    number / r.number)> requires std::common_with<OtherNumber, Number> = qty::one(number / r.number);
  operator/: <OtherNumber> (this, r: OtherNumber) -> _
    requires scalar_for<OtherNumber, Number> = :quantity = (name, number / r, unit);
  operator%: <OtherNumber> (this, r: OtherNumber) -> _
    requires modulus_for<OtherNumber, Number> = :quantity = (name, number % r, unit);
  operator%: <OtherNumber> (this, r: quantity<Name, Unit, OtherNumber>) -> _ requires modulus_for<OtherNumber, Number> =
    this % r.number;

  operator*: <OtherNumber> (this, r: OtherNumber) -> _
    requires scalar_for<OtherNumber, Number> = :quantity = (name, number * r, unit);
}
export operator*: <Name, Unit, Number, OtherNumber> (l: OtherNumber, r: quantity<Name, Unit, Number>) -> _
  requires scalar_for<OtherNumber, Number> = r * l;

I'm not done yet (e.g., <=> is homogeneous rather than heterogeneous).
When I first started rewriting it, the member functions were unconstrained and homogeneous.

Cpp2 snapshot of an homogeneous and unconstrained quantity

export quantity: @struct @ordered <Name, Unit, Number: type> type = {
  name_type: type   == Name;
  unit_type: type   == Unit;
  number_type: type == Number;
  name: JEGP_QTY_NAME_MEM_TYPE = missing_name_in_initializer(this);
  number: Number               = missing_number_in_initializer(this);
  unit: JEGP_QTY_UNIT_MEM_TYPE = missing_unit_in_initializer(this);

  operator+=: (inout this, that) -> forward quantity = {
    _ = number += that.number;
    return this;
  }
  operator-=: (inout this, that) -> forward quantity = {
    _ = number -= that.number;
    return this;
  }

  operator+: (this, that) -> quantity = (name, number + that.number, unit);
  operator-: (this, that) -> quantity = (name, number - that.number, unit);

  operator*: (this, r: Number) -> quantity = (name, number * r, unit);
  operator/: (this, r: Number) -> quantity = (name, number / r, unit);
}
export to: <Number> (forward q: quantity) -> _ //
  = :quantity = (q.name, cpp2::unsafe_narrow<Number>(forward q.number), q.unit);

As I go back to improve quantity, I find it much easier to read than the Cpp1 version.
Its structure stand out more because the names that make it up come first.
There's little ceremony for introducing template parameters (and even less soon).
Coupled with correct defaults, the code is succinct.

Granted, some of these issues can be amortized in Cpp1 with proper formatting.
But you still lose real state in Cpp1:

// Cpp1.
template<class T> [[nodiscard]] T // One extra line.
f();
// Cpp2.
f: <T> () -> T;

// Cpp1.
template<class T>  // One extra line.
[[nodiscard]] T
g();
// Cpp2.
g: <T> ()
  -> T;

Where Cpp2 has fallen short, most of the time I have opened issues
(for quantity in particular, there's #583 (comment) and #654).
Although I'm still waiting on the constexpr story for Cpp2.
I also use this to have [[no_unique_address]] members:

#define QTY_NAME_MEM_TYPE [[no_unique_address]] name_type

And because there's no way of spelling post-increment or post-decrement,
the body of those overloads in Cpp2 have to be longer than their Cpp1 version:

  // Cpp1.
  [[nodiscard]] constexpr quantity operator++(int) & requires number_line<N> { return {number++}; }
  // Cpp2 is:
  operator++: (inout this, _: int) -> quantity requires number_line<Number> = {
    res := this;
    _ = this++;
    return res;
  }
  // Cpp2 could have been (where `INC(x)` is Cpp1 `x++`):
  operator++: (inout this, _: int) -> quantity requires number_line<Number> = (name, INC(number), unit);

When rewriting the tests for the number_line concept,
the regularity of this parameters helped me notice that
the expected and actual cause of success of a test case differed.

struct number_line_5 : number_line<number_line_5> {
  number_line_5& operator++() &;
  number_line_5& operator++(int);
};
struct number_line_6 : number_line<number_line_6> {
  number_line_6& operator++() &;
  number_line_6& operator++(int) &;
};
static_assert(not waarudo::number_line<number_line_5>, "No `lvalue++`.");
static_assert(not waarudo::number_line<number_line_6>, "The type of `lvalue++` is not `number_line_6`.");

This is how I rewrote it in Cpp2.

number_line_5: @struct type = {
  this: number_line<number_line_5>;
  operator++: (inout this) -> forward number_line_5 = this;
  operator++: (this, _: int) -> forward number_line_5 = as_lvalue(this);
}
number_line_6: @struct type = {
  this: number_line<number_line_6>;
  operator++: (inout this) -> forward number_line_6 = this;
  operator++: (inout this, _: int) -> forward number_line_6 = this;
}
static_assert(not waarudo::number_line<number_line_5>, "No `lvalue++`.");
static_assert(not waarudo::number_line<number_line_6>, "The type of `lvalue++` is not `number_line_6`.");

These test cases actually pass for the same reason, unlike the assertions document.
At some point I refactored the Cpp1 for a similar inconsistency,
and I was aware that this result probably wasn't all that correct.
The Cpp2 rewrite helped me notice that only the type of this differed.
Changing the return type of number_line_5::operator++ to be number_line_5
makes it actually model number_line and the test not pass.
Turns out that because concepts are structural and not nominal,
the post-increment constraint is satisfied even with in this.

[JohelEGP]

lefticus/cpp_weekly#297 presents a comparison in Cpp1
between using default initialization and initializing later
vs. initializing a const variable with an IILE.
I presented the equivalent of the former using Cpp2,
and here's the diff with the latter:

How does the Cpp2 equivalent of the Cpp1 inefficient way
compares to the better Cpp1 version?
See https://cpp2.godbolt.org/z/4bnG94TY4.

Here's the diff: https://godbolt.org/z/3K4dn4bqY.
It seems to add quite a few more things.

-- lefticus/cpp_weekly#297 (comment).

[AbhinavK00]

GCC seems to generate longer code though
https://cpp2.godbolt.org/z/Tf6rxEWr9

I hope it's a problem with gcc only

[JohelEGP]

The diff with GCC 13: https://godbolt.org/z/M7849YzWM.

[AbhinavK00]

So, I guess it's a version problem.