<[ (0x01000193 * (($initExprConst) + ($gethashcode)) )]>
такое выражение разворачивается в 0x01000193 * $initExprConst + $gethashcode
Это глюк или так задумано?

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

А><[ (0x01000193 * (($initExprConst) + ($gethashcode)) )]>
А>такое выражение разворачивается в 0x01000193 * $initExprConst + $gethashcode
А>Это глюк или так задумано?

Приведи более полный код, что такое initExprConst и gethashcode, и как ты его разворачиваешь.

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

А><[ (0x01000193 * (($initExprConst) + ($gethashcode)) )]>
А>такое выражение разворачивается в 0x01000193 * $initExprConst + $gethashcode
А>Это глюк или так задумано?

В смысле, приоритет операторов не верный получается?

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

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

А>><[ (0x01000193 * (($initExprConst) + ($gethashcode)) )]>
А>>такое выражение разворачивается в 0x01000193 * $initExprConst + $gethashcode
А>>Это глюк или так задумано?

VD>В смысле, приоритет операторов не верный получается?

игнорируются скобки
a*(b+c) превращается в a*b+c

приходится писать так
def temp =<[$b+$c]>
<[$a*$temp]>

такая конструкция <[$a*($b+$c)]> неверно работает

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

VD>В смысле, приоритет операторов не верный получается?
Я подозреваю, что преттипринт кривой, а сам код нормальный.

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

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

VD>>В смысле, приоритет операторов не верный получается?
WH>Я подозреваю, что преттипринт кривой, а сам код нормальный.

<[ _*_(a,b+c)]> вот так получается нормальный код (правда через лямбды....)

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

VD>>В смысле, приоритет операторов не верный получается?
WH>Я подозреваю, что преттипринт кривой, а сам код нормальный.

Возможно. Надо смотреть в отладчике.

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

А><[ _*_(a,b+c)]> вот так получается нормальный код (правда через лямбды....)

Лябды — это перебор.

Ты посмотри все же как реально объекты в АСТе расположены (под отладчиком). Возможно дело действительно в некорректом прети-принте, а сам АСТ правильный. Уж больно банальная ошибка. На нее бы многие нарвались бы уже.

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

VD>Ты посмотри все же как реально объекты в АСТе расположены (под отладчиком). Возможно дело действительно в некорректом прети-принте, а сам АСТ правильный. Уж больно банальная ошибка. На нее бы многие нарвались бы уже.

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

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

VD>Ты посмотри все же как реально объекты в АСТе расположены (под отладчиком). Возможно дело действительно в некорректом прети-принте, а сам АСТ правильный. Уж больно банальная ошибка. На нее бы многие нарвались бы уже.

Вот как печатает pretty print:
def a = 1;
def b = 2;
def c = 3;
<[ $c * ($a + $b) ]>, для него это выражение *(3, +(1, 2)) или PExpr.Call(PExpr.Ref("*"), [PExpr.Literal(3), PExpr.Call(PExpr.Ref("+"), [PExpr.Literal(1), PExpr.Literal(2)]) ])
*(a, b) или любой вызов PExpr.Call печатает $a * $b => "3" "*" "1" + "2"

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

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

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

VD>>Ты посмотри все же как реально объекты в АСТе расположены (под отладчиком). Возможно дело действительно в некорректом прети-принте, а сам АСТ правильный. Уж больно банальная ошибка. На нее бы многие нарвались бы уже.

CU>Вот как печатает pretty print:
CU>def a = 1;
CU>def b = 2;
CU>def c = 3;
CU><[ $c * ($a + $b) ]>, для него это выражение *(3, +(1, 2)) или PExpr.Call(PExpr.Ref("*"), [PExpr.Literal(3), PExpr.Call(PExpr.Ref("+"), [PExpr.Literal(1), PExpr.Literal(2)]) ])
CU>*(a, b) или любой вызов PExpr.Call печатает $a * $b => "3" "*" "1" + "2"

CU>то есть надо как то думать о расставлении скобок в нужных местах при печати.

Нефига

Выражение в dotpeek
def temp=<[ $a+$b ]>
<[$temp^$c]>

раскрыл как temp^a+b

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

А>Нефига

А>Выражение в dotpeek
А>def temp=<[ $a+$b ]>
А><[$temp^$c]>

А>раскрыл как temp^a+b

Мы говорим о разных вещах, я говорю что печати pretty print все равно в каком порядке операторы, конечный код разворачивается правильно, но если посмотреть на него в отладчике в качестве выражения, порядок будет нарушен.
Если верхний пример переписать так, то опять в печати увидите тоже самое:

def a = 1;
def b = 2;
def c = 3;
def temp= <[ $a + $b ]>;
def expr = <[ $c * $temp ]>;
expr

Будет печататься в отладчике как 3 * 1 + 2, а конечный код в любом случае вычисляется правильно и с применением скобок и с применением переменных

Это код макроса уровня выражения, можно создать и посмотреть в отладчике его раскрытие и печать по переменной expr.

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

CU>то есть надо как то думать о расставлении скобок в нужных местах при печати.

Вся информация для этого есть. Она задается приоритетом в атрибуте OperatorAttribute. Сделать можно. В Н2 мы уже подобное сделали. Только нам сложнее. У нас скобки могут быть не одни, а могут вообще отсутствовать.

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

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

А>>Нефига

А>>Выражение в dotpeek
А>>def temp=<[ $a+$b ]>
А>><[$temp^$c]>

А>>раскрыл как temp^a+b

CU>Мы говорим о разных вещах, я говорю что печати pretty print все равно в каком порядке операторы, конечный код разворачивается правильно, но если посмотреть на него в отладчике в качестве выражения, порядок будет нарушен.
CU>Если верхний пример переписать так, то опять в печати увидите тоже самое:


CU>

CU>def a = 1;
CU>def b = 2;
CU>def c = 3;
CU>def temp= <[ $a + $b ]>;
CU>def expr = <[ $c * $temp ]>;
CU>expr

CU>

CU>Будет печататься в отладчике как 3 * 1 + 2, а конечный код в любом случае вычисляется правильно и с применением скобок и с применением переменных

CU>Это код макроса уровня выражения, можно создать и посмотреть в отладчике его раскрытие и печать по переменной expr.

Об одном и том же
если a*(b+c) раскроется правильно в коде, но не верно в отладчике
то a^(b+c) раскроеться неверно и там и там.

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

А>Об одном и том же
А>если a*(b+c) раскроется правильно в коде, но не верно в отладчике
А>то a^(b+c) раскроеться неверно и там и там.

Это как же? Проверьте еще раз, пример:

def a = 1;
def b = 2;
def c = 3;

<[$c ^ ($a + $b) ]>

в результате макроса получается 0 а не 4, а печать печатает без порядка.

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

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

А>>Об одном и том же
А>>если a*(b+c) раскроется правильно в коде, но не верно в отладчике
А>>то a^(b+c) раскроеться неверно и там и там.

CU>Это как же? Проверьте еще раз, пример:

CU>

CU>def a = 1;
CU>def b = 2;
CU>def c = 3;

CU><[$c ^ ($a + $b) ]>
CU>

CU>в результате макроса получается 0 а не 4, а печать печатает без порядка.

return -2128831035 ^ base.GetHashCode() ^ 16777619 * (16777619 * (16777619 * (-2128831035 ^ this.a1) ^ this.a2) ^ this.a3) + 3;

а должно быть
return -2128831035 ^ base.GetHashCode() ^ (16777619 * (16777619 * (16777619 * (-2128831035 ^ this.a1) ^ this.a2) ^ this.a3) + 3);

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


А>return -2128831035 ^ base.GetHashCode() ^ 16777619 * (16777619 * (16777619 * (-2128831035 ^ this.a1) ^ this.a2) ^ this.a3) + 3;

А>а должно быть
А>return -2128831035 ^ base.GetHashCode() ^ (16777619 * (16777619 * (16777619 * (-2128831035 ^ this.a1) ^ this.a2) ^ this.a3) + 3);

Че то вы мудрите, я переписал код без ваших констант с переполнением в C# и N, и результат одинаковый, разбирайтесь сами, что у вас там с расчетами:

На C#:

Int64 b = -2 ^ 2000 ^ (16 * (16 * (16 * (-2 ^ 1) ^ 2) ^ 3) + 3);
Console.WriteLine(b);
Console.ReadLine();

На N:

def ext = 2000;
def a1 = 1;
def a2 = 2;
def a3 = 3;
def res = <[ -2 ^ $ext ^ (16 * (16 * (16 * (-2 ^ $a1) ^ $a2) ^ $a3) + 3) ]>;
res

результат 2589

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

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


А>>return -2128831035 ^ base.GetHashCode() ^ 16777619 * (16777619 * (16777619 * (-2128831035 ^ this.a1) ^ this.a2) ^ this.a3) + 3;

А>>а должно быть
А>>return -2128831035 ^ base.GetHashCode() ^ (16777619 * (16777619 * (16777619 * (-2128831035 ^ this.a1) ^ this.a2) ^ this.a3) + 3);

CU>Че то вы мудрите, я переписал код без ваших констант с переполнением в C# и N, и результат одинаковый, разбирайтесь сами, что у вас там с расчетами:

CU>На C#:
CU>

CU>Int64 b = -2 ^ 2000 ^ (16 * (16 * (16 * (-2 ^ 1) ^ 2) ^ 3) + 3);
CU>Console.WriteLine(b);
CU>Console.ReadLine();
CU>

CU>На N:

CU>

CU>def ext = 2000;
CU>def a1 = 1;
CU>def a2 = 2;
CU>def a3 = 3;
CU>def res = <[ -2 ^ $ext ^ (16 * (16 * (16 * (-2 ^ $a1) ^ $a2) ^ $a3) + 3) ]>;
CU>res
CU>

CU>результат 2589
\
Ты просто проверил тождество. Я мог сказать и раньше, все верно.
не верное выражение генерируется.

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


А>Ты просто проверил тождество. Я мог сказать и раньше, все верно.
А>не верное выражение генерируется.

Почему неверное, в C# результат такой же как и в сгенерированном макросе коде Н, значит поведение у них одинаковое и в Н нет ошибки как и в C#, а там где не ставите скобок, приоритет операторов начинает работать аналогично как он установлен. Приведите полный код и покажите каким образом вы получаете неверный код, каким средством это определяете, пока кроме ваших утверждений ни какого доказательства ошибки не было.

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

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


А>>Ты просто проверил тождество. Я мог сказать и раньше, все верно.
А>>не верное выражение генерируется.

CU>Почему неверное, в C# результат такой же как и в сгенерированном макросе коде Н, значит поведение у них одинаковое и в Н нет ошибки как и в C#, а там где не ставите скобок, приоритет операторов начинает работать аналогично как он установлен. Приведите полный код и покажите каким образом вы получаете неверный код, каким средством это определяете, пока кроме ваших утверждений ни какого доказательства ошибки не было.

Только что просмотрел генерацию.
там где все значения константы выходит верно.
Но у меня там выражения.

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

using Nemerle;
using Nemerle.Collections;
using Nemerle.Extensions1;
using Nemerle.Text;
using Nemerle.Utility;

using System;
using System.Collections.Generic;
using System.Linq;
using System.Console;

module Program
{

 
[StructuralEquality(Ignore = name, NotIgnore = A.name, AllIgnore = true)]
variant X
{
 | A { name : string; name2 : string; other : int; }
 | B { name : string }
 | C {
     [EqualsNotIgnore] a1:int; 
     [EqualsNotIgnore] a2:int; 
     [EqualsNotIgnore] a3:int }
}

  Main() : void
  {
        def a1 = X.A("abc", "aaa", 1);
        def a2 = X.A("abcd", "aaa", 1);
        WriteLine(a1 == a2);

    _ = ReadLine();
}
}

Nemerle.Extensions1 брать из пулреквеста немерли сегодняшнего StructuralEquality.n

декомпилируй и посмотри.
Кстати, когда константы генерирует правильно.
декомпилировал я дотпиком

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

А>Только что просмотрел генерацию.
А>там где все значения константы выходит верно.
А>Но у меня там выражения.

Не знаю как вы смотрите, я сделал аналогичный код в С# и N:

    public class Class1
    {
          public int a1 = 1;
          public int a2 = 2;
          public int a3 = 3;

          public override int GetHashCode()
          {
              unchecked { return -2128831035 ^ base.GetHashCode() ^ (16777619 * (16777619 * (16777619 * (-2128831035 ^ this.a1) ^ this.a2) ^ this.a3) + 3); }
          }
    }

    class Program
    {
        static void Main(string[] args)
        {
            var cl = new Class1();
            Console.WriteLine(cl.GetHashCode());
            Console.ReadLine();
        }
    }

и

[MacroUsage(MacroPhase.BeforeInheritance, MacroTargets.Class)]
  macro Macro1(ty : TypeBuilder)
  {
    def body = <[ -2128831035 ^ base.GetHashCode() ^ (16777619 * (16777619 * (16777619 * (-2128831035 ^ this.a1) ^ this.a2) ^ this.a3) + 3) ]>;
    ty.Define(<[decl: public override GetHashCode() : int { unchecked { $body } } ]>)
  }

// в другом проекте
[Macro1]
class Class1
{
  public a1 : int = 1;
  public a2 : int = 2;
  public a3 : int = 3;
}

module Program
{
  Main() : void
  {
    def cl = Class1();
    def res = cl.GetHashCode();
    WriteLine($"Hi! $res");
    _ = ReadLine();
  }
}

получается -706362363

Все работает совершенно одинаково и код Reflector показывает одинаковый и там и там, в верном порядке, ищите ошибки у себя, порядок компилятор уже 10 лет как генерирует правильный.