About naming and usability

[YarikTH]

Current names for classes are:

• context - reactive engine and graph holder
• var_signal - reactive value that can be imperatively assigned
• signal - reactive value that automatically calculated using other singlals/var_singnals using formulae
• observer - a way to get notified about some changes in reactive nodes
• event_source ( potentially ported from c++react) - event node that allows to imperatively send events
• events (potentially ported from c++react) - transformed set of events from other events/event_sources using formulae

They are more or less the same as in the original c++react.

In the urp I've seen a way more expressive and elegant naming:

• value (var_signal)
• function (signal)
• trigger (event_source)
• event (events)

There are no context and observer class analogues in urp.

observable:

• value (var_signal)
• expression (signal)

Also, I've seen another expressive name for event_source -- emitter.

Naming and syntax sugar is very important to make usage of the library pleasant and intuitive.

Let's compare hello world examples from different libraries:

ureact:

ureact::context ctx;

ureact::var_signal<int> b = ctx.make_var( 1 );
ureact::var_signal<int> c = ctx.make_var( 2 );
ureact::signal<int> a = b + c;

CHECK( a.value() == 3 );
b <<= 10;
CHECK( a.value() == 12 );

c++react

using namespace react;
REACTIVE_DOMAIN( D, sequential )
USING_REACTIVE_DOMAIN( D )

VarSignalT<int> b = MakeVar<D>( 1 );
VarSignalT<int> c = MakeVar<D>( 2 );
SignalT<int> a = b + c;

CHECK( a.Value() == 3 );
b <<= 10;
CHECK( a.Value() == 12 );

observable

observable::value<int> b{ 1 };
observable::value<int> c{ 2 };

observable::expression<int, observable::immediate_evaluator> a( b + c );

CHECK( a.get() == 3 );
b = 10;

CHECK( a.get() == 12 );

urp:

using namespace usingstdcpp2019;

urp::value b = 1;
urp::value c = 2;
urp::function a = b + c;

CHECK( a.get() == 3 );
b = 10;
CHECK( a.get() == 12 );

urp is definitely a winner here (with some cheating of using c++17 features).

To achieve the same way of coolness first of all need to make some kind of default context and make c++17 example:

ureact::var_signal b = 1;
ureact::var_signal c = 2;
ureact::signal a = b + c;

CHECK( a.value() == 3 );
b <<= 10;
CHECK( a.value() == 12 );

Then need naming change. For example like this:

ureact::value b = 1;
ureact::value c = 2;
ureact::expression a = b + c;

CHECK( a.get() == 3 );
b <<= 10;
CHECK( a.get() == 12 );

I personally like <<= operator because it definitely says that there is something unusual happening here. This is not a free operation.

Namespace ureact is quite verbose at my taste, 3 letters long names are better (std, fmt, urp), but it is not a big problem in general.

Another beautiful masterpiece that worth borrowing from urp is a function piping.

urp::value x = 0;

auto f=[](int x){return x+1;};
auto g=[](int x){return 2*x;};
auto h=[](int x){return x*(x+1);};

urp::function z = x | f | g | h;

Ureact has inherited operator ->* from c++react, but it is way less expressive:

ureact::context ctx;

auto f=[](int x){return x+1;};
auto g=[](int x){return 2*x;};
auto h=[](int x){return x*(x+1);};

ureact::var_signal<int> x = ctx.make_var( 0 );

ureact::signal<int> z = x ->* f ->* g ->* h;

But it is definitely more universal because allows the joining of 2 inputs into a single function:

ureact::context ctx;

auto f=[](int x){return x+1;};
auto g=[](int x){return 2*x;};
auto h=[](int x, int y){return x*y;};

ureact::var_signal<int> x = ctx.make_var( 0 );

ureact::signal<int> z = (x ->* f ->* g,    x) ->* h;

Changing operator ->* is definitely worth it.

[joaquintides]

You can have 2-input joining with operator|

namespace usingstdcpp2019::urp{
    
namespace detail{
    
template<typename T,typename U>
struct function_pair
{
  template<typename F>
  auto operator|(F f)&&
  {
    return urp::function{f,std::forward<T>(x),std::forward<U>(y)};
  }
  
  T x;
  U y;
};

} /* namespace detail */

template<
  typename T,typename U,
  std::enable_if_t<detail::is_function_or_value<T>>* =nullptr,
  std::enable_if_t<detail::is_function_or_value<U>>* =nullptr
>
detail::function_pair<T&&,U&&> operator,(T&& x,U&& y)
{
  return {std::forward<T>(x),std::forward<U>(y)};
}
    
} /* namespace usingstdcpp2019::urp */

#include <iostream>

int main()
{
  using namespace usingstdcpp2019;
  
  auto times3=[](auto x){return 3*x;};
  auto mult=[](auto x,auto y){return x*y;};
  
  urp::value x=0,y=0;
  urp::function z=(x,y|times3)|mult;
  x=2;
  y=3;
  std::cout<<z.get()<<"\n"; // prints 18
}

[YarikTH]

Good to know. Not so universal (signal_pack from c++react allows to join N signals), but maybe it is at least more performant. Todo for the benchmark.

[joaquintides]

Just to be clear, μrp, as originally written, does not support input joining with pipe syntax, my post merely was to show how such extension could be done. N-input is in principle doable as well, but urp::function does not do temporary composition (slide 27 of the presentation) for function arities greater than 2, so that'd have to be extended as well.

[YarikTH]

So, after a set of interface changes ureact become a little more beautiful.

• operator ->* is replaced with operator |
• var_signal is replaced with value
• signal::value() is replaced with ::get()
• signal is replaced with function

Now, ureact looks more like urp.

ureact::context ctx;

ureact::var_signal<int> b = ctx.make_var( 1 );
ureact::var_signal<int> c = ctx.make_var( 2 );
ureact::signal<int> a = b + c;

CHECK( a.value() == 3 );
b <<= 10;
CHECK( a.value() == 12 );

=>

ureact::context ctx;

ureact::value<int> b = ctx.make_value( 1 );
ureact::value<int> c = ctx.make_value( 2 );
ureact::function<int> a = b + c;

CHECK( a.get() == 3 );
b <<= 10;
CHECK( a.get() == 12 );

Optionally if we use c++17, the type can be omited:

ureact::value b = ctx.make_value( 1 );
ureact::value c = ctx.make_value( 2 );
ureact::function a = b + c;

But context is still required, so need to perform some more changes to achieve following sintax:

ureact::value b = 1;
ureact::value c = 2;
ureact::function a = b + c;