Няшная / Говнокод #27420 Ссылка на оригинал

0

  1. 1
  2. 2
  3. 3
  4. 4
  5. 5
  6. 6
  7. 7
  8. 8
  9. 9
  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
  97. 97
  98. 98
  99. 99
  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 j123123, (Updated )

Комментарии (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 используется ` на конце. Её через стек легко реализовать, кстати.
        Тьфу, перепутал со своим диалектом.
        Ответить
  • В коде нят ни одного malloc ⇒ в коде баг.
    Потому что в SKI должно быть можно нясоздавать бесконечно большие термы.

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

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

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


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

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

                          Валидна или не валидна программа вначале - вообще пофиг. После метушения разберемся.
                          Ответить
                    • Ну вот смотри. Ты хочешь взять некий крестокод, что-то с ним сделать, и выплюнуть новый код. Т.е. тебе надо писать код, который с AST работает и как-то его меняет, верно? Тебе для этого надо видеть это AST, верно? Глядя на крестосинтаксис, совершенно не очевидно, какой именно AST из него выйдет, верно? Итак, ты предлагаешь чтоб некая тула тебе из обычного крестоговносинтаксиса выплевывала его AST (альтернативный синтаксис типа, который тоже компилируется т.е. является валидным крестокодом), и вот этот синтаксис ты видишь, и под него пишешь свою метушню, которая что-то там трансформирует, генерируя новую хуйню. Ты так хочешь? А не кажется ли тебе, что это малость ебануто? Будет ли выплюнутый этой тулой AST-код хотя бы малость человекочитаем?
                      Ответить

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

Помни, guest, за тобой могут следить!

    А не использовать ли нам bbcode?


    8