Hogere typen met C++

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 een reverse-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::vectorneemt een type parameter om een ​​echt type te creëren zoals std::vector<int>, dus het heeft een soort * -> *.

Other episodes