Необходимость перегрузки шаблонных параметров шаблонов ? - C/C++

2 frogkiller особенно

Хочу организовать CompileTime комбинаторы (SKI). Например Ix = x

template <template <class> class X>
struct I
{ template <template <class> class A>
  struct L
  { typedef typename X<A>::L R;
  };
};

Все в принципе замечательно, но X могжет принимать в качестве аргументов
неизвестное количество функций, т.е.

template <class,...> class X
возможно, что правильнее даже:
template <template <...> class> class X

и так с неограничееной вложенностью

У кого нибудь есть мысли как организовать I в CompileTime ???

Здравствуйте, Gluk_Kazan, Вы писали:

G_K>2 frogkiller особенно

G_K>Хочу организовать CompileTime комбинаторы (SKI). Например Ix = x

G_K>Все в принципе замечательно, но X могжет принимать в качестве аргументов
G_K>неизвестное количество функций, т.е.

G_K>template <class,...> class X

засунь class,... в тип Tuple, с ним и работай.

G_K>возможно, что правильнее даже:
G_K>template <template <...> class> class X

ты бы template <template <> class X> не очень увлекался.

G_K>и так с неограничееной вложенностью

G_K>У кого нибудь есть мысли как организовать I в CompileTime ???

если объяснишь, что конкретно хочешь получить, вероятность получить помощь возрастет...

Здравствуйте, night beast, Вы писали:

NB>засунь class,... в тип Tuple, с ним и работай.
NB>ты бы template <template <> class X> не очень увлекался.

какой-то переходник с переменных числом аргументов вероятно необходим
но Tuple принимает классы, а мне надо принимать шаблоны
Думать надо

NB>если объяснишь, что конкретно хочешь получить, вероятность получить помощь возрастет...

Хочу получить S, K и I комбинаторы в CompileTime

Здравствуйте, night beast, Вы писали:

NB>ты бы template <template <> class X> не очень увлекался.

И это говорит автор night lambda?

NB>если объяснишь, что конкретно хочешь получить, вероятность получить помощь возрастет...

Имхо, товарищ конкретно не знает, что хочет получить — пробует разные инструменты для эмуляции элементов ФП.
Но кто знает, вдруг из этого получится что-то интересное. Имхо вреда от этого точно не будет, а польза, хотя бы для него лично, несомненна.

Здравствуйте, frogkiller, Вы писали:

NB>>ты бы template <template <> class X> не очень увлекался.

F>И это говорит автор night lambda?

вот как раз template <template <> class X> у меня там нет.
стандартный подход описан в книге "C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond":

struct F {
   template<typename T1>
   struct apply {
      typedef чегонибудь<T1> type;
   }
};

и везде передавать F.

NB>>если объяснишь, что конкретно хочешь получить, вероятность получить помощь возрастет...

F>Имхо, товарищ конкретно не знает, что хочет получить — пробует разные инструменты для эмуляции элементов ФП.
F>Но кто знает, вдруг из этого получится что-то интересное. Имхо вреда от этого точно не будет, а польза, хотя бы для него лично, несомненна.

дык а кто спорит?
просто не все знакомы с хаскелем (увы)

Здравствуйте, Gluk_Kazan, Вы писали:

G_K>

G_K>template <template <class> class X>
G_K>struct I
G_K>{ template <template <class> class A>
G_K>  struct L
G_K>  { typedef typename X<A>::L R;
G_K>  };
G_K>};
G_K>

G_K>Все в принципе замечательно, но X могжет принимать в качестве аргументов
G_K>неизвестное количество функций, т.е.

G_K>template <class,...> class X
G_K>возможно, что правильнее даже:
G_K>template <template <...> class> class X

G_K>и так с неограничееной вложенностью

G_K>У кого нибудь есть мысли как организовать I в CompileTime ???

Подойдёт обычный typelist. Только для шаблонов с разным количеством параметров нужно написать адаптер,
делающий его обычным классом:

template <typename T>
struct Adaptor0
{
    struct Rebind
    {
        typedef T Result;
    };
};

template <template <class> class T>
struct Adaptor1
{
    template <class T1>
    struct Rebind
    {
         typedef T<T1> Result;
    };
};

template <template <template <class> class, class> class T>
struct Adaptor21
{
    template <template <class> T11, class T12>
    struct Rebind
    {
         typedef T<T11, T12> Result;
    };
};

И тд...
Соответственно, если после каждого применения "оператора" у нас будет полностью определенный класс, то со вложенностью проблем быть не должно

Здравствуйте, frogkiller, Вы писали:

F>Подойдёт обычный typelist. Только для шаблонов с разным количеством параметров нужно написать адаптер,
F>делающий его обычным классом:

...

F>И тд...
F>Соответственно, если после каждого применения "оператора" у нас будет полностью определенный класс, то со вложенностью проблем быть не должно

Сенькс подумаю

Здравствуйте, night beast, Вы писали:

NB>вот как раз template <template <> class X> у меня там нет.
NB>стандартный подход описан в книге "C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond":
NB>

NB>struct F {
NB>   template<typename T1>
NB>   struct apply {
NB>      typedef чегонибудь<T1> type;
NB>   }
NB>};
NB>

NB>и везде передавать F.

Если я правильно понимаю, то одной из причин рекомендации этой техники является недостаточная поддержка шаблонов разными компиляторами, а требовалось, чтобы это компилялось какими-нибудь VC6 и bcc5.5.

F>>Имхо, товарищ конкретно не знает, что хочет получить — пробует разные инструменты для эмуляции элементов ФП.
F>>Но кто знает, вдруг из этого получится что-то интересное. Имхо вреда от этого точно не будет, а польза, хотя бы для него лично, несомненна.

NB>дык а кто спорит?
NB>просто не все знакомы с хаскелем (увы)

Ух, хаскель такая страшная штука, я уже несколько лет хожу вокруг него с переменным успехом — очень трудно идёт.
А шаблоны, они родные, С++шные. Способ познания через реализацию привычными инструментами — вполне себе способ.

Здравствуйте, Gluk_Kazan, Вы писали:

G_K>2 frogkiller особенно

G_K>Хочу организовать CompileTime комбинаторы (SKI). Например Ix = x

G_K>

G_K>template <template <class> class X>
G_K>struct I
G_K>{ template <template <class> class A>
G_K>  struct L
G_K>  { typedef typename X<A>::L R;
G_K>  };
G_K>};
G_K>

G_K>Все в принципе замечательно

"ComeauTest.c", line 5: error: argument list for template template parameter "A" is
missing
{ typedef typename X<A>::L R;
^

template <template <template<class> class> class X>
struct I
{ template <template <class> class A>
  struct L
  { typedef typename X<A>::L R;
  };
};

Здравствуйте, frogkiller, Вы писали:

F>Ух, хаскель такая страшная штука, я уже несколько лет хожу вокруг него с переменным успехом — очень трудно идёт.
F>А шаблоны, они родные, С++шные. Способ познания через реализацию привычными инструментами — вполне себе способ.

+1

на монадах пока увяз, сделал перерывчик

Здравствуйте, Lorenzo_LAMAS, Вы писали:

L_L>"ComeauTest.c", line 5: error: argument list for template template parameter "A" is
L_L> missing
L_L> { typedef typename X<A>::L R;

Это был иллюстративный пример. Принципиально нерабочий

Здравствуйте, frogkiller, Вы писали:

NB>>вот как раз template <template <> class X> у меня там нет.
NB>>стандартный подход описан в книге "C++ Template Metaprogramming: Concepts, Tools, and Techniques from Boost and Beyond":

NB>>struct F {
NB>>   template<typename T1>
NB>>   struct apply {
NB>>      typedef чегонибудь<T1> type;
NB>>   }
NB>>};

NB>>и везде передавать F.

F>Если я правильно понимаю, то одной из причин рекомендации этой техники является недостаточная поддержка шаблонов разными компиляторами, а требовалось, чтобы это компилялось какими-нибудь VC6 и bcc5.5.

не совсем.
шаблон может принимать разное количество и типы параметров. а может и вообще не принимать.
если напишешь только для оного, то все остальные варианты работать не будут.
а так получаешь единый механизм для всего.

Здравствуйте, Gluk_Kazan, Вы писали:

G_K>Хочу организовать CompileTime комбинаторы (SKI). Например Ix = x

Прежде всего, нужно сообразить — как ты хочешь выразить аппликацию combinator.arg1.arg2.arg3... и группировку comb1.(comb2.args...).args...
Очень неудобно превращать аппликацию в кучу скобок (((comb.arg1).arg2).arg3, лучше найти какой-то левоассоциативный инфиксный оператор.

Предлагаю:
— для группировки использовать угловые скобки
— для аппликации — вот такую конструкцию

SomeCombinator ::apply<Arg1>::type ::apply<Arg2>::type ::apply<Arg3>::type

В общем виде это будет выглядеть так

struct SomeCombinator
{
    template<class X> struct apply : mpl_blablabla {};
};

Поехали

#define BEGIN typename
#define APPLY(x) ::template apply< x >::type

template<class X> struct identity { typedef X type; };

struct I
{
    template<class X> struct apply : identity< X > {};
};

template<class X> struct Kx
{
    template<class Y> struct apply : identity< X > {};
};
struct K
{
    template<class X> struct apply : identity< Kx<X> > {};
};

template<class X, class Y> struct Sxy
{
    template<class Z> struct apply : identity< BEGIN X APPLY(Z) APPLY(BEGIN Y APPLY(Z)) > {};
};
template<class X> struct Sx
{
    template<class Y> struct apply : identity< Sxy<X,Y> > {};
};
struct S
{
    template<class X> struct apply : identity< Sx<X> > {};
};

// пример

BEGIN I APPLY(int) i1 = 123; // идентичность
BEGIN K APPLY(int) APPLY(S) i2 = 123; // проверяем, как работает канцеллятор
BEGIN S APPLY(K) APPLY(K) APPLY(int) i3 = 123; // теорема: I = SKK

typedef BEGIN S APPLY(K) APPLY(K) SKK; // обратите внимание: результат редукции - это не шаблон, а обычный тип!
BEGIN SKK APPLY(int) i4 = 123; // и действительно, SKK работает как I

Пример показывает, что базис IKS — избыточен, достаточно базиса KS.
(Кстати, базис булевой алгебры {и,или,не} тоже избыточен, достаточно {и,не} либо {или,не}).

Следующий шаг — это автоматический карринг.

struct S_
{
    template<class X, class Y, class Z> struct apply3 : identity< BEGIN X APPLY(Z) APPLY(BEGIN Y APPLY(Z)) > {};
};
struct S : applicator3<S_> {};

// или даже вот так

struct S : applicator3< BEGIN _1 APPLY(_3) APPLY(BEGIN _2 APPLY(_3) > {};

Ну это я пока не знаю, как реализовать.

... << RSDN@Home 1.2.0 alpha rev. 655>>

	От:	Gluk_Kazan
	Дата:	19.06.08 07:21
	Оценка:

	От:	night beast
	Дата:	19.06.08 07:40
	Оценка:

	От:	Gluk_Kazan
	Дата:	19.06.08 07:56
	Оценка:

	От:	frogkiller
	Дата:	19.06.08 07:57
	Оценка:

	От:	night beast
	Дата:	19.06.08 08:06
	Оценка: