Added Seq

internals/testing/functional_test.cpp

@@ -0,0 +1,28 @@
+#include "lax_v1/arithmetic.hpp"
+#include "lax_v1/functional.hpp"
+
+#include "config.hpp"
+
+static_assert(lax::value_of_v<lax::apply_m<
+                  lax::compose_m<lax::fn_t<lax::neg_m>, lax::fn_t<lax::neg_m>>,
+                  lax::value_t<int, 2>>> == 2);
+
+static_assert(
+    lax::value_of_v<lax::apply_m<
+        lax::compose_m<lax::fn_t<lax::add_m, 2, lax::value_t<int, 1>>,
+                       lax::fn_t<lax::neg_m>,
+                       lax::fn_t<lax::add_m, 2, lax::value_t<int, -1>>>,
+        lax::value_t<int, 1>>> == 1);
+
+static_assert(lax::value_of_v<lax::apply_m<
+                  lax::pipe_m<lax::fn_t<lax::add_m, 2, lax::value_t<int, 1>>,
+                              lax::fn_t<lax::neg_m>,
+                              lax::fn_t<lax::add_m, 2, lax::value_t<int, -1>>>,
+                  lax::value_t<int, 1>>> == -3);
+
+static_assert(
+    lax::value_of_v<
+        lax::thru_m<lax::value_t<int, 1>,
+                    lax::fn_t<lax::add_m, 2, lax::value_t<int, 1>>,
+                    lax::fn_t<lax::neg_m>,
+                    lax::fn_t<lax::add_m, 2, lax::value_t<int, -1>>>> == -3);

internals/testing/seq_test.cpp

@@ -0,0 +1,26 @@
+#include "lax_v1/arithmetic.hpp"
+#include "lax_v1/functional.hpp"
+#include "lax_v1/seq.hpp"
+#include "lax_v1/value.hpp"
+
+#include "config.hpp"
+
+#include <type_traits>
+
+using values_t = lax::Seq::t<lax::value_t<int, 3>,
+                             lax::value_t<int, 1>,
+                             lax::value_t<int, 4>,
+                             lax::value_t<int, 1>,
+                             lax::value_t<int, 5>,
+                             lax::value_t<int, 9>>;
+
+static_assert(lax::value_of_v<lax::Seq::length_m<values_t>> == 6);
+
+static_assert(std::is_same_v<
+              lax::force_t<lax::Seq::map_m<lax::fn_t<lax::neg_m>, values_t>>,
+              lax::Seq::t<lax::value_t<int, -3>,
+                          lax::value_t<int, -1>,
+                          lax::value_t<int, -4>,
+                          lax::value_t<int, -1>,
+                          lax::value_t<int, -5>,
+                          lax::value_t<int, -9>>>);

internals/testing/tycon_test.cpp

@@ -0,0 +1,11 @@
+#include "lax_v1/arithmetic.hpp"
+#include "lax_v1/functional.hpp"
+#include "lax_v1/tycon.hpp"
+
+#include "config.hpp"
+
+struct V;
+
+static_assert(
+    lax::value_of_v<lax::apply_m<lax::tycon_f<V, lax::add_m<V, lax::neg_m<V>>>,
+                                 lax::value_t<int, 1>>> == 0);

provides/include/lax_v1/functional.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+#include "lax_v1/logical.hpp"
+#include "lax_v1/synopsis.hpp"
+
+template <template <class... Formals> class Function,
+          size_t arity,
+          class... BoundActuals>
+struct lax_v1::fn_t {
+  using eval = fn_t;
+  template <class... Actuals>
+  struct m
+      : force_t<
+            if_m<auto_t<(sizeof...(BoundActuals) + sizeof...(Actuals) < arity)>,
+                 fn_t<Function, arity, BoundActuals..., Actuals...>,
+                 Function<BoundActuals..., Actuals...>>> {};
+};
+
+//
+
+template <class Function, class... Actuals>
+struct lax_v1::apply_m : force_t<typename Function::template m<Actuals...>> {};
+
+//
+
+struct lax_v1::identity_m {
+  using eval = identity_m;
+  template <class Expr> struct m : force_t<Expr> {};
+};
+
+//
+
+template <> struct lax_v1::compose_m<> : identity_m {};
+
+template <class Function>
+struct lax_v1::compose_m<Function> : force_t<Function> {};
+
+template <class Function1, class Function2, class... Functions>
+struct lax_v1::compose_m<Function1, Function2, Functions...> {
+  using eval = compose_m;
+  template <class Expr>
+  struct m
+      : force_t<apply_m<Function1,
+                        apply_m<compose_m<Function2, Functions...>, Expr>>> {};
+};
+
+//
+
+template <> struct lax_v1::pipe_m<> : identity_m {};
+
+template <class Function>
+struct lax_v1::pipe_m<Function> : force_t<Function> {};
+
+template <class Function1, class Function2, class... Functions>
+struct lax_v1::pipe_m<Function1, Function2, Functions...> {
+  using eval = pipe_m;
+  template <class Expr>
+  struct m : force_t<apply_m<pipe_m<Function2, Functions...>,
+                             apply_m<Function1, Expr>>> {};
+};
+
+//
+
+template <class Expr> struct lax_v1::thru_m<Expr> : force_t<Expr> {};
+
+template <class Expr, class Function>
+struct lax_v1::thru_m<Expr, Function> : force_t<apply_m<Function, Expr>> {};
+
+template <class Expr, class Function, class... Functions>
+struct lax_v1::thru_m<Expr, Function, Functions...>
+    : force_t<thru_m<apply_m<Function, Expr>, Functions...>> {};

provides/include/lax_v1/seq.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "lax_v1/force.hpp"
+#include "lax_v1/logical.hpp"
+#include "lax_v1/value.hpp"
+
+template <class... Elements> struct lax_v1::Seq::t { using eval = t; };
+
+template <class Sequence>
+struct lax_v1::Seq::length_m : force_t<length_m<force_t<Sequence>>> {};
+template <class... Elements>
+struct lax_v1::Seq::length_m<lax_v1::Seq::t<Elements...>>
+    : auto_t<sizeof...(Elements)> {};
+
+template <class Predicate, class Sequence>
+struct lax_v1::Seq::any_m : force_t<any_m<Predicate, force_t<Sequence>>> {};
+template <class Predicate, class... Elements>
+struct lax_v1::Seq::any_m<Predicate, lax_v1::Seq::t<Elements...>>
+    : force_t<or_m<apply_m<Predicate, Elements>...>> {};
+
+template <class Function, class Sequence>
+struct lax_v1::Seq::map_m
+    : force_t<map_m<force_t<Function>, force_t<Sequence>>> {};
+template <class Function, class... Elements>
+struct lax_v1::Seq::map_m<Function, lax_v1::Seq::t<Elements...>>
+    : t<force_t<apply_m<Function, Elements>>...> {};

provides/include/lax_v1/synopsis.hpp

@@ -1,5 +1,7 @@
 #pragma once
 
+#include <cstddef>
+
 namespace lax_v1 {
 
 // force.hpp ===================================================================
@@ -53,6 +55,43 @@ template <class... Exprs> struct or_m;
 
 template <class Expr> struct not_m;
 
+// functional.hpp ==============================================================
+
+template <template <class... Formals> class Function,
+          size_t arity = 0,
+          class... BoundActuals>
+struct fn_t;
+
+template <class Function, class... Actuals> struct apply_m;
+
+struct identity_m;
+
+template <class... Functions> struct compose_m;
+
+template <class... Functions> struct pipe_m;
+
+template <class Expr, class... Functions> struct thru_m;
+
+// tycon.hpp ===================================================================
+
+template <class Formal, class Expr> struct tycon_f;
+
+// seq.hpp =====================================================================
+
+struct Seq {
+  template <class... Elements> struct t;
+
+  template <class Sequence> struct length_m;
+
+  template <class Predicate, class Sequence> struct any_m;
+
+  template <class Function, class Sequence> struct map_m;
+
+  template <class Sequence> struct has_duplicates_m;
+
+  template <class Subset, class Superset> struct is_subset_of_m;
+};
+
 // lazify.hpp ==================================================================
 
 template <template <class... Formals> class Trait, class... Actuals>

provides/include/lax_v1/tycon.hpp

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "lax_v1/type.hpp"
+
+namespace lax_v1 {
+
+class tycon_private {
+  template <class Formal, class Expr> friend struct tycon_f;
+
+  template <class Formal, class Actual, class Expr> struct subst_m;
+
+  template <class Formal, class Actual, class Expr>
+  using subst_t = type_of_t<subst_m<Formal, Actual, Expr>>;
+};
+
+} // namespace lax_v1
+
+template <class Formal, class Expr> struct lax_v1::tycon_f {
+  using eval = tycon_f;
+  template <class Actual>
+  struct m : tycon_private::subst_t<Formal, Actual, Expr> {};
+};
+
+//
+
+template <class Formal, class Actual>
+struct lax_v1::tycon_private::subst_m<Formal, Actual, Formal> : type_t<Actual> {
+};
+
+template <class Formal, class Actual, class Expr>
+struct lax_v1::tycon_private::
+    subst_m<Formal, Actual, lax_v1::tycon_f<Formal, Expr>>
+    : type_t<tycon_f<Formal, Expr>> {};
+
+template <class Formal,
+          class Actual,
+          template <class... Formals>
+          class Function,
+          class... Exprs>
+struct lax_v1::tycon_private::subst_m<Formal, Actual, Function<Exprs...>>
+    : type_t<Function<subst_t<Formal, Actual, Exprs>...>> {};
+
+template <class Formal,
+          class Actual,
+          template <template <class... Formals> class F, class... As>
+          class R,
+          template <class... Formals>
+          class F,
+          class... Exprs>
+struct lax_v1::tycon_private::subst_m<Formal, Actual, R<F, Exprs...>>
+    : type_t<R<F, subst_t<Formal, Actual, Exprs>...>> {};
+
+template <class Formal, class Actual, class ReturnType, class... ParamTypes>
+struct lax_v1::tycon_private::subst_m<Formal, Actual, ReturnType(ParamTypes...)>
+    : type_t<subst_t<Formal, Actual, ReturnType>(
+          subst_t<Formal, Actual, ParamTypes>...)> {};