Collection of powerfuls - C++ Single-Header Libraries Files
Home Page: https://guillaumedua.github.io/CppShelf/
License: MIT License
Note: this is my personnal - thus, not professional - account.
Related to :
The following synthaxe should be valid :
auto route = [](){ return 42; }
>>= mp::ttps<int, char>{}
>>= []<typename T, typename U>(int){
static_assert(std::same_as<int, T>);
static_assert(std::same_as<char, U>);
}
;C++23 ?
Currently (12/03/2021), NTTPs are not supported by the current API,
thus have to be passed as TTPs using for instance std::integral_constant, so true becomes std::true_type
As-is, this result in counter-intuitive syntaxes, considered as usage impediments.
APIs might looks like :
template <template auto ... ttps, typename ... args_t>
decltype(auto) csl::wf::invoke(args_t && ... args);Seems like there's no update since 2015, see n4473
simplify front_binder with some semi-type-erasure
// definition
front_binder<F, ...>; // non-mandatory ttps, args
front_binder::front_binder(auto && ...);
// internal storage for bound elements become a type-erased lambda with variadic capture group,
// into an std::function<void(F)>, to allow some visitation pattern ?front_binder<F, ttps<...>, args<...>> :
class front_binder<F, mp::ttps<ttps_bounded_args_t...>, mp::args<bounded_args_t...>>;
// ^^^^^ ^^^^^^Related to :
The following syntaxes must be correct :
discard_args / drop / take
auto route = [](){ return 21; } >>= discard_args >>= [](){};auto route = [](){ return 21; } >>= discard_args >>= [](int i = 42){ /* i == 42 */ };mp::args
auto route = [](){ return 21; } >>= discard_args >>= mp::args{ 42 } >>= [](int i){ /* i == 42 */ };auto route = [](){ return 21; } >>= mp::args{ 42 } >>= [](int i){ /* i == 42 */ };as well as :
mp::discard_n_args<N> / mp::drop_n_args<2>
auto route = [](){ return 42; } >>= mp::args_before{ 'a', 'b', 'c' } >>= mp::drop_n_args<2> >>= [](char c, int i){
// c == 'c'
// i == 42
};Consider P2347 "Argument type deduction for non-trailing parameter packs" to deduce a single non-trailing parameters pack for function arguments
template <typename auto ... n_ttps>
csl::wf::bind_invoke([](auto&&... args) {
// invocation
}, fwd(bound_args)..., fwd(args)..., marker<>{});Consider adding an execution policy matrix to chain invocation
Extend the interface of front_binder so it becomes more user-friendly.
Also, only bind_front is covered with tests, not front_binder itself.
As such type is exposed publicly, it should be tested as well in UTs.
operator=operator===, not_eqnoexcept) constructorsAlso consider some binding similar to std::bind/std::bind_front
Dev branch : enhancement/front_binder
Based on gcl::serialization for type-indexing, but with customisation points (and still default behaviors).
TBD
serialize<T>deserialize_as<T>deserialize (gcl::serialization's reader)Based on the detection-idiom :
serializable/not_serializable
Descriptor :
template-type-parameter-list <members to invoke...>
(deserialization reverse the order)
https://hub.docker.com/repository/docker/gussd/cpp-toolchain/general
Q: Can be based on https://github.com/jfalcou/compilers/blob/main/Dockerfile ?
GCCClang, lldb, libc++, clang-tidy, clang-format, etc. )CMakeQ: Can we add ranges of release/version for theses packages,
with updates-alternatives (the latest stable release the better ?)
Q: as a script, invoked in the DockerFile ?
CMake toolchains for such common configurationsRelated issues/requests :
Related to :
The following syntaxes should be correct :
mp::argsusing namespace csl::wf;
auto route = [](){}
>> mp::args{ 42 }
>> [](int i){}
;See #25 for more details about mp::args behavior here
mp::args_beforeusing namespace csl::wf;
auto route = [](){ return std::string{}; }
>> mp::args_before{ 42 }
>> [](int, std::string){}
;mp::args_afterusing namespace csl::wf;
auto route = [](){ return std::string{}; }
>> mp::args_after{ 42 }
>> [](std::string, int){}
;Can be linked to #37
Move F as part of bounded_args internal storage tuple.
Use std::get<0> to access
Accessor for F
auto f1_then_f2_then_f3 =
f1 >>= f2 >>= f3;auto f1_then_either_f2_f3_or_f4 = f1 >>= (f2 | f3 | f4);auto f1_3_times = f1 * 3;
auto f1_3_times = f1 * std::integral_constant<std::size_t, 3>;Requires extension for concurrency
auto f1_and_f2 = f1 || f2;
// design 1 : synchronized join
auto route = f1_and_f2 >>= f3;
route(); // csl::wf::invoke(f3, std::future::when_all(f1_future, f2_future));
// design 2 :
auto route = f1_and_f2 |= f3;
route(); // csl::wf::invoke(f3, std::future::when_any(f1_future, f2_future)); get for stuctured-bindinghttps://github.com/GuillaumeDua/CppShelf/blob/main/includes/wf/csl/wf.hpp#L1406
auto route = csl::wf::route{ node_1, node_2, node_3 };
const auto & [ n1, n2, n3 ] = route;Compile-time io-stream (read/write interface) for constexpr-dependent context testing
CppShelf testing is compile-time.
format("<expr>", Fs...);auto route = a >>= (b | c) >>= d;
// equivalent to
auto route = csl::wf::parse(
"{} >>= ({} | {}) >>= {}",
a,b,c,d
);
// and
auto route = csl::wf::parse(
"{a} >>= ({b} | {c}) >>= {d}",
"a"_a_value,
"b"_b_value,
"c"_c_value,
"d"_d_value,
); C++??, maybe C++26
For tuple implementation, simplier :
[:]Motivation :
copy_constructible is not the requirement for Fcsl::wf::front_binderAnd more intuitive & obvious resources acquisition / ownership / lifetime
Solution :
Motivation synthaxe :
auto f1_then_f2 = f1 >>= not_owning{ f2 };
// or
auto f1_then_f2 = f1 >>= view | f2;Use Clang-specific attribute [[clang::noexcept_verify]] to avoid unexpected std::terminate() calls
40ants generated badges are not working anymore.
See opened issue : 40ants/github-actions#8
P0847R5 can greatly ease the implementation of various csl::wf components, especially the ones which have multiples operator() overloads to preverse cvref-qualifiers correctness.
In opposition to the way std::function or std::any_invocable are designed,
create some wrapper that conditionaly expose any operator()
namespace csl::wf {
// not template
struct function {
template <typename ...>
operator()();
};
}Add more user-friendly error at compile-time, ratherthan long C++ tmp errors-bloat messages.
Allow by-default std::get<index> on any aggregate type.
Can improve csl::srl, providing a better - yet default - way to (un)serialize aggregates by accessing members using the tuple-interface.
https://godbolt.org/z/7oo3j6dxq
Hypothetic implementation relying on P1061 - Structured Bindings can introduce a Pack
// test using structured-binding with `field_counts` elements ( `== sizeof...(fields_value)`)
// is this expression valid ?
auto [ fields_value... ] = std::declval<T>();
// if so, tuple-like type using `tie`-like function, or
using type = aggregate_tuple_accessor<
std::remove_cvref_t<decltype(fields_value)>
>;
return type{ std::move(fields_value)... };struct toto{ int i; char c; };
using accessors = aggregate_accessors<toto>;
static_assert(std::same_as<
accessors,
csl::srl::descriptions::aggregate_initialization<
&test::tutu::get_i,
&test::tutu::get_c
>
>);
// injection for csl::srl as description-type
namespace csl::srl {
template <Aggregate T>
struct description<T> {
using type = aggregate_accessors<T>;
};
}As addition and/or replacement to STL's
Invocation
Type-traits
csl::wf::is_invocable
csl::wf::is_nothrow_invocable
csl::wf::invoke_result
csl::wf::is_applyable
csl::wf::is_nothrow_applyable
csl::wf::apply_result
POC : https://godbolt.org/z/8noTGTvqa
namespace details::invocation_literals::eval {
// detection/evaluation only
constexpr auto operator>>(auto && args, auto && f)
noexcept (std::is_nothrow_invocable_v<decltype(f), decltype(fwd(args))>)
-> std::invoke_result_t<decltype(f), decltype(args)>
requires (std::invocable<decltype(f), decltype(fwd(args))>)
; // for evaluation only, never defined
}
namespace details::invocation_literals {
// do the job
constexpr auto operator>>=(auto && args, auto && f)
noexcept (std::is_nothrow_invocable_v<decltype(f), decltype(fwd(args))>)
{
return std::invoke(fwd(f), fwd(args));
}
}
namespace details::mp {
template <typename Fs, typename Args>
struct is_chain_nothrow_invocable {
constexpr static bool value = []<std::size_t ... indexes>(std::index_sequence<indexes...>) {
using namespace details::invocation_literals::eval;
return noexcept((std::declval<Args>() >> ... >> std::get<indexes>(std::declval<Fs>())));
}(std::make_index_sequence<std::tuple_size_v<std::remove_cvref_t<Fs>>>{});
};
}mp::depth_ofGet the depth of a template instanciation
using type = int;
static_assert(0 == csl::mp::depth_of_v<type>);using type = std::tuple<int>;
static_assert(1 == csl::mp::depth_of_v<type>);using type = std::tuple<std::tuple<int>>;
static_assert(2 == csl::mp::depth_of_v<type>);Context :
mp::ttps<ts...>Problem :
Current behavior :
auto func = []<typename T>(auto && value){
static_assert(std::same_as<T, int>);
static_assert(std::same_as<std::remove_cvref_t<decltype(value)>, char>);
};
// OK :
func.template operator()<int>('a');
csl::wf::invoke<int>(func, 'a');
csl::wf::invoke(func, csl::wf::mp::ttps<int>{}, 'a');
// OK, redundant ttps
csl::wf::invoke<int>(func, csl::wf::mp::ttps<int>{}, 'a');
// KO : mismatch ttps
csl::wf::invoke<bool>(func, csl::wf::mp::ttps<int>{}, 'a');
csl::wf::invoke<int>(func, csl::wf::mp::ttps<bool>{}, 'a');Solution :
or
wf use mp ?csl::wf could use :
csl::mp::flatten<Ts...>csl::mp::deduplicate_t<Ts...>So there won't be any duplicated code in wf and mp.
Libraries won't be single-files/independent
Dependency of #3 ?
Take is_invocable for instance. Handling two parameter-pack (which are function ttps and args) is not convenient,
thus create an error-prone context.
Before :
template <typename F, typename ... args_t>
constexpr bool is_invocable_v = std::is_invocable_v<F, args_t...>;
template <typename F, typename ... args_t>
constexpr bool is_invocable_v<F, ttps_pack<>, args_t...> =
std::is_invocable_v<F, args_t...>;
;
template <typename F, typename ... ttps_args_t, typename ... args_t>
constexpr bool is_invocable_v<F, ttps_pack<ttps_args_t...>, args_t...> =
requires{ std::declval<F>().template operator()<ttps_args_t...>(std::declval<args_t>()...); }
;Proposal :
ttps and args. template <typename F, typename ttps, typename args>
struct invocable {
static_assert([](){ return false; }(), "parameters must be wrapped in `pack`");
};
template <typename F, typename ... ttps, typename ... args>
struct invocable<F, pack<ttps...>, pack<args...>> {
constexpr static bool value = requires{
std::declval<F>().template operator()<ttps...>(std::declval<args>()...);
};
};
template <typename F, typename ... args>
struct invocable<F, pack<>, pack<args...>> {
constexpr static bool value = std::is_invocable_v<F, args...>;;
};
template <typename F, typename ttps, typename args>
constexpr bool is_invocable_v = invocable<F, ttps, args>::value;
consteval void test() {
const auto f_witht_ttps = []<typename T>(bool, int){};
static_assert(is_invocable_v<decltype(f_witht_ttps), pack<int>, pack<bool, int>>);
const auto f_void = []<typename T>(){};
static_assert( is_invocable_v<decltype(f_void), pack<int>, pack<>>);
static_assert(not is_invocable_v<decltype(f_void), pack<int>, pack<void>>);
static_assert( is_invocable_v<decltype(f_void), pack<int>, details::skip_void_t<pack<void>>>);
}See poc at https://godbolt.org/z/4c674j6Pj.
Pros :
pack_traits over both ttps (no need for additional wrap/unwrap / fold/unfold)Cons :
packSimilar to bind_front, but expand ttps and args after operator() parameters.
Like std::bind_back, but according to the csl::wf design philosophy.
[x] Status token
(see gcl)
route :
- invoke
- same for apply ?
=> as invoke_policy : invoke | apply ?
or automated : is_applyable ? apply : invoke
Part of #50
ag.cmake should only generated C++ code, not preprocessor macros
Make the project easier to debug, rather than forcing user to use external tools or additional compiler options to expand preprocessor macros.
(as currently, this is the compiler that provides the most C++20 features)
/usr/bin/g++ pathDCPP_SHELVE_STANDALONE_EDIT__The following should be a valid syntax :
auto route = []<typename>(char){} >>= [](){};
route.template operator<int>()('a');Requirement for #50
template <std::size_t fields_count> // result of fields_count<T>
auto as_tuple(Aggregate auto && value) {
auto & [ /* id_ ... */ ] = value;
return std::tuple</* of references */>{ /* id_ ... */ };
}As P1061 is not available yet, the only remaining options seems to generate the C++ code - e.g as_tuple specialization using some cmake/python scripts at configure time.
Consider the following design for implementation : https://godbolt.org/z/M59ob4z45
cvref-qualifiers propagationTTPS propagation
noexcept propagationconstexprMost does not scale enough
cvref propagation involves x4 members functions definitions
Not great from a readability/maintenance perspective
Same with recursive lambda
mp::ttps in args should never be discardableContext :
As is, args are discardable while performing a not-nodiscard invocation,
meaning that :
[](){ return int{}; } >>= [](){}; // discard the node_1 return valueis a legal synthax
Improvement :
mp::ttps<Ts...> to be potentionaly discarded.Existing code simplification using C++23 features.
Both can greatly ease the implementation of various csl::wf components, especially the ones which have multiples operator() overloads to preverse cvref-qualifiers correctness, or are restricted to ttps only (nttps not supported yet).
Github-Actions yml file that configures, builds, tests using circle compilerC++23-relying featuresmain branch ./docsmain updateEach component as independent INTEFACE library
csl::wfcsl::workflowAs well as all regrouped into on INTERFACE library, csl::csl
Take best-practices from gcl
Add graphviz into readme
Motivation : create flattening utility to ease flattening of meta-type/sequences
Dependency of :
Depends on :
Consider using a chain_trait to split the detection/infos logic of chains,
https://godbolt.org/z/YjovqK4ds
static_assertsF(args...) vs nodiscard F()Related to #16 (msvc build into the CI)
Internally use a compile-time id-to-lambda mapping
Based on the experience of developing gcl::io::serialization,
Create a compile-time mapping from cx-type-(id|name|hash) to (<some lambda> | function type-erasure) - yet accessible using runtime index
Retrieve T type information from a runtime index/name/hash,
in order to then dispatch it to a generic/overloaded callable (like [](auto && value){ /*decltype(value) is T&&*/ })
Depends on #45
Ease of use ?
csl::srl -> thot-io
Either :
csl::srl componentRequires extension for concurrency
auto f1_and_f2 = f1 || f2;
// design 1 : synchronized join
auto route = f1_and_f2 >>= f3;
route(); // csl::wf::invoke(f3, std::future::when_all(f1_future, f2_future));
// design 2 :
auto route = f1_and_f2 |= f3;
route(); // csl::wf::invoke(f3, std::future::when_any(f1_future, f2_future)); An option should be add to provide a way to differ compact from pretty print (with indentation).
fmt default formatter :
[ 'a', 'b', 'c' ]( 'a', 'b', 'c' )csl::ag formatter :
{ 'a', 'b', 'c' }fmt/std::formatFormatter's parse() presentation : 'c' (compact, default), 'p' (pretty)
Draft/WIP :
React
A declarative, efficient, and flexible JavaScript library for building user interfaces.
🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
Django
The Web framework for perfectionists with deadlines.
Laravel
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. 📊📈🎉
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
Facebook
We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft
Open source projects and samples from Microsoft.
Google
Google ❤️ Open Source for everyone.
Alibaba
Alibaba Open Source for everyone
D3
Data-Driven Documents codes.
Tencent
China tencent open source team.