From 21ab7cea4f12c37795224a81ce326797a7da44c0 Mon Sep 17 00:00:00 2001
From: Simon Brand <tartanllama@gmail.com>
Date: Sat, 21 Oct 2017 22:55:58 +0100
Subject: [PATCH] Comments

---
 optional.hpp | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/optional.hpp b/optional.hpp
index affebb0..114b13f 100644
--- a/optional.hpp
+++ b/optional.hpp
@@ -53,6 +53,8 @@ template <class T> class optional;
 
 /// \exclude
 namespace detail {
+
+// C++14-style aliases for brevity
 template <class T> using remove_const_t = typename std::remove_const<T>::type;
 template <class T>
 using remove_reference_t = typename std::remove_reference<T>::type;
@@ -62,21 +64,23 @@ using enable_if_t = typename std::enable_if<E, T>::type;
 template <bool B, class T, class F>
 using conditional_t = typename std::conditional<B, T, F>::type;
 
+// std::conjunction from C++17
 template <class...> struct conjunction : std::true_type {};
 template <class B> struct conjunction<B> : B {};
 template <class B, class... Bs>
 struct conjunction<B, Bs...>
     : std::conditional<bool(B::value), conjunction<Bs...>, B>::type {};
 
+// std::void_t from C++17
 template <class...> struct voider { using type = void; };
 template <class... Ts> using void_t = typename voider<Ts...>::type;
 
+// Trait for checking if a type is a tl::optional
 template <class T> struct is_optional_impl : std::false_type {};
-
 template <class T> struct is_optional_impl<optional<T>> : std::true_type {};
-
 template <class T> using is_optional = is_optional_impl<decay_t<T>>;
 
+// std::invoke from C++17
 // https://stackoverflow.com/questions/38288042/c11-14-invoke-workaround
 template <typename Fn, typename... Args,
           typename = enable_if_t<std::is_member_pointer<decay_t<Fn>>{}>,
@@ -95,6 +99,7 @@ constexpr auto invoke(Fn &&f, Args &&... args) noexcept(
   return std::forward<Fn>(f)(std::forward<Args>(args)...);
 }
 
+// std::invoke_result from C++17
 template <class F, class, class... Us> struct invoke_result_impl;
 
 template <class F, class... Us>
@@ -110,6 +115,8 @@ using invoke_result = invoke_result_impl<F, void, Us...>;
 template <class F, class... Us>
 using invoke_result_t = typename invoke_result<F, Us...>::type;
 
+
+// Change void to tl::monostate
 template <class U>
 using fixup_void = conditional_t<std::is_void<U>::value, monostate, U>;
 
@@ -129,6 +136,7 @@ using get_invoke_ret = typename conditional_t<is_optional<F>::value,
 template <class F, class U>
 using get_map_return = optional<fixup_void<get_invoke_ret<F, U>>>;
 
+// Check if invoking F for some Us returns void
 template <class F, class... U>
 using returns_void = std::is_void<get_invoke_ret<F, U...>>;