tsmanner/cpp-gen - Change 6FA27FLNKYSKFHX7IJTITDYWHUYYFYDEYF24SPWZF22OXCGLI3EAC

Made Term a variadic so that a chain of member accesses and functions can be represented as a single Term.

Created by BZRjFpe4yWcELV5q9m5goQecQ5GyKG6yp24mWXjq2gpf on July 7, 2024

6FA27FLNKYSKFHX7IJTITDYWHUYYFYDEYF24SPWZF22OXCGLI3EAC

Dependencies

In channels

main

Change contents

Insertion in src/main.cpp at line 1 [3.50]
[3.50]
[3.51]
```
#include <bitset>
```
Insertion in src/main.cpp at line 4 [3.50]
[3.89]
[3.89]
```
#include <tuple>
#include <type_traits>
```
Replacement in src/main.cpp at line 12 [3.50]
B:BD[3.443] → [3.443:459]
```
template <auto>
```
[3.443]
[3.459]
```
template <auto ...>
```

Replacement in src/main.cpp at line 15 [3.50]

B:BD[3.473] → [3.473:526]

template <typename _T, typename _V, _V(_T::*_field)>

[3.473]

[3.526]

// Single item: field (member or method) of _T.
template <typename _T, typename _R, _R(_T::*_field)>

Replacement in src/main.cpp at line 18 [3.50]

B:BD[3.548] → [2.0:22]

  using Operand = _T;

[3.548]

[2.22]

  using Operand = std::decay_t<_T>;
  using Result = std::decay_t<std::conditional_t<
    std::is_function_v<_R>,
    std::invoke_result_t<decltype(_field), _T>,
    _R
  >>;

Replacement in src/main.cpp at line 25 [3.50]

B:BD[2.23] → [2.23:112]

  static constexpr
  _V const &get(Operand const &operand) {
    return operand.*_field;

[2.23]

[2.112]

  constexpr
  Result const &operator()(Operand const &operand) const {
    if constexpr (std::is_function_v<_R>) {
      return (operand.*_field)();
    } else {
      return operand.*_field;
    }

Replacement in src/main.cpp at line 35 [3.50]

B:BD[3.552] → [3.552:631]

B:BD[3.631] → [2.117:139]

template <typename _T, typename _V, _V(_T::*_method)()>
struct Term<_method> {
  using Operand = _T;

[3.552]

[2.139]

// Single item: function of _T.
template <typename _T, typename _R, _R(*_function)(_T &)>
struct Term<_function> {
  using Operand = std::decay_t<_T>;
  using Result = std::decay_t<_R>;

Replacement in src/main.cpp at line 41 [3.50]

B:BD[2.140] → [2.140:228]

  static constexpr
  _V const &get(Operand &operand) {
    return (operand.*_method)();

[2.140]

[2.228]

  constexpr
  Result const &operator()(Operand const &operand) const {
    return _function(operand);
  }
  constexpr
  Result const &operator()(Operand &operand) const {
    return _function(operand);

Replacement in src/main.cpp at line 52 [3.50]

B:BD[3.635] → [3.635:720]

B:BD[3.720] → [2.233:255]

template <typename _T, typename _V, _V(_T::*_method)() const>
struct Term<_method> {
  using Operand = _T;

[3.635]

[2.255]

// Multiple items: recursively forward the result of the first term to the remaining ones.
template <auto _head, auto ..._tail>
struct Term<_head, _tail...> {
  using Operand = std::decay_t<typename Term<_head>::Operand>;
  using Result = typename Term<_tail...>::Result;

Replacement in src/main.cpp at line 58 [3.50]

B:BD[2.256] → [2.256:350]

  static constexpr
  _V const &get(Operand const &operand) {
    return (operand.*_method)();

[2.256]

[2.350]

  constexpr
  Result const &operator()(Operand const &operand) const {
    return Term<_tail...>{}(Term<_head>{}(operand));
  }
  constexpr
  Result const &operator()(Operand &operand) const {
    return Term<_tail...>{}(Term<_head>{}(operand));

Insertion in src/main.cpp at line 68 [3.50]

[3.723]


template <typename _L, typename _R>
struct Equal {
 static_assert(std::is_same_v<typename _L::Operand, typename _R::Operand>);
  using Operand = std::decay_t<typename _L::Operand>;
  using Result = bool;

Replacement in src/main.cpp at line 78 [3.50]

B:BD[3.724] → [3.724:807]

B:BD[3.807] → [2.355:377]

template <typename _T, typename _V, _V(*_function)(_T &)>
struct Term<_function> {
  using Operand = _T;

[3.724]

[2.377]

  constexpr
  Result operator()(Operand const &operand) const {
    return _L{}(operand) == _R{}(operand);
  }

Replacement in src/main.cpp at line 83 [3.50]

B:BD[2.378] → [2.378:468]

  static constexpr
  _V const &get(Operand &operand) {
    return (operand.*_function)();

[2.378]

[2.468]

  constexpr
  Result operator()(Operand &operand) const {
    return _L{}(operand) == _R{}(operand);

Replacement in src/main.cpp at line 89 [3.50]

B:BD[3.811] → [3.811:900]

B:BD[3.900] → [2.473:495]

template <typename _T, typename _V, _V(*_function)(_T const &)>
struct Term<_function> {
  using Operand = _T;

[3.811]

[3.1104]


template <auto ..._l, auto ..._r>
constexpr
Equal<Term<_l ...>, Term<_r ...>> operator==(Term<_l ...>, Term<_r ...>) {
  return {};
}
// std::get helper
namespace detail {
template <std::size_t, typename>
struct std_get_f;

Insertion in src/main.cpp at line 104 [3.50]

[3.1105]

[2.496]

template <std::size_t _i, typename ..._Ts>
struct std_get_f<_i, std::tuple<_Ts...>> {
  using Function =
    std::tuple_element_t<_i, std::tuple<_Ts...>> const &(*)(std::tuple<_Ts...> const &);

Replacement in src/main.cpp at line 110 [3.50]

B:BD[2.515] → [2.515:592]

∅:D[2.592] → [3.1226:1230]

B:BD[3.1226] → [3.1226:1230]

  _V const &get(Operand const &operand) {
    return (operand.*_function)();
  }

[2.515]

[3.1230]

  auto value =
    static_cast<Function>(&std::get<_i, _Ts...>);

Insertion in src/main.cpp at line 114 [3.50]
[3.1234]
[3.1234]
```
} // namespace detail
```

Replacement in src/main.cpp at line 116 [3.50]

B:BD[3.1235] → [2.593:712]

template <typename _L, typename _R>
struct Equal {
  using L = typename _L::Operand;
  using R = typename _R::Operand;

[3.1235]

[2.712]

template <std::size_t _i, typename _T>
constexpr auto std_get =
  detail::std_get_f<_i, _T>::value;
//
// A list of constraints
//

Replacement in src/main.cpp at line 125 [3.50]

B:BD[2.713] → [2.713:807]

∅:D[2.807] → [3.1354:1358]

B:BD[3.1354] → [3.1354:1358]

  static constexpr
  bool test(L const &l, R const &r) {
    return _L::get(l) == _R::get(r);
  }

[2.713]

[3.1358]

template <auto ..._constraints>
struct Constraints {
  static_assert((std::is_same_v<bool, typename std::decay_t<decltype(_constraints)>::Result> && ...));
  using Minterm = std::bitset<sizeof...(_constraints)>;

Replacement in src/main.cpp at line 131 [3.50]

B:BD[2.809] → [2.809:1008]

// TODO: How do you handle references to subobjects?  What if a
//       class has a field that is a class and you want to solve
//       for that subfield but only within the context of the parent?

[2.809]

[3.1361]


//
//
// Userland!
//
//

Insertion in src/main.cpp at line 141 [3.50]
[3.1362]
[3.1362]
```
// Foo
```
Insertion in src/main.cpp at line 148 [3.50]
[3.1412]
[3.1412]
```
// Bar
```
Insertion in src/main.cpp at line 157 [3.50]
[3.1566]
[3.1566]
```
// Aggregate
```

Insertion in src/main.cpp at line 159 [3.50]

[3.1567]

struct Aggregate {
  Foo foo;
  Bar bar;
};
constexpr
auto aggFooValue =
  Term<&Aggregate::foo, &Foo::value>{};
constexpr
auto aggBarValue =
  Term<&Aggregate::bar, &Bar::value>{};
constexpr
auto fooEqBar =
  aggFooValue == aggBarValue;
// Pair of Foo
using FooFoo = std::pair<Foo, Foo>;
constexpr
auto fooEqFoo =
  Term<&FooFoo::first, &Foo::value>{} == Term<&FooFoo::second, &Foo::value>{};
// Tuple of Foo
using FooFooFoo = std::tuple<Foo, Foo, Foo>;
constexpr
auto fooEqFoo2 =
  Term<std_get<0, FooFooFoo>, &Foo::value>{} == Term<std_get<1, FooFooFoo>, &Foo::value>{};
//
// Main
//

Replacement in src/main.cpp at line 204 [3.50]

B:BD[3.1656] → [2.1009:1093]

  std::cout << Equal<Term<&Foo::value>, Term<&Bar::value>>::test(foo, bar) << '\n';

[3.1656]

[3.1711]

  std::cout << fooEqBar({foo, bar}) << ' ' << fooEqFoo({foo, Foo{"foo2", 4}}) << ' ' << fooEqFoo2({Foo{"foo0", 0}, Foo{"foo1", 0}, Foo{"foo2", 0}}) << '\n';

Replacement in src/main.cpp at line 206 [3.50]

B:BD[3.1728] → [2.1094:1178]

  std::cout << Equal<Term<&Foo::value>, Term<&Bar::value>>::test(foo, bar) << '\n';

[3.1728]

[3.1783]

  std::cout << fooEqBar({foo, bar}) << ' ' << fooEqFoo({foo, Foo{"foo2", 5}}) << ' ' << fooEqFoo2({Foo{"foo0", 0}, Foo{"foo1", 1}, Foo{"foo2", 2}}) << '\n';