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

    +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
    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))

    https://github.com/CafeOBJ/cafeobj/blob/master/chaos/e-match/match-acz.lisp

    ГОМОИКОНЫ копипаст лиспе
    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
      (55):NzNat
      (0.0000 sec for parse, 0.0020 sec for 529 rewrites + 760 matches)
      
      %NAT>
      Ответить
      • %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
        (3628800):NzNat
        (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 только для умных, а умных мало
                  Ответить
                  • > XSLT только для умных

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

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

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

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

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

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

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

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

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

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

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

                            Я не говорю, что это очень уж плохо, просто код, эквивалентный тому, что ты принёс, написать невозможно.
                            Ответить
                            • Именно поэтому...
                              <?php
                              function spaceless($callback) {
                                  ob_start(function($x){return trim($x);});
                                  $callback();
                                  ob_end_flush();
                              }
                              
                              spaceless(function(){
                                  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)]
                                  %>
                                  <table>
                                      % for row in rows:
                                          ${makerow(row)}
                                      % endfor
                                  </table>
                                  
                                  <%def name="makerow(row)">
                                      <tr>
                                      % for name in row:
                                          <td>${name}</td>\
                                      % endfor
                                      </tr>
                                  </%def>
                                  Ответить
                                • В шаблонизаторах наблюдаются все свойства "взрослых" языков.
                                  Сначала хотели сделать что-то выразительное и легковесное, потом стало чего-то не хватать - добавили, ещё чего-то не хватало, ещё и ещё..., надобавляли - и вот уже второй C++ вышел, только для шаблонов.
                                  Ответить
                      • А теперь сделай этими тегами древовидные коменты.
                        Ответить
                    • А есть транслятор из человекопонятного синтаксиса в XSLT и обратно?
                      Ответить
                      • возможно, вы имели ввиду пхпонятного?
                        Ответить
                        • debug.com гомоиконный: можно в нём написать интерпретатор и передать на него управление, а можно модификать код самого дебагера как надо.
                          Ответить
            • Это язык преобразования XML для тех, кто не осилил ни один язык программирования?
              Ответить
              • Именно поэтому я за "PHP".
                Ответить
              • Это язык преобразования деревьев для тех, кто не хочет иметь проблем с эскейпом и бизнес логикой в шаблонах
                Ответить
            • Как если бы у лиспа был племянник с синдромом Дауна.
              Ответить
            • The rewriting calculus Horatiu Cirstea and Claude Kirchner and Luigi Liquori

              http://cgi.csc.liv.ac.uk/~coopes/comp319/2016/papers/Rewriting-Calculus-RHO-pp.pdf#truc18.0


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

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

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