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


    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
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    55. 55
    56. 56
    57. 57
    58. 58
    59. 59
    60. 60
    61. 61
    62. 62
    63. 63
    64. 64
    65. 65
    66. 66
    67. 67
    68. 68
    69. 69
    70. 70
    71. 71
    72. 72
    73. 73
    74. 74
    75. 75
    76. 76
    77. 77
    78. 78
    79. 79
    80. 80
    81. 81
    82. 82
    83. 83
    84. 84
    85. 85
    86. 86
    87. 87
    88. 88
    89. 89
    90. 90
    91. 91
    92. 92
    93. 93
    94. 94
    95. 95
    96. 96
    ;;; the toplevel operators of each equation in the system
    ;;; type : array[term]
    (defmacro match-acz-state-methods (state__) `(svref ,state__ 0))
    ;;; functional terms
    ;;; type : array[term]
    (defmacro match-acz-state-lhs-f (state__) `(svref ,state__ 1))
    ;;; variables on the LHS
    ;;; type : array[term]
    (defmacro match-acz-state-lhs-v (state__) `(svref ,state__ 2))
    ;;; contants on the RHS
    ;;; type : array[term]
    (defmacro match-acz-state-rhs-c (state__) `(svref ,state__ 3))
    ;;; functional terms on RHS
    ;;; type : array[term]
    (defmacro match-acz-state-rhs-f (state__) `(svref ,state__ 4))
    ;;; notes repeated functional terms of LHS
    ;;; type : array[bool]
    (defmacro match-acz-state-lhs-f-r (state__) `(svref ,state__ 5))
    ;;; notes repeated variables of LHS
    ;;; type : array[bool]
    (defmacro match-acz-state-lhs-v-r (state__) `(svref ,state__ 6))
    ;;; notes repeated constants of RHS
    ;;; type : array[bool]
    (defmacro match-acz-state-rhs-c-r (state__) `(svref ,state__ 7))
    ;;; notes repreated funcational terms of RHS
    ;;; type : array[bool]
    (defmacro match-acz-state-rhs-f-r (state__) `(svref ,state__ 8))
    ;;; variables and funs acocunted for by RHS-c-sol
    ;;; type : fixnum
    (defmacro match-acz-state-lhs-mask (state__)  `(svref ,state__ 9))
    ;;; funs accounted for by RHS-c-sol
    ;;; type : fixnum
    (defmacro match-acz-state-lhs-f-mask (state__) `(svref ,state__ 10))
    ;;; bit vector of all repeated (> 0) terms on LHS
    (defmacro match-acz-state-lhs-r-mask (state__)  `(svref ,state__ 11))
    ;;; solution matrix for constants
    ;;; type : array[fixnum]
    (defmacro match-acz-state-rhs-c-sol (state__) `(svref ,state__ 12 ))
    ;;; max value of elements of RHS-C-sol
    ;;; type : fixnum
    (defmacro match-acz-state-rhs-c-max (state__) `(svref ,state__ 13))
    ;;; solutions matrix; functional terms
    ;;; type : array[fixnum]
    (defmacro match-acz-state-rhs-f-sol (state__) `(svref ,state__ 14))
    ;;; max value of elements of RHS-f-sol
    ;;; type : fixnum
    (defmacro match-acz-state-rhs-f-max (state__) `(svref ,state__ 15))
    ;;; type : fixnum 11111 ... 1111
    (defmacro match-acz-state-rhs-full-bits (state__) `(svref ,state__ 16))
    ;;; array of compatibility bitvectors; constants
    ;;; type : array[fixnum]
    (defmacro match-acz-state-rhs-c-compat (state__) `(svref ,state__ 17))
    ;;; array of compatibility bitvectors; funcs
    ;;; type : array[fixnum]
    (defmacro match-acz-state-rhs-f-compat (state__) `(svref ,state__ 18))
    ;;; number of constants on LHS after simplification
    ;;; type : fixnum
    (defmacro match-acz-state-lhs-c-count (state__) `(svref ,state__ 19))
    ;;; number of functions on LHS after simplification
    ;;; type : fixnum
    (defmacro match-acz-state-lhs-f-count (state__) `(svref ,state__ 20))
    ;;; number of variables on LHS after simplification
    ;;; type : fixnum
    (defmacro match-acz-state-lhs-v-count (state__) `(svref ,state__ 21))
    ;;; number of constants on RHS after simplification
    ;;; type : fixnum
    (defmacro match-acz-state-rhs-c-count (state__)  `(svref ,state__ 22))
    ;;; number of functions on RHS after simplification
    ;;; type : fixnum
    (defmacro match-acz-state-rhs-f-count (state__) `(svref ,state__ 23))
    ;;; t iff all solutions have been reported.
    (defmacro match-acz-state-no-more (state__) `(svref ,state__ 24))


    ГОМОИКОНЫ копипаст лиспе
    CafeOBJ is a most advanced formal specification language which inherits many advanced features (e.g. flexible mix-fix syntax, powerful and clear typing system with ordered sorts, parameteric modules and views for instantiating the parameters, and module expressions, etc.) from OBJ (or more exactly OBJ3) algebraic specification language.

    CafeOBJ is a language for writing formal (i.e. mathematical) specifications of models for wide varieties of software and systems, and verifying properties of them. CafeOBJ implements equational logic by rewriting and can be used as a powerful interactive theorem proving system. Specifiers can write proof scores also in CafeOBJ and doing proofs by executing the proof scores.

    CafeOBJ has state-of-art rigorous logical semantics based on institutions. The CafeOBJ cube shows the structure of the various logics underlying the combination of the various paradigms implemented by the language. Proof scores in CafeOBJ are also based on institution based rigorous semantics, and can be constructed using a complete set of proof rules

    Запостил: j123123, 20 Декабря 2018

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

    • ;; and now stuff the state full of information, and return it.
                     (setf (match-ACZ-state-methods state) sys-methods)
                     (setf (match-ACZ-state-LHS-f state) lhs-f)
                     (setf (match-ACZ-state-LHS-v state) lhs-v)
                     (setf (match-ACZ-state-RHS-c state) rhs-c)
                     (setf (match-ACZ-state-RHS-f state) rhs-f)
                     (setf (match-ACZ-state-LHS-f-r state) lhs-f-r)
                     (setf (match-ACZ-state-LHS-v-r state) lhs-v-r)
                     (setf (match-ACZ-state-RHS-c-r state) rhs-c-r)
                     (setf (match-ACZ-state-RHS-f-r state) rhs-f-r)
                     ;; (setf (match-ACZ-state-LHS-mask state) 0)
                     (setf (match-ACZ-state-LHS-f-mask state) 0)
                     (setf (match-ACZ-state-LHS-r-mask state) lhs-r-mask)
                     (setf (match-ACZ-state-RHS-c-sol state) rhs-c-sol)
                     (setf (match-ACZ-state-RHS-c-max state) rhs-c-max)
                     (setf (match-ACZ-state-RHS-f-sol state) rhs-f-sol)
                     (setf (match-ACZ-state-RHS-f-max state) rhs-f-max)
                     (setf (match-ACZ-state-RHS-full-bits state) rhs-full-bits)
                     (setf (match-ACZ-state-RHS-c-compat state) rhs-c-compat)
                     (setf (match-ACZ-state-RHS-f-compat state) rhs-f-compat)
                     (setf (match-ACZ-state-LHS-c-count state) 0)
                     (setf (match-ACZ-state-LHS-f-count state) lhs-f-count)
                     (setf (match-ACZ-state-LHS-v-count state) lhs-v-count)
                                              ; off 1+ intentionally 
                     (setf (match-ACZ-state-RHS-c-count state) rhs-c-count)
                     (setf (match-ACZ-state-RHS-f-count state) rhs-f-count)
                     (setf (match-ACZ-state-no-more state) nil)
                     (setf (match-ACZ-state-acz-state-p state) 'acz-state)
    • https://www.preining.info/blog/2018/05/specification-and-verification-of-software-with-cafeobj-part-3-first-steps-with-cafeobj/

      Specification and Verification of Software with CafeOBJ – Part 3 – First steps with CafeOBJ

      > As a challenge the reader might try to give definitions of the factorial function and the Fibonacci function, the next blog will present solutions for it.

      %NAT> op fib : Nat -> Nat .
      %NAT> eq fib(0) = 0 .
      %NAT> eq fib(1) = 1 .
      %NAT> eq fib(A:NzNat) = fib(p A) + fib(p p A) .
      %NAT> red fib(10) .
      -- reduce in %NAT : (fib(10)):Nat
      (0.0000 sec for parse, 0.0020 sec for 529 rewrites + 760 matches)
      • %NAT> op fact : Nat -> Nat .
        %NAT> eq fact(0) = 1 . 
        %NAT> eq fact(A:NzNat) = fact(p A) * A .
        %NAT> red fact(10) .
        -- reduce in %NAT : (fact(10)):Nat
        (0.0000 sec for parse, 0.0000 sec for 30 rewrites + 49 matches)
    • Делать нехуй?
      • Крестоблядям не понять
        • Действительно, ебаться с закорючками то еще веселье. Кресты такая же хуйня.
    • (Какой ' (LISP ( )))
    • За S" Forth" я поэтому именно .
    • Когда языку нужны мокросы это говорит о говнистости языка , S" Forth'у" нинужны никакие мокросы , именно поэтому я за S" Си".
      • Хочу чтобы был такой язык, суть токова. Код парсился и был как двусвязный список из массивов байт, и в процессе интерпретация этот двусвязный список мог бы самопереписывать себя. Ну типа я напишу
        ( fuck = shit ) asdasd
        asdfgh gdfg

        и с точки зрения языка это будет двусвязный список
        START <-> "(" <-> "fuck" <-> "=" <-> "shit" <-> ")" <-> "asdasd" <-> "asdfgh" <-> "gdfg" <-> END

        И чтоб можно было интерпретировать это, элементы в двусвязном списке менять как массивы байт, вставлять новые элементы в двусвязный список и потом интерпретировать свежевставленное на основе каких-то правил, которые могут быть заданы двусвязными списками и которые могут быть сгенерированы в процессе интерпретации двусвязных списков из этой всей питушни. Можно грабить корованы
        • "fuck = shit"

          А нам всё равно — что жопа, что говно.
        • Какая-то это слишком низкоуровневая питушня. Видна тяжёлая рука пердолинга с сишкой, коньпеляторами и ассемблером. Мне кажется, из такого языка выйдет только черепаха гомоиконный брейнфак.
          В программировании уже почти не обойтись без иерархии и циклических ссылок (то есть графов). Сюда надо хотя бы что-то вроде SAX-питушни.

          А вот простой синтаксис для перезаписи деревьев (вроде функций с паттерн матчингом) был бы полезен.
          • Ну, на основе линейного текста программы (которая прочитается как двусвязный список) можно на основе rewriting rules на этапе интерпретации сгенерить ориентированный граф, и потом уже с ним что-нибудь делать. Двусвязный список это будет просто частный случай этого ориентированного графа, который парсится из текстового файла в самом начале и с которого начинается построение дерева и дальнейшей манипуляции с ним.
            • Основная идея в том, что синтаксиса как такового у нас нет. Есть просто набор слов (точнее, массивов байт), разделенных пробелами. Если надо в самом слове пробел использовать, можно использовать скобки и сделать что-то вроде
              abc "test test" abc

              А если нужно сами скобки или еще какую-то фигню записать, можно это сделать эскейп-последовательностью
              abc "test \" test \\ test asdgh \" \xFF \x00 test" abc

              Если строка слишком длинная, можно делать так
              abc "very very very very \*"
              "very long string" abc

              распознается как
              abc "very very very very very long string" abc

              И можно даже сделать подобие инклуда, типа
              abc "\PC:\somefile.txt" abc
              просто воткнет в один элемент двусвязного списка всё содержимое файла C:\somefile.txt
          • > синтаксис для перезаписи деревьев
            • Громоздкий синтаксис, попроще бы его.
              • Зато он может трансформировать сам себя. Гомоиконы, все дела.
                • Кроме того он функциональный, со встроенным паттерн-матчингом и да гомоиконен

                  К сожалению, XSLT только для умных, а умных мало
                  • > XSLT только для умных

                    Для старательных он, замучаешься этими тегами хоть что-то интересное писать.
                    • Толи дело современные шаблонизаторы!

                      Вот например Django (самый попу лярный фреймворк питона)
                      {% spaceless %}{% for widget in widget.subwidgets %}{% include widget.template_name %}{% endfor %}{% endspaceless %}
                      • <xsl:template match="/">
                          <xsl:for-each select="widget/subwidgets">
                             <!-- Я не знаю, что тут написать, include нельзя в for-each писать. -->
                        • зачем spaceless? Там и так все spaceless автоматически

                          И инклуды не нужны в цикле: ты сначала все инклудишь, а потом матчишь.

                          У тебя есть виджет для вывода чебокса? так и напиши что у него match на запись с типом bool, и выводи по ней widget.

                          Шаблонизатор это не такой анально огороженный недоязык программирования с глобальной видимостью и хуевым синтаксисом, шаблон это способ преобразования одного дерева (данных) в другое (UI)
                          • Блядь какой ты умный пиздабол
                            А почему тогда его никто не использует, если он такой хороший?

                            Все блядь идут не в ногу, а один ты в ногу

                            Ну давай, спиздни что все кругом дураки. В гугле дураки, в фейсбуке дураки, в Microsoft дураки, а ты один умный
                          • > шаблон это способ преобразования одного дерева (данных) в другое (UI)

                            Спасибо, капитан, я в своё время километры этого xslt-говна написал, удручающий опыт (не помню, для чего именно — вроде из выхлопа какого-то апи генерил отчёты в pdf через разметку apache poi).

                            > И инклуды не нужны в цикле: ты сначала все инклудишь, а потом матчишь.

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

                            В XSLT так в принципе невозможно сделать, нужно заранее всё инклюдить руками.

                            Я не говорю, что это очень уж плохо, просто код, эквивалентный тому, что ты принёс, написать невозможно.
                            • Именно поэтому...
                              function spaceless($callback) {
                                  ob_start(function($x){return trim($x);});
                                  foreach ($widget->subwidgets as $widget) {
                                      include ($widget->template_name);
                            • Так и не надо инклудить. Сама идея использования шаблонизатора как императивного языка с хуёвым синтаксисом, она провальная.

                              Когда я вижу как люди пишут
                              {% if user.is_petuh %}
                              <strong>поди подмойся</strong>
                              {% else if user.is_sjavka %}
                              <strong>мал ты еще с ворами водку пить</strong>
                              {% else %}
                              <strong>милости прошу к нашему шалашу</strong>
                              {% endif %}

                              у меня внутри подгорает. Ну нахуя изобрели еще один хуевый язык?
                              • > у меня внутри подгорает. Ну нахуя изобрели еще один хуевый язык?

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

                                У меня от всех шаблонизаторов (кроме typesafe-аналогов printf) пригорает.
                                • Типа HAML в Ruby и HTML Builders в Kotin/Groovy?:)

                                  Возможно, это и правда лучше. Но не все языки умеют DSL.
                                  Придумай-ка мне красивый DSL на питоне или пер/\е:)

                                  Обычно шобло начинается с того что "вот тут у нас надо просто переменную вывести", а потом (реальный пример из mako)
                                  <%inherit file="base.html"/>
                                      rows = [[v for v in range(0,10)] for row in range(0,10)]
                                      % for row in rows:
                                      % endfor
                                  <%def name="makerow(row)">
                                      % for name in row:
                                      % endfor
                                • В шаблонизаторах наблюдаются все свойства "взрослых" языков.
                                  Сначала хотели сделать что-то выразительное и легковесное, потом стало чего-то не хватать - добавили, ещё чего-то не хватало, ещё и ещё..., надобавляли - и вот уже второй C++ вышел, только для шаблонов.
                      • А теперь сделай этими тегами древовидные коменты.
                    • А есть транслятор из человекопонятного синтаксиса в XSLT и обратно?
                      • возможно, вы имели ввиду пхпонятного?
                        • debug.com гомоиконный: можно в нём написать интерпретатор и передать на него управление, а можно модификать код самого дебагера как надо.
            • Это язык преобразования XML для тех, кто не осилил ни один язык программирования?
              • Именно поэтому я за "PHP".
              • Это язык преобразования деревьев для тех, кто не хочет иметь проблем с эскейпом и бизнес логикой в шаблонах
            • Как если бы у лиспа был племянник с синдромом Дауна.
            • The rewriting calculus Horatiu Cirstea and Claude Kirchner and Luigi Liquori


              Note that XSLT is just a (special) kind of rewriting language, acting on XML documents

              (там еще в качестве примера приводятся конфиги сендмейла)

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