Jawa / Говнокод #11346 Ссылка на оригинал

0

  1. 1
  2. 2
  3. 3
  4. 4
status.setCounter(new Number(
 Number.nullToZero(
status.getCounter()).add(
value.movePointRight(2))));

Действительно, кому нужна перегрузка операторов?

Запостил: Zozopy Zozopy, (Updated )

Комментарии (106) RSS

  • На ту же тему из исходников клиента одной игрушки:
    sz = max.add(wbox.bsz().add(mrgn.mul(2)).add(tlo).add(rbo)).add(-1, -1);
    Ответить
          • Первый раз я с вами согласен.

            Если не абузить операторы, и использовать их только в очевидных случаях - арифметика, строки, операции над контейнерами, и возможно что-то еще, то особых проблем не вижу.
            Ответить
              • Java -- это язык, который пошёл по пути уменьшения вариабельности с целью упрощения поддержки. Это не особенно ускоряет разработку, а может даже и наоборот, потому как снижается гибкость. Но в сравнении, скажем, c C++ Java позволяет снизить влияние "деталей" на разработку, что сильно подбрасывает скорость конструирования. Возможно, что с точки зрения именно поддержки, Java -- очень удачный.
                Ответить
              • да и jvm не сильно удачный. чего только стоят генерики и невозможность создать свой примитив

                а джава по сравнению со скалой вообще УГ
                Ответить
                • > jvm не сильно удачный
                  В основном радует встроенная многопоточность и HotSpot. А так тоже фэйлов хватает.
                  Ответить
                • Generic -- это механизм периода компиляции и не требует управления во время исполнения.
                  И что это за "свой примитив"?
                  Ответить
                    • Да.
                      Дженерики -- это просто-напросто такая фича, которая позволяет не расставлять кастовки типов у классов, реализующих общий интерфейс доступа вне зависимости от данного.
                      Компилятор расставляет кастовки типа за программиста и следит, чтобы правильное в правильное превращалось. В runtime есть только минимальная память о дженериках. Хорошему программисту она не требуется.

                      По-сути, это механизм именно периода компиляции.
                      Ответить
                      • Ну это в Яве так, позаимствовано из С++ шаблонов. Но это уродски, и вообще искажение изначальной идеи. Просто их очевидно задолбали пожеланиями и улучшениями - вот они к пятой версии и сделали, по принципу лишь бы отвязались. Вообще смысл ни разу не сводится ни к шаблонам, ни к работе компилятора. По большому счету, это механизм для ограничения типа над коротым работает функция. На какой стадии это происходит - зависит от языка. Даже жалкое подобие родовых переменных в AS3 тем не менее распространяется на рантайм, и, например, зафигачить изподтишка new Foo() в вектор типа Vector.<Bar> не получится (а в Яве через всякие выкртутасы с рефлекшн такое проходит на ура).
                        Ответить
                        • > в Яве через всякие выкртутасы с рефлекшн
                          Не нужно выкрутасов:
                          Сollection<Bar> bars = new ArrayList<Bar>();
                          bars.add(new Bar());
                          Collection raw = bars; // compiler warning here
                          raw.add(new Foo());
                          > по принципу лишь бы отвязались
                          Нет, чтобы обеспечить максимально возможную совместимость со старым кодом.
                          Ответить
                          • Ну тут еще постараются предупредить. Самые веселые пляски начинаются при необходимости глубокого копирования объектов с родовыми парамтетрами. Их даже через рефлекшн не особо получишь, их приходится вообще из строки парсить, что чревато всякими ошибками связаными с класс-лоадером и вообще... не дай бог кто-то использовал интерфейс в качестве родового параметра - глубокое копирование в таком случае накрывается медным тазом 🙂
                            Ответить
                            • Реализации Generics не должны выполнять каких-либо действий, которые зависели бы от типа параметра в определении. Копирование -- запрос к классу Generics, оно должно быть выполнено так, чтобы не заботиться о типах хранящихся внутри элементов.
                              А на этапе компиляции будет проверена статическая совместимость параметров.

                              В 90% случаев крики о Generics от непонимания того, для чего вообще это нужно. Хорошие программисты всегда читают документацию, прежде, чем работать с чужим кодом.
                              Кроме того, вы говорите о языке Java. Здесь главный принцип "это вам не нужно". Если вы начинаете писать такой код, что вам не хватает гибкости -- не пишите его. Сделайте по-другому.
                              Или пишите на другом языке, более гибком.
                              Ответить
                              • Я просто заплакал и, просветленный, побрел с пескарями домой.

                                Да что вы такое говорите. Не должны? Кому? Почему? От куда такая уверенность? При чем тут чужой код? Хорошие программисты читают документацию? - Ну наверное, а Волга тоже иногда впадает в Каспийское море... В Яве генерики сделаны плохо, а от того, что этот факт хорошо задокументирован лучше как-то не становиться.

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

                                Спасибо, что порекомендовали мне другой лучший язык. Я бы сам не догадался, и продолжал бы мучаться, так и не подозревая о том, что есть и другие языки!
                                Ответить
                                • Как бы попроще выразиться...
                                  На приземлённом примере.

                                  Покупаете вы mp3 плеер, который предназначен для прослушивания файлов со звуковым содержимым, а вы забиваете им гвозди. Он рассыпается.
                                  Вы приходите в мастерскую и жалуетесь: "У вас mp3 плеер плохо сделан! Я не могу забить им гвозди!"

                                  Каждый инструмент имеет определённое назначение, которое описано в документации к инструменту. Generics в Java имеют определённое назначение. Если вам нужно что-то другое, то и использовать нужно что-то другое. Это не значит, что mp3 плеер плохо сделан, он просто не предназначен для забивания гвоздей. Если часто возникает какая-то задача, а вас инструмент не удовлетворяет -- вы выбрали не тот инструмент.

                                  Когда заявлено одно, а получается другое, своего рода "обман", это плохо -- "что-то плохо сделано", "не продумано" и т.д.
                                  А то, что какая-то библиотека не оправдывает ваших личных ожиданий -- не делает её плохой. Неудобной для вас -- да. Но не плохой. То, для чего она означена, она делает прекрасно.
                                  Если этот инструмент, делающий зависимое копирование, действительно нужен -- пишите в Oracle, может быть они услышат. Ведь и Generics появились в ответ на зов разработчиков, так как с абстрактными контейнерами можно было легко наделать ошибок.

                                  И не надо ныть: "ой, плохо сделано", "ой, там всё неправильно". Там -- всё правильно! Разруха в головах.
                                  Ответить
                                • Дженерики в джаве - это приемлимый компромис, принятый компетентными инженерами с учётом различных факторов. Кстати, их автор - Мартин Одерски, автор Scala, человек, очень компетентный в теории типизации. Он выжал из жабы всё, что можно, уж поверьте.

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

                                  То, что они не решают каких-то других, ваших проблем - это ваша проблема. С такими дженериками гораздо лучше, чем без них.
                                  Ответить
                                  • Так сделали-то не генерики, сделали те же самые С++ шаблоны, а назвали гордо, потому что см. выше про пожелания-улучшения. То, что в Яве называют генериками только очень отдаленно вообще напоминает то, что в принципе генериками является.

                                    А компетентные / не компетентные, вон MXML придумал Eli Greenfield - человек с несколькими учеными степенями, главный инжинер Адоби по всему, что касается Флеша - и такое редкостное говно придумал, что любой студент-первокурсник лучше бы сделал. Ученая степень не гарантирует, что получится не-говно.

                                    У меня нет проблем с Явой, т.как слава богу использовать ее почти не приходится. Проблема есть с идиотами, для которых Ява - это образец того, как нужно программировать и эталон терминологии в программировании, в то время как в ней в большинстве случаев все шиворот-навыворот.
                                    Ответить
                                    • >сделали те же самые С++ шаблоны
                                      Ну вот вы же сами смешиваете огурцы с помидорами, а потом возмущаетесь, что кто-то там тоже смешивает понятия.

                                      Может быть термин неудачный, не знаю. Но тогда так говорите: "Generics -- очень неудачное название для параметризованных типов в Java".
                                      Ответить
                                      • И чем не шаблоны? Ну только что в С++ препроцессор гораздо более продвинутый и настраиваемый, а в Яве все просто заменяется на Object и привет. Но смысл в том, что в рантайме ни там ни там информации о типе не останется, если специально не хранить. Т.е, мы предположительно написали функцию специализирующуюся на родовых параметрах X, Y, Z - а получили по-настоящему, функцию специализрующуюся на Object, Object, Object. Да, где-то это помогло компилятору проследить за ошибками, но все ошибки он не сможет найти, т.как работа с рефлекшн для компилятора - загадка, а ошибки такого плана будут именно в этом месте, и их будет очень тяжело определять.
                                        Ответить
                                        • Ммм..
                                          Если вы действительно не понимаете разницу между C++ шаблонами и Java Generics, то в нескольких словах: "C++ шаблоны это мета-язык генерации новых типов", а Java Generics -- это механизм привидения параметризованных типов к абстрактным.
                                          То есть, это вообще в разные стороны вектора направлены.
                                          C++ Templates -- генерирует новые типы
                                          Java Generics -- уничтожает типы
                                          Ответить
                                          • То, что вы называете параметризированными типами на самом деле таковыми не является, это условность, с которой вы соглашаетесь, но она не поддерживается на уровне языка.

                                            Точно так же, например, в FlashDevelop (редактор AS) можно ставить аннотации после объявления массивов, типа:
                                            var array = new Array()/*String*/;

                                            и редактор вам выдаст предупреждение если вы напишете array.push(100); но это исключительно фича редактора, а не языка / рантайма. Языком / рантаймом это не поддерживается. Точно таким же образом в Яве не поддерживаются родовые параметры функции или класса. Родовых переменных не существует в принципе (даже на уровне шаблонов). На какие-то выражения родовые параметры распространяются, а на какие-то нет (catch не может ловить ошибки не объедененные в один конкретный тип потому что catch (Object e) естественно не проходит.)

                                            Это и есть убогая реализация, которая работает меньше чем на половину, которую, из практических соображений, лучше вообще избегать, т.как чревато всякими недоумениями, именно изза непоследовательности в реализации.
                                            Ответить
                                            • Вас же никто не заставляет использовать Generics. Используйте List<Object> явно, List<?> или List (вообще уйдите от параметров).
                                              Generics выполняют определённую задачу, эту задачу они выполняют хорошо. Какие могут быть претензии к Generics?

                                              У вас какая-то очень эгоистичная философия, самоцентричная. Раз мне не подходит, значит это плохо, значит это вообще не то, это плохо, этого не должно быть.

                                              В очередной раз.
                                              Вы говорите, что вам нужна информация о параметре Generic типа во время работы системы. Но параметризованные классы в Java созданы для таких задач, когда информация нужна чуть чаще, чем никогда. Значит вы выбрали не тот инструмент для вашей задачи.
                                              Generics не стали хуже.

                                              Мне с ними очень удобно. Я могу использовать контейнеры и не ставить кастовки руками. Если даже ошибусь -- компилятор предупредит. Мне этого достаточно для моих задач.
                                              И я думаю, что многим этого хватает. А если вы работаете в такой специфической области, то может быть для ваших задач и язык есть не универсальный, а специфический?
                                              Чего вы людям головы морочите?

                                              Это уже какой-то флейм на Java идёт.
                                              Ответить
                                              • Объясню очень просто почему:

                                                Яву преподают в учебных заведениях связанных с программированием, но типично забывают объяснить, что система типов в Яве очень упрощенная и не соответсвующая обычному представлению о том, что такое типы. К чему это приводит: растет количество программистов с искаженным мировосприятием, которые верят в то, что в Яве есть родовые параметры, (а с ними - параметризированые классы и функции), в то время, как их по-сути нет, а то, что предлагается вместо них - профанация и искажение идеи. Мало того, что они в это верят, они еще и пытаются навязать свою точку зрения другим. Достаточно почитать пожелания-улучшения других языков типа того же Яваскрипта - так от туда просто за версту несет.

                                                Я не говорю как вам писать код и какие задачи решать, а говорю следующее: называйте вещи своими именами, нет в Яве родовых переменных / параметров и никогда не было. Есть шаблоны / аннотации, которые помогают предотвратить некоторые ошибки возникающие там, где в принципе хорошо было бы использовать родовые параметры / переменные. Удобно их использовать? - за неимением лучшего - вполне возможно. Помогает? - ну, раз ничего другого нет, то наверное же! Но это ж не значит, что именно так нужно делать.
                                                Ответить
                                                • Идеальных языков не бывает. У языков, генерирующих код для шаблонов, другие заморочки. Какую бы модель не выбрал дизайнер языка, где-нибудь будут видны грабли, идеальных языков не бывает, особенно, когда в дело вступает обратная совметсимость.
                                                  Java - далеко не идеал, но в каждом практичном языке были и будут свои проблемы. Где-то на них будут натыкаться чаще, где-то реже (и в этих случаях, скорее всего, проблемы будут глубже и непонятней).
                                                  Ответить
                                              • > Это уже какой-то флейм на Java идёт.
                                                @wvxvw - особая разновидность тролля. Он ругает хаскеллы и эрланги, противопоставляя их "кошерным" java и JS, а в соседних тредах хаит JS и Java, как языки, лучше которых, видите ли, придумали бы даже школьники.
                                                Ответить
                                                  • Common Lisp                     # Parthenon
                                                    Scheme HaXe Go C Python         # Die unendliche Geschichte
                                                    Erlang JavaScript eLisp bash C# # The Old Man And The Sea
                                                    Java PHP AS                     # Das Letze (Regenbogen) Einhorn 
                                                    Haskell                         # Opus Anglicanum

                                                    Разъяснения и дополнения к пирамиде языков глазами wvxvw

                                                    Но есть много языков, про которые я мало что знаю. Типа того же Паскаля или Перла.
                                                    Ответить
                                                • >противопоставляя их "кошерным" java и JS
                                                  Сцылку, пожалуйста. А вообще лучше просто было его процитировать.
                                                  Ответить
                                                • И вообще хоть я не был согласен с ним ни там, ни здесь - не вижу ничего плохого в том, что он хаит языки.

                                                  >Пирамида языков глазами wvxvw:
                                                  Ты забыл про ЭкщонСкрипт.
                                                  Ответить
                                        • > ни там ни там информации о типе не останется
                                          это как теплое с мягким сравнивать
                                          Ответить
                            • >>Так сделали-то не генерики, сделали те же самые С++ шаблоны
                              То что оно выглядит внешне как шаблоны С++ еще не означает что внутри оно тоже шаблоны С++. И ведь шаблоны С++ далеко не идеал. Именно из-за своей усложненности.

                              >> и вообще искажение изначальной идеи
                              Да. Это немного другая вещь. И потому название другое.

                              >>в Яве так, позаимствовано из С++ шаблонов
                              Да, отчасти. Ну и что? А С++ позаимствовал их из Ады - там такое издавна есть. Верно, Тарас?

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

                              >>вы говорите о языке Java. Здесь главный принцип "это вам не нужно"
                              Лол, надо запомнить.
                              Ответить
                              • И абсолютно случайно String / Integer уже оказались загружеными класс-лоадером. А теперь такой же фокус, но с классами, которые еще не загрузились / возможно не загрузятся никогда?
                                Ответить
                                • JVM гарантирует загрузку классов до их первого использования. Приведите пример, когда код будет работать неправильно (если требуемых классов нет в classpath, то java тут не при чём, это ваш косяк).

                                  Есть особые случаи, например, Полиморфная Рекурсия
                                  http://tinyurl.com/75x59me
                                  , и я даже могу представить себе примеры её использования (гетерогенные списки, которые нужны чуть реже чем никогда). Но в реальной жизни такое встретить довольно сложно.

                                  А если вам нужны глубокие копии - реализуйте Clonable и делайте clone() ручками, но, опять же, в реальной жизни это нужно довольно редко.
                                  Ответить
                                  • С чего бы это Ява гарантировала загрузку параметров типа?
                                    Пример использования: есть два jar'a в одном библиотечные классы, в другом какой-то код конкретного инстанса сервера. Обычно они компилируются вместе, но тут кто-то решил пропатчить библиотечный jar и залил его на сервер не интересуясь другими jar'ами, которые использовали его как ClassFromConcreteServer<LibraryClass>. Врезультате чего следующая загрузка конкретного инстанса проходит "успешно" - т.как Ява не будет искать родовой парамтер пока мы его конкретно не попросим, а т.как инстансы ClassFromConcreteServer<LibraryClass> на самом деле создаются как ClassFromConcreteServer<Object>, то мы об этой проблеме узнаем не скоро, а, как повезет, может через час, а может через пару дней, когда вдруг окажется что ClassFromConcreteServer<LibraryClass> нужно сериализовать для передачи куда-нибудь, а сериализовать не из чего.
                                    Ответить
                                    • > кто-то решил пропатчить библиотечный jar и залил его на сервер не интересуясь другими jar'ами
                                      >> если требуемых классов нет в classpath, то java тут не при чём, это ваш косяк

                                      Если у вас неконсистентный classpath, последствия будут удручающими и всё может грохнуться в самый неожиданный момент. И дженерики тут не при чём, всё прекрасно грохнется и без них.

                                      > ClassFromConcreteServer<LibraryClass>
                                      Этот класс, очевидно, должен в себе содержать инстансы этого типа. Где есть инстансы, там есть классы, которые, очевидно, должны быть загружены.
                                      Ответить
                                      • Кому обязан? Никому ничем не обязан. Почему рассказываю - потому, что сталкивался с таким. Протоколы которые сохраняют тип данных при передаче, типа того же АМФ / Протобаф обламываются на таком поведении. Т.е. приходят данные которые нужно прочитать в определенный формат, который в принципе должен был бы быть, а его нету.
                                        Ответить
                                        • Дык это ремоутинг, тут косяков наделать - раз плюнуть. Дженерики тут вообще не при чём, ибо, повторуюсь, задача дженериков была в выявлении ошибок типов на этапе компиляции, а не предоставлении каких-либо гарантий в рантайме. Инстанциированные типы сохраняются в .class файлах в основном для того, чтобы компилятор мог нормально работать без полного исходного кода всех библиотек.

                                          Если дженерики не решают ваших проблем, это не значит, что они - говно. Это означает лишь то, что вы их неправильно используете.

                                          Продолжать дискуссию не вижу смысла.
                                          Ответить
                                          • В Яве нет генериков, есть шаблоны которые пытаются решать проблемы генериков.
                                            Я смысла не видел с самого начала, но проект иногда долго собирается.
                                            Ответить
                                            • Java Language Specification называет это дело Generic Classes, это устоявшаяся терминология, связанная с type erasure. Шалбоны - templates - это средство кодогенерации, это повторялось в треде много раз. Если у вас своя терминология - это опять же ваши проблемы.
                                              Ответить
                                            • >В Яве нет генериков, есть шаблоны которые пытаются решать проблемы генериков.

                                              И сразу фейл.

                                              Вот "В танке нет гусениц, есть колеса которые пытаются решать проблемы гусениц" - схожее утверждение.
                                              Ответить

                        • ява фигня мне не понравилось !!!!!!!!!!! остоётся токо ждать лутшего.Это для меня говно плохо зделана тупо.Немогли зделать всё как в крустах!!! И шаблоны и управление памятью.Не рекоминдую такую яву!!!
                          Ответить
          • В javaScripte нету, в C нету и в обджективе тоже.
            Про пхп и пасцаль хотелось бы умолчать.
            Ответить
            • мы тут уже выясняли, что JS мало кто любит 🙂
              Да, сишка - исключение. Это язык, в котором всё должно быть просто и влоб by design.
              Ответить
                • Haskell: +, -, etc. работают с инстансами класса Number, можно определять инстансы собственных типов со своей арифметикой. Это не перегрузка в классическом её понимании, а реализация протокола, но эффект в принципе тот же.

                  Scala: +, -, * - это обычные методы, 1 + 2 == 1.+(2). Для "перегрузки" достаточно просто определений вроде def +(x: Int): Int = ....

                  В Lisp всё немного сложнее: похоже, придётся определить свой дженериковый +, скрывающий + из стандартного пакета/нэймспейса. Но в целом операторы там также ничем не отличаются от обычных функций.
                  Ответить
                  • >Scala: +, -, * - это обычные методы
                    >Но в целом операторы там также ничем не отличаются от обычных функций.
                    Ключевая фраза. То есть на самом деле очередная killer-фича (перегрузка операторов) языку не нужна.
                    А нужно приведение всего к общему знаменателю, унификация и упрощение.
                    Ответить
                  • >нужно приведение всего к общему знаменателю, унификация и упрощение...
                    ...и поэтому мне нравится JS. Именно его канонiчная редакция ECMAScript 1.6.
                    Ну а почти все фичи что дальше то ересь, ну может за исключением yieldов, генераторов-итераторов и пары других приятных моментов (хотя тоже спорно).
                    >мы тут уже выясняли, что JS мало кто любит 🙂
                    Это где вы посмели?!
                    Ответить
                      • Спасибо.
                        Вот почитал тот тред и понял:
                        в javaScripte нету перегрузки операторов, но есть очень похожая по духу вещь - прототипы.
                        Ответить
                        • Мне сложно найти связь между прототипами и перегрузкой операторов, они скорее ближе к наследованию. Надо найти метод/свойство - ищем по всей цепочке прототипов. Причём можно сеттить и изменять прототипы (причём изменение будет затрагивать всех "наследников").
                          Это выносит мозг чуть более чем всем новичкам в JS.
                          Ответить
                          • Перегрузка операторов это в каком-то смысле (если шире смотреть на вещи) тоже наследование.

                            Прототипы и перегрузку объединяет одно - они легко превращают код в пиздец.
                            Ответить
                    • а мне JS мне как раз нравится за его лаконичную запись объектов (то, что сейчас модно называть JSON)
                      Ответить
                      • >нравится за его лаконичную запись объектов
                        Вот. Именно это самая вкусная его часть
                        Заплюсовываю тебя в ответ.
                        Ответить
                        • btw, те, кто ругает JS, просто пытаются натянуть модель ООП на объектный язык.

                          на самом деле что может быть красивее:
                          var obj = {
                            fld : "",
                            mthd: function(p1,p2) {}
                          }
                          
                          obj.mthd(obj.fld);
                          Ответить
                          • >просто пытаются натянуть модель ООП на объектный язык
                            Они мудаки. Для меня это структурный и функциональный язык.

                            Где там вообще инкапсуляция, зачем гетеры, сеттеры? Непонятно.

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

                            А полиморфизм - это просто наличие метода с нужным именем.
                            Ответить
                            • > наследование через расширение одной структуры другой (с заменой)
                              можно пояснить мысль примером на JS?
                              Ответить
                                • понятно, но это не в "голом" JS.
                                  тут в основе либо прототипирование, либо делегирование.

                                  а вообще подход jQuery в смысле обертывания стандартных объектов и уже последующей манипуляции с оберткой мне как-то настолько понравилась, что я сделал нечто такое на php
                                  Ответить
                                  • >понятно, но это не в "голом" JS.
                                    Ну в любом случае без либ - никуда.
                                    >>подход jQuery в смысле обертывания стандартных объектов и уже последующей манипуляции с оберткой

                                    Роман меня поправит, если я неправ, но это дело попахивает монадами (безотносительно чистых вычислений).
                                    Ответить
                                      • jquery deferred - это монады в чистом виде.
                                        просто тут кто-то заявлял типа монады - нахуй они нужны, в js никто не пишет.
                                        но как цепочка связанных вычислений, монады - вполне юзабельный паттерн.
                                        Ответить
                                    • Так и есть: это монада (обёртка есть функтор, для которого определены операции заворачивания в обёртку и flatten), подозрительно похожая на список: все красивые fluent-api методы по сути преобразуются в операции над вложенными элементами.
                                      Ответить
                  • Переопределить + не каждый Лисп позволит. По стандарту не обязаны, некоторые сделают с предупреждением, некоторые пошлют. Можно со всякими извращениями типа ридер макросов и созданием зависимых от пакета таблиц синтаксиса, но смысла в этом не много... + - это функция в cl-user пакете, и чтобы ее переопределить нужно будет ее unintern (а как тогда привавлять?) и вместо нее объявить генерик и пару методов... Может как-то потом можно хитро через алиас притащить плюс обратно из cl-user, но это настолько заморочливо, что никто это делать не будет. Разве что из вредительских соображений.

                    Хз, может в Схеме по-другому.
                    Ответить
          • а мне нравятся языки, такие как Ruby, где операторы являются методами
            Ответить
            • А в хаскеле, зато, любую бинарную функцию можно превратить в оператор 😉
              elem x y
              x `elem` y
              Ответить
                • Скорее средство для улучшения читабельности
                  if point1 `laysInTheSamePlaneQuarterAs` point2
                  then combine point1 point2
                  Ответить
                  • Вот оно как.
                    Так тогда можно статик-методы комбинировать с методами классов
                    (и даже extension methods в C# и implicit в скале)
                    if point1.laysInTheSamePlainQuarterAs(point2)
                     Point.combine(point1, point2)
                    Ответить
                    • Прелесть в том, что в хацкеле laysInTheSamePlainQuarterAs - обычная функция, которую можно подставлять везде, где нужна функция (мапить или делать фильтрацию с частичным применением):
                      filter (laysInTheSamePlaneQuarterAs somePoint) points
                      Также можно использовать в таком виде любые функции от двух аргументов, даже если их автор не подразумевал такого использования. Не киллер-фича, конечно, но всё же уменьшает количество сущностей, необходимых языку.
                      Ответить
                      • Ну на то оно и функциональное 🙂

                        Кстати я только теперь начинаю сознательно улавливать мистическую связь между:
                        - перегрузкой операторов
                        - Prototype в js
                        - extension methods в C# и implicit в скале

                        и понимать почему это всё мне не нравится.
                        Ответить
                        • > мистическую связь между:

                          Все суть винегрет модели (абстрактная часть) и реализации (конкретная)?
                          Ответить
                • Некорректно же: + такой же привычный. `elem` немного хуже чем in в:
                  needle in haystack
                  но последний - элемент синтаксиса, а elem - ф-ия. Символы вроде !#$% окавычивать не надо.
                  К тому же `identifier` редактор может подсветить как оператор - будет читабельнее.
                  Ответить
            • В таких языках жопа начинается тогда, когда дело доходит до приоритета операторов.
              Ответить
              • как всегда, половина решается встроенными в язык средствами, другая - скобками
                Ответить
      • А надо было юзать варарги конечно
        max.add(
            wbox.bsz().add(
                  mrgn.mul(2)
                 ,tlo
                ,rbo
            )
           ,[-1, -1]
        );

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

          > Ну и код нормально форматировать.
          Ну в том коде еще не помешало бы нормально называть переменные. Ибо, зачастую, хрен поймешь, что означает какой-нибудь ols или nrg.
          Ответить
            • > Чего так?
              Нет уверенности, что компилятор и jit превратят код с ними во что-то шустрое и доброе.
              Ответить
              • А что оно чем оно хуже массива параметров? Или массивы тоже плохо?
                Не пойму.
                Ответить
                • Думаю, @bormand имеет ввиду, что перегруженные операторы умный компилятор сможет заинлайнить (в отличие от массива параметров). Далеко не во всех языках реализация "перегрузки" позволит компилятору провернуть такое.
                  Ответить
                  • Я вообще думал что мы говорим о жабе, которая к тому же не умеет инлайнить.
                    Ответить
                    • Хм. jit тоже не умеет инлайнить, хотя бы немного? Тогда совсем печально. И что массив, что временные объекты будут одинаково дрючить GC ;(
                      Ответить
                      • JIT Умеет.
                        >умный компилятор сможет заинлайнить
                        А вот javac не умеет. Речь была об этом

                        >А вот с массивами у меня такой уверенности уже нет
                        Спасибо, я понял. Учту в будущем.
                        Но любителям немутабельных хацкилов грех на такое жаловаться.
                        Ответить
                • > А что оно чем оно хуже массива параметров?
                  Да собственно что там массив что там массив. Так что ничем.

                  Но в оригинальном коде то функции с двумя аргументами. Причем довольно простые. И, имхо, есть вероятность того, что они заинлайнятся, из их кишков будут выкинуты все new, и они просто превратятся в несколько арифметических операций. А вот с массивами у меня такой уверенности уже нет.
                  Ответить
  • В некоторых случаях counter не инициализирован
    Ответить
    • null там имеет какой-то определенный смысл (например, чтобы показать, что счетчик остановлен) или это просто баг?
      Ответить
      • определенный смысл - с аппаратной стороны такого счетчика не было
        Ответить

Добавить комментарий

Я, guest, находясь в здравом уме и твердой памяти, торжественно заявляю:

    А не использовать ли нам bbcode?


    8