using System;

namespace Test
{
    public struct Date
    {
        public this(year: int, month: int, day: int)
        {
            _value = 10000 * year + 100 * month + day;
        }

        public Test1(date: Date): DateTime
        {
            date:> DateTime
        }

        public Test2(date: Date): int
        {
            date:> int
        }

        public static @:>(date: Date): int
        {
            date.Value
        }
        
        public static @:>(date: Date): DateTime
        {
            DateTime(date.Year, date.Month, date.Day)
        }

        public Year: int { get { Value / 10000 } }
        public Month: int { get { (Value % 10000) / 100 } }
        public Day: int { get { Value % 100 } }
        
        private Value: int { get { _value } }
        private _value: int;
    }
}

D:\>ncc -target:library test.n
test.n:27:15:27:40: <[01;31merror<[0m: attempted return type overload on method Test.Date.op_Explicit(date : Test.Date): System.DateTime and method Test.Date.op_Explicit(date : Test.Date) : int
test.n:27:15:27:40: <[01;31merror<[0m: redefinition of method Test.Date.op_Explicit(date : Test.Date) : System.DateTime

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

I>D:\>ncc -target:library test.n
I>test.n:27:15:27:40: <[01;31merror<[0m: attempted return type overload on method Test.Date.op_Explicit(date : Test.Date): System.DateTime and method Test.Date.op_Explicit(date : Test.Date) : int
I>test.n:27:15:27:40: <[01;31merror<[0m: redefinition of method Test.Date.op_Explicit(date : Test.Date) : System.DateTime
I>[/code]

Возможно это баг. Надо бы заслать в их багтрекер.

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

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

VD>Возможно это баг. Надо бы заслать в их багтрекер.

А можно определить две одиннаковые функции, различающиеся только возвращающим значением ?
Или опереторы приведения — это специальный случай ?

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

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

DK>Или опереторы приведения — это специальный случай ?
Да, в C# это специальный случай. В Nemerle видимо нет.

Я кстати не уверен, что это баг. У компилятора Nemerle есть тесты, в том числе и для операторов приведения, вот в них я ни разу не видел больше одного оператора явного и неявного приведения(в смысле с одинаковыми параметрами).

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

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

DK>А можно определить две одиннаковые функции, различающиеся только возвращающим значением ?

Нет, конечно. Это будет несовместимо с C#. Но вот с операторами явного приведения типов как раз все иначе.

DK>Или опереторы приведения — это специальный случай ?

Специальный.

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

DK>>А можно определить две одиннаковые функции, различающиеся только возвращающим значением ?
VK>Нет, нельзя. В C# кстати тоже нельзя.

Именно потому и нельзя. Возмжно это еще усложняет вывод типов, но потенциально MSIL это поддерживает.

DK>>Или опереторы приведения — это специальный случай ?
VK>Да, в C# это специальный случай. В Nemerle видимо нет.

Думаю, это ошибка. Nemerle декларирует совместимость с C# по публичному интерфейсу. Так что любой публичный интерфейс который можно написать на C# должно быть можно на Nemerle.

VK>Я кстати не уверен, что это баг. У компилятора Nemerle есть тесты, в том числе и для операторов приведения, вот в них я ни разу не видел больше одного оператора явного и неявного приведения(в смысле с одинаковыми параметрами).

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

VK>Возможно это by design. Авторы Nemerle вообще не любят подобные штуки, вот и решили не делать специальных случаев для операторов приведения.

Любя, не любят — это не аргументация. Это не приводит к конфликтам, и это требуется для совместимости. Значит это должно быть.

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

VK>>Возможно это by design. Авторы Nemerle вообще не любят подобные штуки, вот и решили не делать специальных случаев для операторов приведения.
VD>Любя, не любят — это не аргументация. Это не приводит к конфликтам, и это требуется для совместимости. Значит это должно быть.
Да я в принципе согласен. А вот согласятся ли с этим "Немерлисты"? В качестве разминки я исправил эту "ошибку" и отправил репорт и патч. Но вот что они на это скажут это еще очень большой вопрос...

Кстати по поводу совместимости. Nemerle в отличие от C# операторы приведения типов еще и не наследует(т.е. унаследованные операторы попросту не действуют на наследник), так что на этом эпопея не закончится.

DK>>>А можно определить две одиннаковые функции, различающиеся только возвращающим значением ?
VK>>Нет, нельзя. В C# кстати тоже нельзя.
VD>Именно потому и нельзя. Возмжно это еще усложняет вывод типов, но потенциально MSIL это поддерживает.
Я кстати ради интереса включил и слегка потестировал перегрузку по возвращаемым значениям. Она вроде бы работает(собственно в этом я изначально не сомневался), но что будет в более сложных случаях я не знаю. Вот пара тестов, которые работают на моей версии компилятора:

class foo {
    public static @:>(_x : foo) : char { '1' }
    public static @:>(_x : foo) : string { "2" }
    public static @:(_x : foo) : int { 1 }
    public static @:(_x : foo) : float { 2.0f }
    public baz() : int { 1 }
    public baz() : float { 2.0f }
}

class bar : foo {
    public static @:>(_x : bar) : list[string] { ["3"] }
    public static @:(_x : foo) : bar { bar() }
    public static @:(_x : bar) : double { 3.0 }
    public baz() : double { 3.0 }
}

def b = bar();
def f : foo = b;

def i0 : int = f;
def i1 : float = f;
def i2 : double = f : bar;

def e0 = f :> char;
def e1 = f :> string;
def e2 = b :> list[string];

def o0 : int = f.baz();
def o1 : float = f.baz();
def o2 : double = b.baz();

System.Console.WriteLine((i0,i1,i2));
System.Console.WriteLine((e0,e1,e2));
System.Console.WriteLine((o0,o1,o2));

public class foo
{
    public bar() : int
    {
        1
    }
    public bar() : string
    {
        "123"
    }
}

def blob(x : string)
{
    System.Console.WriteLine(x);
}

def x = foo();
def y = x.bar();
blob(y);

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

VK>Да я в принципе согласен. А вот согласятся ли с этим "Немерлисты"?

Думаю — "спасибо".

VK> В качестве разминки я исправил эту "ошибку" и отправил репорт и патч. Но вот что они на это скажут это еще очень большой вопрос...

О! Здорово! А не хочешь ли ты в качестве разминки помочь нам в доведении до ума Интеграции со студией?
Ты бы мог сильно помочь нам. Нам рук ой как нехватает.

VK>Кстати по поводу совместимости. Nemerle в отличие от C# операторы приведения типов еще и не наследует(т.е. унаследованные операторы попросту не действуют на наследник), так что на этом эпопея не закончится.

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