Deze vraag is voor de mensen die zowel Haskell (of een andere functionele taal die hogere typen ondersteunt) als C++ kennen…
Is het mogelijk om hogere typen typen te modelleren met behulp van C++-sjablonen? Zo ja, hoe dan?
BEWERKEN:
Van ditpresentatie door Tony Morris:
Polymorfisme van hogere orde:
-
Talen zoals Java en C# hebben
eerste-orde polymorfisme omdat ze
laat ons abstraheren over typen. bijv.
List<A>
kan eenreverse
-functie hebben
dat werkt op elk elementtype (de
A
). -
Meer praktische programmeertalen
en typesystemen stellen ons in staat om
abstract over typeconstructors als
goed. -
Deze functie wordt hogere orde genoemd
(of hoger soort) polymorfisme.
Voorbeeld:
Pseudo-Java met een uitgevonden notatie voor polymorfisme van hogere orde
interface Transformer<X, Y> {
Y transform(X x);
}
interface Monad<M> { // M :: * -> *
<A> M<A> pure(A a);
<A, B> M<B> bind(Transformer<A, M<B>> t, M<A> a);
}
Antwoord 1, autoriteit 100%
Template-template parameters?
template <template <typename> class m>
struct Monad {
template <typename a>
static m<a> mreturn(const a&);
template <typename a, typename b>
static m<b> mbind(const m<a>&, m<b>(*)(const a&));
};
template <typename a>
struct Maybe {
bool isNothing;
a value;
};
template <>
struct Monad<Maybe> {
template <typename a>
static Maybe<a> mreturn(const a& v) {
Maybe<a> x;
x.isNothing = false;
x.value = v;
return x;
}
template <typename a, typename b>
static Maybe<b> mbind(const Maybe<a>& action, Maybe<b>(*function)(const a&)) {
if (action.isNothing)
return action;
else
return function(action.value);
}
};
Antwoord 2, autoriteit 5%
Is een normaal sjabloon meestal niet al een hoger type? Bijvoorbeeld std::vector
neemt een type parameter om een echt type te creëren zoals std::vector<int>
, dus het heeft een soort * -> *
.