ipapadop / deferred Goto Github PK

A switch-case (series of if-else-if) is needed.

Proposed mechanism:

  auto var = deferred::variable<int>();
  auto ex  = deferred::switch_(var,
                              deferred::default_("unknown"),
                              deferred::case_(10, [] { return "10"; }),
                              deferred::case_(12, [] { return "12"; }));
  auto ex2 =  deferred::switch_(ex, deferred::case_(11, [] { return "11"; }));

The functionality appears to be similar.

E.g.,

auto i = variable<int>();
auto loop = for_(i, i != 10, ++i, [&](auto&& i) { std::cout << i << '\n'; });
i = 2;
loop();

Implementation is similar to while.

It also needs a function make_function_object

The information is duplicated, iterating over the subexpression types should tell if something is a constant expression.

The following code will have issues:

auto f()
{
  auto c = constant(10);
  auto c2 = c * 2;
  return c2;
}

since c will be stored as a reference in decltype(c2).

The lifetime of objects in valarray's expressions is not properly extended (GCC/clang, the expression template mechanism keeps expressions as const&).

A potential solution is to detect deferred expressions that fail std::is_move_assignable and std::is_copy_assignable and store them in deferred::expression_

Support the following

auto ex = while_([] { return condition(); }, [] { expression(); });
ex();

If a deferred expression had the ability to call itself with some special keyword, then it should be possible to implement recursion.

Remove ref / rref from the type should happen at the call-site.