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

VD>Тогда должен понмать, что сравнивать if немерла нужно с ?: С, а не со стейтментом.

А я вообще ни с чем не сравнивал. Тут другие сравнивали, в т.ч. с F# (аноним) и C# (ты, кстати). В обоих случаях языки сработали не идеально, но лучше

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

FDS>Зато само сообщение гораздо приятнее.

Это поправить не сложно. Сделаем.

В немерловом компиляторе много не очень внятных сообщений, к сожалению.

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

FDS>А я вообще ни с чем не сравнивал. Тут другие сравнивали, в т.ч. с F# (аноним) и C# (ты, кстати). В обоих случаях языки сработали не идеально, но лучше

Ты это делал подсознательно. Это видно из твоих требований.

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

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

FDS>>А я вообще ни с чем не сравнивал. Тут другие сравнивали, в т.ч. с F# (аноним) и C# (ты, кстати). В обоих случаях языки сработали не идеально, но лучше

VD>Ты это делал подсознательно. Это видно из твоих требований.

По-моему, ты их на 50-ый раз только прочитал, и то невнимательно.
Из них такого вывода принципиально сделать невозможно.

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

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

FDS>>А я вообще ни с чем не сравнивал. Тут другие сравнивали, в т.ч. с F# (аноним) и C# (ты, кстати). В обоих случаях языки сработали не идеально, но лучше

VD>Ты это делал подсознательно. Это видно из твоих требований.

Я вот сравнивал вполне сознательно. И с удивлением обнаружил, что F# определяет правильную ветку, для которой выводить ошибку.
Был бы благодарен за любые комментарии относительного того, можно ли такое сделать в Nemerle.

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

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

В частном, случае? Согласен, у F# получается не плохо. Моно попробовать делать так же.

Только это частный случай. Значение всего выражения будет известно не всегда (особенно в F#, который выводит обобщенные типы). Так что довольно быстро ты получишь ситуацию когда понять что за тип у выражения будет невозможно.

А>Был бы благодарен за любые комментарии относительного того, можно ли такое сделать в Nemerle.

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

Вот что будет в F#, если убрать аннотацию типов?

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

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

VD>Вот что будет в F#, если убрать аннотацию типов?

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

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

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

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

VD>В частном, случае? Согласен, у F# получается не плохо. Моно попробовать делать так же.

VD>Только это частный случай. Значение всего выражения будет известно не всегда (особенно в F#, который выводит обобщенные типы). Так что довольно быстро ты получишь ситуацию когда понять что за тип у выражения будет невозможно.

А>>Был бы благодарен за любые комментарии относительного того, можно ли такое сделать в Nemerle.

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

VD>Вот что будет в F#, если убрать аннотацию типов?

Чуда, конечно, не произойдет, о чем я уже писал.
Сообщение об ошибке будет на первую ветку. Но тут уже без вариантов, т.к. компилятор не телепат.
Мне вообщем и было интересно как разница в выводе типов влияет на такие вещи.

А>Чуда, конечно, не произойдет, о чем я уже писал.
А>Сообщение об ошибке будет на первую ветку. Но тут уже без вариантов, т.к. компилятор не телепат.
А>Мне вообщем и было интересно как разница в выводе типов влияет на такие вещи.

Очепятка. Правильно читать "Сообщение об ошибке будет на вторую ветку."

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

FDS>Влад, я, например, в сложных местах специально аннотирую типы, даже если не требуется,

Ну, вот в Немерле этого не требуется. И это очень хорошо.
Ты и твои предпочтения это одно, а язык — другое. Он не только под твои предпочтения заточен.

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

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

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

VD>>Вот что будет в F#, если убрать аннотацию типов?

А>Чуда, конечно, не произойдет, о чем я уже писал.
А>Сообщение об ошибке будет на первую ветку. Но тут уже без вариантов, т.к. компилятор не телепат.

Вот, последняя мысль очень верная. Не телепат.
Правильным же вариантом, похоже, является выдача сообщения на сам if.

А>Мне вообщем и было интересно как разница в выводе типов влияет на такие вещи.

Если тебе интересны подробности алгоритмов, то (я думаю), что тут дело во так обстоит.

При типизации выражения с одной стороны выводится тип этого выражения путем анализа его содержимого, а с другой есть так называемый ожидаемый (expected) тип. Ожидаемый тип позволяет связать подвыражение и внешний контекст (другой выражение, или, например, тело метода). В F#, скорее всего при обнаружении проблемы унификации подвыражений if-а пытаются унифицировать обе ветки с этим самым ожидаемым типом. Это дает более ожидаемый ответ. Вот только если унифицировать не с чем (что встречается сплошь и рядом), то ответ будет все равно не правильный. А лучше бы иметь всегда понятный ответ.

В F# отсутствует неявное приведение типов. По этому для выявления "неправильности" достаточно унификации типов. В Nemerle же (как и в C#) унификации мало. Нужно пытаться подбирать приведение типов. Это так же осложняет алгоритм.

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

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

FDS>>Влад, я, например, в сложных местах специально аннотирую типы, даже если не требуется,

VD>Ну, вот в Немерле этого не требуется. И это очень хорошо.

Как раз в Немерле это и требуется: в остальных языках аннотации типов всё равно приходится задавать всегда.

VD>Ты и твои предпочтения это одно, а язык — другое. Он не только под твои предпочтения заточен.

Однако это одно из достоинств языка лично для меня: на других языках так делать нельзя.

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

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

Это не более надёжное решение: это решение одной из двух описанных мною проблем: неверного места выдачи и неиспользования всех доступных для вывода типов данных.
Опять же, ты просто отбрасываешь вторую проблему, потому что она сложная. Я не против, но надо чётко и ясно заявлять, что проблема есть, а не говорить, что "это не требуется". У тебя всё, что сложно сделать, получает метку "никому не нужно". Те же Enum в шаблонных типах например.

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

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

VD>>>Вот что будет в F#, если убрать аннотацию типов?
А>>Чуда, конечно, не произойдет, о чем я уже писал.

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

А>>Сообщение об ошибке будет на первую ветку. Но тут уже без вариантов, т.к. компилятор не телепат.

VD>Вот, последняя мысль очень верная. Не телепат.

Из-за чего требует указания необходимой для вывода информации.

VD>Правильным же вариантом, похоже, является выдача сообщения на сам if.

Влад, однако Nemerle какой-то паршивый F# обставил там, где телепатия не нужна: он сообразил, на какую ветку указывать ошибку, если задавать аннотацию, которую не задать в Nemerle невозможно в данном конкретном реальном коде. Если ты не пишешь аннотаций нигде — это твоё дело, Nemerle не специально под тебя заточен , а ты подходишь к нему как к языку, который является твоей собственностью. Я не против, если чего-то в языке нет — я за него ничего не плачу и могу лишь указать, что что-то не так, но будь добр, признавай право других программистов программировать так, как они хотят на языке, который специально предоставляет для этого кучу возможностей, в том числе возможность создавать классы и объекты с обязательной аннотацией, которая лично меня крайне раздражает, но при этом не используется там, где могла бы облегчить ему жизнь.

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

FDS>Как раз в Немерле это и требуется: в остальных языках аннотации типов всё равно приходится задавать всегда.

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

VD>>Ты и твои предпочтения это одно, а язык — другое. Он не только под твои предпочтения заточен.

FDS>Однако это одно из достоинств языка лично для меня: на других языках так делать нельзя.

Ничего не понял.

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

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

VD>>>>Вот что будет в F#, если убрать аннотацию типов?
А>>>Чуда, конечно, не произойдет, о чем я уже писал.

FDS>Влад, а ты знаешь, что в том коде, что я дал как баг, аннотацию убрать невозможно? Чуда не произойдёт, в том месте Nemerle требует аннотацию.

Это, вообще-то, цитата другого человека.

Что касается "того места", то у тебя там баг на баге. Убери баги и аннотация скорее всего не потребуется.

Реально аннотация требуется при неоднозначностях. У тебя ее я не заметил.

VD>>Вот, последняя мысль очень верная. Не телепат.

FDS>Из-за чего требует указания необходимой для вывода информации.

У них алгоритм слабенький, вот и требует. В немреле ничего не требуется.

FDS>Влад, однако Nemerle какой-то паршивый F# обставил

Ой, только не надо этой демагогии. Он и C# "обствил". Поправим сообщение и проблема исчезнет. А то что вывод типов у F# в разы слабее — это факт не приложный. И то что F# частенько выдает сообщения об ошибках которые без пол литры понять нельзя, тоже факт. Аннотации в нем тоже требуются раз в 10 чаще. А сколько он не умеет того что Nemerle и C# умеет? В общем, в F# гордиться можно только тем, что их алгоритм вывода типов быстрый и линейный.

FDS> там, где телепатия не нужна: он сообразил,

В этом случае сообразил. В другом лажанет. Чем меньше аннотаций, тем больше будет лажать.

FDS>на какую ветку указывать ошибку, если задавать аннотацию, которую не задать в Nemerle невозможно в данном конкретном реальном коде.

Прямо таки невозможно? Код (компилируемый) в студию!

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

VD>Это просто говорят твои привычки. Те кто по опытнее в Н, типы указывают очень редко. Внутри выражений, так почти никогда.
Влад, не считай других неопытными дураками: это невежливо и глупо, уж извини. То, что я указываю в Nemerle типы, это следствие
1. Того, что компилятор от меня это требует при декларациях классов, что ОЧЕНЬ меня достаёт
2. Моего опыта программирования на Nemerle, т.к. я знаю, что если вообще никогда не указывать типы, то мне потом самому тяжелее код читать, где на 500 строк ни одной явно типизированной декларации нет и компилятор зачастую при моих ошибках ошибается строк эдак на 150-200 в анализе того, где я допустил ошибку в типах.

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

Согласен в том смысле, что компилятор вообще должен хорошо работать. И если аннотация по каким-то причинам есть, то диагностика не должна превращаться в плохую, т.е. не учитывающую аннотацию.
Понимаешь?

Я не говорю, что это просто сделать, но если программист уже указал аннотацию, тем более, если он не мог её не указать, то хороший компилятор эту аннотацию учтёт. И это лишнее достоинство языка, а не его недостаток. Мне очень радостно, что я могу указывать типов в 10 раз меньше, чем обычно, и думать над этим в 30 раз меньше, чем обычно, но мне не радостно, что если уж я указал тип, то компилятор на это наплевал. Здесь вступает в силу обратный закон: лично мне удобно использовать мощь компилятора указывая аннотации типов, потому что если я укажу один тип из 10 или 20-ти это меня не затормозит, но код сделает читаемей и компилятору будет дополнительная подсказка, где я ошибся. В итоге программировать на таком языке становится удобнее.

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

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

VD>>>>>Вот что будет в F#, если убрать аннотацию типов?
А>>>>Чуда, конечно, не произойдет, о чем я уже писал.

FDS>>Влад, а ты знаешь, что в том коде, что я дал как баг, аннотацию убрать невозможно? Чуда не произойдёт, в том месте Nemerle требует аннотацию.

VD>Это, вообще-то, цитата другого человека.

Влад, где цитата другого человека? Вот эта:
VD>>>>>Вот что будет в F#, если убрать аннотацию типов?

Ты читай всю цитату, что приводится.

VD>Что касается "того места", то у тебя там баг на баге. Убери баги и аннотация скорее всего не потребуется.

Давай тогда скажем, что вообще сообщения об ошибках компилятора не нужны: давай всё сами сделаем. Да и вывод типов не нужен: сам аннотируй, и всё будет хорошо.
Что касается "баг на баге" — этот код реальный из недописанного приложения, и всё, что нужно, он делает без ошибок вообще. Так что ошибки там чисто синтаксичесекие.

VD>Реально аннотация требуется при неоднозначностях. У тебя ее я не заметил.

Влад, а ты не заметил, что это декларация метода класса, и аннотация там требуется, потому что Nemerle иначе работать отказывается?

VD>У них алгоритм слабенький, вот и требует. В немреле ничего не требуется.

Требуется. Я был бы рад не указать аннотацию там, где мне её пришлось указать, т.к. этого требует компилятор Nemerle.

FDS>>Влад, однако Nemerle какой-то паршивый F# обставил

VD>Ой, только не надо этой демагогии. Он и C# "обствил". Поправим сообщение и проблема исчезнет.

Проблема не исчезнет до конца, т.к. Nemerle не использовал аннотацию типа, а вот F# — использовал.

VD> А сколько он не умеет того что Nemerle и C# умеет?

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


FDS>> там, где телепатия не нужна: он сообразил,

VD>В этом случае сообразил. В другом лажанет. Чем меньше аннотаций, тем больше будет лажать.

Согласен. Но здесь Nemerle сам принудил меня сделать аннотацию, так что меньше аннотаций здесь не станет.

FDS>>на какую ветку указывать ошибку, если задавать аннотацию, которую не задать в Nemerle невозможно в данном конкретном реальном коде.

VD>Прямо таки невозможно? Код (компилируемый) в студию!

Пожалуйста, вот тебе компилируемый код: убери аннотацию с любого метода

using Nemerle.Collections;
using Nemerle.Text;
using Nemerle.Utility;
using Nemerle.Compiler;
using Nemerle.Compiler.Parsetree;
using Nemerle.Compiler.Typedtree;

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

using System.IO;
using System.Text;

using Nemerle.Imperative;

namespace TabFile
{
    macro forToMacro(v, index1, index2, body)
    syntax ("for", v, "from", index1, "to", index2, "do", body)
    {
        Console.WriteLine(v.GetType().ToString());
        def id = (v:> PExpr.Ref).name.Id;
        <[ 
            mutable $(id: dyn): int = $index1;
            def     e = $index2;
            for (; $(id: dyn) <= e; $(id: dyn)++)
            {
                $body
            }
        ]>
    }

    macro for0Macro(v, index2, body)
    syntax ("for0", v, "to", index2, "do", body)
    {
        Console.WriteLine(v.GetType().ToString());
        def id = (v:> PExpr.Ref).name.Id;
        <[ 
            mutable $(id: dyn): int = 0;
            def     e = $index2;
            for (; $(id: dyn) <= e; $(id: dyn)++)
            {
                $body
            }
        ]>
    }

    macro forDowntoMacro(v, index1, index2, body)
    syntax ("for", v, "from", index1, "downto", index2, "do", body)
    {
        Console.WriteLine(v.GetType().ToString());
        def id = (v:> PExpr.Ref).name.Id;
        <[ 
            mutable $(id: dyn): int = $index1;
            def     e = $index2;
            for (; $(id: dyn) >= e; $(id: dyn)--)
            {
                $body
            }
        ]>
    }

    public class TabFileReader
    {
        public class TabTreeElement
        {
            public Name:    string;
            public parent:  TabTreeElement;

            public childs: List[TabTreeElement];

            public this(Name: string, parent: TabTreeElement)
            {
                this.Name   = Name;
                this.parent = parent;

                childs = List(4);
            }

            public write(): string
            {
                def sb = StringBuilder();
                write("", sb);
                sb.ToString();
            }


            public write(tab: string, sb: StringBuilder): void
            {
                def newTab = 
                    if (parent != null)
                    {
                        _ = sb.AppendLine(tab + Name);
                        tab + "\t"
                    }
                    else tab;

                foreach (child in childs)
                    child.write(newTab, sb);
            }
        }

        public tabFileName: string;
        public this(tabFileName: string)
        {
            def fi = FileInfo(tabFileName);
            unless (fi.Exists)
                throw FileNotFoundException($"Файл '$tabFileName' не найден.\r\n[полный путь '$(fi.FullName)']\r\nОбъект TabFileReader принимает имя только существующего файла.");

            this.tabFileName = fi.FullName;
        }

        public parse(): TabTreeElement
        {
            def root = TabTreeElement("", null);
            _ = parse(File.ReadAllLines(tabFileName), 0, "", root);
            root;
        }

        public parse(lines: array[string], curLine: int, curTab: string, curTreeTabParent: TabTreeElement): bool * int
        {
            when (lines.Length <= curLine)
                return (false, curLine);

            def line = lines[curLine];
            def subtreeContinue(): bool
            {
                line.StartsWith(curTab)
            }

            def getCurName()
            {
                line.Substring(curTab.Length)
            }

            def emptyLine()
            {
                line.Length <= curTab.Length && line.Trim().Length == 0;
            }

            when (emptyLine())
                return parse(lines, curLine + 1, curTab, curTreeTabParent);

            when (!subtreeContinue())
                return (false, curLine);

            def current = TabTreeElement(getCurName(), curTreeTabParent);
            curTreeTabParent.childs.Add(current);

            def childParse = parse(lines, curLine + 1, curTab + "\t", current);
            if (childParse[0])
                throw Exception("Фатальная ошибка алгоритма TabFileReader.parse: распарсены все потомки, но childParse - истинный")
            else
                parse(lines, childParse[1], curTab, curTreeTabParent);
        }
    }
}

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

VD>>>>>>Вот что будет в F#, если убрать аннотацию типов?
А>>>>>Чуда, конечно, не произойдет, о чем я уже писал.

FDS>>>Влад, а ты знаешь, что в том коде, что я дал как баг, аннотацию убрать невозможно? Чуда не произойдёт, в том месте Nemerle требует аннотацию.

VD>>Это, вообще-то, цитата другого человека.

FDS>Влад, где цитата другого человека? Вот эта:
VD>>>>>>Вот что будет в F#, если убрать аннотацию типов?

Выделено жирным.

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

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

VD>>>>>>>Вот что будет в F#, если убрать аннотацию типов?
VD>А>>>>>Чуда, конечно, не произойдет, о чем я уже писал.

FDS>>>>Влад, а ты знаешь, что в том коде, что я дал как баг, аннотацию убрать невозможно? Чуда не произойдёт, в том месте Nemerle требует аннотацию.

VD>>>Это, вообще-то, цитата другого человека.

FDS>>Влад, где цитата другого человека? Вот эта:
VD>>>>>>>Вот что будет в F#, если убрать аннотацию типов?

VD>Выделено жирным.

Подчеркнул

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

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

VD>>>>>>>Вот что будет в F#, если убрать аннотацию типов?
VD>А>>>>>Чуда, конечно, не произойдет, о чем я уже писал.

FDS>>>>Влад, а ты знаешь, что в том коде, что я дал как баг, аннотацию убрать невозможно? Чуда не произойдёт, в том месте Nemerle требует аннотацию.

VD>>>Это, вообще-то, цитата другого человека.

FDS>>Влад, где цитата другого человека? Вот эта:
VD>>>>>>>Вот что будет в F#, если убрать аннотацию типов?

VD>Выделено жирным.

Извините, может быть я не точно выразился.
Метод не требует аннотации. В этом можно убедиться в случае когда он не содержит ошибки.
> let f () = (1,2,3);;

val f : unit -> int * int * int

> let f2 () = (3,4,5);;

val f2 : unit -> int * int * int

> let g cond = if (cond) then f() else f2();;

val g : bool -> int * int * int

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