random usage in cpp2?

[feature-engineer]

Hi, I'm trying to convert this code to cpp2:

auto random_between_0_and_1() -> double {
    std::random_device rd;  
    std::mt19937 gen(rd()); 
    std::uniform_real_distribution<double> dist(0.0, 1.0); 

    return dist(gen);  
}

I encounter an error for the return dist(gen) line for the simpler case where I don't use static.

random_between_0_and_1: () -> double = {
    rd: std::random_device = ();
    gen: std::mt19937 = (rd());
    dist: std::uniform_real_distribution<double> = (0.0, 1.0);
    
    return dist(gen);
}

Doesn't compile due to the following error:

no match for call to ‘(std::uniform_real_distribution) (std::mersenne_twister_engine<long unsigned int, 32, 624, 397, 31, 2567483615, 11, 4294967295, 7, 2636928640, 15, 4022730752, 18, 1812433253>)’
[build] 40 | return dist(gen);
[build] | ~~~~~~~~~~ ^

[DyXel]

The issue you are having is due to the fact that Cpp2 automatically moves from definite last use:

random_between_0_and_1: () -> double = {
    rd: std::random_device = ();
    gen: std::mt19937 = (rd());
    dist: std::uniform_real_distribution<double> = (0.0, 1.0);
    
    return dist(gen); // <-- definite last use of `gen`, so its cpp2::move'd.
}

Usually, what you do in these cases is explicitly discard the new state of the object that was mutated. In order to do that, you'd need to create an intermediary variable:

random_between_0_and_1: () -> double = {
    rd: std::random_device = ();
    gen: std::mt19937 = (rd());
    dist: std::uniform_real_distribution<double> = (0.0, 1.0);
    r := dist(gen);
    _ = gen;
    return r;
}

However this is annoying since you introduce a temporary on top of having the discard explicitly. Instead, what you can do is use a named return value, which is only 1 extra line total (the explicit discard):

random_between_0_and_1: () -> (r: double) = {
    rd: std::random_device = ();
    gen: std::mt19937 = (rd());
    dist: std::uniform_real_distribution<double> = (0.0, 1.0);
    r = dist(gen);
    _ = gen;
}

[feature-engineer]

Another question:

What is wrong with this class:

Rand: <T: type> type = {
    engine_: std::mt19937;
    dist_: std::uniform_real_distribution<T>;
    upper_bound_: T;
    public operator=: (out this, upper_bound: T, seed: std::optional<ulong>) = {
        engine_ = (seed.or_else(:() -> std::optional<ulong> = std::make_optional(std::random_device()()); )*);
        dist_ = (0.0, upper_bound);
        upper_bound_ = upper_bound;
    }
    public operator(): (inout this) -> T = dist_(engine_); 
}

If I'm not using operator() but instead use a regular function (e.g. get), this works fine with:

l: std::vector<Eigen::Vector3d> = (1000);
r := Rand<double>(0.01, 0);
std::ranges::generate(l, :() = Eigen::Vector3d(r&$*.get(), r&$*.get(), r&$*.get()); );

But when I'm using the operator I get a bunch of errors:

error: no match for call to ‘(const std::ranges::__generate_fn) (std::vector<Eigen::Matrix<double, 3, 1> >&, BM_cumrot_mat(benchmark::State&)::<lambda()>)’
  271 |     std::ranges::generate(l, :() -> _ =  Eigen::Vector3d(r&$*(), r&$*(), r&$*()); );
      |     ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                              
In file included from /usr/include/c++/14.2.1/algorithm:63,
                 from /usr/include/cpp2util.h:257,
                 from /home/feature/projects/cpp2/ex1/build/_cppfront/main.cpp:6:
/usr/include/c++/14.2.1/bits/ranges_algo.h:947:7: note: candidate: ‘template<class _Out, class _Sent, class _Fp>  requires (input_or_output_iterator<_Out>) && (sentinel_for<_Sent, _Out>) && (copy_constructible<_Fp>) && ((invocable<_Fp&>) && (indirectly_writable<_Out, typename std::invoke_result<_Fp&>::type>)) constexpr _Out std::ranges::__generate_fn::operator()(_Out, _Sent, _Fp) const’
  947 |       operator()(_Out __first, _Sent __last, _Fp __gen) const
      |       ^~~~~~~~
/usr/include/c++/14.2.1/bits/ranges_algo.h:947:7: note:   candidate expects 3 arguments, 2 provided
/usr/include/c++/14.2.1/bits/ranges_algo.h:957:7: note: candidate: ‘template<class _Range, class _Fp>  requires (copy_constructible<_Fp>) && ((invocable<_Fp&>) && (output_range<_Range, typename std::invoke_result<_Fp&>::type>)) constexpr std::ranges::borrowed_iterator_t<_Range> std::ranges::__generate_fn::operator()(_Range&&, _Fp) const’
  957 |       operator()(_Range&& __r, _Fp __gen) const
      |       ^~~~~~~~
/usr/include/c++/14.2.1/bits/ranges_algo.h:957:7: note:   template argument deduction/substitution failed:
/usr/include/c++/14.2.1/bits/ranges_algo.h:957:7: note: constraints not satisfied
...
concepts: In substitution of ‘template<class _Range, class _Fp>  requires (copy_constructible<_Fp>) && ((invocable<_Fp&>) && (output_range<_Range, typename std::invoke_result<_Fp&>::type>)) constexpr std::ranges::borrowed_iterator_t<_Range> std::ranges::__generate_fn::operator()(_Range&&, _Fp) const [with _Range = std::vector<Eigen::Matrix<double, 3, 1> >&; _Fp = BM_cumrot_mat(benchmark::State&)::<lambda()>]’:
/home/feature/projects/cpp2/ex1/src/main.cpp2:271:26:   required from here
  271 |     std::ranges::generate(l, :() -> _ =  Eigen::Vector3d(r&$*(), r&$*(), r&$*()); );
      |     ~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~                              
/usr/include/c++/14.2.1/concepts:360:13:   required for the satisfaction of ‘invocable<_Fp&>’ [with _Fp = BM_cumrot_mat::._anon_943]
/usr/include/c++/14.2.1/concepts:360:25: note: the expression ‘is_invocable_v<_Fn, _Args ...> [with _Fn = BM_cumrot_mat::._anon_943&; _Args = {}]’ evaluated to ‘false’
  360 |     concept invocable = is_invocable_v<_Fn, _Args...>;
      |                         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Interestingly, q := Eigen::Quaterniond(r(), r(), r(), r()).normalized();, does work just fine.

It only fails if it's captured, apparently, but with a regular member function the capture works fine. Is this a bug?

[DyXel]

Hard to debug without the entire source file, plus I have never used std::ranges, but here's a few notes:

• Functions on types are public by default in Cpp2 (no need for public)
• I don't see a .get() method in your Rand class (I assume you mean renaming operator()?)
• :() = today (without the -> for return type) defaults to -> void, this is hopefully going to change soon, see this discussion. For now you need to add -> _ or remove the = (yuck!)
• r&$*() seems to be parsed as (r&) * (), which is wrong in your case, (r&$*)(); works though. I am not sure if this is a bug or not, you can open an issue so it can be discussed.