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

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

FR>>Пойми реально D сильно отличается от C++. Практически не меньше чем шарп. И продолжить на нем проект не получится.

AF>Я понимаю. C# от C++ еще больше отличается, но организовать между ними интероп у МС получилось очень даже неплохо.

Может тогда расскажите, как решить вышеупомянутую задачку с ACE в .NET?

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

FR>На таком уровне с D тоже получится, каких то принципиальных ограничений не видно.

даже и близко не получится

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

E>Может тогда расскажите, как решить вышеупомянутую задачку с ACE в .NET?

Вероятно, придется делать неуправляемый класс-наследник и обертки для управляемых функций.

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

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

E>>Может тогда расскажите, как решить вышеупомянутую задачку с ACE в .NET?

AF>Вероятно, придется делать неуправляемый класс-наследник и обертки для управляемых функций.

И после этого вы еще предъявляете какие-то претензии к D?

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

E>Ни в D, ни в Nice, ни в Nemerle, я не видел возможности использования old в постусловях. Т.е. ни один из этих языков не реализует оригинальной концепции Design By Contract. И компиляторы этих языков созданы на разных принципах. Так какое же преимущество имеет микроядро с макросами Nemerle, если контракты там такие же ущербные, как и в других языках?
Возьми да добавь.
Там все просто.
Вот весь макрос:

  /** Enforces given boolean condition at the end of method invocation.  

      It checks at runtime, that given condition is true at the end
      of each method invocation. The `otherwise' section allows to specify
      what should happen when condition is false (for example throw some
      exception).                                            
  
     Example:  [Ensures (foo () != 4)]
            foo (i : int) : int { ... }
          or
            foo (i : int) : int
             ensures value > 0
            { ... }

          after opening Nemerle.Assertions namespace
   */
  [Nemerle.MacroUsage (Nemerle.MacroPhase.WithTypedMembers,
                       Nemerle.MacroTargets.Method,
                       Inherited = true, AllowMultiple = true)]
  macro Ensures (_ : TypeBuilder, m : MethodBuilder, assertion, other = null)
  syntax ("ensures", assertion, Optional ("otherwise", other))
  {
    def check =
      if (other != null)
        <[ unless ($assertion) $other ]>
      else
        <[ assert ($assertion, "The ``Ensures'' contract of method `" +
                   $(m.Name : string) + "' has been violated.") ]>;
    
    def newBody = Util.locate(m.Body.Location, 
      if (m.ReturnType.Equals (MType.Void ()))
        <[
          $(m.Body);
          $check;
        ]>
      else
        <[
          def $("value" : usesite) = $(m.Body);
          $check;
          $("value" : usesite);
        ]>);
      
      m.Body = newBody;
  }

Все что нужно это запомнить аргументы функции до вызова body и передать их в check.
Думаю с этим даже ты справишься.

E>Более того, использование синтаксиса и блоков кода Ruby для декларативных описаний -- это общепринятая практика в Ruby, так что нельзя говорить, что язык на это расчитан не был. И в Ruby вся эта магия делается не макросами, не изменением синтаксиса, а обычными библиотеками.
А макросы чем тебе не библиотеки?

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

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

E>>Ни в D, ни в Nice, ни в Nemerle, я не видел возможности использования old в постусловях. Т.е. ни один из этих языков не реализует оригинальной концепции Design By Contract. И компиляторы этих языков созданы на разных принципах. Так какое же преимущество имеет микроядро с макросами Nemerle, если контракты там такие же ущербные, как и в других языках?
WH>Возьми да добавь.
WH>Там все просто.
...
WH>Все что нужно это запомнить аргументы функции до вызова body и передать их в check.
WH>Думаю с этим даже ты справишься.

Если уж разработчики Nemerle с их гениальными идеями не смогли это сделать, то я даже и пытаться не буду.

E>>Более того, использование синтаксиса и блоков кода Ruby для декларативных описаний -- это общепринятая практика в Ruby, так что нельзя говорить, что язык на это расчитан не был. И в Ruby вся эта магия делается не макросами, не изменением синтаксиса, а обычными библиотеками.
WH>А макросы чем тебе не библиотеки?

Я уже пытался объяснять про проблемы совместного использования нескольких разных синтаксических макросов с одинаковыми ключевыми словами. Но вам выгоднее не обращать на них внимания. Хотя как раз в этом отличие между макросами и библиотеками и состоит -- в отсутствии конфликтов.

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

E>Если уж разработчики Nemerle с их гениальными идеями не смогли это сделать, то я даже и пытаться не буду.

Я ща начну разговаривать в стиле колхоза...
Я начинаю его понимать...

E>Я уже пытался объяснять про проблемы совместного использования нескольких разных синтаксических макросов с одинаковыми ключевыми словами. Но вам выгоднее не обращать на них внимания. Хотя как раз в этом отличие между макросами и библиотеками и состоит -- в отсутствии конфликтов.
Не делай using и используй макрос как вызов функции. Делов то.

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

E>>Я уже пытался объяснять про проблемы совместного использования нескольких разных синтаксических макросов с одинаковыми ключевыми словами. Но вам выгоднее не обращать на них внимания. Хотя как раз в этом отличие между макросами и библиотеками и состоит -- в отсутствии конфликтов.
WH>Не делай using и используй макрос как вызов функции. Делов то.

Может покажешь, как макросы require и ensure использовать как вызов функции?

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

E>>Ни в D, ни в Nice, ни в Nemerle, я не видел возможности использования old в постусловях. Т.е. ни один из этих языков не реализует оригинальной концепции Design By Contract. И компиляторы этих языков созданы на разных принципах. Так какое же преимущество имеет микроядро с макросами Nemerle, если контракты там такие же ущербные, как и в других языках?
WH>Возьми да добавь.
WH>Там все просто.
WH>Вот весь макрос:

Собственно, вот как реализуются контракты в Nice:
Граматика:

Contract contract() :
{
  Contract res = bossa.syntax.fun.noContract;
  Expression condition, name;
}
{
  [ "requires" { res = new Contract(); }
    contractElements(res, true)
  ]
  [ "ensures" { if (res == bossa.syntax.fun.noContract) res = new Contract(); }
    contractElements(res, false)
  ]
  { return res; }
}

void contractElements(Contract contract, boolean precond) :
{}
{
  contractElement(contract, precond)
  ( "," [ // Trailing "," allowed for easy reordering, removal of last line..
    contractElement(contract, precond)
  ] )*
}

void contractElement(Contract contract, boolean precond) :
{ Expression condition, name=null; }
{
  condition = SideEffectFreeExpression()
  [ ":" name = SideEffectFreeExpression() ]
  { contract.addElement(condition, name, precond); }
}

и еще чуть-чуть в AST компилятора:

/**
   The contract of a method.

 */
public class Contract
{
  private List<Expression> pre  = new LinkedList();
  private List<Expression> post = new LinkedList();

  private StringBuffer requireRepr = new StringBuffer("requires ");
  private StringBuffer ensureRepr = new StringBuffer("ensures ");

  public void addElement(Expression condition, ?Expression name, boolean precond)
  {
    let sym = createIdentExp(new LocatedString("!assert", condition.location()));

    Expression call;
    String repr;
    if (name == null)
      {
        call = createCallExp(sym, condition);
        repr = condition.toString() + ",";
      }
    else
      {
        call = createCallExp(sym, condition, name);
        repr = condition.toString() + ":" + name.toString() + ",";
      }

    if (precond)
      {
        pre.add(call);
        requireRepr.append(repr);
      }
    else
      {
        post.add(call);
        ensureRepr.append(repr);
      }
  }

  void resolve(VarScope scope, TypeScope typeScope,
           mlsub.typing.Monotype resultType,
               Location location)
  {
    pre = pre.map(Expression e => analyse(e, scope, typeScope));

    if (post.isEmpty())
      return;

    SymbolTable<VarSymbol> vars = new SymbolTable();

    // Make 'result' a variable in the scope of the post-conditions
    if (! nice.tools.typing.Types.isVoid(resultType))
      vars["result"] = new ResultMonoSymbol
        (new LocatedString("result", location), type: resultType);

    post = post.map(Expression e => analyse(e, scope, typeScope, vars));
  }

  void typecheck()
  {
    for (pe : pre)
      typecheck(pe);

    for (pe : post)
      typecheck(pe);
  }

  public gnu.expr.Expression compile(gnu.expr.Expression body)
  {
    return new gnu.expr.CheckContract(Expression_compile(pre), 
                      Expression_compile(post), 
                      body);
  }

  toString()
  {
    StringBuffer res = new StringBuffer();
    if (! pre.isEmpty())
      res.append(requireRepr.toString());
    if (! post.isEmpty())
      res.append(ensureRepr.toString());
    return res.toString();
  }

}

let Contract noContract = new NoContract();

class NoContract extends Contract
{
  resolve(scope, typeScope, resultType, location) {}
  typecheck() {}
  compile(body) = body;
  toString() = "";
}

class ResultMonoSymbol extends MonoSymbol
{
  isAssignable() = false;
  compile() = gnu.expr.CheckContract.result;
}

Ты серьезно думаешь, что реализация на Nice на порядки сложнее таковой в Nemerle?

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

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

E>>Попробуйте довести Nemerle хотя бы до такого состояния.

VD>До какого? Уж судьбу Эфила я бы никому не пожелал.

Просто для информации: по словам Мейера, сейчас EiffelStudio -- это больше 2M строк на Eiffel (наверное, сюда входит еще и EiffelVision2 (кросс-платформенная графическая библиотека) и EiffelBuild (GUI дизайнер)). Всего EiffelStudio (опять же по словам Мейера) была продана в количестве десятков тысяч копий (причем каждая копия стоит значительно дороже $1000).

А теперь вопрос: ты не пожелаешь Nemerle иметь проекты такого масштаба, объемы продаж которых будут исчисляться десятками тысяч копий?

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

E>Может покажешь, как макросы require и ensure использовать как вызов функции?
Их можно использовать с синтаксисом атрибутов.
Ты бы хоть камент к Ensures посмотрел.

     Example:  [Ensures (foo () != 4)]
            foo (i : int) : int { ... }

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

E>Ты серьезно думаешь, что реализация на Nice на порядки сложнее таковой в Nemerle?
Да.
То что я привел полный код макроса ensures.
Если бы не уродская система типов .NET'а (в данном случае пакостит тип void) то макрос был бы еще короче.
Добавление old туда добавит еще строк 5-10.
И это при том что этот макрос опциональный и его добавление/удаление не влияет на ядро компилятора вобще. Те совсем никак.
Болие того этот макрос вполне могли написать посторонние люди, а авторы компилятора просто заапрувить.

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

E>А теперь вопрос: ты не пожелаешь Nemerle иметь проекты такого масштаба, объемы продаж которых будут исчисляться десятками тысяч копий?
Десятки тысяч это просто ничто.
Сравни с С++ который примерно тогоже возроста.
Или хотябы с жабой которая моложе.
Да и что-то мне кажется что даже хаскель интенсивние используют.

Так что мое мнение: Eiffel провальный проект.

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

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

E>>Может покажешь, как макросы require и ensure использовать как вызов функции?
WH>Их можно использовать с синтаксисом атрибутов.
WH>Ты бы хоть камент к Ensures посмотрел.
WH>

WH>     Example:  [Ensures (foo () != 4)]
WH>            foo (i : int) : int { ... }
WH>

Тогда два вопроса:

* если все это можно сделать без макросов, на анотациях, то зачем макросы?
* что делать с макросами, которые в анотации не засунуть? Насколько я понимаю, вещи типа using и for в Nemerle -- это макросы. Они так же функциями заменяются?

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

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

E>>А теперь вопрос: ты не пожелаешь Nemerle иметь проекты такого масштаба, объемы продаж которых будут исчисляться десятками тысяч копий?
WH>Десятки тысяч это просто ничто.

Продукты на Nemerle уже достигли такого уровня продаж?

WH>Так что мое мнение: Eiffel провальный проект.

Eiffel, по крайней мере, 20 лет кормил своего создателя и еще команду разработчиков EiffelStudio.

Способен ли на это Nemerle?

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

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

E>>Ты серьезно думаешь, что реализация на Nice на порядки сложнее таковой в Nemerle?
WH>Да.
WH>То что я привел полный код макроса ensures.

То, что я привел, содержит не только код макроса ensures, но и макроса requires, а так же код, отвечающий за pretty-print этих вещей.

WH>Если бы не уродская система типов .NET'а (в данном случае пакостит тип void) то макрос был бы еще короче.
WH>Добавление old туда добавит еще строк 5-10.

Есть у меня подозрения, что это будет не совсем так.

WH>И это при том что этот макрос опциональный и его добавление/удаление не влияет на ядро компилятора вобще. Те совсем никак.
WH>Болие того этот макрос вполне могли написать посторонние люди, а авторы компилятора просто заапрувить.

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

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

E>* если все это можно сделать без макросов, на анотациях, то зачем макросы?
Еще раз:
Это не атрибуты. Это макросы с синтаксисом атрибутов.

E>* что делать с макросами, которые в анотации не засунуть? Насколько я понимаю, вещи типа using и for в Nemerle -- это макросы. Они так же функциями заменяются?
Еще раз:
Это не функции. Это макросы с синтаксисом функций.

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

E>Продукты на Nemerle уже достигли такого уровня продаж?
Через 20 лет посмотрим.

E>Способен ли на это Nemerle?
Не хуже чем питон, руби и прочие поделки.

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

E>То, что я привел, содержит не только код макроса ensures, но и макроса requires,
Угу... смешать все в кучу... прелесно.
Кстати как там у Nice с сообщениями о ошибках

Автор: Klapaucius
Дата: 01.02.08

?

E>а так же код, отвечающий за pretty-print этих вещей.
Это ваще шедевр. За такой код в приличном обществе руки отрывают.

E>Есть у меня подозрения, что это будет не совсем так.
Проверь.
Мне данные конкретные макры (и темболие old в них) не нужны.

E>А вот пользователям языка это побарабану. Об этом уже много раз говорили.
Пользователи бывают разные.
E>Язык должен предоставлять базовый набор средств пользователям.
А что немерле не предоставляет
E>И без разницы, как этот базовый набор реализуется -- макросами или изменением грамматики.
Нет не безразници.
Если нужно менять граматику то это затронет всех, а не тех кому эти макры нужны.
Если нужно менять граматику то я не смогу добавить макру которая нужна только мне.
Если нужно менять граматику то это значительно усложняет разработку и как следствие колличество и качество фич оставляет жилать лучшего.
Как там с сообщениями об ошибках у Nice? А где я могу посмотреть на аналоги Memoize и Late для D?
...

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

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

E>>То, что я привел, содержит не только код макроса ensures, но и макроса requires,
WH>Угу... смешать все в кучу... прелесно.

Если ты не заметил, то там класс-наследник Expression и он реализует его методы. В каждом методе свой набор действий, которые не смешиваются.

WH>Кстати как там у Nice с сообщениями о ошибках

Автор: Klapaucius
Дата: 01.02.08

?

Жить можно. Klapaucius для красного словца убрал строку, в которой печатается имя файла, номер строки и столбца в строке. Так что диагностирует место возникновение ошибки nicec точно. А что вывод такой -- так лучше пусть такой, чем то, что позволяет себе MS VC++ 2003. Тот вообще, на ошибку в имени типа параметра в конструкторе выдает сообщение о синтаксической ошибке в совсем другой строке.

E>>а так же код, отвечающий за pretty-print этих вещей.
WH>Это ваще шедевр. За такой код в приличном обществе руки отрывают.

Странно, что после вот этого кода

Автор: WolfHound
Дата: 04.02.08

(там где через ssh сервер пингуется) ты еще с руками ходишь.

E>>Есть у меня подозрения, что это будет не совсем так.
WH>Проверь.
WH>Мне данные конкретные макры (и темболие old в них) не нужны.

Неумение пользоваться чем-то еще не означает его ненужности.

E>>А вот пользователям языка это побарабану. Об этом уже много раз говорили.
WH>Пользователи бывают разные.
E>>Язык должен предоставлять базовый набор средств пользователям.
WH>А что немерле не предоставляет
E>>И без разницы, как этот базовый набор реализуется -- макросами или изменением грамматики.
WH>Нет не безразници.
WH>Если нужно менять граматику то это затронет всех, а не тех кому эти макры нужны.

Если эта функциональность входит в ядро языка, то она и должна затрагивать всех.

WH>Если нужно менять граматику то я не смогу добавить макру которая нужна только мне.

По мне, так это только плюс для универсального языка.

WH>А где я могу посмотреть на аналоги Memoize и Late для D?

А какие гарантии предоставляет Memoize в многопоточной программе? А по исключениям?
А если мне нужны другие гарантии? Собственный макрос делать? Тогда зачем Memoize в стандартной поставке языка?