чем плохи шаблоны? - Nemerle

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

CU>Довольно странное определение, к чисто функциональным языкам относят языки неиспользующими деструктивные модификации, но в шаблонах С++ нет переменных как таковых, есть только типы и константы, порядок вычисления и поток выполнения не определен, то есть невозможно понять в каком порядке компилятор обработает их и невозможно отладить это. К тому же функциональные языки чтобы называться таковыми должны уметь выполнять типичные алгоритмы, можно ли на шаблонах построить дерево, сбалансировать, преобразовать в другой вид? Функции в этих языках первоклассные сущности, в шаблонах же нет функций как таковых преобразующих данные из одного в другой. Поэтому вряд ли их можно назвать чисто функциональным языком, это более надстройка во время компиляции для настройки системы типов, которую пытаются растянут чтобы получить некое метапрограммирование в терминах типов.
В шаблон можно передать шаблон. Шаблон есть первоклассный объект времени компиляции, аналогично функции в чисто функциональном. Для полноты достаточно альтернативы и рекурсии.
С отладкой проблемы. Но тут Просто никто не писал отладку. Представьте если бы в немерли было нельзя останавливать во время компиляции

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

CU>Довольно странное определение, к чисто функциональным языкам относят языки неиспользующими деструктивные модификации, но в шаблонах С++ нет переменных как таковых, есть только типы и константы
Операции над типами и константами недеструктивны по определению

Кто-то (remark? Сложно найти, когда форум отвечает на часть запросов фразой "Language color pattern source xml stream is not valid") на forum/cpp находил способ запоминать кое-какое состояние между вызовами шаблонов, но в результате пришли к выводу, что этот спецэффект возник из-за недочёта реализации используемой фичи в компиляторах.

CU>порядок вычисления и поток выполнения не определен, то есть невозможно понять в каком порядке компилятор обработает их и невозможно отладить это.
Определён

Это ещё и ленивый функциональный язык в плане получения результата — пока явно не запросишь, вычисления не будут произведены.

CU>К тому же функциональные языки чтобы называться таковыми должны уметь выполнять типичные алгоритмы, можно ли на шаблонах построить дерево, сбалансировать, преобразовать в другой вид?
Да без проблем. Дерево можно задать как набор lisp/scheme'вских cons'ов, а потом выполнить неразрушающее преобразование над ним.

CU>Функции в этих языках первоклассные сущности, в шаблонах же нет функций как таковых преобразующих данные из одного в другой.
Их заменяют типы, которые преобразуют переданные типы и тем самым ведут себя как функции.

CU>Поэтому вряд ли их можно назвать чисто функциональным языком, это более надстройка во время компиляции для настройки системы типов, которую пытаются растянут чтобы получить некое метапрограммирование в терминах типов.
Вполне можно назвать, и называют — см. аргументы выше.

Здравствуйте, Аноним, Вы писали:

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

А>В шаблон можно передать шаблон. Шаблон есть первоклассный объект времени компиляции, аналогично функции в чисто функциональном. Для полноты достаточно альтернативы и рекурсии.
Шаблон это не тоже что и функция, и то что он первоклассный это не говорит о том что это делает язык функциональным, как это принято понимать, типичный алгоритм не вызвать в шаблоне запустив его из другого шаблона.

А>С отладкой проблемы. Но тут Просто никто не писал отладку. Представьте если бы в немерли было нельзя останавливать во время компиляции
это и говорит о том что шаблоны не спроектированы чтобы использоваться как полноценная система метапрограммирования, а более допущение, которое пытаются использовать

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

Может кому то все же очень хочется назвать этот язык шаблонов функциональным, ну пожалуйста называйте и используйте, мы же говорим не о терминах, а чем плохи шаблоны по сравнению с макросами Н, я эту разницу показал.

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

CU>Шаблон это не тоже что и функция, и то что он первоклассный это не говорит о том что это делает язык функциональным, как это принято понимать, типичный алгоритм не вызвать в шаблоне запустив его из другого шаблона.
Шаблон представляет собой чистую функцию, позволяющие запускать другие алгоритмы (написанные на шаблонах) из другого шаблона.

CU>это и говорит о том что шаблоны не спроектированы чтобы использоваться как полноценная система метапрограммирования, а более допущение, которое пытаются использовать
Никто не спорит с этим, а вот со следующим:

CU>Может кому то все же очень хочется назвать этот язык шаблонов функциональным, ну пожалуйста называйте и используйте, мы же говорим не о терминах, а чем плохи шаблоны по сравнению с макросами Н, я эту разницу показал.
Спор разгорелся как раз из-за терминов — странного определения тьюринг-полноты.
Никто в ветке не умаляет значимости макросов Nemerle (возможность общаться с системой прямо во время компиляции шикарна) и не хвалит шаблоны плюсов, но оценивать тьюринг-полноту по чтению/записи файлов это же не дело

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

CU>Может кому то все же очень хочется назвать этот язык шаблонов функциональным, ну пожалуйста называйте и используйте, мы же говорим не о терминах, а чем плохи шаблоны по сравнению с макросами Н, я эту разницу показал.
Шаблоны сложны в отладке так как не поддерживаются иде в отличии от макросов. Шаблоны медленны из за того что работают фактически в текстовом виде и не поддерживается компиляция шаблонов в отличии от макросов. Шаблоны сложны в понимании так как являются чистым функциональным языком в отличии от более привычным императивных. Как в чистом функциональном есть проблемы ввода вывода. Шаблоны в отличии от макросов не содержат сайтэффектов. Шаблоны не позволяют создавать произвольный синтаксис. Шаблоны близки к доказательному программированию

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

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

CU>>Довольно странное определение, к чисто функциональным языкам относят языки неиспользующими деструктивные модификации, но в шаблонах С++ нет переменных как таковых, есть только типы и константы
AF>Операции над типами и константами недеструктивны по определению

Кто-то (remark? Сложно найти, когда форум отвечает на часть запросов фразой "Language color pattern source xml stream is not valid") на forum/cpp находил способ запоминать кое-какое состояние между вызовами шаблонов, но в результате пришли к выводу, что этот спецэффект возник из-за недочёта реализации используемой фичи в компиляторах.

CU>>К тому же функциональные языки чтобы называться таковыми должны уметь выполнять типичные алгоритмы, можно ли на шаблонах построить дерево, сбалансировать, преобразовать в другой вид?
AF>Да без проблем. Дерево можно задать как набор lisp/scheme'вских cons'ов, а потом выполнить неразрушающее преобразование над ним.

Вот это не вполне понятно как можно произвести любое преобразование над любым деревом в шаблоне, например балансировку, поясните примером

CU>>Функции в этих языках первоклассные сущности, в шаблонах же нет функций как таковых преобразующих данные из одного в другой.
AF>Их заменяют типы, которые преобразуют переданные типы и тем самым ведут себя как функции.
А как запустить шаблон из шаблона, с новыми аргументами?

AF>Вполне можно назвать, и называют — см. аргументы выше.
Но все же говоря о теме, мы говорим чем они плохи по сравнению с Н, если и попытаться поставить их в разряд чисто функциональных языков, но не дает никакого преимущества

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

AF>Шаблон представляет собой чистую функцию, позволяющие запускать другие алгоритмы (написанные на шаблонах) из другого шаблона.
С этим очень много ограничений, например помоему невозможно вызвать шаблон T с параметрами шаблона T<T2, T3>, ведь T еще не определен, тут придется изловчаться с инстанционированием

AF>Спор разгорелся как раз из-за терминов — странного определения тьюринг-полноты.
AF>Никто в ветке не умаляет значимости макросов Nemerle (возможность общаться с системой прямо во время компиляции шикарна) и не хвалит шаблоны плюсов, но оценивать тьюринг-полноту по чтению/записи файлов это же не дело

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

Здравствуйте, Аноним, Вы писали:

А>Просто писать после императивного в чисто функциональном тяжело. Не понимаешь почему надо писать кучу кода вместо обычного императива. У вас есть опыт написания на чисто функциональном?
Не знаю как на чистом, но на Haskell вместо кучи императивного кода приходится писать несколько строчек функционального.

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

CU>Может я не так понимал тьюринг полноту, я просто сразу вижу что на С++ я могу написать любую программу, а на шаблонах нет. Действительно вопрос вроде ясен, если даже и оставить все эти термины за шаблонами.
А спор был только из-за термина тьюринг-полноты. Шаблоны и brainfuck у нас так, под руку подвернулись

. (Возможно, я повторяюсь, пару раз форум ошибку выплёвывал)

CU>С этим очень много ограничений, например помоему невозможно вызвать шаблон T с параметрами шаблона T<T2, T3>, ведь T еще не определен, тут придется изловчаться с инстанционированием
Можно:

template<class T, class U>
struct Node {
    typedef T head;
    typedef U tail;
};

template<class T, class U>
struct Test2 {
    typedef Node<T, U> result;
};

template<template<class, class> class T, class U, class Z>
struct Test {
    typedef typename T<U, Z>::result result;
};


typedef Test<Test2, int, double>::result A;

Можно свести к синтаксису T::Func<A, B>, если изменить Test2.

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

CU>Довольно странное определение, к чисто функциональным языкам относят языки неиспользующими деструктивные модификации, но в шаблонах С++ нет переменных как таковых, есть только типы и константы, порядок вычисления и поток выполнения не определен, то есть невозможно понять в каком порядке компилятор обработает их и невозможно отладить это.
Скажешь это не программа на чистом функциональном языке?
http://www.rsdn.ru/forum/philosophy/1910243.1.aspx
Там есть функция MergeSort которая принимает список и предикат Int2TypeLess.

Если у меня вдруг появится настроение я даже машину Тьюринга на шаблонах могу изобразить.

... << RSDN@Home 1.2.0 alpha 4 rev. 1472>>

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

WH>Скажешь это не программа на чистом функциональном языке?
WH>http://www.rsdn.ru/forum/philosophy/1910243.1.aspx
WH>Там есть функция MergeSort которая принимает список и предикат Int2TypeLess.

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

Здравствуйте, Аноним, Вы писали:

А>собственно какие возражения против шаблонов? Чем они отличаются от функциональнозапрограммированых макросов

попробуйте написать парсер с#?
посмотрите на сложность кода?
сравните как это сделано в Н. через год расскажите

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

C>Что-то мне кажется, что сделать шаблоны из макросов Nemerle — не запросто.

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

В общем, и целом дженерики решают проблему обобщенного программирования. А шаблоны С++ интересны, в основном, своими возможностями метапрограммирования. Но в этой области макросам нет равных. И уж эмулировать МП на шаблонах созданных на базе макросов просто глупо.

Здравствуйте, Аноним, Вы писали:

А>собственно какие возражения против шаблонов? Чем они отличаются от функциональнозапрограммированых макросов

Анализ кода?
например можно сделать проверку функции на чистоту(правда никто пока не заморачивался) или статическую проверку контрактов целевой функции

удаление или модификация кода?
хотя это и в Н не приветствуется.

уже говорили, но повторюсь
введение синтаксиса,
ввод-вывод

и ещё много много того что невозможно либо очень трудно сделать в шаблонах но легко либо не очень сложно в Н

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

P>Здравствуйте, Аноним, Вы писали:

А>>собственно какие возражения против шаблонов? Чем они отличаются от функциональнозапрограммированых макросов

P>попробуйте написать парсер с#?
P>посмотрите на сложность кода?
P>сравните как это сделано в Н. через год расскажите

вообще то сделали на спирит. Правда дефакто не более чем демонстрация принципиальной возможности

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

Итааак...

>А как запустить шаблон из шаблона, с новыми аргументами?
Это я уже показал: http://rsdn.ru/forum/nemerle/4603395.1.aspx

>Вот это не вполне понятно как можно произвести любое преобразование над любым деревом в шаблоне, например балансировку, поясните примером
Балансировка оказалась крепким орешком. Я не знаю, что я делал дольше — писал реализацию на Scheme в функциональном стиле или переводил на шаблоны C++. Функциональный стиль для некоторых алгоритмов мне не даётся до сих пор

Поэтому я позволил себе некоторую роскошь: вместо cons взял более привычный императивщикам (struct Node (value left right)) и цвет оставил прямо в структуре узла: (struct Node (value left right color)). Исходник на Scheme приводить не буду, т.к. он до страшного упрощён, чтобы было легче переводить в шаблоны, а результат — ниже.
Алгоритм принимает на вход сбалансированное бинарное дерево (именно дерево, не представляющий дерево список) и балансирует его. Вывод результатов ради удобства форматирования сделан в runtime.

Код

#include <cstdio>
#include <string>

enum Color {
    white,
    grey
};

struct Null {};

template<int Value, class LeftType = Null, class RightType = Null, Color ColorValue = white>
struct Node {
    static int const value = Value;
    typedef LeftType Left;
    typedef RightType Right;
    static Color const color = ColorValue;
};

// ---

template<class T, class U>
struct Equal {
    static bool const value = false;
};

template<class T>
struct Equal<T, T> {
    static bool const value = true;
};

// ---

template<class T>
struct IsLeaf {
    static bool const value =
        Equal<typename T::Left, Null>::value
        && Equal<typename T::Right, Null>::value;
};

// ---

template<class T>
struct IsHaveRightChild {
    static bool const value = not Equal<typename T::Right, Null>::value;
};

// ---

template<class X>
struct LeftTurn {
    typedef typename X::Right Y;
    typedef Node<
        Y::value,
        Node<X::value, typename X::Left, typename Y::Left>,
        typename Y::Right
>> Result;
};

// ---

template<class Tree>
struct TreeToLeftList;

template<class Tree, bool Leaf, bool HaveRightChild>
struct TreeToLeftListImpl;

template<class Tree, bool HaveRightChild>
struct TreeToLeftListImpl<Tree, true, HaveRightChild> {
    typedef Tree Result;
};

template<class Tree>
struct TreeToLeftListImpl<Tree, false, true> {
    typedef typename LeftTurn<Tree>::Result Transformed;
    typedef typename TreeToLeftList<Transformed>::Result Result;
};

template<class Tree>
struct TreeToLeftListImpl<Tree, false, false> {
    typedef typename TreeToLeftList<typename Tree::Left>::Result Left;
    typedef Node<Tree::value, Left> Result;
};

template<class Tree>
struct TreeToLeftList {
    typedef typename TreeToLeftListImpl<Tree, IsLeaf<Tree>::value, IsHaveRightChild<Tree>::value>::Result Result;
};

// ---

template<class Tree>
struct TreeLeftLength {
    static std::size_t const value = 1 + TreeLeftLength<typename Tree::Left>::value;
};

template<>
struct TreeLeftLength<Null> {
    static std::size_t const value = 0;
};

// ---

template<class X>
struct RightTurn {
    typedef typename X::Left Y;
    typedef Node<
        Y::value,
        typename Y::Left,
        Node<X::value, typename Y::Right, typename X::Right>
>> Result;
};

// ---

template<std::size_t Value>
struct IsPowerOfTwo {
    static bool const value = (( Value & ( Value - 1 )) == 0) && Value != 0;
};

// ---

template<class Tree, std::size_t Addition = 1>
struct CorrectTree;

template<class Tree, std::size_t Addition, bool End>
struct CorrectTreeImpl {
    typedef typename RightTurn<Tree>::Result Transformed;

    typedef
        Node<Transformed::value, typename CorrectTree<typename Transformed::Left, Addition + 1>::Result, typename Transformed::Right>
    Result;
};

template<class Tree, std::size_t Addition>
struct CorrectTreeImpl<Tree, Addition, true> {
    typedef Tree Result;
};

template<class Tree, std::size_t Addition>
struct CorrectTree {
    typedef typename CorrectTreeImpl<
        Tree,
        Addition,
        IsPowerOfTwo<TreeLeftLength<Tree>::value + Addition>::value
>>::Result Result;
};

// ---

template<class Tree>
struct IsEnd {
    static bool const value = Tree::Left::color == grey;
};

template<int Value, class Right, Color ColorValue>
struct IsEnd< Node<Value, Null, Right, ColorValue> > {
    static bool const value = true;
};

// ---

template<class Tree>
struct BalanceStep;

template<class Tree, bool IsEnd>
struct BalanceStepImpl;

template<class Tree>
struct BalanceStepImpl<Tree, true> {
    typedef Node<Tree::value, typename Tree::Left, typename Tree::Right, grey> Result;
};

template<class Tree>
struct BalanceStepImpl<Tree, false> {
    typedef typename RightTurn<Tree>::Result Transformed;
    typedef typename Transformed::Left Left;
    typedef typename Transformed::Right Right;

    typedef Node<
        Transformed::value,
        typename BalanceStepImpl<Left, IsEnd<Left>::value>::Result,
        Node<Right::value, typename Right::Left, typename Right::Right, grey>
>> Result;
};

template<class Tree>
struct BalanceStep {
    typedef typename BalanceStepImpl<Tree, IsEnd<Tree>::value>::Result Result;
};

template<class Tree, bool isEnd>
struct BalanceImpl {
    typedef typename BalanceStep<Tree>::Result CurrentTree;
    typedef typename BalanceImpl<CurrentTree, IsEnd<CurrentTree>::value>::Result Result;
};

template<class Tree>
struct BalanceImpl<Tree, true> {
    typedef Tree Result;
};

// ---

template<class Tree>
struct Balance {
    typedef typename TreeToLeftList<Tree>::Result LeftList;
    typedef typename CorrectTree<LeftList>::Result CorrectedTree;

    typedef typename BalanceStep<CorrectedTree>::Result CurrentTree;
    typedef typename BalanceImpl<CurrentTree, IsEnd<CurrentTree>::value>::Result Result;
};

// ----

template<class T>
struct Printer;

template<>
struct Printer<Null> {
    static void print( std::size_t const level = 0, bool const printNull = true ) {
        if( printNull ) {
            std::string tabs( level, ' ' );
            std::printf( "%s[none]\n", tabs.c_str() );
        }
    }
};

template<int Value, class Left, class Right, Color ColorValue>
struct Printer< Node<Value, Left, Right, ColorValue> > {
    static void print( std::size_t const level = 0, bool = true ) {
        std::string tabs( level, ' ' );
        std::printf( "%s%d\n", tabs.c_str(), Value );

        if( not IsLeaf< Node<Value, Left, Right, ColorValue> >::value ) {
            Printer<Left>::print( level + 1 );
            Printer<Right>::print( level + 1, false );
        }
    }
};

// ---

typedef
    Node<20,
        Node<14,
            Node<10,
                Node<7,
                    Node<5,
                        Node<3>,
                        Node<6>
                >>
            >>,
                Node<11,
                    Null,
                    Node<12>
            >>
        >>
    >>,
        Node<25>
>>
Graph1;

typedef
    Node<1,
        Null,
        Node<6,
            Node<4,
                Node<2,
                    Null,
                    Node<3>
            >>,
                Node<5>
        >>,
            Node<13,
                Node<8,
                    Node<7>,
                    Node<12,
                        Node<9,
                            Null,
                            Node<11,
                                Node<10>
                        >>
                    >>
                >>
            >>,
                Node<14,
                    Null,
                    Node<15>
            >>
        >>
    >>
>>
Graph2;

int main() {
    Printer<Graph1>::print();
    std::puts( "" );
    Printer<Balance<Graph1>::Result>::print();
    std::puts( "===" );
    Printer<Graph2>::print();
    std::puts( "" );
    Printer<Balance<Graph2>::Result>::print();
}

Вывод (бинарное дерево, сбалансированное дерево, разделитель "===", [none] == "левый узел отсутствует"):

	Вывод
	`20 14 10 7 5 3 6 11 [none] 12 25 7 5 3 6 12 10 [none] 11 20 14 25 === 1 [none] 6 4 2 [none] 3 5 13 8 7 12 9 [none] 11 10 14 [none] 15 8 4 2 1 3 6 5 7 12 10 9 11 14 13 15`

Здравствуйте, Аноним, Вы писали:

А>Что мешает эту прагму использовать в шаблонах и получать сообщения об ошибках? Эта прагма не более чем printf

Мешают сразу две вещи.

1. Прагма не является частью языка и не может быть испльзована в переносимомо коде.
2. Она выведет сообщение не во время воплощения (инстанциации, как это дело часто называют) шаблона, и не в зависимости от условий, а тупо при обработке компилятором строки файла в котором она применяется.

Короче, вот тебе простой макрос. Попробуй его повторить на С++:

macro Hello(name : string, count : int)
{
  if (count <= 0)
    Message.Error("The parameter 'count' must be greater than 0.");
  else repeat (count)
    Message.Hint($"Hello, $name!");

  <[ () ]> // ничего не генерировать в программе
}

И это еще так, цветочки. Макросы в отличии от шаблонов ведь могут анализировать код, читать данные из внешних источников (вплоть до баз данных), типизировать полученные выражения и генерировать, на основании всего этого специализированный код. Причем код макроса — это откомпилированный код по скорости не отличающийся от кода самого компилятора. В отличии от шаблонов, вычисления в которых делаются на побочных эффектах весьма дорогостоящих операций вроде рекурсивного воплощения шаблонов.

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

CU>Так о каких таких шаблонах идет речь, если не о С++ и где там чисто функциональный язык и хвостовая рекурсия?

Пойди и почитай теорию.

ЗЫ

Ты не о том споришь. Тюринг полнота ни разу не достаточна для решения конкретных задач.

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

AF>Никто в ветке не умаляет значимости макросов Nemerle (возможность общаться с системой прямо во время компиляции шикарна) и не хвалит шаблоны плюсов, но оценивать тьюринг-полноту по чтению/записи файлов это же не дело

Вообще-то умаляет и хвалит. Но с тюринг-полнотой CodingUnit действительно путает. Это распространенное заблуждение — подмена понятия отсутствие ограничений в доступе к данным и полноту по тьюрингу.

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

WH>Если у меня вдруг появится настроение я даже машину Тьюринга на шаблонах могу изобразить.

Это вряд ли. Что будешь в качестве непрерывной ленты использовать?

	От:	Аноним
	Дата:	04.02.12 10:47
	Оценка:	+1

	От:	Alexey F
	Дата:	04.02.12 11:00
	Оценка:

	От:	CodingUnit
	Дата:	04.02.12 11:20
	Оценка:

	От:	Alexey F
	Дата:	04.02.12 11:27
	Оценка:

	От:	Аноним
	Дата:	04.02.12 11:32
	Оценка:	+1

От:	VladD2	www.nemerle.org
Дата:	04.02.12 18:13
Оценка: