Why can't ranges be used if in a function?

Question

I'm trying to get a range like python like below:

#include <iostream>
#include <ranges>

auto Range(double start, double end, double step)
{
    if (start <= end) {
        auto step_fun = [=](auto x) { return x * step + start; };
        auto end_pred = [=](auto x) { return x <= end; };
        auto range =
            std::views::iota(0)
            | std::views::transform(step_fun)
            | std::views::take_while(end_pred);
        return range;
    }
    else {
        auto step_fun = [=](auto x) { return -x * step + start; };
        auto end_pred = [=](auto x) { return x >= end; };
        auto range =
            std::views::iota(0)
            | std::views::transform(step_fun)
            | std::views::take_while(end_pred);
        return range;
    }
}
int main() {
    auto range = Range(108, 100, 1);

    for (auto i : range)
        std::cout << i << ' ';
    return 0;
}

But the Visual Studio told me:

Error   C3487   'std::ranges::take_while_view<std::ranges::transform_view<std::ranges::iota_view<_Ty,std::unreachable_sentinel_t>,Range::<lambda_3>>,Range::<lambda_4>>': all return expressions must deduce to the same type: previously it was 'std::ranges::take_while_view<std::ranges::transform_view<std::ranges::iota_view<_Ty,std::unreachable_sentinel_t>,Range::<lambda_1>>,Range::<lambda_2>>'

and

Message     No user-defined-conversion operator available that can perform this conversion, or the operator cannot be called    test

But only start>endorstart<end,it can work,like:

auto Range(double start, double end, double step)
{
auto step_fun = [=](auto x) { return x * step + start; };
        auto end_pred = [=](auto x) { return x <= end; };
        auto range =
            std::views::iota(0)
            | std::views::transform(step_fun)
            | std::views::take_while(end_pred);
        return range;
}

How can I fix it?

because the predicate is part of signature. – apple apple Apr 22 '22 at 14:51 — apple apple, Apr 22 '22 at 14:51

Caleth · Accepted Answer · 2022-04-22T15:15:43.217

4

A function must have one return type, auto doesn't change that. Your two returns have different, incompatible types, because each lambda expression has a unique type.

The error message rather buried it: blah blah Range::<lambda_3>,Range::<lambda_4> vs blah blah Range::<lambda_1>,Range::<lambda_2>

You can do some arithmetic to reduce it to one return

auto Range(double start, double end, double step)
{
    if (start > end) {
        step *= -1;
    }
    int count = (end - start) / step;

    auto step_fun = [=](auto x) { return x * step + start; };
    return std::views::iota(0, count)
         | std::views::transform(step_fun);
}

Caveat: this function is still problematic if step is negative, you might instead want to throw if end is not reachable from start.

edited Apr 22 '22 at 15:15

answered Apr 22 '22 at 14:53

Caleth

52,200
2
44
75

Oh, I get it, thank you. I'm silly to forget it. – Learning Lin Apr 22 '22 at 14:54
1

@newlearner don't worry, the error message rather buried it: `blah blah Range::,Range::` vs `blah blah Range::,Range::` – Caleth Apr 22 '22 at 14:57
I need to be more careful. Thank you. – Learning Lin Apr 22 '22 at 15:10
`if((start>end)==(step>0)) step=-step;` just xnor (bool==bool) to conditions to get what you want! but after that: `if(step==0) count=0; else count=...;` – Red.Wave Apr 22 '22 at 16:43

score 1 · Answer 2 · answered Apr 22 '22 at 15:10

Because the result type of take_while and transform contains the function type as part of signature, but one function can only have single return type.

in addition to what already answered, you can also erase the type.

#include <iostream>
#include <ranges>
#include <functional>

auto Range(double start, double end, double step)
{
    std::function<double(double)> step_fun;
    std::function<double(double)> end_pred;

    if (start <= end) {
        step_fun = [=](auto x) { return x * step + start; };
        end_pred = [=](auto x) { return x <= end; };
    }
    else {
        step_fun = [=](auto x) { return -x * step + start; };
        end_pred = [=](auto x) { return x >= end; };    
    }
    auto range =
            std::views::iota(0)
            | std::views::transform(step_fun)
            | std::views::take_while(end_pred);
    return range;
}
int main() {
    auto range = Range(108, 100, 1);

    for (auto i : range)
        std::cout << i << ' ';
    return 0;
}

Why can't ranges be used if in a function?

2 Answers2