1. C# / Говнокод #20187

    +4

    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
    public bool IsNormal() {
    	return Type == TypeOfWord.Normal;
    }
    
    public bool IsNumber() {
    	return Type == TypeOfWord.Number;
    }
    
    public bool IsOperator() {
    	return Type == TypeOfWord.Operator;
    }
    		
    public bool IsBracket() {
    	return Type == TypeOfWord.Bracket;
    }
    
    public bool IsSymbol() {
    	return IsOperator() || IsBracket();
    }
    
    public bool IsSpace() {
    	return Type == TypeOfWord.Space;
    }
    
    public bool IsComment() {
    	return Type == TypeOfWord.Comment;
    }
    
    public bool IsExcess() {
    	return IsComment() || IsSpace();
    }
    
    public bool IsQuotedText() {
    	return Type == TypeOfWord.QuotedText;
    }
    
    public bool IsQuotedChar() {
    	return Type == TypeOfWord.QuotedChar;
    }
    
    public bool IsQuotedTextOrChar() {
    	return IsQuotedText() || IsQuotedChar();
    }
    
    public bool IsUnknown() {
    	return Type == TypeOfWord.Unknown;
    }

    Запостил: dm_fomenok, 13 Июня 2016

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

    • не говно
      Ответить
    • Здравствуйте
      Ответить
    • Здравствуйте. Это Фоменок. И это не говно.
      Ответить
    • >>TypeOfWord

      Просто премию Тьюринга этому человеку за лучшее имя переменной
      Ответить
    • > IsNormal()

      ты нормальный вообще?
      Ответить
    • Можно было сократить немного, сделав метод
      public bool Is(TypeOfWord type) {
          return Type == type;
      }
      public bool IsOneOf(params TypeOfWord[] types) {
          foreach (var type in types) {
              if (Type == type) return true;
          }
          return false;
      }
      Что-то вроде этого в лексере clang видел. А так ничего страшного.
      Ответить
      • > params
        params - это вариадик аргументы?
        Ответить
      • Чет ты метод написал. а юзать не стал

        public bool IsOneOf(params TypeOfWord[] types) {
            foreach (var type in types) {
                if (Is(type)) return true;
            }
            return false;
        }
        Ответить
        • А можно линком примерно в таком духе (псевдокод)?
          public bool IsOneOf(params TypeOfWord[] types) {
              return types.Any(type => Is(type));
          }
          Ответить
          • Можно.

            types.Any(x => type.Is(x));
            Ответить
            • Круто. Почти хаскель.
              Ответить
              • ololo-LINQ

                Берём plain old C
                enum{
                Number=1
                ,Operator=2
                ,Bracket=4
                ,Space=8
                } TypeOfWord




                auto isOneOf(types,type) {
                return types &type ;
                }

                isOneOf(Number & Operator, myType)
                Ответить
                • fix:
                  >isOneOf(Number | Operator, myType)
                  ШОК: код стал короче и читабельнее.
                  Ответить
            • А каррирование есть? Или только лямбды?
              Ответить
              • Каррирования нет, но некто не запрещает объявлять функции многих аргументов как в хаскеле

                a => b => a + b
                Ответить
            • types.Any(type.Is);
              Ответить
              • ну и так можно, не как-то нечитабельно
                Ответить
                • Ты неосилятор
                  Ответить
                  • Я за читабельность
                    Ответить
                    • Кстати, тут нет питушни со многими аргументами как в JS?
                      > [10,10,10,10,10,10].map(parseInt)
                      [10, NaN, 2, 3, 4, 5] // в parseInt пошло число, его индекс в массиве и сам массив
                      > [10,10,10,10,10,10].map(x=>parseInt(x))
                      [10, 10, 10, 10, 10, 10]
                      > [10,10,10,10,10,10].map(x=>parseInt(x,5))
                      [5, 5, 5, 5, 5, 5]
                      Ответить
                      • > нет питушни со многими аргументами как в JS?

                        Нет, там нет таких унылых динамикопроблем.
                        Ответить
                      • >> > [10,10,10,10,10,10].map(parseInt) 
                        [10, NaN, 2, 3, 4, 5] // в parseInt пошло число, его индекс в массиве и сам массив


                        Что это за блядство?
                        Ответить
                        • 1. map(f) передаёт в f не только элемент x, но и его индекс и весь массив
                          2. parseInt принимает не только строку, но и основание
                          Числа преобразуются в строку, а потом парсятся с системой счисления, равной индексу в массиве: 0, 1, 2, 3, 4, 5.
                          Ответить
                          • А в четвёртом и пятом параметрах - небо и аллах?
                            Ответить
                            • Я бы сказал, что там их проекции на плоский атеистический мир.
                              Ответить
                          • Это пиздец.
                            Ответить
                            • Тсс... Экмаскриптеры считают, что это удобно и полезно... Не буди их.
                              Ответить
                            • Гном дело говорит. За такое надо пиздить ногами по лицу
                              Ответить
                          • А тут что не так? http://govnokod.ru/20187#comment334754
                            Лишние параметры тупо отбрасываются?
                            Ответить
                            • Да. Лишние отбрасываются, недостающие добавляются... Чем бы скрипт не тешился, лишь бы исключение не кидал...
                              Ответить
                      • [10,10,10,10,10,10].map(x=>parseInt(x))
                        Array [ 10, 10, 10, 10, 10, 10 ]


                        ЧЯДНТ?
                        Ответить
                        • Затупил

                          [10,10,10,10,10,10].map(x=>x)
                          Array [ 10, 10, 10, 10, 10, 10 ]

                          Это как?
                          Ответить
                          • А что плохого? Всё как надо.
                            Только в случае parseInt числа в строку переводятся перед парсингом.
                            Ответить
            • > x => type.Is(x)
              > types.Any(type.Is)

              Господа, а кто такой type и откуда он взялся?
              Ответить
      • >IsOneOf(params TypeOfWord[] types) {
        > foreach (var type in types) {
        > return types.Any(type => Is(type));
        По треду O(N) решения. Эээх.

        А если это енум, а это обязан был енум. Так вот если это енум (сиподобный) можно битовую масочку сделать.
        А в жабе из каробки enumset внутри себя так и работает.
        Ответить
        • > O(N) решения
          Для N=2
          Ответить
          • Во-1 в оп-посте N чуток побольше.
            Во-2, даже при N=2 можно избавиться от бранчинга и перепитушни цикла, а также создания массива и "всего-лишь" в 2 раза ускорить код.
            Ответить
            • Ткни пальцем, в какой из функций там N > 2...
              Ответить
              • Чёт я туплю вечером. Подумал N - размер енума.
                См. п. 2
                Ответить
                • Это в жабе енум няшный, с именованными и пронумерованными элементами.

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

                    Ну сдвиги есть. Думаю можно метод нацепить
                    int mask(){ return 1<<ordinal();}

                    В жабе вот что очень няшное:

                    http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/RegularEnumSet.java#RegularEnumSet
                    Ответить
                • З.Ы. Атрибут System.FlagsAttribute, походу, должен помочь.
                  Ответить
                  • Азаза
                    This API supports the product infrastructure and is not intended to be used directly from your code.

                    Не, там реально какая-то дрочь. 3.5 метода. Жабовский реально удобно, для людей сделан.
                    Ответить
                    • Ну обычный сишный енум. А [FlagsAttribute] просто разрешает ложить в него не только элементы, но и их кобенации (которые в сишке приходилось сувать в какой-нибудь безликий int).
                      Ответить
                  • Не сильно помогает, нумеровать всё равно нужно самому. Но хотя бы основную сишкопроблему убирает - потерю типизации у полей с флажками.
                    Ответить

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