CreateIndex(name, table, isClustered, isUnique, entries) ::= <<
/* General:CreateIndex */
CREATE $Unique(isUnique)$ $Clustered(isClustered)$ INDEX $Quot(name)$ ON $Quot(table)$
(
  $entries:{ entry | $entry.Column$ $Direction(entry.IsAscending)$}; separator=",\n"$
)
>>

10.1 Гигиеничные макросы Scheme

У нашей системы много общего с современными макрорасширениями Scheme[1]:
• Альфа-переименование и связывание переменных выполняется после развертывания макроса, с использованием контекста, хранимого в макросе.
• Макросы могут контролируемо использовать внешние имена, не боясь пересечься с посторонними именами.
• Сторона, на которой вызывается макрос, не использует какого-либо особого синтаксиса для вызова макросов, единственное место, где используется особый синтаксис – определение макроса, что обуславливает легкость использования макросов программистами, несведущими в метапрограммировании.
Поддерживая перечисленное выше, мы встроили систему макросов в статически типизированный язык. Типы в сгенерированном коде проверяется после раскрытия. Мы также обеспечиваем четкое разделение этапов – метафункции до использования должны быть скомпилированы и сохранены в библиотеке.
Работа над Scheme длилась довольно долго, и предлагалось много интересных вещей. Например, макросы первого класса в [9], кажется, можно реализовать в Nemerle с помощью простой передачи функций, оперирующих кодом объектов.

10.4 CamlP4

CamlP4 [12] – это препроцессор для OCaml. Его LL(1)-парсер — полностью динамический, что позволяет выразить весьма сложные расширения грамматики. Макросы (именуемые расширениями синтаксиса) должны быть скомпилированы и загружены в парсер до использования. При работе они могут конструировать новые выражения (используя систему цитирования), но только на уровне нетипизированного дерева разбора. Более углубленное взаимодействие с компилятором невозможно.

10.2 Template Haskell

Между макросами Template Haskell [2] и Nemerle есть интересные различия:
• Разрешение связываний при трансляции цитирования дает возможность сделать вывод о корректности типов объектного кода до его использования. Это позволяет значительно раньше обнаруживать ошибки. Но наличие splicing-конструкции $ делает типизацию отложенной до следующего этапа компиляции, и в этом случае новые связывания должны быть динамическими.
• Макросы Template Haskell, как и любая другая функция Haskell, являются функциями высшего порядка: их можно передавать как аргументы, применять частично и т.д. Это, однако, требует вручную помечать, какой код должен исполняться при компиляции. Мы решили позволить вызывать макросы просто по имени (как в Scheme), так что их использование выглядит как вызов обычной функции. Вы по-прежнему можете использовать функции высшего порядка (функции, оперирующие объектным кодом, могут быть произвольными), но только верхние метафункции (предваряемые macro) запускают вычисления во время компиляции.
• Мы не ограничиваем splicing объявлений с кодом верхнего уровня и не вводим особого синтаксиса для вводящих их макросов. Это кажется хорошим способом использования преимуществ связывания имен после раскрытия макроса и императивного стиля, присущего Nemerle. Для императивного программиста естественно думать о вводимых определениях как о побочных эффектах вызова макросов, даже если эти вызовы находятся в цитируемом коде.
• Мы вводим макросы, оперирующие с типами, объявляемыми в программе, и способные императивно изменять их. Более того, они выглядят как атрибуты, применяемые к определениям типов, так что опять же программисту не обязательно знать что-нибудь о метапрограммировании, чтобы использовать их.
Есть еще много сходств с Template Haskell. Мы напрямую позаимствовали оттуда идею квази-цитирования и splicing-а. Идеи исполнения функций при компиляции и отложенной проверки типов также навеяна Template Haskell.

MetaOCaml is a compiled dialect of MetaML.

10.6 MetaML

MetaML [7] вдохновил и Template Haskell и MacroML, введя квази-цитирование и идею типизация объектного кода. Он был разработан в основном для операций с кодом и его исполнения в рантайме, так что это несколько отличающаяся от нашей область деятельности.

10.5 MacroML

В MacroML [6] было предложено использовать макросы времени компиляции для языка ML. Это имеет много общего с Template Haskell в смысле связывания имен в цитировании до раскрытия макросов. MacroML, кроме того, позволяет захватывать символы в месте применения макроса (это похоже на нашу функцию UseSiteSymbol()). И все это производится без необходимости отказываться от типизации цитат.
Макросы в MacroML ограничены конструированием кода из имеющихся частей, поиск декомпозиция и кода невозможны.

Ну, а лично я полностью уверен, что Неперле превосходит Окамл и Хаскель. Как минимум Немерле значительно удобнее если рассматривать его как статически-типизированный, типобезопасный, объектно-ориентированный язык.

Ну, а лично я полностью уверен, что Неперле превосходит Окамл и Хаскель. Как минимум Немерле значительно удобнее если рассматривать его как статически-типизированный, типобезопасный, объектно-ориентированный язык.

Я считаю реализацию ООП в Окале неудобной.

Функциональное программирование — это парадигма программирования трактующая вычисления как вычисление математических функций, т.е. отсуствие побочных эффектов/изменения переменных.

fun(список параметров){ тело }

lambda x -> тело

def list1 = [1, 3, 5, 9];
def Add(a, b) { a + b } // функция с двумя аргументами
def list2 = list1.Map(Add(_, 1)); // Применяем ее как функцию с одни аргументом

variant Tree [T]
{ | Node { left : Tree[T]; mid : T; right : Tree[T]; }
  | Leaf

  public override ToString () : string
  {
    match (this)
    { | Node (l, m, r) => $"($l $m $r)"
      | Leaf           => "."
    }
  }
} 

def tree = Tree.Node(Tree.Node(Tree.Leaf(), 1, Tree.Leaf()), 2, Tree.Leaf());
System.Console.WriteLine(tree.ToString());

((. 1 .) 2 .)

Как приятный бонус я ей рад. Но как единственно-верное учение — увольте.

AXX>Это о возможности писать в функциональном стиле... и ведь верно, очень хорошо, что я могу не меняя язык, писать, как в одном стиле, так и в другом. И именно в этом прелесть Nemerle, а не в том, что он в плане функционального программирования лучше любого ФЯ (он не претендует на это звание) или что он в плане ООП лучше любого ОО языка (на это он тоже, как я понимаю, не претендует... хотя я могу и ошибаться )

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

Проблема С++ не в том, что в нем есть мультипарадигменность. Его проблема в том, что никто не думал о том, чтобы встроить мультипарадигменность в С++. Никто не проектировал, не думал о том, как сделать лучше.

AXX>А вот то, что разошелся такой внушительный спор, мне например несколько не понятно. (ну т.е. все таки понятно, с одной стороны , bigger longer and uncut хочет доказать, что Nemerle никакой не ФЯ, т.е. доказать то, чего никто и не утверждал , а VladD2 пытается ему это объяснить, — что мол не стоит опровергать то, чего никто и не говорил (по крайней мере он сам)).

Nemerle is a high-level statically-typed programming language for the .NET platform. It offers functional, object-oriented and imperative features. It has a simple C#-like syntax and a powerful meta-programming system.

Nemerle — это высокоуровневый, статически-типизированный, язык программирования для платформы .NET. Он предлагает функциональные, объектно-ориентированные и императивные возможности. Он имеет простой похожий на C# синтаксис и мощьную подсистему метапрограммирования.

AXX> или что он в плане ООП лучше любого ОО языка (на это он тоже, как я понимаю, не претендует... хотя я могу и ошибаться ).

;; Scheme
(define curry
  (lambda (f)
    (lambda (x)
      (lambda (y) (f x y)))))

(define positive? ((curry <) 0))
(define add-42    ((curry +) 42))

#include <cstddef>
#include <iostream>

template <std::size_t N>
class array_of_ints {
    int value[N];
public:
    std::size_t size() { return N; }
    int& operator[](int i) { return value[i]; }
    array_of_ints& operator+=(int v)
    {
        for (int i = 0; i < N; ++i)
            value[i] += v;
        return *this;
    }
};

int main()
{
    array_of_ints<10> a;
    for (int i = 0; i < a.size(); ++i)
        a[i] = i;
    a += 5;
    for (int i = 0; i < a.size(); ++i)
        std::cout << a[i] << ' ';
    std::cout << '\n';
}

Z>;; Scheme
Z>(define curry
Z>  (lambda (f)
Z>    (lambda (x)
Z>      (lambda (y) (f x y)))))

Z>(define positive? ((curry <) 0))
Z>(define add-42    ((curry +) 42))
Z>

def curry[X,Y,R](f : X * Y -> R)
{
    fun(x : X) { fun(y : Y) { f(x, y) } }
}

def add_42 = add(_ + _)(42);
def positive = curry(_ < _)(0);

def add42 = 42 + _; // или _ + 42
def positive = 0 < _; // или _ > 0

Z>Странно, но я прочитав "Grokking Nemerle" — так и не смог грокнуть насколько функции first-class, а насколько это все макросы Просветите меня.

VK>def add_42 = add(_ + _)(42);
VK>

def add_42 = curry(_ + _)(42);

Z>;; Scheme
Z>(define curry
Z>  (lambda (f)
Z>    (lambda (x)
Z>      (lambda (y) (f x y)))))

Z>(define positive? ((curry <) 0))
Z>(define add-42    ((curry +) 42))
Z>

// Функции-обертки над операторами ">" и "+".
def GreaterThan(x, y) { x > y }
def Add(x : int, y) { x + y }

// Curry полиморфна, что в Немерле нужно указывать явно. По умолчанию будет производиться
// вывод типов который выведет тип фунции для первого применения и сочтет второе 
// (полиморфное) применение ошибкой. 
// T - тип параметров.
// R - тип возвращаемого значения функции.
// f - это фукнция имеющая тип "T * T -> R". Звездочкой разделяются параметры, а после "->" 
//     идет описание возвращаемого значения функции.
def Curry[T, R](f : T * T -> R) { fun(x) { fun(y) { f(x, y); } } }

// Остальное как в примере на Схеме.
def Positive(value) { Curry(GreaterThan)(0)(value) }
def Add42(value) { Curry(Add)(42)(value) }

// Тесты:
System.Console.WriteLine(Positive(2)); 
System.Console.WriteLine(Positive(-1)); 

System.Console.WriteLine(Add42(2)); 
System.Console.WriteLine(Add42(-1));

False
True
44
41

def Positive(value) { value > 0 }
def Add42(value) { value + 42 }

Z>Странно, но я прочитав "Grokking Nemerle" — так и не смог грокнуть насколько функции first-class, а насколько это все макросы Просветите меня.

// Переменная позволяющая хранить ссылку на функцию принимающую 
// два параметра типа инт и возвращающая булево значение.
mutable f1 : int * int -> bool;

// Функция принимающая в качестве параметра другую функцию (int * int -> bool), два значения типа int и возвращающая инвертированное значение вызова переданной фукнции.
def Func(f : int * int -> bool, x : int, y : int) : bool
{
    !f(x, y)
}

// Используя вывод типов можно записать эту же функцию так:
def Func(f : int * int -> bool, x, y)
{
    !f(x, y)
}
// или так:
def Func(f, x : int, y : int) : bool
{
    !f(x, y)
}
// или даже так:
def Func(f, x, y)
{
    !f(x, y)
}

using System.Console;

def GreaterThan(x, y) { x > y }

def Func(f, x, y)
{
    !f(x, y)
}

WriteLine(Func(GreaterThan, 3, 5));

def LocalFunc(param1, param2) { /* тело */ }

mutable x = 1;

def AddX(y) { x + y }

WriteLine(AddX(4)); 
x++;
WriteLine(AddX(4));

5
6

fun(x, y){ /*тело фукнции*/ }

lambda параметр -> выражение

BLA>Причем макросы в немерле — это вообще говоря антифункциональная вещь.

Во как? Прэлесно!

BLA> То есть они не first-class values,

Ну, и что? Кому-то это мешает? Мне — нет.

BLA> их нельзя передавать куда-то или возвращать, хотя со стороны они выглядят как функции. Удачи
маленьким любителям функциональных языков.

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

                valarray<type>    tr(2);                                             \
                                                                                     \
                tr[0] = rhs.real();                                                  \
                tr[1] = rhs.imag();                                                  \
                                                                                     \
                type            mixam = static_cast<type>(1)/(abs(tr).max)();        \
                                                                                     \
                tr *= mixam;                                                         \
                                                                                     \
                valarray<type>    tt(4);                                             \
                                                                                     \
                tt[0] = +a*tr[0]+b*tr[1];                                            \
                tt[1] = -a*tr[1]+b*tr[0];                                            \
                tt[2] = +c*tr[0]-d*tr[1];                                            \
                tt[3] = +c*tr[1]+d*tr[0];                                            \
                                                                                     \
                tr *= tr;                                                            \
                                                                                     \
                tt *= (mixam/tr.sum());                                              \
                                                                                     \
                a = tt[0];                                                           \
                b = tt[1];                                                           \
                c = tt[2];                                                           \
                d = tt[3];                                                           \
                                                                                     \
                return(*this);                                                       \

                fixed_valarray<type, 2>    tr;                                       \
                                                                                     \
                tr[0] = rhs.real();                                                  \
                tr[1] = rhs.imag();                                                  \
                                                                                     \
                type            mixam = static_cast<type>(1)/abs(tr).max();          \
                                                                                     \
                tr *= mixam;                                                         \
                                                                                     \
                fixed_valarray<type, 4>    tt;                                       \
                                                                                     \
                tt[0] = +a*tr[0]+b*tr[1];                                            \
                tt[1] = -a*tr[1]+b*tr[0];                                            \
                tt[2] = +c*tr[0]-d*tr[1];                                            \
                tt[3] = +c*tr[1]+d*tr[0];                                            \
                                                                                     \
                tr *= tr;                                                            \
                                                                                     \
                tt *= (mixam/tr.sum());                                              \
                                                                                     \
                a = tt[0];                                                           \
                b = tt[1];                                                           \
                c = tt[2];                                                           \
                d = tt[3];                                                           \
                                                                                     \
                return(*this);                                                       \

Foreword
by Scott Meyers

. . .

... a column by John Barton and Lee Nackman in the
January 1995 C++ Report that described how templates could be used to perform typesafe dimensional
analysis with zero runtime cost. This was a problem I'd spent some time on myself, and I knew that many
had searched for a solution, but none had succeeded. Barton and Nackman's revolutionary approach made
me realize that templates were good for a lot more than just creating containers of T.
As an example of their design, consider this code for multiplying two physical quantities of arbitrary
dimensional type:

template<int m1, int l1, int t1, int m2, int l2, int t2>
Physical<m1+m2, l1+l2, t1+t2> operator*(Physical<m1, l1, t1> lhs,
                                        Physical<m2, l2, t2> rhs)
{
    return Physical<m1+m2, l1+l2, t1+t2>::unit*lhs.value()*rhs.value();
}

Even without the context of the column to clarify this code, it's clear that this function template takes six
parameters, none of which represents a type!

. . .

(Modern C++ Design: Generic Programming and Design Patterns Applied, Andrei Alexandrescu)

import std.stdio;
abstract class aPhysical {}

class physical(int M, int L, int T) : aPhysical
{
    enum { M = M, L = L, T = T }

    public double value;

    public this(double value)
    {
        this.value = value;
    }

    template opMulT(P) { alias physical!(M+P.M, L+P.L, T+P.T) opMulT; }
    
    public template opMul(P : aPhysical)
    {
        opMulT!(P) opMul(P rhs)
        {
            return new opMulT!(P)(value * rhs.value);
        }
    }

    override char[] toString()
    {
        return std.string.format("%.2f kg^%d * m^%d * sec^%d", value, M, L, T);
    }
}
void main()
{
    auto value1 = new physical!(1,1,1)(2.0);
    auto value2 = new physical!(3,2,1)(3.0);
    auto result = value1 * value2;
    // 6.00 kg^4 * m^3 * sec^2
    writef("%s\n", result.toString());
}

IT>Кстати, мне ужасно не нравится его название. Давай обсудим это

What does "Nemerle" mean?

It is inspired by a name of mage Nemmerle from book of Ursula K. Le Guin "A Wizard of Earthsea" (spelling with a single 'm' is a design decision )

...Коснувшись серебристым наконечником посоха сначала груди Геда, потом его губ, Неммерле что-то прошептал. Гед вздрогнул и глубоко вздохнул. Старый маг поднял свой посох, затем поставил его на землю, сложил на рукояти руки и опустил на них голову. У него не осталось сил стоять прямо.

...Он лежал неподвижно. Его ястребиный нос, высокий лоб и седые
волосы, залитые лунным светом, были цвета китовой кости. Неммерле истратил
всю свою силу на то, чтобы остановить действие заклинания и прогнать Тень
от Геда, а вместе с силой из его тела ушла и жизнь. Он умирал. Но смерть
Верховного Мага, еще при жизни не раз ступавшего по крутым иссушенным
тропам царства мертвых, не похожа на смерть обычного человека — он уходит
уверенно, хорошо зная дорогу...

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

    def x = Parse(ReadLine());
    def y = Parse(ReadLine());

    def nod (x,y)
    {
        def nod2 (x,y) 
        {
            def p = (x,y);
            match (p)
            {
                | (0,y) => y
                | (1,_) => 1
                | _ => nod2(y%x,x)
            }
        }
        preved
            kakdila (x < y) zachet nod2(x,y) nizachet nod2(y,x);
        medved
    }

    voutput($"НОД($x, $y) == $(nod(x,y))");