Initial

Author: polytypic

.clang-format

@@ -0,0 +1 @@
+.cppsm/.clang-format

.cppsm

@@ -0,0 +1 @@
+.cppsm/.gitignore

.gitignore

@@ -0,0 +1,4 @@
+[submodule ".cppsm"]
+	path = .cppsm
+	url = https://github.com/cppsm/cppsm-boilerplate.git
+	branch = master

.gitmodules

@@ -0,0 +1 @@
+.cppsm/.prettierrc

.prettierrc

@@ -0,0 +1,29 @@
+language: cpp
+
+notifications:
+  email: false
+
+matrix:
+  include:
+    - os: linux
+      dist: trusty
+      addons:
+        apt:
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-7
+          packages:
+            - g++-8
+            - clang-7
+    - os: osx
+      osx_image: xcode10.2
+    - os: windows
+
+git:
+  submodules: false
+
+before_install:
+  - git submodule update --init
+
+script:
+  - .cppsm/travis-ci || ./test

.travis.yml

@@ -0,0 +1,2 @@
+cmake_minimum_required(VERSION 3.9)
+include(.cppsm/c++17-no-rtti-no-exns.cmake)

CMakeLists.txt

@@ -0,0 +1,18 @@
+Copyright © 2019 Vesa Karvonen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

LICENSE.md

@@ -0,0 +1,11 @@
+Apparently VC++ 2017 is not quite ready for
+
+```c++
+template <auto v> struct value_t {
+  using eval = value_t;
+  using type = decltype(v);
+  static constexpr auto value = v;
+};
+```
+
+because `decltype(v)` does not always seem to give the expected type.

NOTES.md

@@ -0,0 +1,3 @@
+# [≡](#contents) [Lax.C++](#) [![Build Status](https://travis-ci.org/per-framework/lax.cpp.svg?branch=v1)](https://travis-ci.org/per-framework/lax.cpp)
+
+Non-strict template metaprogramming primitives for C++.

README.md

@@ -0,0 +1,2 @@
+add_conventional_executable_test(lax_test)
+target_link_libraries(lax_test PRIVATE lax_v1)

internals/CMakeLists.txt

@@ -0,0 +1,25 @@
+#include "lax_v1/comparison.hpp"
+#include "lax_v1/logical.hpp"
+#include "lax_v1/type.hpp"
+#include "lax_v1/type_traits.hpp"
+#include "lax_v1/value.hpp"
+
+#include <type_traits>
+
+namespace lax = lax_v1;
+
+static_assert(std::is_same_v<lax::value_t<bool, true>::type, bool>);
+
+static_assert(std::is_same_v<lax::value_t<char, 'x'>::type, char>);
+static_assert(std::is_same_v<lax::value_t<short, 101>::type, short>);
+static_assert(std::is_same_v<lax::value_t<int, 101>::type, int>);
+static_assert(std::is_same_v<lax::value_t<unsigned, 101u>::type, unsigned>);
+static_assert(std::is_same_v<lax::value_t<long, 101l>::type, long>);
+static_assert(
+    std::is_same_v<lax::value_t<unsigned long, 101ul>::type, unsigned long>);
+static_assert(std::is_same_v<lax::value_t<unsigned long long, 101ull>::type,
+                             unsigned long long>);
+
+static_assert(lax::value_of_v<lax::is_array_m<lax::type_t<int[2]>>>);
+
+int main() { return 0; }

internals/testing/compile_only_test.cpp

@@ -0,0 +1 @@
+add_conventional_library(lax_v1)

provides/CMakeLists.txt

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "lax_v1/comparison_synopsis.hpp"
+#include "lax_v1/value.hpp"
+
+template <class LhsExpr, class RhsExpr>
+struct lax_v1::lte_m
+    : value_t<bool, (value_of_v<LhsExpr> <= value_of_v<RhsExpr>)> {};

provides/include/lax_v1/comparison.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace lax_v1 {
+
+template <class LhsExpr, class RhsExpr> struct lte_m;
+
+}

provides/include/lax_v1/comparison_synopsis.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+namespace lax_v1 {}

provides/include/lax_v1/config.hpp

@@ -0,0 +1,3 @@
+#pragma once
+
+#include "lax_v1/force_synopsis.hpp"

provides/include/lax_v1/force.hpp

@@ -0,0 +1,7 @@
+#pragma once
+
+namespace lax_v1 {
+
+template <class Expr> using force_t = typename Expr::eval;
+
+}

provides/include/lax_v1/force_synopsis.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include "lax_v1/lazify_synopsis.hpp"
+#include "lax_v1/type.hpp"
+#include "lax_v1/value.hpp"
+
+template <template <class... Parameters> class Function, class... Arguments>
+struct lax_v1::lazify_t
+    : type_t<typename Function<type_of_t<Arguments>...>::type> {};
+
+template <class Type, template <class... Parameters> class Function,
+          class... Arguments>
+struct lax_v1::lazify_v
+    : value_t<Type, Function<type_of_t<Arguments>...>::value> {};

provides/include/lax_v1/lazify.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace lax_v1 {
+
+template <template <class... Parameters> class Function, class... Arguments>
+struct lazify_t;
+
+template <class Type, template <class... Parameters> class Function,
+          class... Arguments>
+struct lazify_v;
+
+} // namespace lax_v1

provides/include/lax_v1/lazify_synopsis.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "lax_v1/force.hpp"
+#include "lax_v1/logical_synopsis.hpp"
+#include "lax_v1/value.hpp"
+
+template <class... Exprs> struct lax_v1::and_m : true_t {};
+template <class... Exprs>
+struct lax_v1::and_m<lax_v1::false_t, Exprs...> : false_t {};
+template <class... Exprs>
+struct lax_v1::and_m<lax_v1::true_t, Exprs...> : and_m<Exprs...> {};
+template <class Expr, class... Exprs>
+struct lax_v1::and_m<Expr, Exprs...> : and_m<force_t<Expr>, Exprs...> {};
+
+template <class... Exprs> struct lax_v1::or_m : false_t {};
+template <class... Exprs>
+struct lax_v1::or_m<lax_v1::true_t, Exprs...> : true_t {};
+template <class... Exprs>
+struct lax_v1::or_m<lax_v1::false_t, Exprs...> : or_m<Exprs...> {};
+template <class Expr, class... Exprs>
+struct lax_v1::or_m<Expr, Exprs...> : lax_v1::or_m<force_t<Expr>, Exprs...> {};

provides/include/lax_v1/logical.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace lax_v1 {
+
+template <class... Exprs> struct and_m;
+
+template <class... Exprs> struct or_m;
+
+} // namespace lax_v1

provides/include/lax_v1/logical_synopsis.hpp

@@ -0,0 +1,8 @@
+#pragma once
+
+#include "lax_v1/type_synopsis.hpp"
+
+template <class T> struct lax_v1::type_t {
+  using eval = type_t;
+  using type = T;
+};

provides/include/lax_v1/type.hpp

@@ -0,0 +1,9 @@
+#pragma once
+
+namespace lax_v1 {
+
+template <class T> struct type_t;
+
+template <class Expr> using type_of_t = typename Expr::eval::type;
+
+} // namespace lax_v1

provides/include/lax_v1/type_synopsis.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "lax_v1/lazify.hpp"
+#include "lax_v1/type_traits_synopsis.hpp"
+
+#include <cstddef>
+#include <type_traits>
+
+template <class T>
+struct lax_v1::alignment_of_m : lazify_v<size_t, std::alignment_of, T> {};
+
+template <class T>
+struct lax_v1::is_array_m : lazify_v<bool, std::is_array, T> {};
+
+template <class T>
+struct lax_v1::is_pointer_m : lazify_v<bool, std::is_pointer, T> {};
+
+template <class T>
+struct lax_v1::remove_all_extents_m : lazify_t<std::remove_all_extents, T> {};
+
+template <class T>
+struct lax_v1::remove_pointer_m : lazify_t<std::remove_pointer, T> {};

provides/include/lax_v1/type_traits.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace lax_v1 {
+
+template <class T> struct alignment_of_m;
+
+template <class T> struct is_array_m;
+
+template <class T> struct is_pointer_m;
+
+template <class T> struct remove_all_extents_m;
+
+template <class T> struct remove_pointer_m;
+
+} // namespace lax_v1

provides/include/lax_v1/type_traits_synopsis.hpp

@@ -0,0 +1,10 @@
+#pragma once
+
+#include "lax_v1/type.hpp"
+#include "lax_v1/value_synopsis.hpp"
+
+template <class Type, Type value_> struct lax_v1::value_t {
+  using eval = value_t;
+  using type = Type;
+  static constexpr Type value = value_;
+};

provides/include/lax_v1/value.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "lax_v1/type_synopsis.hpp"
+
+namespace lax_v1 {
+
+template <class Type, Type value> struct value_t;
+
+template <class Expr>
+inline constexpr type_of_t<Expr> value_of_v = Expr::eval::value;
+
+using true_t = value_t<bool, true>;
+using false_t = value_t<bool, false>;
+
+} // namespace lax_v1