Vtyjkyuk

I'm trying to write syntactic sugar, in a monad-style, over std::optional. Please consider:

template<class T>
void f(std::optional<T>)

As is, this function cannot be called with a non-optional T¹ (e.g. an int), even though there exists a conversion from T to std::optional<T>².

Is there a way to make f accept an std::optional<T> or a T (converted to an optional at the caller site), without defining an overload³?

¹⁾f(0): error: no matching function for call to 'f(int)' and note: template argument deduction/substitution failed, (demo).
²⁾ Because template argument deduction doesn't consider conversions.
³⁾ Overloading is an acceptable solution for a unary function, but starts to be an annoyance when you have binary functions like operator+(optional, optional), and is a pain for ternary, 4-ary, etc. functions.

Another version. This one doesn't involve anything:

template <typename T>
void f(T&& t) 
 std::optional opt = std::forward<T>(t);

Class template argument deduction already does the right thing here. If t is an optional, the copy deduction candidate will be preferred and we get the same type back. Otherwise, we wrap it.

Instead of taking optional as argument take deductible template parameter:

template<class T>
struct is_optional : std::false_type;

template<class T>
struct is_optional<std::optional<T>> : std::true_type;

template<class T, class = std::enable_if_t<is_optional<std::decay_t<T>>::value>>
constexpr decltype(auto) to_optional(T &&val)
 return std::forward<T>(val);


template<class T, class = std::enable_if_t<!is_optional<std::decay_t<T>>::value>>
constexpr std::optional<std::decay_t<T>> to_optional(T &&val)
 return std::forward<T>(val) ;


template<class T>
void f(T &&t)
 auto opt = to_optional(std::forward<T>(t));


int main() 
 f(1);
 f(std::optional<int>(1));

Live example

This uses one of my favorite type traits, which can check any all-type template against a type to see if it's the template for it.

#include <iostream>
#include <type_traits>
#include <optional>


template<template<class...> class tmpl, typename T>
struct x_is_template_for : public std::false_type ;

template<template<class...> class tmpl, class... Args>
struct x_is_template_for<tmpl, tmpl<Args...>> : public std::true_type ;

template<template<class...> class tmpl, typename... Ts>
using is_template_for = std::conjunction<x_is_template_for<tmpl, std::decay_t<Ts>>...>;

template<template<class...> class tmpl, typename... Ts>
constexpr bool is_template_for_v = is_template_for<tmpl, Ts...>::value;


template <typename T>
void f(T && t) 
 auto optional_t = [&]
 if constexpr (is_template_for_v<std::optional, T>) 
 return t; 
 else 
 return std::optional<std::remove_reference_t<T>>(std::forward<T>(t));
 
 ();
 (void)optional_t;


int main() 
 int i = 5;
 std::optional<int> oi5;

 f(i);
 f(oi);

https://godbolt.org/z/HXgoEE

Another version. This one doesn't involve writing traits:

template <typename T>
struct make_optional_t 
 template <typename U>
 auto operator()(U&& u) const 
 return std::optional<T>(std::forward<U>(u));
 
;

template <typename T>
struct make_optional_t<std::optional<T>> 
 template <typename U>
 auto operator()(U&& u) const 
 return std::forward<U>(u);
 
;

template <typename T>
inline make_optional_t<std::decay_t<T>> make_optional;

template <typename T>
void f(T&& t)
 auto opt = make_optional<T>(std::forward<T>(t));