implement min_element

Author: ecrypa

example/src/list.cpp

@@ -681,5 +681,29 @@ IS_SAME(
     >
 );
 /// [accumulate]
+
+HIDE(
+/// [min_element]
+using nums = metal::numbers<4, 42, 17, -7, 0>;
+
+IS_SAME(metal::min_element<nums>, metal::number<-7>);
+
+using comp_lt = metal::lambda<metal::less>;
+IS_SAME(metal::min_element<nums, comp_lt>, metal::number<-7>);
+
+using comp_gt = metal::lambda<metal::greater>;
+IS_SAME(metal::min_element<nums, comp_gt>, metal::number<42>);
+
+using vals = metal::list<const char[3], char[1], char[1], char[3], const char[1]>;
+
+template<typename x, typename y>
+using smaller = metal::number<(sizeof(x) < sizeof(y))>;
+IS_SAME(metal::min_element<vals, metal::lambda<smaller>>, char[1]);
+
+template<typename x, typename y>
+using larger = metal::number<(sizeof(x) > sizeof(y))>;
+IS_SAME(metal::min_element<vals, metal::lambda<larger>>, const char[3]);
+/// [min_element]
+)
 )
 #endif

include/metal/list.hpp

@@ -28,6 +28,7 @@
 #include "list/iota.hpp"
 #include "list/join.hpp"
 #include "list/list.hpp"
+#include "list/min_element.hpp"
 #include "list/none_of.hpp"
 #include "list/partition.hpp"
 #include "list/powerset.hpp"

include/metal/list/min_element.hpp

@@ -0,0 +1,81 @@
+#ifndef METAL_LIST_MIN_ELEMENT_HPP
+#define METAL_LIST_MIN_ELEMENT_HPP
+
+#include "../config.hpp"
+#include "../lambda/apply.hpp"
+#include "../lambda/lambda.hpp"
+#include "../number/if.hpp"
+#include "../number/less.hpp"
+
+namespace metal {
+    /// \cond
+    namespace detail {
+        template<class lbd = metal::lambda<metal::less>>
+        struct _min_folder;
+    }
+    /// \endcond
+
+    /// \ingroup list
+    ///
+    /// ### Description
+    /// TODO
+    ///
+    /// \note{The first such element is returned if the ordering relation is [strict].}
+    /// [strict]:
+    /// https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings
+    ///
+    /// ### Usage
+    /// For any \list `l` and \lambda `lbd`
+    /// \code
+    ///     using result = metal::min_element<l, lbd>;
+    /// \endcode
+    ///
+    /// \pre: For any two \values `val_i` and `val_j` contained in `l`
+    /// `metal::invoke<lbd, val_i, val_j>` returns a \number
+    /// \returns: \value
+    /// \semantics:
+    ///     TODO
+    ///
+    /// \tip{`lbd` may be omitted, in which case it defaults to `metal::lambda<metal::less>`.}
+    ///
+    /// ### Example
+    /// \snippet list.cpp min_element
+    ///
+    /// ### See Also
+    /// \see sort
+#if !defined(METAL_WORKAROUND)
+    template<class seq, class lbd = metal::lambda<metal::less>>
+    using min_element = apply<
+        lambda<detail::_min_folder<if_<is_lambda<lbd>, lbd>>::template type>,
+        seq>;
+#else
+    // MSVC 14 has shabby SFINAE support in case of default alias template args
+    template<class seq, class... lbd>
+    using min_element = apply<
+        lambda<detail::_min_folder<if_<is_lambda<lbd>, lbd>...>::template type>,
+        seq>;
+#endif
+}
+
+#include "../lambda/invoke.hpp"
+#include "../value/fold_left.hpp"
+
+namespace metal {
+    /// \cond
+    namespace detail {
+        template<class lbd>
+        struct _min_folder {
+            template<class x, class y>
+            using custom_min = if_<invoke<lbd, y, x>, y, x>;
+            // Must use `invoke` in order to support SFINAE. It is tempting to
+            // pattern-match the `expr` from `lbd` and use `expr<y, x>`, but
+            // the latter approach spoils SFINAE guarantees.
+
+            template<class... vals>
+            using type = fold_left<lambda<custom_min>, vals...>;
+        };
+    }
+    /// \endcond
+}
+
+#endif