Они к компилятору отношения не имеют вроде бы

Они в смак пытались DPC++ протащить

вроде протащено давно

во всяком случае я собираю семплы шмейком

Гм. Завернули их

(<*>).(<*>)
подскажите, а я могу в c++ описать некий маппинг от типа в тип и использовать его в описании темплейта? вроде такого:

template <typename T, typename X = MapType(T)>
... ...()
{
 return f<T>(...);
}

(<*>).(<*>)
опечатка, вот:

template <typename T, typename X = MapType(T)>
... ...()
{
return f<X>(...);
}

(<*>).(<*>)
я не хочу указывать X вручную. но смотря на T я знаю какой будет X

(<*>).(<*>)
более конкретно. вот есть у меня полиморфная функция:

template <typename A, template<typename>typename P = Parser>
P<A> map_parsing_failure(function<ParsingError(ParsingError)> map_fn, P<A> parser)
{
return P<A>{[=](auto input) {
 return visit(overloaded {
  [=](ParsingError err) -> ParsingResult<A, Input> { return map_fn(err); },
  [](ParsingSuccess<A, Input> x) -> ParsingResult<A, Input> { return x; }
 }, parser(input));
}};
}

(<*>).(<*>)
вот видите тут Input, дело в том, что для разных P там разный тип должен быть. просто когда я вижу P = Parser, я знаю что это Input, а когда например у P = FromJsonParser, то там уже не Input будет, а JsonValue

(<*>).(<*>)
для конкретного P, всегда конкретный этот тип должен быть. нет смысла его вручную писать

(<*>).(<*>)
если не ошибаюсь, то условно то, что я хочу, называется — functional dependencies

(<*>).(<*>)
пример на Haskell:

type family MapType (t :: Type) :: Type where
 MapType Parser = Input
 MapType FromJsonParser = JsonValue

Через ассоциированный тип у обобщённой структуры. Всякие char_traits/iterator_traits из STL так работают

(<*>).(<*>)
я хотел бы что-нибудь вроде этого, если бы это было возможно:

template <template<typename>typename T>
class ParserInput;

using ParserInput<Parser> = Input;

(<*>).(<*>)
пытаюсь (пока без успеха) провернуть такое:

template <template<typename>typename T>
struct ParserInput;

template <>
struct ParserInput<Parser> { typedef Input ParserInputType; };

template <>
struct ParserInput<FromJsonParser> { typedef FromJsonInput ParserInputType; };

ParserInput<P> x;
... ParsingResult<A, decltype(x.ParserInputType)> { ... },

(<*>).(<*>)
лол, кажется получилось

(<*>).(<*>)
template <template<typename>typename T>
struct ParserInput;
template <>
struct ParserInput<Parser> { Input input_type; };
template <>
struct ParserInput<FromJsonParser> { FromJsonInput input_type; };

(<*>).(<*>)
template <typename A, template<typename>typename P = Parser>
P<A> map_parsing_failure(function<ParsingError(ParsingError)> map_fn, P<A> parser)
{
ParserInput<P> x;
using I = decltype(x.input_type);
return P<A>{[=](auto input) {
 return visit(overloaded {
  [=](ParsingError err) -> ParsingResult<A, I> { return map_fn(err); },
  [](ParsingSuccess<A, I> x) -> ParsingResult<A, I> { return x; }
 }, parser(input));
}};
}

(<*>).(<*>)
есть ли менее грязный способ провернуть подобное?