Re[8]: Функциональное программирование в Nemerle
От: IT Россия blogs.rsdn.ru
Дата: 17.05.07 17:56
Оценка: +2
Здравствуйте, <Аноним>, Вы писали:

А>Мои 150 выполняют больше работы


Можно мои 2 цента? Спасибо!

Хочешь я твои 150 легко превращу в 300 просто убрав искусственное сжатие кода, предназначенное исключительно для экономии строк?
... << RSDN@Home 1.2.0 alpha rev. 0>>
//rsdn.org/forum/images/bis.gif Если нам не помогут, то мы тоже никого не пощадим.
Re[8]: Функциональное программирование в Nemerle
От: VladD2 Российская Империя www.nemerle.org
Дата: 17.05.07 20:34
Оценка:
Здравствуйте, <Аноним>, Вы писали:

А>Мои 150 выполняют больше работы, но это, как я уже писал, из-за работы по памяти.


Больше? Он не делал то что от него требовалось. И друго полезного тоже ничего не делает.

А>К тому же моя иерархия, возможно (из-за незнания Nemerle), строже.


Серьезно? Ну, сделай ее менее строгой. Хотя что-то я не заметил там какой-то строгости. Недоработки вот видны сразу. Например, контроль количества параметров у фунций отсуствует. Можно такую несуразность как Min() с одинм параметром сделать.

А>Например у меня некоторые классы в иерархии абстрактные, то есть их нельзя создать.


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

VD>>Причем, заметь, я не менял весь код а добавил всего два фрагмента. Фнукцию Convert:

А>Практически аналогично и у меня.

У тебя код не делал то что нужно.

VD>>К каждому классу иерархии был добавлен соврешенно метод RemoveOneParameterMin().

VD>>Он увеличил код и сделал его плохо читаемым.
А>Спорно что плохочитаемым.

Это спорно только для тебя. И то потому что ты любиль спорить и не любишь призновать своей не правоты (сам такй, по этому знаю не по наслышке ).

Заметь, люди которые знают оба зыка откровенно помеялись над твоим кодом.

К тому же если все так хорошо, что же ты переписал код как только увидел мой вариант?

VD>>К тому же RemoveOneParameterMin не универсален, а в исходном задании было сказано о том, что требуется универсальное решение, а не для конкретного случая.

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

Да уж это неверотное приемущество, вот только этого не требовалось по условию задачи и не ясно что оно дает.

VD>>Не выполнено по сути и задие с добавлением фунций. Ведь у тебя количество параметров не контролируется.

А>Легко добавляется.

То-то я гляжу, все так легко, что дня не хвает на реализацию.

VD>>Теперь можно продолжить наши упраженния. Сколько тебе потребуется времени и сил чтобы добавить еще две оптимизирующие трансформации — заменять выражение max(константа, константа) на значение большей из констант. И соответственно min(константа, константа), меньшей? Мне — пол минуты. Я просто добавлю пару образцов и все.

А>После написания функции Convert для поддержки конвертации, тоже, что-то в этом духе

Что же ты ее не написал в этом же духе сразу? И как выглядит код твоих трансформаций? Заметь я привел совсем примитивные примеры образцов. Они у тебя уже порождают кучу кода. А даже небольшое их усложнение приведет к настоящей горе кода. Причем совершенно нечитаемого.

Сравни:
static Expr RemoveMaxOfLiterals(Expr expr)
{
  Max max = expr as Max;
  if (max != null)
  {
    Lit first = max.First as Lit;
    Lit second = max.Second as Lit;
    if (first != null && second != null)
      return new Lit(Math.Max(first.Eval(), second.Eval()));
  }
  return expr;
}

и
| Call("max", [Lit(x), Lit(y)]) => Lit(Math.Max(x, y))

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

VD>>Заметь, по сути мне нужно было добавить две строки. Тебе же прийдется еще раз менять дизайн всего приложения.

А>Не придется.

Да? А как понимать, то что ты полностью переписал свой код и отказался от так защищаемого тбой RemoveOneParameterMin()?

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

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

А>Да, но похоже у посетителя, таже проблема, что и с общим методом в корневом классе. При добавлении классов в иерархию, ошибка не обработки, какого-либо класса переносится в runtime.

Отнюдь. Как раз посетители отлично выявляют необработанные классы иерархии, если конечно, правильно их готовить.

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

А>Все-таки вопрос привычки.

Серьезно? Ну, я почти на верняка пишу на C# дольше тебя (начал еще в 2000-ном когда первые превью появились), но вот почему-то никак не могу привыкнуть к тому, что вместо:
def expr = expr.Convert(_ => { 
    | Mul(x, Literal(1.0))                  => x 
    | Call("max", [Literal(x), Literal(y)]) => Literal(Math.Max(x, y))
    | Call("mix", [Literal(x), Literal(y)]) => Literal(Math.Min(x, y))
    | e                                     => e });

я вынужден писать:
static Expr Transform(Expr expr)
{
    return RemoveMulToOne(RemoveMaxOfLiterals(RemoveMinOfLiterals(expr)));
}

static Expr RemoveMulToOne(Expr expr)
{
    Mul mul = expr as Mul;
    if (mul != null)
    {
        Lit lit = mul.Second as Lit;
        if (lit != null && lit.Eval() == 1)
            return mul.First;
    }
    return expr;
}

static Expr RemoveMaxOfLiterals(Expr expr)
{
    Max max = expr as Max;
    if (max != null)
    {
        Lit first = max.First as Lit;
        Lit second = max.Second as Lit;
        if (first != null && second != null)
            return new Lit(Math.Max(first., second.Eval()));
    }
    return expr;
}

static Expr RemoveMinOfLiterals(Expr expr)
{
    Min min = expr as Min;
    if (min != null)
    {
        Lit first = min.First as Lit;
        Lit second = min.Second as Lit;
        if (first != null && second != null)
            return new Lit(Math.Min(first.Eval(), second.Eval()));
    }
    return expr;
}

...

expr = expr.Convert(Transform);


Расскажи, как ты к такому привыкаешь?

Я даже могу тебе подсказать, как сократить еще по строчки в каждой из функий. Например, RemoveMinOfLiterals можно записать так:
static Expr RemoveMinOfLiterals(Expr expr)
{
  Min min = expr as Min;
  if (min != null)
  {
    if (min.First is Lit && min.Second is Lit)
      return new Lit(Math.Min(min.First.Eval(), min.Second.Eval()));
  }
  return expr;
}

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

А>Вот код:...


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

Теперь еще раз разберем полеты.

Объем кода
После устранения в твоем коде совсем уж затариенных в одну строку вещей кода получилось около 200 строк. Причем он еще остался "ужатым". В реальных проетах код будет по рыхлее. Мой код занимает 75 строк.
Получается кода более чем в 2 раза больше. Его вдвое больше при любых других измерения (в словах, в символах и т.п.). Если твой код отформатировать скажем по правилам РСДН, то его станет в трое больше.

Читаемость кода

Вряд ли ты станешь спорить, что теперь наш код иделогически близок. Но вот что лучше читается? На мой взгляд действия собранные вместе и без лишних заголовков функций читается намного лучше. Его и поддерживать проще.
Код правил трансформации даже сранвивать смешно. Три ясных как божий день строчки против порядка 40 строк! И это на примитивных паттернах! Что будет при их уложнении?

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

Если для тебя вывод еще не очевиден, то я уже даже и не знаю что саазать.
... << RSDN@Home 1.2.0 alpha rev. 637>>
http://nemerle.org/Banners/?g=dark
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[5]: книга?
От: Аноним  
Дата: 18.05.07 12:13
Оценка:
Здравствуйте, VladD2, Вы писали:

[...]

VladD2, а вы не думали издать книгу про Nemerle и вообще по функциональным языкам?
Чисто Ваших статей только по Nemerle (из тех что в открытом доступе) набралось уже на 125 страниц формата А4, т.е. распечатать конечно можно но это будет ворох бумаги, что крайне неудобно. Хочется именно книгу.
Если присоединить туда обзорные статьи по ФП в целом, по Haskell, Erlang, Scala (это будет полезно, для обзора и для сравнения возможностей языков), то получится еще столько же. Ну и еще "связующий" текст, что-то из стандарта языка, побольше примеров и т.д.
Re[9]: Функциональное программирование в Nemerle
От: Аноним  
Дата: 18.05.07 20:54
Оценка: -1
Здравствуйте, VladD2, Вы писали:

VD>Больше? Он не делал то что от него требовалось. И друго полезного тоже ничего не делает.

Так же легко повернуть, что и код на Nemerle не делает, того что от него требовалось, и другого полезного ничего не делает.

VD>Серьезно? Ну, сделай ее менее строгой. Хотя что-то я не заметил там какой-то строгости. Недоработки вот видны сразу. Например, контроль количества параметров у фунций отсуствует. Можно такую несуразность как Min() с одинм параметром сделать.

Что несуразного в Min с одним параметром? Не больше чем в умножении на 1. К тому же добавить контроль количества параметров очень легко, что я и показал в следующем коде. А так у меня даже был Min с любым количеством параметров, не помню только выкладывал или нет.

VD>Это проблемы твоей реализации и выбронного тбой подхода. Сделай по другому. Главное, чтобы по фунциональности было тоже самое.

Серьезно не понимаю, зачем добиваться той же функциональности с точностью до миллиметра. Разговор с моей стороны идет, что по объему кода никакого пятикратного преимущества у Nemerle нет, а есть максимум двухкратное, как по количеству строк, так и по объему файла за вычетом ведущих проблелов. А уж если сравнивать по количеству нажатий на кнопки в среде оснащенной Intellisense'ом.

VD>У тебя код не делал то что нужно.

Это на Nemerle не делал то что нужно

VD>Это спорно только для тебя. И то потому что ты любиль спорить и не любишь призновать своей не правоты (сам такй, по этому знаю не по наслышке ).

Всего второй раз говорю здесь о Nemerle, а уже любитель спорить. Что касается правоты/не правоты, то я не любитель бинарной логики.
На вопрос вполне может быть несколько ответов.

VD>Заметь, люди которые знают оба зыка откровенно помеялись над твоим кодом.

Пускай, я пока не смеюсь.

VD>К тому же если все так хорошо, что же ты переписал код как только увидел мой вариант?

А откуда такая уверенность. Я переписал, код как только получил доступ к форуму и смог посмотреть на исходные условия. Да и что в твоем примере такого существенного?

VD>Да уж это неверотное приемущество, вот только этого не требовалось по условию задачи и не ясно что оно дает.

Инкапсуляция всегда небесполезна.

VD>То-то я гляжу, все так легко, что дня не хвает на реализацию.

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

VD>Что же ты ее не написал в этом же духе сразу? И как выглядит код твоих трансформаций? Заметь я привел совсем примитивные примеры образцов. Они у тебя уже порождают кучу кода. А даже небольшое их усложнение приведет к настоящей горе кода. Причем совершенно нечитаемого.

Я подумал, подумал и написал сопоставление с образцом на C#.

VD>Кстати, использовать Eval() для доступа к значениям литералов плохой подход. В будущем поведение может измениться и этот код превратится в ошибочный, а компилятор снова не сможет ничего подсказать.

С этим не согласен. К тому же добавить свойство — всего одна дополнительная строка, а работа с литералами у меня и так типизированная.

VD>Да? А как понимать, то что ты полностью переписал свой код и отказался от так защищаемого тбой RemoveOneParameterMin()?

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

VD>Ты уже начиташь сам себе противоречить и своими же действиями опровергать свои же слова .

Отнюдь, я просто показал широту своих взглядов и легкость к изменениям.

VD>Отнюдь. Как раз посетители отлично выявляют необработанные классы иерархии, если конечно, правильно их готовить.

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

VD>Серьезно? Ну, я почти на верняка пишу на C# дольше тебя (начал еще в 2000-ном когда первые превью появились), но вот почему-то никак не могу привыкнуть к тому, что вместо:

Я тоже начал в 2000 с бета версий, правда, тогда в основном упирал на VB.NET, ну да в контексте .NET это не так важно.
И оценка на brainbench у нас примерно одинаковая по C#.

VD>Расскажи, как ты к такому привыкаешь?


VD>Я даже могу тебе подсказать, как сократить еще по строчки в каждой из функий.

Мысль неплохая.

А>>Вот код:...


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

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

VD>Теперь еще раз разберем полеты.


VD>Объем кода

VD>После устранения в твоем коде совсем уж затариенных в одну строку вещей кода получилось около 200 строк. Причем он еще остался "ужатым". В реальных проетах код будет по рыхлее. Мой код занимает 75 строк.
VD>Получается кода более чем в 2 раза больше. Его вдвое больше при любых других измерения (в словах, в символах и т.п.). Если твой код отформатировать скажем по правилам РСДН, то его станет в трое больше.
Сравнивал, получалось не больше двух раз. К тому же и в коде на Nemerle в паре мест есть ужимания, где код уместно перенести на строчку/другую.
И еще в большинстве случаев я стараюсь использовать полные имена для переменных, а не одно-двухбуквенные имена.

VD>

Читаемость кода

VD>Вряд ли ты станешь спорить, что теперь наш код иделогически близок. Но вот что лучше читается? На мой взгляд действия собранные вместе и без лишних заголовков функций читается намного лучше. Его и поддерживать проще.
C# неплохо читается, можно по отдельности классы разбирать.

VD>Развитие кода

VD>Если нам понадобиться добавить новую операцию обработки кода мне будет достаточно создать новый метод, а тебе придется лазить по всем классам и добавлять в каждый из них по фукнции.
Во все не по всем. За счет наследования метод надо будет добавить буквально в нескольких классах.

VD>Если прийдется добавить новую ветку AST, то тебе прийдется добавить один класс и реализовать в нем по методу для каждого метода обработки, а мне добавить в каждый метод обработки по записи. Причем компилятор сам подксажет где это нужно сделать.

Так и мне подскажет. Набираешь override (даже несколько букв) вот и готово тело метода.

А вот код сопоставления по образцу:
  static Expr RemoveMulToOne(Expr expr)
  {
    Mul mul = null; Expr first = null; Lit lit = null;
    if (new Pattern<Mul, Expr, Lit>().Match<Expr>(expr, ref mul, ref first, ref lit))
    {
      if (lit.Eval() == 1) return first;
    }
    return expr;
  }

  static Expr RemoveMaxOfLiterals(Expr expr)
  {
    Max max = null; Lit lit1 = null; Lit lit2 = null;
    if (new Pattern<Max, Lit, Lit>().Match<Expr>(expr, ref max, ref lit1, ref lit2))
    {
      return new Lit(Math.Max(lit1.Eval(), lit2.Eval()));
    }
    return expr;
  }
Re[9]: Функциональное программирование в Nemerle
От: Аноним  
Дата: 18.05.07 21:03
Оценка: -1 :)
Здравствуйте, IT, Вы писали:

IT>Хочешь я твои 150 легко превращу в 300 просто убрав искусственное сжатие кода, предназначенное исключительно для экономии строк?

Главное, не забыть при этом, что я могу аналогичный код на Nemerle легко превратить в 150.
Re[10]: Функциональное программирование в Nemerle
От: IT Россия blogs.rsdn.ru
Дата: 18.05.07 21:19
Оценка: +1
Здравствуйте, <Аноним>, Вы писали:

IT>>Хочешь я твои 150 легко превращу в 300 просто убрав искусственное сжатие кода, предназначенное исключительно для экономии строк?

А>Главное, не забыть при этом, что я могу аналогичный код на Nemerle легко превратить в 150.

Не сможешь, там от силы пять строчек можно добавить для улучшения читабельности. А вот твой код с первого взгляда выглядит как попытка ужать посильнее и впихнуть побольше. Такие вещи таким способом не делаются. Пиши нормально, так чтобы другие глаза не ломали о твои нагромождения кода и твой код, даже больше в строчках, будут читаться гораздо лучше.
... << RSDN@Home 1.2.0 alpha rev. 0>>
//rsdn.org/forum/images/bis.gif Если нам не помогут, то мы тоже никого не пощадим.
Re[9]: Функциональное программирование в Nemerle
От: Аноним  
Дата: 18.05.07 21:20
Оценка:
Здравствуйте, VladD2, Вы писали:

      | Call(_, _)   => throw InvalidOperationException(this.ToString());

Кстати, а зачем этот код? Разве Nemerle не отслеживает все случаи когда соспоставление с образцом не сработает?
А тут, как я вижу проверка перенесена в Runtime.
Re[11]: Функциональное программирование в Nemerle
От: Аноним  
Дата: 18.05.07 21:28
Оценка: -2 :)
Здравствуйте, IT, Вы писали:

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


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


Тогда и у меня пять строчек. А свой код я могу еще процентов на 30 (120 строк вместо 160 ) сократить, сохранив читабельность.

using System;
using System.Console;
using Nemerle.Utility;
using Expr;

public variant Expr
{
  | Literal 
    { 
      value : double; 
    }
  | Call    
    { 
        name  : string; 
        parms : list[Expr]; 
    }
  | Plus    
    { 
        expr1 : Expr;   
        expr2 : Expr; 
    }
  | Minus   
    { 
        expr1 : Expr;   
        expr2 : Expr; 
    }
  | Mul     
    { 
        expr1 : Expr;   
        expr2 : Expr; 
    }
  | Div     
    { 
        expr1 : Expr;   
        expr2 : Expr; 
    }
  
  public override ToString() : string
  {
    match (this)
    {
      | Literal(value)    => 
      {
        value.ToString()
      }
      | Call(name, parms) => 
      {
        $"$name(..$parms)"
      }
      | Plus(e1, e2) with op = "+" 
      | Minus(e1, e2) with op = "-" 
      | Mul (e1, e2) with op = "*" 
      | Div  (e1, e2) with op = "/" 
      {
        => $"$e1 $op $e2"
      }
    }
  }

  public Eval() : double
  {
    match (this)
    {
      | Literal(value) => 
      {
        value
      }
      | Plus (e1, e2) => 
      {
        e1.Eval() + e2.Eval()
      }
      | Minus(e1, e2) => 
      {
        e1.Eval() - e2.Eval()
      }
      | Mul  (e1, e2) => 
      {
          e1.Eval() * e2.Eval()
      }
      | Div  (e1, e2) => 
      {
        e1.Eval() / e2.Eval()
      }
      | Call("max", [arg1, arg2]) => 
      {
        Math.Max(arg1.Eval(), arg2.Eval())
      }
      | Call("min", [arg1, arg2]) => 
      {
        Math.Min(arg1.Eval(), arg2.Eval())
      }
      | Call("foo", [arg1]) => 
      {
        arg1.Eval() // добавили поддержку фунции foo() с одним параметром
      }
      | Call(_, _) => 
      {
        throw InvalidOperationException(this.ToString());
      }
    }
  }

  public Convert(transform : Expr -> Expr) : Expr // добавили поддержку трансформации выражений
  {
    def res = transform(this);
    match (res)
    {
      | Literal => 
      {
        res
      }
      | Plus(e1, e2) => 
      {
        Plus(e1.Convert(transform), e2.Convert(transform))
      }
      | Minus(e1, e2) => 
      {
        Minus(e1.Convert(transform), e2.Convert(transform))
      }
      | Mul(e1, e2) => 
      {
        Mul(e1.Convert(transform), e2.Convert(transform))
      }
      | Div(e1, e2) => 
      {
        Div(e1.Convert(transform), e2.Convert(transform))
      }
      | Call(name, parms) => 
      {
        Call(name, parms.Map(_.Convert(transform)))
      }
    }
  }
}

module Program
{
  Main() : void
  {
    def expr = Mul(Plus(Literal(1.23), Call("max", [Literal(1), Literal(2)])), Literal(1));
    WriteLine("До трансформации");
    WriteLine($"Expression '$expr' = $(expr.Eval())");

    def expr = expr.Convert(fun(e : Expr) 
    { 
        | Mul(x, Literal(1.0)) => x 
        | _ => e 
    });
    WriteLine("После трансформации");
    WriteLine($"Expression '$expr' = $(expr.Eval())");
    WriteLine("..."); _ = ReadLine();
  }
}
Re[12]: Функциональное программирование в Nemerle
От: IT Россия blogs.rsdn.ru
Дата: 18.05.07 22:00
Оценка: +2
Здравствуйте, <Аноним>, Вы писали:

А>
А>using System;
А>using System.Console;
А>using Nemerle.Utility;
А>using Expr;

А>public variant Expr
А>{
А>  | Literal 
А>    { 
А>      value : double; 
А>    }
А>  | Call    
А>    { 
А>        name  : string; 
А>        parms : list[Expr]; 
А>    }
А>  | Plus    
А>    { 
А>        expr1 : Expr;   
А>        expr2 : Expr; 
А>    }
А>  | Minus   
А>    { 
А>        expr1 : Expr;   
А>        expr2 : Expr; 
А>    }
А>  | Mul     
А>    { 
А>        expr1 : Expr;   
А>        expr2 : Expr; 
А>    }
А>  | Div     
А>    { 
А>        expr1 : Expr;   
А>        expr2 : Expr; 
А>    }
А>

Здесь ты не добавил читабельности. Здесь ты её убил.

Пожалуйста, не надо считать других за идиотов и демонстрировать упёртость. Твой C# код по читабельности от приведённого Владом даже рядом никогда не стоял. Это может быть не очевидно только человеку, которому истина уже ни к чему, которому главное доказать, не важно что, лишь бы доказать. Это не продуктивно и не конструктивно.
... << RSDN@Home 1.2.0 alpha rev. 0>>
//rsdn.org/forum/images/bis.gif Если нам не помогут, то мы тоже никого не пощадим.
Re[13]: Функциональное программирование в Nemerle
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.07 22:49
Оценка:
Здравствуйте, IT, Вы писали:

IT>Пожалуйста, не надо считать других за идиотов и демонстрировать упёртость.


Собственно именно это и происхордит на протяжении всего разговора с Аноним 150. Демонстрация упертости. Бессмысленной и беспощадной. Посему нужно завязывать этот разговор. Все кто захочет сделает выводы сам. Заниматься воспитанием объективности не входит в наши задачи. Да и вряд ли это ее можно воспитать у взрослого человека.
... << RSDN@Home 1.2.0 alpha rev. 637>>
http://nemerle.org/Banners/?g=dark
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[6]: книга?
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.07 22:49
Оценка: +1
Здравствуйте, <Аноним>, Вы писали:

А>VladD2, а вы не думали издать книгу про Nemerle и вообще по функциональным языкам?

А>Чисто Ваших статей только по Nemerle (из тех что в открытом доступе) набралось уже на 125 страниц формата А4, т.е. распечатать конечно можно но это будет ворох бумаги, что крайне неудобно. Хочется именно книгу.
А>Если присоединить туда обзорные статьи по ФП в целом, по Haskell, Erlang, Scala (это будет полезно, для обзора и для сравнения возможностей языков), то получится еще столько же. Ну и еще "связующий" текст, что-то из стандарта языка, побольше примеров и т.д.

Создание кник требует времени. А его и так на другие задачи не хватает.
... << RSDN@Home 1.2.0 alpha rev. 637>>
http://nemerle.org/Banners/?g=dark
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[10]: Функциональное программирование в Nemerle
От: VladD2 Российская Империя www.nemerle.org
Дата: 18.05.07 22:49
Оценка:
Здравствуйте, <Аноним>, Вы писали:

А>
А>      | Call(_, _)   => throw InvalidOperationException(this.ToString());
А>

А>Кстати, а зачем этот код? Разве Nemerle не отслеживает все случаи когда соспоставление с образцом не сработает?
А>А тут, как я вижу проверка перенесена в Runtime.

Компилятор отслеживает, что match отлавливает все вариации. Если какой-то вариант не отлавливается выдается предупрждение. Если его прогнорировать и в рантайме появится тако паттерн, то вылетет исключение говорящее, что сопоставление с образцом не удалось. Делать так естественно не стоит. По этому если паттерны не покрывают все вариации, то нужно добвлять паттерн отлавливаеющий все что осталось. В данном случае он отлавливает все ошибки связнаные с неверным числом парметров у фукнции.
... << RSDN@Home 1.2.0 alpha rev. 637>>
http://nemerle.org/Banners/?g=dark
Есть логика намерений и логика обстоятельств, последняя всегда сильнее.
Re[11]: Функциональное программирование в Nemerle
От: Аноним  
Дата: 19.05.07 19:38
Оценка: :))
Здравствуйте, VladD2, Вы писали:

VD>Компилятор отслеживает, что match отлавливает все вариации. Если какой-то вариант не отлавливается выдается предупрждение. Если его прогнорировать и в рантайме появится тако паттерн, то вылетет исключение говорящее, что сопоставление с образцом не удалось. Делать так естественно не стоит. По этому если паттерны не покрывают все вариации, то нужно добвлять паттерн отлавливаеющий все что осталось. В данном случае он отлавливает все ошибки связнаные с неверным числом парметров у фукнции.


А вот и преимущество абстрактных классов.
В моем коде вообще нельзя создать Call с каким угодно количеством параметров, хоть правильным, хоть не правильным.
Похоже быстрота написания иерархии, через варианты в Nemerle влечет за собой необходимость дополнительных проверок да еще и в runtime.
Какие еще проблемы вылезут в дальнейшем, кто знает...
Re[13]: Функциональное программирование в Nemerle
От: Аноним  
Дата: 19.05.07 19:59
Оценка: :)
Здравствуйте, IT, Вы писали:

IT>Здесь ты не добавил читабельности. Здесь ты её убил.

Отлично, с учетом того, что это был выстрел вслепую, так как мне не было показано, во что должен превратиться мой код после увеличения количества строк до 300, для, возможного, увеличения читабельности. Причем я по-честному не стал приводить свою версию кода на Nemerle в своем первом ответе на обещание увеличить мой код до 300 строк. Однако это не привело к показу кода, поэтому я счел нужным первым перевести разговор в конкретную плоскость, с конкретным кодом и конкретными цифрами. В ответ я получил обиду, что не так переформатировал код, но так и не получил в ответ образец как надо было переформатировать мой код чтобы он занимал 300 строк, чтобы я на основании этого образца мог бы переформатировать код на Nemerle.

IT>Пожалуйста, не надо считать других за идиотов и демонстрировать упёртость.

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

IT>которому истина уже ни к чему, которому главное доказать, не важно что, лишь бы доказать

Честно говоря, слабо понимаю, как это истина может быть не важна, когда она доказывается.
Re[13]: Функциональное программирование в Nemerle
От: Аноним  
Дата: 19.05.07 20:08
Оценка:
Здравствуйте, IT, Вы писали:

Да, я правильно понял, что мне тоже можно в C# размещать декларации для нескольких разнотипных переменных на одной строке или это прерогатива кода на Nemerle?
Re[14]: Функциональное программирование в Nemerle
От: Аноним  
Дата: 19.05.07 20:21
Оценка: -1 :))
Здравствуйте, VladD2, Вы писали:

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


VD>Собственно именно это и происхордит на протяжении всего разговора с Аноним 150. Демонстрация упертости. Бессмысленной и беспощадной.

Я правильно понимаю, что вы решили не замечать реализацию паттерн матчинга в C# и быстренько свернуть разговор.
Я, конечно, конкретный код реализации матчинга не привел, хотя он у меня и есть, а привел пример использования.
Re[15]: Функциональное программирование в Nemerle
От: konsoletyper Россия https://github.com/konsoletyper
Дата: 20.05.07 06:13
Оценка:
Здравствуйте, <Аноним>, Вы писали:

VD>>Собственно именно это и происхордит на протяжении всего разговора с Аноним 150. Демонстрация упертости. Бессмысленной и беспощадной.

А>Я правильно понимаю, что вы решили не замечать реализацию паттерн матчинга в C# и быстренько свернуть разговор.
А>Я, конечно, конкретный код реализации матчинга не привел, хотя он у меня и есть, а привел пример использования.

Обратили-обратили. Даже минус поставили. Всё потому, что ты даже не удосужился понять, что такое паттерн-матчинг. Только я тут этого объяснять не буду, а отошлю ещё раз внимательно перечитать статьи по Nemerle (или по другим ML-образным ФЯ) или к примерам кода. Кстати, на неконструктивные замечания я отвечать не намерен.
... << RSDN@Home 1.2.0 alpha rev. 672>>
Re[14]: Функциональное программирование в Nemerle
От: konsoletyper Россия https://github.com/konsoletyper
Дата: 20.05.07 06:13
Оценка:
Здравствуйте, <Аноним>, Вы писали:

А>Отлично, с учетом того, что это был выстрел вслепую, так как мне не было показано, во что должен превратиться мой код после увеличения количества строк до 300, для, возможного, увеличения читабельности. Причем я по-честному не стал приводить свою версию кода на Nemerle в своем первом ответе на обещание увеличить мой код до 300 строк. Однако это не привело к показу кода, поэтому я счел нужным первым перевести разговор в конкретную плоскость, с конкретным кодом и конкретными цифрами. В ответ я получил обиду, что не так переформатировал код, но так и не получил в ответ образец как надо было переформатировать мой код чтобы он занимал 300 строк, чтобы я на основании этого образца мог бы переформатировать код на Nemerle.


Отличный пример софистики и демагогии. Нуль конструкрива. Ты вообще понимаешь слово "читабельный", или просто издеваешься над собеседниками?
... << RSDN@Home 1.2.0 alpha rev. 672>>
Re[14]: Функциональное программирование в Nemerle
От: konsoletyper Россия https://github.com/konsoletyper
Дата: 20.05.07 06:13
Оценка:
Здравствуйте, <Аноним>, Вы писали:

А>Да, я правильно понял, что мне тоже можно в C# размещать декларации для нескольких разнотипных переменных на одной строке или это прерогатива кода на Nemerle?


В Nemerle, обрати внимание, такая практика существует только по отношению к вариантам. Потому что варианты унаследованы Nemerle от ML, где такое практикуется почти 30 лет. И это вполне обоснованная практика. Я не сильно разбираюсь в тонкостях computer science. Так что судить могу по абстрактному понятию "читабельность". Так вот, в вариантах размещение нескольких "деклараций" на одной строке читабельность повышает. В классах же — понижает. Думаю, всё это связано с тем, что классы поддерживают ООП-парадигму, так что должны походить на чёрный ящик, потому для них требуется пространное описание структуры. Варианты же — вещь ортогональная ООП, они, наоборот, максимально открыты, чтобы по ним было проще сопостовлять по образцу.
... << RSDN@Home 1.2.0 alpha rev. 672>>
Re[3]: Функциональное программирование в Nemerle
От: FDSC Россия consp11.github.io блог
Дата: 20.05.07 12:09
Оценка:
Здравствуйте, konsoletyper, Вы писали:

K>Какое SDK? Сейчас Блудов Павел раз в месяц выкладывает инсталлятор, и ничего (кроме инсталлятора, 2Мб) качать не нужно. Правда, есть неудобство — Интеграция пока жутко глючит. Но это всё же гораздо удобнее, чем в Блокноте.


Блин, ребят, что же вы не написали, а! Надо же было орать на весь форум!!! А я мучаюсь без интеграции....
Подождите ...
Wait...
Пока на собственное сообщение не было ответов, его можно удалить.