A *range adaptor closure object* is a unary function object that accepts
a range argument.

For
a range adaptor closure object C and an expression R such that
decltype((R)) models range, the following
expressions are equivalent:
C(R)
R | C

Given an additional range adaptor closure object D,
the expression C | D produces another range adaptor
closure object E.

E is a perfect forwarding call wrapper ([func.require])
with the following properties:

- It has one bound argument entity, an object c of type decay_t<decltype((C))> direct-non-list-initialized with C.

The expression C | D is well-formed if and only if
the initializations of the state entities of E are all well-formed.

Given an object t of type T, where

- t is a unary function object that accepts a range argument,
- T models derived_from<range_adaptor_closure<T>>,
- T has no other base classes of type range_adaptor_closure<U> for any other type U, and
- T does not model range

If an expression of type cv D
is used as an operand to the | operator,
D shall be complete and
model derived_from<range_adaptor_closure<D>>.

The behavior of an expression involving an object of type cv D
as an operand to the | operator is undefined
if overload resolution selects a program-defined operator| function.

If an expression of type cv U
is used as an operand to the | operator,
where U has a base class of type range_adaptor_closure<T>
for some type T other than U, the behavior is undefined.

A *range adaptor object* is a
customization point object ([customization.point.object])
that accepts a viewable_range as its first argument and returns a view.

If a range adaptor object adaptor accepts more than one argument,
then let range be an expression
such that decltype((range)) models viewable_range,
let args... be arguments
such that adaptor(range, args...) is a well-formed expression
as specified in the rest of subclause [range.adaptors], and
let BoundArgs be a pack
that denotes decay_t<decltype((args))>....

The expression adaptor(args...) produces a range adaptor closure object f
that is a perfect forwarding call wrapper ([func.require]) with the following properties:

- Its target object is a copy of adaptor.
- Its bound argument entities bound_args consist of objects of types BoundArgs... direct-non-list-initialized with std::forward<decltype((args))>(args)..., respectively.
- Its call pattern is adaptor(r, bound_args...), where r is the argument used in a function call expression of f.

The expression adaptor(args...) is well-formed if and only if
the initialization of the bound argument entities of the result,
as specified above, are all well-formed.