I'm still trying to get a Haskell type system for metaprogramming, and today I relalized that Concepts Lite is the right way to go. So I was going to start writting concepts for my library but then stoped: What if you can use exactly the same concepts for both the metaprogramming type system and the C++ type system? That's why I'm here.
So yeah, your idea isn’t crazy at all Manu.
First of all I will try to get a Concepts Lite compiler working (I'm trying to build gcc-clite on windows/cygwin, completely unsuccessful. Seems impossible to me being able to play battlefield while doing meta stuff...). Later wrap your existing concepts as
constexpr boolean predicates as their implementation expects (What about a clitebranch?). Then I could continue haskellizing both TMP and C++ with Hana as the starting point.
One challenge though is that C++ is a strict language. So you can’t have exactly the same concepts as in Haskell. For example, you can’t right fold infinite lists in C++.
This message was deleted
Applicative if you let go of automatic currying
Monad just the same
Yes, Hana has the
curry adaptor.
Regarding Applicative, by the way, Hana uses the
curry adaptor to emulate automatic currying. This makes things like f <transform> x <ap> y <ap> z equivalent to curry(f) <transform> x <ap> y <ap> z, where <...> is just infix application of ….
This exact process happens here. Given
f a function inside an Applicative and n arguments inside the same Applicative, I simply fmap curry f, which gives me an Applicative of curried functions.
I’m not sure how a
lazy adaptor would help.
To implement lazy folds, I mean.
One problem is that Haskell does deep laziness, in the sense that every subexpressions of every expression is lazy. With a
lazy adaptor, we can only get superficial laziness at one level.
Conceptually, having deep laziness in C++ means to do the “evaluation” of lazy thunks manually, whereas it is done automatically in Haskell. Also, you won’t be memoizing the results of computations, which makes a lot of brilliant lazy patterns completely worthless.
My impression is that evaluating lazy thunks manually will be very painful from a programmer’s perspective.
Anyway, that’s the current state of my understanding of things. This is why Hana does not try to go
lazy except in some simple cases (e.g. for conditional statements), and this is also why the usual Haskell concepts are broken up into more parts (Iterable, Foldable and Searchable instead of just Foldable in Haskell).
But I agree that laziness would be something nice to have. Also, I’d like to point out that this issue is really not limited to metaprogramming or implementing Haskell in C++. Indeed, the range-v3 people are bumping against similar issues, see ericniebler/range-v3#142.
Being frankly the only use case that comes to my mind for laziness (From the C++ point of view) are infinite ranges and related. In depth laziness and non-strict functions are cool, but their advantages may not worth the effort. Let's forget lazy for now (right fold included).
I'm gonna try to focus on translating the existing concepts to CL for now.