switch( { state_A, Data }, msg_to_B ) -> { state_B, a_to_b( Data ) };
switch( { state_A, Data }, msg_to_C ) -> { state_C, a_to_C( Data ) };

switch( { state_A, Data }, Message ) ->
   case Message of
      msg_to_B -> { state_B, a_to_b( Data ) };
      msg_to_C -> { state_C, a_to_C( Data ) };
   end;

> ПК>subtype NonNegativeInt is INTEGER range 0 .. INTEGER'LAST;
> ПК>subtype NegativeInt is INTEGER range INTEGER'FIRST .. -1;
> ПК>

foo(10);
foo(-1);

> procedure foo(Param: INTEGER range 0 .. 5) is
>      ...
> procedure foo(Param: INTEGER range INTEGER 4 .. 10) is
>      ...
>

> ПК>struct { int i; double m; } my_variable;
> ПК>

In computer science, a datatype (often simply called type) is a statically assigned constraint on a programming language phrase that denotes the kinds of values it may take on and gives it certain semantic meaning for the purposes of preventing errors, building abstractions, documenting the program, and gaining some measure of runtime safety and efficiency.

V>(defun my_mul (a b) (declare (number a b)) (* a b)) 

V>(setq num (read)) 

V>(cond
V>    ( (= num 12345 ) (write (my_mul "Vasja" "Masha")) )
V>    ( T (write (my_mul 10 2 )) )
V>)
V>

Soft typing is a generalization of static type checking that accommodates both dynamic typing and static typing in one framework. A soft type checker infers types for identifiers and inserts explicit run-time checks to transform untypable programs to typable form. Soft Scheme is a practical soft type system for R4RS Scheme.

I'm not a CS PhD, nor do I play one on TV, but maybe I
ease your aching soul.

A [static] type system is a state of mind. A way of
viewing the world. Specifically a way of saying
statically what is and isn't a valid program. Now
there are many ways of seeing the world and so there
are many type systems. And they all say certain
programs are valid and certain programs are invalid
and they all get it wrong a occasionally. But you
knew that already.

Now if we take this view that a type system is a
static thing we can apply many type systems to the
same program. This is what the PLT guys have done —
Soft Scheme, MrSpidey, and MrFlow all apply different
type systems to Scheme and all accept and reject
certain (and different) programs. So if you desire
you can HM Scheme (which is what Soft Scheme does I
believe) and program in an ML style. Not many Scheme
programs will pass that test but you can make sure the
ones you write do. So you can be statically typed.
And then you can write programs that don't pass the
type checker and you can just tell the Scheme system
to put in the appropriate run time checks and fail if
you made a type error.

So we can take a dynamically type system and by
limiting the language we use we can turn it into a
statically typed system. Any statically typed system.

Now lets go the other way. Hmmm... Can't be done. If
the type system you use fits your program then you're
home. So writing compilers in ML and simulations in
Java probably doesn't suck. It's when you go the
other way that you feel the pain. And that's when you
wished you had a dynamically typed language: because
there are more problems than there are type systems to
handle them and though more advanced type systems
require you to tie less of your hand behind your back
they'll never do away with it entirely (and least
while they remain decidable).

So for my money I'd rather use Scheme than ML. A lot
of my programs look like ML but there are occasions
where they don't and its those outliers that make the
difference. I'm happy to have static type systems
built on to Scheme so that I can statically check 90%
of my programs and I'm just as happy to throw away the
type system for the other 10% of programs. It's the
perfect middle ground!

> ПК>subtype NonNegativeInt is INTEGER range 0 .. INTEGER'LAST;
> ПК>subtype NegativeInt is INTEGER range INTEGER'FIRST .. -1;
> ПК>

> func pat1 = ..
> func pat2 = ..
> ...
>

> func x = case x of
>  pat1 -> ..
>  pat2 -> ..
> ..
>

template <class T>
void foo(T t, typename enable_if< is_arithmetic<T> >::type* = 0);

template <class T>
void foo(T t, typename enable_if< is_floating<T> >::type* = 0);

G>>О как (век живи — век учись)! Пример пожалуйста, особенно "обычного языка", где учитываются значения аргументов при полиморфном вызове в run-time (твой комментарий по правилам русского языка относится ко всему абзацу, а не ко второй половине ).

Вместе с тем, достаточно часто возникают ситуации, когда гомоморфные иерархии, определяемые как иерархии классов с одинаковым открытым интерфейсом, унаследованным от общего базового класса [1], взаимодействуют через функцию, виртуальную к произвольному числу полиморфных параметров. Такая функция называется мультиметодом [2], а возможность ее использования существует в языке программирования CLOS (Common Lisp Object System). Однако широко распространенные ОО языки программирования не поддерживают подобный механизм в связи с отсутствием его эффективной реализации [3].

G>>Гхм. Имеющееся средство называется...

VD>В гугле думаю сразу поймешь о чем я говорю. У нас на сайте тоже статейки имеются.

subtype NonNegativeInt is INTEGER range 0 .. INTEGER'LAST;
subtype NegativeInt is INTEGER range INTEGER'FIRST .. -1;

    procedure foo(Param: NonNegativeInt) is
    begin
       ...
    end foo;

    procedure foo(Param: NegativeInteger) is
    begin
       ...
    end foo;

foo(10);
foo(-10);

    procedure foo(Param: INTEGER range 0 .. INTEGER'LAST) is
    begin
       ...
    end foo;

    procedure foo(Param: INTEGER range INTEGER'FIRST .. -1) is
    begin
       ...
    end foo;

In computer science, a datatype (often simply type) is a name or label for a set of values and some operations which can be performed on that set of values.

struct { int i; double m; } my_variable;

::MyType = MyTuple Int Int | MyList [Int]

Funct:: MyType -> Int
Funct ( MyTuple a b ) = a
Funct ( MyList [ a, b ] ) = a

 
f(1)->...
f(2)->...
f(3)->...

(
(class myclass)
((member m1) a)
((member m2) b)
)

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

VD>Которой по сути нет. И получается, что точно так же генерируют специализации, только из-за того, что рантайм пермешан с компайлтаймом, черт ногу сломит в классификации того или иного явления.

VD>Очередное преувеличение. Аналогично моожно сделать обратное заявление. А что? Попробуй сделать типизированную конструкцию на Лиспе?

VD>Честно говоря Лисп с его миллионом скобочек меня вводит в состояние гипноза.

VD>одинаково фигово.

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

ГВ> Не, скорее наоборот — это C++ и в страшном сне не приснится то, что можно творить на LISP. Например, можно и вложенные while как параметр передать.

Итак, макросы лиспа приметивны потому что не позволяют проивзодить примитивные операции записи в файл, вывода на принтер и т.п. Так же они примитивны по сравнению с простейшим оператором if, так как в отличии от него не позволяют выполнять проверок в рантайме. Ну, и уж несомненно они явлются полнейшим примитивизмом по сравнению с такими мощнешими средствами С++ как Шаблоны! Ведь в отличии от шаблонов они не позволют создавать статически-типизированный, типобезопасный код. В то же время шаблоны С++ не просто на голову рабивают это примитивное образование, но и вообще низвергают весь лисп в небытие, так как кроме всех выше перечисленных достоинств еще позволяют создавать выско-производительный код, а так же, использую побочные эффекты, даже эмулировать действия тех самых примитивных макросов Листпа.

G>А вообще, между нами девочками, вопрос адресовался Владу, лично, который вместо того, чтобы написать нормальный содержательный ответ демонстрирует какие-то странные ужимки. Наверно готовится к очередному замеру. А потом еще удивляется, что с ним нормально общаться не получается.

G>А во вторых, при разрешении полиморфного вызова учитываются не только типы, но и значения аргументов (в "обычных" языках — только типы). Причем, в разрешении вызова принимаются во внимание все аргументы (а не только тип неявного аргумента виртуальной функции — объект). Это самое главное отличие полиморфизма ФЯ от обычных языков.

VD>В "обычных языках" это называется мутиметодами. Они кое где реализованы. А кое где реализуются имеющимися средствами.

G>О как (век живи — век учись)! Пример пожалуйста, особенно "обычного языка", где учитываются значения аргументов при полиморфном вызове в run-time (твой комментарий по правилам русского языка относится ко всему абзацу, а не ко второй половине ).

VD>1. Мы кажется уже договорились, что полиморфизм бывает статический. При этом 90% современных языков это делают.
VD>2. мультиметоды multimethods

G>Примеров "обычных языков" нет. Впрочем, как и необычных. Все понятно. Вопрос снят.

VD>Значит MultiJava и насширения для Питона, Perl-а и С++

Автор(ы): Клюев Александр
Дата: 19.07.2003
Мультиметоды — виртуальные функции, принадлежащие сразу нескольким классам. В статье разбирается суть мультиметодов, их особенности, а также возможная реализация мультиметодов на C++.

ты незаметил.

G>Я в курсе что такое мультиметоды, вообще-то. И то, что добавить их можно при желании куда угодно — дурацкое-то дело нехитрое, а семантика простая.

А во вторых, при разрешении полиморфного вызова учитываются не только типы, но и значения аргументов (в "обычных" языках — только типы). Причем, в разрешении вызова принимаются во внимание все аргументы (а не только тип неявного аргумента виртуальной функции — объект). Это самое главное отличие полиморфизма ФЯ от обычных языков.

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

V>P.S.: Страуструп на счет макросов очень точно подметил, что активное их использовании говорит о недостатках выбранного языка, о недостаточности его выразительных средств (там, правда, упаминался еще один вариант, но я не об этом ). Так что такое распространение макросов в лиспе наталкивает на мысли...

#define MY_MACRO(abc) abc + - / BCD

ПК>subtype NonNegativeInt is INTEGER range 0 .. INTEGER'LAST;
ПК>subtype NegativeInt is INTEGER range INTEGER'FIRST .. -1;
ПК>

subtype velocity is INTEGER;
subtype mass     is INTEGER;
...
procedure foo(Param: velocity) is
begin
     ...
end foo;

procedure foo(Param: mass) is
begin
     ...
end foo;
...

ПК>    procedure foo(Param: INTEGER range 0 .. INTEGER'LAST) is
ПК>    begin
ПК>       ...
ПК>    end foo;

ПК>    procedure foo(Param: INTEGER range INTEGER'FIRST .. -1) is
ПК>    begin
ПК>       ...
ПК>    end foo;
ПК>

procedure foo(Param: INTEGER range 0 .. 5) is
     ...
procedure foo(Param: INTEGER range INTEGER 4 .. 10) is
     ...

def foo(int val) = 
    where
        if      паттерн1: {...}
        else if паттерн2: {...}
        else            : {...}

int foo(int val)
{
        if (паттерн1(val))
            foo1(val);
        else if (паттерн2(val))
            foo2(val);
        else
            foo3(val);
}

ПК>struct { int i; double m; } my_variable;
ПК>

funct( { X, Y } ) where X <10, Y>0 -> X * Y.

G>А вы не сильно удивитесь, если я скажу, что определение типа несложно разбить на три определения, так, чтобы и tuple и list являлись отдельными типами? И что это у нас поменяет? Радикально — ничего, но функция станет полиморфной, так?

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

В общем, думаю что через несколько лет (возможно десятков) у разработчиков компиляторов/рантаймов и т.п. руки дойдут и до этого. Тогда вопрос статичности или динамичности полиморфизма станет таким же важным как сейчас вопросы автоматического инлайнинга методов, т.е. будут интересовать только разработчиков компиляторов.

(while (cond) (operators)) <- Вот такое возможно в Лиспе

#define While(condition) { if (!(condition)) goto end_while;
#define EndWhile end_while: }
...
int i = 0;
While(i < 10)
    ...
    i++;
EndWhile

Трудно найти людей, которые одновременно в курсе реализации полиморфизма типов в ФЯ и в еще не существующих языках

G> Все гораздо проще. В динамически типизированном языке любая функция — "шаблонная". И любой "класс".

G>Хотя, если посмотреть книжку Александреску, в которой он жестко надругался над С++ — то очень даже можно и нужно . Там он демонстрирует, что в compile time при помощи шаблонов можно сделать практически все, что угодно — благодаря наличию рекурсии мы имеем вычислительную полноту. Ничего не напоминает? Мне напоминает макросы лисп . Так что ответ не так однозначен.

Бред какой-то... Лиспу не нужны эти возможности шаблонов, поскольку в его рамках они бессмысленны.

G>Подойдет для чего? Что ты мне доказать хочешь? Я в курсе что такое мультиметоды, вообще-то. И то, что добавить их можно при желании куда угодно — дурацкое-то дело нехитрое, а семантика простая. Вот когда они появятся в стандарте и популярных компиляторах, тогда и будешь спрашивать "подойдет?". А пока — хоть обгуглись.

G>А вообще, между нами девочками, вопрос адресовался Владу, лично, который вместо того, чтобы написать нормальный содержательный ответ демонстрирует какие-то странные ужимки. Наверно готовится к очередному замеру. А потом еще удивляется, что с ним нормально общаться не получается.

в разрешении вызова принимаются во внимание все аргументы (а не только тип неявного аргумента виртуальной функции — объект). Это самое главное отличие полиморфизма ФЯ от обычных языков.

А во вторых, при разрешении полиморфного вызова учитываются не только типы, но и значения аргументов (в "обычных" языках — только типы). Причем, в разрешении вызова принимаются во внимание все аргументы (а не только тип неявного аргумента виртуальной функции — объект). Это самое главное отличие полиморфизма ФЯ от обычных языков.

template <class T> T mul(T a, T b){ return a*b; }