1. Куча / Говнокод #17782

    +130

    1. 1
    List(1,2,3) + "X" == "List(1, 2, 3)X"

    Скала

    Запостил: laMer007, 13 Марта 2015

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

    • implicit def any2stringadd(x: Any) = new runtime.StringAdd(x)
      Ответить
    • А где смеяться?
      Ответить
      • Легендарный wat.mov. 55 секунда
        This is actually deserving how awesomw ruby is.
        Ответить
      • Так такое поведение в стандартной библиотеке. Там зачем-то добавили вышеназванный implicit
        Ответить
    • а можно мануал для скалаебовнубов?
      Ответить
      • Programming Scala, опупенная книжка. Только толстая. Правда, скалка ни нужна.
        Ответить
        • я тут параллельно читаю книжки по крестам, хаски, J и комикс про Константина, боюсь больше ядер у меня нет

          почему не нужна? жаболожцы же ее боготворят
          Ответить
          • >я тут параллельно читаю книжки по крестам, хаски, J
            >читаю книжки по крестам, хаски, J
            Почему я СОВЕРШЕННО не удивлён таком сочетанию?
            Ответить
          • >крестам, хаски, J

            Прям как я раньше.
            Ответить
        • >Правда, скалка ни нужна.
          Бухыхыхы. А чё так? Помню год-два назад я слышал совсем другие разговоры.
          Ответить
          • для модный хиповых языков "год-два" это вечность.

            в чем цель скалы я так и не уловил. груви - да. скала - нет.
            Ответить
            • груви вообще опасен
              Ответить
              • зато да же я, от жабы удаленный, оценил.
                Ответить
              • Почему-то те, кто пишут на Груви все время стремятся другой язык написать. Грейдл - один пример, Гремлин - еще один. И все время получается ПХП-подобное что-то.
                Ответить
                • Это называется EDSL, и я бы не сказал, что это плохо.
                  Ответить
                  • От того, что оно как-то называется, лучше оно не становится. Оба недоязыка - просто мусор, только отнимают время на то, чтобы расшифровать авторские задумки, которые обычно не стоят усилий затраченых на расшифровку.

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

                    По этому поводу очень хорошо сказал Уилкинсом, автор Grammar of Graphics, [...]orthogonality (as much as possible, everything should work everywhere and in every combination) and hierarchy (complicated tasks should be done by enlisting the support of simple helpers) [...] А эти языки только ухудшают и без того плохую ситуацию.
                    Ответить
                • Почему-то те, кто пишут на Лиспе, все время стремятся другой язык написать. ASDF - один пример, CLSQL - еще один. И все время получается Лиспо-подобное что-то.
                  Ответить
                  • неспецифицированная, глючная и медленная реализация половины языка Common Lisp.
                    Ответить
                  • А кто говорит, что специальные языки ASDF / cl-sql это что-то хорошее? ASDF иногда на столько становится поперек горла, что легче без него (но обычно все-таки изгаляешься для того, чтобы как-то подружить другие системы, которые от него тоже зависят, типа того же FFI). SQL - я, если честно, пользовался только SQLite, и в итоге пользовался именно cl-sqlite а не cl-sql. Возможность записать SQL на Лиспе абсолютно не нужна. Другое дело, если бы можно было Лисп выполнить внутри базы данных, а так - это одно и то же, что просто строки составлять, хуже того, если нужно использовать какой-нибудь вендоро-зависимый синтаксис, то будет облом.
                    Ответить
          • Черезчур переусложнённый язык.
            Я осознал, что гораздо лучше иметь относительно простой язык с чёткой семантикой, возможно, не очень мощный, чем здоровенный сложный язык с пятью системами типизаций и макросами, который умеет всё.

            Старый я стал, короче.
            Ответить
            • >>Черезчур переусложнённый язык.
              Бинго! Абсолютно такие же ощущения сложились при небольшом экскурсе, эдакие кресты в жабомире.
              Притом что я обломался её учить, спрашиваю как у более осведомлённого.

              >>Я осознал, что гораздо лучше иметь относительно простой язык с чёткой семантикой
              Добро пожаловать...
              Голанг кстати сразу понравился, хоть в нем на порядок меньше всякого.
              Ответить
              • > эдакие кресты в жабомире.

                В действительности скалка зачастую сложнее крестов. Я как-то пытался коллеге объяснить, что в деталях происходит в несчастном куске кода
                http://rosettacode.org/wiki/Run-length_encoding#Scala
                Это трындец сколько букв пришлось сказать. Надо знать слишком много, чтобы понимать код.
                Ответить
                • Да вроде ничего особенного, только хитрый паттерн-матчинг:
                  case ((len, c, sb), index) if c != s(index) => sb.append(len); sb.append(c); //ну понятно раз цепочка оборвалась пишем данные в поток
                  
                   (1, s(index), sb) //ЛОЛ, а вот это прикольно, какой-то анонимно-рекурсивный вызов
                  ...
                   for (Code(len, c) <- Code findAllIn s) 
                  //итератор по регулярочке, группы автоматом замапленны на кортеж, тоже прикольно
                  
                  sb.append(c * len.toInt) //блядская перегрузка *, если б не знал задачу - не догадался бы какой эффект


                  Слушайте я реально не знаю скалы, но код очевидный. Кресты гораздо сильнее мозг выносят.

                  Ответить
                  • Ответить
                    • Да, я вот ниже об этом писал.
                      [эта часть комментария доступна только пользователям премиум-аккаунтов]
                      Ответить
                      • куда заплатить что бы получить премиум аккаунт?
                        Ответить
                        • Здесь же. Сотню раз эту ссылку давали.
                          Ответить
                          • Второй раз я на это не куплюсь
                            Ответить
                            • Кому ты не продашься? Ссылка ведет на тред, где написано, что комменты приходят на почту подписавшимся. Плюс можно коммент посмотреть в стоке какое-то время после редактирования
                              Ответить
                  • Не обижай Тараса
                    Ответить
                  • > val Code = """(\d+)([A-Z])""".r
                    Ну вот тут пришлось рассказать про имплиситы - что справа это строка, у которой нет метода r, но он есть у какого-то другого класса, и компилятор ищет, во что такое можно сконвертировать объект, чтобы у него был метод r, и слава либе, это объект, создающий регулярку.

                    > for (Code(len, c) <- Code findAllIn s) sb.append(c * len.toInt)
                    Тут я вообще устал объяснять - тип c не сразу очевиден, нужно понять, что это поматченная строка, которая повторяется len.toInt раз. А Code можно использовать в левой части for, т.к. добрые авторы либы определили у регулярок волшебный метод unapply, который выковыривает группы в переменные, и это мы ещё даже не дошли до семантики for.
                    Короче две строчки, но детально объяснять код замучаешься, слишком много слоёв.
                    Ответить
                    • Меня больше всего (и это неудивительно, т.к. я много раз говорил об этом) смутили нечитабельные перегрузки операторов.

                      Поясните за чудесный механизм вызова самого себя в паттерн-матчинге:

                      case (i,p,s) => if (p==c) (i+1,p,s)
                      Как это работает?
                      Ответить
                      • Тут нет вызова себя. Это функциональная свертка. Функция берет старый стрейт и очередной элемент и возвращает новый стейт. Этот стейт проталкивается через все элементы.
                        Ответить
                        • П.с. стейт тут - кортеж из трёх элементов.
                          Ответить
                        • А, понял то есть это часть foldLeft. А то просто return в лямбде неявный.
                          Ответить
                • Вторая вореция энкода, тоже читабельна, просто её надо было лучше форматнуть, а лепить всё в одну строку.

                  def encode(s:String) = {
                    s.foldLeft((0,s(0),""))(
                      (t,c) => t match {
                          case (i,p,s) => if (p==c) (i+1,p,s) 
                          else (1,c,s+i+p)
                      }
                    )
                    match {case (i,p,s) => s+i+p}
                  }


                  Мозг тут выносит перегрузка плюса на StringBuffere/строке: s+i+p, который неявно вызывает {s.append(i);s.append(p)}. И то что этот append флюент-интерфейсный, то бишь возвращает себя модифицированного или новую немутабельную копию (я хз как там строки).
                  Ответить

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