implement min_element

Author: ecrypa

example/src/list.cpp

@@ -657,6 +657,27 @@ IS_SAME(
 /// [transpose]
 )
 
+HIDE(
+/// [min_element]
+using vals = metal::list<const int[9], const int[2], int[2], volatile int[2]>;
+
+// strict (i.e., irreflexive) ordering: _first_ minimum
+template<class x, class y>
+using smaller = metal::number<(sizeof(x) < sizeof(y))>;
+IS_SAME(metal::min_element<vals, metal::lambda<smaller>>, const int[2]);
+
+ // reflexive ordering: _last_ minimum
+template<class x, class y>
+using not_larger = metal::number<(sizeof(x) <= sizeof(y))>;
+IS_SAME(metal::min_element<vals, metal::lambda<not_larger>>, volatile int[2]);
+
+// can be used with Numbers; more customizable than metal::min
+using nums = metal::numbers<4, 42, 17, 3, 20>;
+IS_SAME(metal::min_element<nums, metal::lambda<metal::less>>, metal::number<3>);
+IS_SAME(metal::min_element<nums>, metal::number<3>); // use default ordering
+/// [min_element]
+)
+
 #if !defined(METAL_WORKAROUND)
 HIDE(
 /// [accumulate]

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,89 @@
+#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
+    /// Finds a minimum element in a \list according to an ordering relation.
+    ///
+    /// \note{The _first_ minimum 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: `l` is not empty, and 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:
+    ///     If `l` contains elements `val_0, ..., val_k, ..., val_m-1`, then
+    ///     \code
+    ///         using result = val_k;
+    ///     \endcode
+    ///     where `val_k` is an element in `l` such that
+    ///       * `metal::invoke<lbd, val_k, val_j>{} != false` for all `j` in
+    ///         `[0, k)` and
+    ///       * `metal::invoke<lbd, val_i, val_k>{} == false` for all
+    ///         `i` in `(k, m-1]`.
+    ///
+    /// \tip{`lbd` may be omitted, in which case it defaults to `metal::lambda<metal::less>`.}
+    ///
+    /// ### Example
+    /// \snippet list.cpp min_element
+    ///
+    /// ### See Also
+    /// \see min, 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

include/metal/list/sort.hpp

@@ -49,7 +49,7 @@ namespace metal {
     /// \snippet list.cpp sort
     ///
     /// ### See Also
-    /// \see list, reverse, rotate
+    /// \see list, min_element, reverse, rotate
 #if !defined(METAL_WORKAROUND)
     template<class seq, class lbd = metal::lambda<metal::less>>
     using sort = detail::call<

include/metal/number/min.hpp

@@ -39,7 +39,7 @@ namespace metal {
     /// \snippet number.cpp min
     ///
     /// ### See Also
-    /// \see number, greater, less, max
+    /// \see number, greater, less, max, min_element
     template<class... nums>
     using min = fold_left<lambda<detail::min>, if_<is_number<nums>, nums>...>;
 }