1. Java / Говнокод #26086

    −1

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    // https://cdn.staticaly.com/gh/landawn/abacus-util/master/docs/MutableBoolean_view.html
    // https://github.com/landawn/abacus-util/blob/76cb7c712d4ce2d167f9170f8d92fd9857db8f99/src/main/java/com/landawn/abacus/util/MutableBoolean.java
    
    public final class MutableBoolean implements Mutable, Serializable, Comparable<MutableBoolean> {
        /**
         * Constructs a new MutableBoolean with the default value of false.
         */
        MutableBoolean() {
            super();
        }
    
        /**
         * Constructs a new MutableBoolean with the specified value.
         * 
         * @param value the initial value to store
         */
        MutableBoolean(final boolean value) {
            super();
            this.value = value;
        }
    
        /**
         *
         * @param value
         * @return
         */
        public static MutableBoolean of(final boolean value) {
            return new MutableBoolean(value);
        }
    
        /**
         *
         * @return true, if successful
         */
        public boolean value() {
            return value;
        }
    
        /**
         * Sets the value.
         * 
         * @param value the value to set
         */
        public void setValue(final boolean value) {
            this.value = value;
        }
    }

    Тут человек изменяемый булеан сделал, что думаете? Функциональное программирование уже проиграло ООП?

    Запостил: Fike, 11 Декабря 2019

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

    • А кто-нибудь знает, для чего такое делается? Там в репозитории целое семейство таких оберток над примитивами.
      Ответить
      • Чтобы out параметры у функций делать, видимо.
        Ответить
        • Это потому, что тупорылые жабоебные импотенты не осилили out и reference to reference, как в C# и C++?
          Ответить
          • У меня блядь от жабы ощущение такое, что я пришел к друзьям побухать, а меня посадили за детский стол с соком "добрый" и аниматором в костюме клоуна

            Я хочу пить пиво и пиздеть с друзьями, а мне аниматор говорит: "да тебе со взрослыми будет скучно, давай лучше смешариков смотреть"

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

            С джаве надо выдавать слюнявчик, блядь, и тихий час делать
            Ответить
            • Что такого плохого в Смешариках? У них там упоминаются разные полезные факты из физики и экономики, а у самих героев можно учиться социальному взаимодействию (что полезно для программиста).
              Тут уже от друзей зависит. Если они за чашкой пива обсуждают ООП и первый канал, то лучше Смешариков посмотреть.
              Ответить
              • Мне понравился сериал «Азбука безопасности» со смешариками. Это почти как «Happy Tree Friends», только с хэппиэндом.
                Ответить
            • А как же распидорашивание кэша маленьких целых чисел?

              http://govnokod.ru/16233
              Ответить
              • Это уже уровень самогона или даже первача. А он пива хотел попить.
                Ответить
            • Так в новой джаве 1.8+ много всякого сахара насыпали. Ну а если и этого мало - всегда есть Scala
              Ответить
              • Некоторые вещи не насыпали, потому что в это не может JVM.
                Так что ни Scala, ни Kotlin тут не помогут.
                Хотя разумеется они в миллион раз лучше Джавы
                Ответить
          • Тип того. Сказали что это нинужно. А сами массивы из одного элемента абузят чтобы вот такие классы не писать.
            Ответить
            • А зачем это реально нужно кроме сомнительных конструкций? В с# знаю что есть всякие методы вроде Try... которые возвращают флаг успешности и принимают out параметры но мне всегда казалось это какой-то хуйней которая пришла из с
              Ответить
              • тем, что не нужно писать
                Ref<String> ref = new Ref();
                SwingUtils.invokeAndWait(new Runnable {ref.set(doAll())});
                ref.get();
                Ответить
              • TryGet-паттерн действительно удобен, особенно для парсинга, когда не хочется ловить исключения на каждый чих.
                Ответить
                • У меня есть ровно одна проблема с этим - в некоторых си подобных языках можно объявить переменную прямо в условии ифа, но при этом нельзя выделить память и оставить референс себе в вызове функции. То есть в условном с++ можно написать(я его не знаю, не бейте)
                  if(std::variant<float, std::exception> res = try_parse_float("123"); std::holds_alternative<float>(res)){/*do smth w/ res*/} else{/*handle error*/}

                  то вот так же сделать с ref параметром не объявляя его заранее нельзя ни в каком языке, насколько я знаю
                  Ответить
                  • Не уверен, что правильно вас понял :-)

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

                    В плюсах, насколько я помню, нет строгого деления между ref/out, там есть просто передача по константной/неконстантной ссылке, поэтому вполне разумно требовать наличия ранее объявленной переменной, ибо ссылка, в отличие от указателя, сама по себе не может существовать.
                    Пытаться как-то обойти это ограничение, значит придумывать какой-то специальный сахар для таких параметров, который бы неявно создавал переменную в куче или на стеке и отдавал методу ссылку на неё.
                    Ответить
                    • Мне бы хотелось примерно так:
                      var result = int.TryParse("123", out var a);
                      // a is accessible here
                      if(result){
                        var b = a + 10;
                      }
                      Ответить
                      • Ну, так сейчас можно (с C#7 точнее). Единственное, в out нужно писать точный тип, а не var.
                        Ответить
                        • Ошибся. var тоже можно.
                          Ответить
                          • Как выводится тип var?
                            по типу аргумента функции, глупый вопрос задал, сори
                            Ответить
                        • Ого, действительно
                          Ответить
                          • Тоже проверил:)

                            Видите, как удобно? Джависты даже не подозревают, как их язык убог
                            Ответить
                            • Именно поэтому я за «PHP».
                              Ответить
                              • А я за js
                                const a = (b) => {
                                	b.a = 1
                                }
                                a(c = {})
                                console.log(c) // {a: 1}
                                Ответить
                                • что, и с "use strict" работает?
                                  Ответить
                                  • А разве 'use strict' запрещает изменять поля объектов?
                                    Ответить
                                    • a(c = {})
                                          ^
                                      
                                      ReferenceError: c is not defined
                                      Ответить
                                      • А, ты об этом.

                                        Пффь, подумаешь, проблема
                                        let c = {};
                                        a(c);
                                        Ответить
                                        • Тогда это даже хуже, чем в C#
                                          Там дефикации не нужно

                                          то-есть дефиниции
                                          Ответить
                                          • можно без дефикации просто декларецией обойтись
                                            без деклареции в c# уже нельзя
                                            var c;
                                            a(c={});
                                            Ответить
                                            • Кстати, как в "python" без хаков с потрошением стекофреймов изменять полуглобальные переменные?

                                              def a():
                                                def b():
                                                  x = 1
                                                  def c():
                                                    halfglobal x
                                                    x = 2 # изменили b::x

                                              Или это тупо нереально?
                                              Ответить
                                            • а без дефлорации?
                                              Ответить
                                      • какой "use strict")))
                                        Ответить
                                • Даже без стрелочной функции работает, если просто описа́ть function a(b){b.a = 1}.
                                  Ответить
                      • Для этого есть монада Result в некоторых языках.
                        val result = int.TryParse("123");
                        
                        when (result) {
                         is Success - > print(result.value)
                         is Error -> throw result.exception
                        }
                        Ответить
                        • Да, очень удобная вещь.

                          Для C# есть библиотека Optional (https://github.com/nlkl/Optional), использую её в ряде проектов как замену возврата null, если нет значения.

                          UPD:

                          var option = GetResult(...);
                          
                          var value = option.Match(
                            some: x => x + 1, 
                            none: () => 10
                          );
                          Ответить
                          • Почему этого нет в самом языке?
                            Эх
                            Ответить
                            • Не знаю, очень не хватает, конечно. С другой стороны, даже если добавят, вряд ли кто-то будет потом перелопачивать всю BCL, чтобы заменить методы вроде FirstOrDefault(), чтобы вместо null возвращался Option/Result/Maybe.
                              Ответить
                              • В том-то и дело. Именно потому, паттерн матчинг с монадами лучше сразу иметь в языке
                                Ответить
                                • Его не надо иметь в языке.

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

                                    Либо будет 978 не совместимых друг с другом реализаций.

                                    Наример в котлине можно его сделать , но в библиотеке егонет

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

                                    1) Интеграция таких вещей со стандартной библиотекой настоящая боль. Приходится писать много бойлерплейта не ради реальных фич, а просто ради попытки обеспечить консистентность кода.
                                    2) Интерфейс всех этих реализаций отличается между библиотеками существенно, то есть, если тот же linq является стандартом де факто при разработке, и все его более-менее знают, и код с ним не выглядит загадочно, то тот же Optional обладает весьма специфическим интерфейсом, малопонятным даже для человека, который работал с другой реализацией подобной библиотеки, а уж для человека, не знакомого с такими вещами, это вообще будет brainfuck поначалу.

                                    На мой взгляд, это слишком низкоуровневая и завязанная на дизайне языка вещь, чтобы доверять её реализацию сторонним библиотекам.
                                    Ответить
                                    • А я и не говорю, что его не должно быть в стандартной библиотеке.

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

                                      Тогда, даже если этого нет в стандартной библиотеке, реализации будут возможны и будут проще. Дальше решит "рынок".

                                      Пример: в Свифте Optional это по сути обычный enum с двумя состояниями. Это не спецконструкция языка и это хорошо.

                                      Но при этом нельзя заиметь свой более лучший enum с поддержкой записи типа Int?, потому что это синтаксический сахар для Optional<Int>. И это уже не так круто.
                                      Ответить
        • boolean[] out={false};
          Ответить
    • https://www.pizdata.is/
      Ответить
    • В некоторых случаях это может быть полезно. Стандартные обертки то иммутабельны, и если нужно менять значение, скажем, int, которое лежит в виде объекта(в коллекции, например), то использовать мутабельную обертку гораздо удобнее и производительнее. То ли создать 1кк новых объектов на каждое изменение значения, то ли просто увеличить int поле у одного объекта.

      П.С. в Apache commons есть MutableInt и т д
      Ответить
      • > производительнее
        > То ли создать 1кк новых объектов на каждое изменение значения

        что?

        > гораздо удобнее

        есть AtomicReference, который и так позволяет все это делать, и не заботиться даже о параллельных стримах.
        если у вас там совсем критично с производительностью и боксинг / cas являются большой проблемой, то эта хуйня вам не потребуется, т.к. вы будете сами писать более подходящие вещи.
        Ответить
        • Ну что "что"?

          Если у тебя объект немутабельный, то единственный способ изменить его -- это создать новый объект.
          Просто товарищ не знает, что в джаве True это (слава яхве) -- синглтон
          Ответить
        • Ссылки в жавке же атомарные по определению?
          Ответить
          • Они не умеют атомарно "compareAndSet" в отличие от AtomicReference
            Ответить
        • На зачем atomicReference когда можно просто MutableBoolean/Int и т д? Так же будет даже удобнее изменять значение. С AtomRef будет странная череда де1ствий
          Достать, изменить, установить. А с MutableInt со стороны разработчика - просто increment/add и т д.
          Если приложение однопоточное, то нет причин использовать StringBuffer вместо StringBuilder. Тут я считаю так же - нет смысла использовать Atomic*** вместо Mutable*** из Apache.
          То же самое - HastTable/HashMap, Random/ThreadLocalRandom
          Ответить
    • Именно поэтому я за "PHP"
      Ответить
    • > Тут человек изменяемый булеан сделал, что думаете?

      Думаю что ему делать нехуй.
      new boolean[1]
      java.util.concurrent.atomic.AtomicBoolean
      Ответить
      • Но у AtomicBoolean похоже, но все же другое предназначение. В первую очередь оно спроектировано для многопоточной среды. Для однопоточной есть реализации в apache commons.
        Это как StringBuilder и StringBuffer
        Ответить

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