How to reduce verbosity when splitting `std::string_view` by `std::views::split`?

Question

Consider the following snippet:

// included, for exposition only
SomeData buzz(std::string_view);

constexpr auto foo(std::string_view v) {
    using namespace std::string_view_literals;

    return v 
    | std::views::split(";"sv) 

    // `std::string_view` constructor from Range is explicit, so this line is necessary
    | std::views::transform([](const auto& s) { return std::string_view(s); })
    | std::views::transform(buzz)
    ;
}

Ideally I'd have only the transformations required by the actual algorithm without working around the language's/Standard Library's limitations:

constexpr auto bar(std::string_view v) {
    using namespace std::string_view_literals;

    // To be used as a chainable range closure more code is required
    constexpr auto split{[](std::string_view v, std::string_view delim){
        return v | std::views::split(delim) | std::views::transform([](const auto& v){ return std::string_view(v); });
    }};

    return split(v, ";"sv)
    | std::views::transform(buzz);
}

Does the Standard Library provide a view adaptor that splits a std::string_view into std::string_view elements without the extra transform, or is a custom wrapper unavoidable?

Wouldn't it make more sense to combine the auto transform with the string_view transform? Even if the second transform is a function, you could just call it with the first. — Nicol Bolas
– Nicol Bolas, Commented Jul 7 at 15:26
From your code, it's not clear why your second transform needs its parameter to be std::string_view. Your first transform only exists to satisfy that unnecessary limitation. — Drew Dormann
– Drew Dormann, Commented Jul 7 at 15:29
@DrewDormann what would you suggest instead? std::string_view adds clarity over just const auto — Sergey Kolesnik
– Sergey Kolesnik, Commented Jul 7 at 15:37
@DrewDormann your suggestion doesn't reduce verbosity. Using a wrapper for split is better in this regard — Sergey Kolesnik
– Sergey Kolesnik, Commented Jul 7 at 15:43

Barry · Accepted Answer · 2025-07-07 15:26:39Z

6

There is no such custom adaptor. But it's easy enough to write your own — which also the advantage that you can make it work with string literals. It's not that much boilier plate:

struct SplitClosure : std::ranges::range_adaptor_closure<SplitClosure> {
  std::string_view delim;
  explicit constexpr SplitClosure(std::string_view delim) : delim(delim) { }

  template <std::ranges::viewable_range R>
  constexpr auto operator()(R&& r) const {
    return r | std::views::split(delim)
             | std::views::transform([](auto&& r){
                  return std::string_view(r);
               });
  }
};


struct SplitAdaptor {
   constexpr auto operator()(std::string_view s) const {
      return SplitClosure(s);
   }
};
inline constexpr SplitAdaptor split2;

That makes s | split2(" ") work (in the sense that we're splitting on a space, not a space and null terminator, in addition to s | split2(" "sv).

If you copy the adaptor implementation from P2387R3, this could be:

inline constexpr adaptor split2 = 
   []<std::ranges::viewable_range R>(R&& r, std::string_view delim){
       return (R&&)r
            | std::views::split(delim)
            | std::views::transform([](auto&& sub){
                  return std::string_view(sub);
              });
   };

answered Jul 7 at 15:26

Barry

312k32 gold badges734 silver badges1.1k bronze badges

Sign up to request clarification or add additional context in comments.

6 Comments

Sergey Kolesnik Jul 7 at 15:35

Would it be possible to pipe the range to split2? The second adaptor looks way more elegant

Barry Jul 7 at 16:36

@SergeyKolesnik Not sure what you're asking. s | split2(" ") works with both implementations. The first one doesn't support split2(s, " ") though (but could be easily made to).

Sergey Kolesnik Jul 7 at 17:14

s | split2(" ") was exactly what I was asking

T.C. Jul 7 at 23:34

If we don't care about the binary version, we can just do auto split2 = []<class T>(T&& delim) { return split(std::forward<T>(delim)) | transform(...); }; (or use string_view directly if you prefer that, at the risk of possible dangling and losing support for single character). Also s | split(" ") shouldn't compile since that's decay-copied into a pointer. Not great, but better than silent wrong behavior from including the null terminator in the pattern...

Sergey Kolesnik Jul 11 at 15:41

btw, why didn't you std::forward sub?

Barry Jul 11 at 17:39

@SergeyKolesnik Because there's no benefit to doing so, it's just more typing.

Drew Dormann · Accepted Answer · 2025-07-07 15:42:08Z

1

Barry's answer is predictably great, but since you are commenting for a specific clarification...

Your code:

    return v 
    | std::views::split(";"sv) 

    // `std::string_view` constructor from Range is explicit, so this line is necessary
    | std::views::transform([](const auto& s) { return std::string_view(s); })
    | std::views::transform([](std::string_view v) { 
        // Some further logic here
        return v; 
      })
    ;

is functionally identical to:

    return v 
    | std::views::split(";"sv) 
    | std::views::transform([](auto&& range) {
        std::string_view v{range} 
        // Some further logic here
        return v; 
      })
    ;

answered Jul 7 at 15:42

Drew Dormann

65.5k14 gold badges133 silver badges200 bronze badges

3 Comments

Sergey Kolesnik Jul 7 at 15:47

I agree, that this is less verbose than my initial code with transform. The point is, my second transform is just a placeholder for the minimal reproducible example. The actual code would pipe split | transform(functionAcceptingStringView). So I'd still need to wrapp the call to a lambda with manual conversion every time. So it is equally verbose. However, worth an upvote

Drew Dormann Jul 7 at 17:14

Then I recommend editing your question, so the code you show better represents the problem you are trying to solve. In the code in your current question, "this line is necessary" is not true.

Sergey Kolesnik Jul 7 at 17:55

I've modified the question's code

Collectives™ on Stack Overflow

How to reduce verbosity when splitting `std::string_view` by `std::views::split`?

2 Answers 2

6 Comments

3 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

6 Comments

3 Comments

Your Answer

Sign up or log in

Post as a guest

Related