1. Си / Говнокод #27420

    +2

    1. 001
    2. 002
    3. 003
    4. 004
    5. 005
    6. 006
    7. 007
    8. 008
    9. 009
    10. 010
    11. 011
    12. 012
    13. 013
    14. 014
    15. 015
    16. 016
    17. 017
    18. 018
    19. 019
    20. 020
    21. 021
    22. 022
    23. 023
    24. 024
    25. 025
    26. 026
    27. 027
    28. 028
    29. 029
    30. 030
    31. 031
    32. 032
    33. 033
    34. 034
    35. 035
    36. 036
    37. 037
    38. 038
    39. 039
    40. 040
    41. 041
    42. 042
    43. 043
    44. 044
    45. 045
    46. 046
    47. 047
    48. 048
    49. 049
    50. 050
    51. 051
    52. 052
    53. 053
    54. 054
    55. 055
    56. 056
    57. 057
    58. 058
    59. 059
    60. 060
    61. 061
    62. 062
    63. 063
    64. 064
    65. 065
    66. 066
    67. 067
    68. 068
    69. 069
    70. 070
    71. 071
    72. 072
    73. 073
    74. 074
    75. 075
    76. 076
    77. 077
    78. 078
    79. 079
    80. 080
    81. 081
    82. 082
    83. 083
    84. 084
    85. 085
    86. 086
    87. 087
    88. 088
    89. 089
    90. 090
    91. 091
    92. 092
    93. 093
    94. 094
    95. 095
    96. 096
    97. 097
    98. 098
    99. 099
    100. 100
    #include <stdio.h>
    #include <stdlib.h>
    #define RW(a, c) for(src = (a);src < (c); src++, dst++){*dst=*src;} 
    void *pairscan(char *p)
    {
      size_t p_count = 1;
      do {
        if(*p == 'P') {
          p_count++;
        }
        else {
          p_count--;
        }
        p++;
      } while(p_count != 0);
      return p;
    }
    
    
    void rewrite(char *src, char *dst)
    {
      int p_r = 0;
      while(*src == 'P') {
        *dst = *src;
        src++; dst++;
        if (p_r < 3)
        {
          p_r++;
        }
      }
      if(*src == 'I') {
        if(p_r < 1) {
          while(*src != 0) {
            *dst = *src;
            src++; dst++;
          }
          *dst = 0;
          return;
        }
        dst--;
        src++;
        //src = pairscan(src+1);
        while(*src != 0) {
          *dst = *src;
          src++; dst++;
        }
        *dst = 0;
        return;
      }
      if(*src == 'K') {
        if(p_r < 2)
        {
          while(*src != 0) {
            *dst = *src;
            src++; dst++;
          }
          *dst = 0;
          return;
        }
        dst-=2;
        char *exp1 = pairscan(src+1);
        char *exp2 = pairscan(exp1);
        RW(src+1,exp1);
        for(; src < exp2; src++){}
        while(*src != 0) {
          *dst = *src;
          src++; dst++;
        }
        *dst = 0;
        return;
      }
      if(*src == 'S') {
        if(p_r < 3) {
          while(*src != 0){
            *dst = *src;
            src++; dst++;
          }
          *dst = 0;
          return;
        }
        dst-=1;
        char *exp1 = pairscan(src+1);
        char *exp2 = pairscan(exp1);
        char *exp3 = pairscan(exp2);
        RW(src+1,exp1);
        RW(exp2,exp3);    
        *dst = 'P';
        dst++;
        RW(exp1,exp2);
        RW(exp2,exp3);
        while(*src != 0) {
          *dst = *src;
          src++; dst++;
        }
        *dst = 0;
        return;
      }
      *dst = 0;
      return;
    }

    Кобенаторная логика
    SKI combinator calculus

    Запостил: j123123, 11 Мая 2021

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

    • https://en.wikipedia.org/wiki/SKI_combinator_calculus
      Там описывается через какие-то скобочки, ну типа там вот

      Ix => x
      Kxy = ((K x) y) => x
      Sxyz = (((S x) y) z) => xz(yz)

      Но это вообще питушня какая-то. Вместо скобочек можно использовать P.
      PIx = Ix
      PPKxy = Kxy
      PPPSxyz = Sxyz

      где x y z это типа хрень или P хрень хрень

      Так что можно подобную питушню эффективно свести к тупому переписыванию текстушни
      и никакие скобочки нахрен не всрались

      https://wandbox.org/permlink/JEV7GQ5jF4HUMBvp
      Ответить
      • // рассмотрим строку
          PIPPPIPSKSK
        // находим паттерн-матчингом первое встретившееся "PI"
          PIPPPIPSKSK
          ^^
        // Есть правило PIx -> x, где x - любая текстушня. Получаем
          PPPIPSKSK
        // Сканируем дальше. Находим
          PPPIPSKSK
            ^^
        // По тому же говноправилу делаем говнозамену, вырезаем нахрен PI
          PP  PSKSK
        // т.е.
          PPPSKSK
        // теперь обнаруживаем 
          PPPSKSK
          ^^^^
        // который принимает 3 аргумента, и перед ним как раз три "P".
        // Отметим первый второй и третий аргумент
          PPPSKSK
          ^^^^xyz
        // По правилу говноподстановки PPPSxyz -> PPxzPyz получаем
          PPKKPSK
        // Теперь обнаруживаем тут хуйню "K" которая принимает две хуйни x y
          PPKKPSK
          ^^^xyyy
        // По правилу говноподстановки PPKxy -> x получаем
          K
        // Дальше эту питушню уже не переписать.
        Ответить
      • Кстати I-кобенатор тут работает немного не по-стандарту. Хуйня "PI" просто нахуй выкидывается, а на самом-то деле она должна выкидываться только если после хуйни PI есть еще какая-то хуйня. Впрочем, хуй с ним, это можно легко пофиксить. Хотя может это и норм, учитывая что в обычной нотации нельзя сделать что-то типа (P, нихуя). А если б можно было, вполне логично что возвращается нихуя
        Ответить
      • Поздравляю с изобретением unlambda. В ней вместо P используется ` на конце. Её через стек легко реализовать, кстати.
        Ответить
        • А ввод-вывод там как реализован?
          Ответить
        • P.S.
          > В ней вместо P используется ` на конце. Её через стек легко реализовать, кстати.
          Тьфу, перепутал со своим диалектом.
          Ответить
      • Анскилл. Целых три кобенатора под control flow, когда достаточно одного: https://en.wikipedia.org/wiki/Iota_and_Jot
        Ответить
    • В коде нят ни одного malloc ⇒ в коде баг.
      Потому что в SKI должно быть можно нясоздавать бесконечно большие термы.

      Возьмём такой терм: PPPSIIPPSII. Он эквивалентен ((λ x. x x) (λ x. x x)). Его кобеняция ня должна завершаться никогда, и для неё нужно бесконячно много памяти, так как он себя бесконячно реплицирует. А твоя прога завершается.
      Ответить
      • Можно сделать реаллоцирующуюся хрень, но память в любом случае закончится, так что WONTFIX

        Подожду когда разработают астральный компьютер с бесконечной памятью.
        Ответить
        • Сегфолт хоть почини.
          Ответить
          • https://wandbox.org/permlink/zvtVCzSbzhaAPl9g починил.
            Поскольку питуля может разрастаться только в кобенаторе S, я добавил проверки исключительно в него.
            Хотя конечно можно и получше заоптимизировать.
            Ответить
            • Хотя не, там не совсем правильно сделано, надо еще и потом проверять, после дописывания хвоста
              Ответить
            • https://wandbox.org/permlink/aUZZaOdJIDBf0EP1 вот починил вроде
              Ответить
    • Кстати вот интересно, кто-нибудь совмещал функциональную и императивную Тьюринговую трясину в одном говноязычке? Ну чтоб там и кобенаторы были, и брейнфак с бесконечной лентой, и чтоб еще они через какую-то питушню могли взаимодействовать, например чтоб из брейнфака можно было передать хрень в функциональную кобенандную питулю которая вернет в ответ какую-то питулю в брейнфак
      Ответить
      • А зачем, если они эквивалентны и можно вылепить одно из другого? Запилить бесконечную ленту-зиппер через кобенаторы и т.п.
        Ответить
        • Для фана конечно. А зачем искать в этом причины? Вряд ли Brainfuck и Unlambda создавались с целью какого-то полезного применения.

          Был же тут какой-то еблан в свое время, носился с каким-то своим сраным WCT, нахуя кому оно было нужно?
          Ответить
        • Так-то если подумать, из сишки можно вполне выкинуть циклы for, while, do-while и конструкцию switch, ведь все это можно заменить говноконструкциями из if (без else) и goto. Все такие сложные конструкции можно костылить некоторой хитрой метушней, из которой генерится if (без else) и goto
          Ответить
          • Можно ещё оставить гццшный goto *label и выкинуть if.
            Ответить
      • Мультипарадигменная эзотерика, brainfuck++?
        Ответить
        • Да, типа того. И чтоб еще функциональная и императивная хрень могла параллельно работать, например из брейнфака можно дать команду унлямбде чтоб она записала результат какой-то питушни в некую ячеку ленты брейнфак, но чтобы при этом брейнфак мог дальше при этом работать, и чтоб race condition мог бы быть, для большей эзотеричности
          Ответить
          • Брейнфаку можно отдать только один тред, а порождаемые им процессы унлямбды могут параллельно работать, и быть их может сколько угодно, и чтобы они могли наперебой набрасывать байтики в бесконечную ленту брейнфака. Обмениваться инфой между собой эти процессы могут только через эту самую ленту, и атомарность гарантируется только для записи-чтения одного 8-битного байта.
            Ответить
            • А потом формально доказать, что всё работает правильно и без рейсов.
              Ответить
          • Из тебя бы вышел хороший крестостандартизатор.
            Ответить
            • Я думаю, мы это ещё успеем увидеть, когда он стадию отрицания пройдёт...
              Ответить
              • Я скорее свой язык с гомоиконами напишу, чем на кресты перейду.
                Ответить
                • Лучше прикрути доступ к AST из шаблонов:)


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

                          тогда придется разделить шаблоны на два сорта
                          * препроцессорные (которые высирают AST)
                          * постпроцессорные (которые уже с AST работают)
                          Ответить
                          • Все шаблоны можно сделать в AST, и уже метушить через AST-метушню сами шаблоны. Т.е. AST-метушней можно насрать шаблонов, которые дальше будут что-то метушить на следующей стадии метушения.

                            Валидна или не валидна программа вначале - вообще пофиг. После метушения разберемся.
                            Ответить
                            • Ну то есть стереть разницу между кодом и шаблонами и стать гомоиконой, как лисп)
                              Ответить
                            • https://i.kym-cdn.com/photos/images/newsfeed/000/531/557/a88.jpg
                              Ответить
                      • Ну вот смотри. Ты хочешь взять некий крестокод, что-то с ним сделать, и выплюнуть новый код. Т.е. тебе надо писать код, который с AST работает и как-то его меняет, верно? Тебе для этого надо видеть это AST, верно? Глядя на крестосинтаксис, совершенно не очевидно, какой именно AST из него выйдет, верно? Итак, ты предлагаешь чтоб некая тула тебе из обычного крестоговносинтаксиса выплевывала его AST (альтернативный синтаксис типа, который тоже компилируется т.е. является валидным крестокодом), и вот этот синтаксис ты видишь, и под него пишешь свою метушню, которая что-то там трансформирует, генерируя новую хуйню. Ты так хочешь? А не кажется ли тебе, что это малость ебануто? Будет ли выплюнутый этой тулой AST-код хотя бы малость человекочитаем?
                        Ответить
                        • >Глядя на крестосинтаксис, совершенно не очевидно, какой именно AST из него выйдет, верно?
                          можно ли так?
                          https://govnokod.ru/27420#comment627054
                          Ответить

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