Динамическая типизация - Философия программирования

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

>> В ленивом языке — сами понимаете, программа будет в целом
>> похожа на то, что я написал — не сильно сложнее.
C>Угу. Кстати, как ваши эксперименты с Эрлангом? Насколько удобнее он чем
C>SystemC?

Кратко — пока не знаю.

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

Чтобы проверить, насколько Эрланг в этом рулит на самом деле, надо сделать на нем мало-мальски большой пример. А времени делать это самому у меня одного не очень много. Пока я сделал только тест производительности, но не нашел времени его запустить

.

Насчет Эрланга план такой. Скоро выдам задание сделать на нем что-нибудь реальное, но простое. Если время будет. Плюс, попытаемся прикинуть, как будет выглядеть интерфейс между Эрлангом и SystemC. Если все пройдет хорошо — получится неплохая связка, в которой критичные по скорости выполнения узлы (вроде памяти) будут писаться на SystemC, в то время как вся система в целом будет описана на Erlang. Впоследствии, надо будет решить, как все это привязать к ModelSim — вроде проблем особых нет.

В данный момент у нас де-факто применяется для поведенческого моделирования Хаскель. В принципе — это хорошо, но есть проблема. Надо выяснить, смогут ли его читать наши аппаратчики.

Скоро это выяснится. Насчет Хаскеля — первые результаты его применения необычайно хороши. (5 человеко-недель на aльфу поведенческой модели проца MIPS). Его будем стыковать с остальным так же, через ModelSim.

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

IT>>На поверку лямбда оказалась всего лишь короткой формой записи локальной функции.

G>

G>funct( X, Y, Container ) -> 
G>   Z = X + Y,
G>   map( fun( X ) -> X + Z end, Container ).
G>

G>Код понятен?

Не очень. Что такое end? Конец лямбды?

G>Просьба записать то же самое через локальные функции — на поверку.

def funct(X, Y, Container)
{
    def Z = X + Y;

    def fmap(X)
    {
        X + Z
    }

    map(fmap, Container);
}

Код на шарпе с анонимными делегатами приводить?

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

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

FR>>Аналог итераторы, ну и плюс сахар в виде yield

G>Ерунда. Итераторы позволяют кое-как сымитировать ленивые списки, но ни разу не помогут в ситуации, как бы объяснить попроще...

Триггер моделировать не буду

Я просто привел ближайший аналог ленивости. Вообще с итераторами и генераторами тоже можно много интересных и красивых штучек сделать, например как тут: List/Generator Monad Combinators

E>Осталось только кого нибудь из Smalltalk-еров подождать

А Erlang?

4> X = 2 + "3".

=ERROR REPORT==== 28-Aug-2006::09:45:24 ===
Error in process <0.44.0> with exit value: {badarith,[{erl_eval,eval_op,3},{erl_
eval,expr,5},{shell,exprs,6},{shell,eval_loop,3}]}

** exited: {badarith,[{erl_eval,eval_op,3},
                      {erl_eval,expr,5},
                      {shell,exprs,6},
                      {shell,eval_loop,3}]} **

5> Y = 2.
2
6> X = Y + "3".

=ERROR REPORT==== 28-Aug-2006::09:46:43 ===
Error in process <0.46.0> with exit value: {badarith,[{erl_eval,eval_op,3},{erl_
eval,expr,5},{shell,exprs,6},{shell,eval_loop,3}]}

** exited: {badarith,[{erl_eval,eval_op,3},
                      {erl_eval,expr,5},
                      {shell,exprs,6},
                      {shell,eval_loop,3}]} **

1> A = fun(Y) -> X = Y + "3" end.
#Fun<erl_eval.6.56006484>
2> Y = 1.
1
3> A(Y).

=ERROR REPORT==== 28-Aug-2006::09:49:57 ===
Error in process <0.39.0> with exit value: {badarith,[{erl_eval,eval_op,3},{erl_
eval,expr,5},{shell,exprs,6},{shell,eval_loop,3}]}

** exited: {badarith,[{erl_eval,eval_op,3},
                      {erl_eval,expr,5},
                      {shell,exprs,6},
                      {shell,eval_loop,3}]} **

Везде вылетает с badarith (bad arithmetical expression).

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

E>Осталось только кого нибудь из Smalltalk-еров подождать

А Erlang?

4> X = 2 + "3".

=ERROR REPORT==== 28-Aug-2006::09:45:24 ===
Error in process <0.44.0> with exit value: {badarith,[{erl_eval,eval_op,3},{erl_
eval,expr,5},{shell,exprs,6},{shell,eval_loop,3}]}

** exited: {badarith,[{erl_eval,eval_op,3},
                      {erl_eval,expr,5},
                      {shell,exprs,6},
                      {shell,eval_loop,3}]} **

5> Y = 2.
2
6> X = Y + "3".

=ERROR REPORT==== 28-Aug-2006::09:46:43 ===
Error in process <0.46.0> with exit value: {badarith,[{erl_eval,eval_op,3},{erl_
eval,expr,5},{shell,exprs,6},{shell,eval_loop,3}]}

** exited: {badarith,[{erl_eval,eval_op,3},
                      {erl_eval,expr,5},
                      {shell,exprs,6},
                      {shell,eval_loop,3}]} **

1> A = fun(Y) -> X = Y + "3" end.
#Fun<erl_eval.6.56006484>
2> Y = 1.
1
3> A(Y).

=ERROR REPORT==== 28-Aug-2006::09:49:57 ===
Error in process <0.39.0> with exit value: {badarith,[{erl_eval,eval_op,3},{erl_
eval,expr,5},{shell,exprs,6},{shell,eval_loop,3}]}

** exited: {badarith,[{erl_eval,eval_op,3},
                      {erl_eval,expr,5},
                      {shell,exprs,6},
                      {shell,eval_loop,3}]} **

Везде вылетает с badarith (bad arithmetical expression).

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

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

IT>К свободе менять типы переменных исполняемой средой как ей вздумается, привыкнуть невозможно

Думаю все же возможно — человек существо с очень сильной приспособляемостью

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

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

IT>Не очень. Что такое end? Конец лямбды?
Да.

IT>

IT>def funct(X, Y, Container)
IT>{
IT>    def Z = X + Y;

IT>    def fmap(X)
IT>    {
IT>        X + Z
IT>    }

IT>    map(fmap, Container);
IT>}
IT>

IT>Код на шарпе с анонимными делегатами приводить?
У тебя тут не просто "локальные функции". Чтобы это заработало — нужны еще и лексические замыкания (lexical closures). Если они поддержаны (я не знаю, как на самом деле работает твой код), и есть "сокращенная форма определения функции", то она называется "лямбда-функцией". Термин такой. Твой анонимный делегат на поверку может оказаться лямбдой.

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

CS>На самом деле то что тебя так волнует в JS чинится примерно так:

CS>

CS>String.prototype.toNumber = function(x)
CS>{
CS>  alert("Тю на тебэ!");
CS>}
CS>

Не

1 + "3"

У меня в Firefox результат "13".

CS>или около того.

А оценка — за /попытку/ продемонстрировать возможность фикса стандартной библиотеки.

http://www.smalltalk.ru | << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

G>У тебя тут не просто "локальные функции". Чтобы это заработало — нужны еще и лексические замыкания (lexical closures). Если они поддержаны (я не знаю, как на самом деле работает твой код), и есть "сокращенная форма определения функции", то она называется "лямбда-функцией". Термин такой. Твой анонимный делегат на поверку может оказаться лямбдой.

Вообще-то, если бы ты был повнимательне, то понял бы, что IT это и говорил.

На поверку лямбда оказалась всего лишь короткой формой записи локальной функции.

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

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

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

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

M>А Erlang?

4>> X = 2 + "3".

M>=ERROR REPORT==== 28-Aug-2006::09:45:24 ===
M>

M>Везде вылетает с badarith (bad arithmetical expression).

А теперь маленький прикол (C#):

using System;

class Program
{
    static void Main()
    {
        int i = 1 + 1;
        Console.WriteLine("1 + 1 = " + i);
    }
}

Компилируется и работает.

И типизация полностью статическая. Приведение типов однако.

Так чт дело действительно в идеологии приведения типов и перекрытии операторов, а не в типе типизации.

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

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

VD>Кстати, локальные фунции в Паскеле, если мне не изменяет память были замкнуты на параметры внешней функции. Так что с натяжкой и их можно назвать замыканиями.

Если только с очень большой натяжкой.

... << RSDN@Home 1.1.4 stable SR1 rev. 568>>

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

IT>>Не очень. Что такое end? Конец лямбды?
G>Да.

OK, буду знать

IT>>Код на шарпе с анонимными делегатами приводить?
G>У тебя тут не просто "локальные функции". Чтобы это заработало — нужны еще и лексические замыкания (lexical closures).

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

G>Если они поддержаны (я не знаю, как на самом деле работает твой код), и есть "сокращенная форма определения функции", то она называется "лямбда-функцией". Термин такой. Твой анонимный делегат на поверку может оказаться лямбдой.

Полноценные лямбды будут введены только в C# 3.0. Там они даже называются так. В 2.0 они называются анонимные делегаты, но замыкания уже вовсю пользуют, не используя при этом термин замыкание

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

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

G>

G>funct( X, Y, Container ) -> 
G>   Z = X + Y,
G>   map( fun( X ) -> X + Z end, Container ).
G>

G>Код понятен? Просьба записать то же самое через локальные функции — на поверку.

function funct( X, Y:integer; Container:TContainer) :TContainer;
  var Z:integer;
  function local(X:integer):integer;
  begin
    local:= X + Z
  end;
begin
  Z := X + Y;
  funct:= map(local, Container)
end

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

IT>Ленивость я не знаю что такое. Если объяснишь, то наверняка можно будет поискать аналог и в нефункциональном мире.
В нефункциональном мире это называется call by name и call by need.

IT>>>Единственное новое что я о них узнал из функциональщины, это то, что их там принято называть первоклассными объектами.
Ради этого не стоило лезть в функциональщину. Впервые функции были объявлены первоклассными объектами в CPL — предшественнике BCPL и, следовательно, С.

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

IT>Полноценные лямбды будут введены только в C# 3.0. Там они даже называются так. В 2.0 они называются анонимные делегаты, но замыкания уже вовсю пользуют, не используя при этом термин замыкание

На самом деле то что ты называешь "анонимные делегаты" реально называется анонимными методами и на 101% подходит под опрделение лямбды. Просто они имеют неуклюжий синтаксис и обязаны содержать staetments. В C# 3.0 же просто введут упрощенный синтаксис (не в последнюю очередь за счет вывода типов) и возможность создавать аномимные методы содержащие expression. То есть по сути это не более чем синтаксический сахар.

А вот что действительно плохо в C# — это то, что к анонимным методам и лямдбам приходится обращаться через делегаты. Это и неудобно, и медленно, и потенциально опасно (ведь делегаты бывают составными).

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

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

G>>

G>>funct( X, Y, Container ) -> 
G>>   Z = X + Y,
G>>   map( fun( X ) -> X + Z end, Container ).
G>>

G>>Код понятен? Просьба записать то же самое через локальные функции — на поверку.

Т>

Т>function funct( X, Y:integer; Container:TContainer) :TContainer;
Т>  var Z:integer;
Т>  function local(X:integer):integer;
Т>  begin
Т>    local:= X + Z
Т>  end;
Т>begin
Т>  Z := X + Y;
Т>  funct:= map(local, Container)
Т>end
Т>

Кстати, где Губанов? С удовольствием послушал бы его мнение про синтаксический оверхэд.

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

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

VD>На самом деле то что ты называешь "анонимные делегаты" реально называется анонимными методами и на 101% подходит под опрделение лямбды.

Кто-то мне, кажется из наших MVP, как-то объяснял, что лямбды это как раз то, что введут в C# 3.0. Впрочем, мне без разницы как оно называется на самом деле, лишь бы было удобно. Те же анонимные методы я использую во всю уже около года, с момента выхода C# 2.0, и как-то особенно не задумывался над названием.

VD>То есть по сути это не более чем синтаксический сахар.

Анонимные методы тоже не более чем синтаксических сахар, т.е. следуя логике лямбда — это синтаксических сахар даже не по отношению к анонимным методам, а вообще ещё к C# 1.0. Т.е. опять же просто более удобная запись, на самом деле ничего военного.

От:	Gaperton	http://gaperton.livejournal.com
Дата:	27.08.06 13:50
Оценка:	11 (1)

От:	IT	linq2db.com
Дата:	27.08.06 15:17
Оценка:

	От:	FR
	Дата:	27.08.06 17:17
	Оценка:

От:	Mamut	http://dmitriid.com
Дата:	28.08.06 06:54
Оценка:

От:	Mamut	http://dmitriid.com
Дата:	28.08.06 06:56
Оценка:

От:	Andrei N.Sobchuck	www.smalltalk.ru
Дата:	28.08.06 10:38
Оценка:

От:	VladD2	www.nemerle.org
Дата:	28.08.06 11:42
Оценка: