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

              http://govnokod.ru/16233
              Ответить
              • Это уже уровень самогона или даже первача. А он пива хотел попить.
                Ответить
            • Так в новой джаве 1.8+ много всякого сахара насыпали. Ну а если и этого мало - всегда есть Scala
              Ответить
          • Тип того. Сказали что это нинужно. А сами массивы из одного элемента абузят чтобы вот такие классы не писать.
            Ответить
            • А зачем это реально нужно кроме сомнительных конструкций? В с# знаю что есть всякие методы вроде Try... которые возвращают флаг успешности и принимают out параметры но мне всегда казалось это какой-то хуйней которая пришла из с
              Ответить
              • показать все, что скрытоvanished
                Ответить
              • 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.
                        Ответить
                      • показать все, что скрытоvanished
                        Ответить
                        • Да, очень удобная вещь.

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

                          UPD:

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

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

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

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

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

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

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

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

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

        что?

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

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

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

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