1. C++ / Говнокод #25842

    +2

    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
    // https://habr.com/ru/post/466985/
    
    // о каррировании в крестоговне
    
    // По сути это каррирующее говно просто складывает куда-то хуйню, а потом целиком ее в функцию призывает.
    // Ну т.е. на Си можно написать дрисню вида
    
    int shit(int a, int b, int c, int d)
    {
      return a*(b+c*d);
    }
    
    // И вот каррирование такой дрисни это как если б я сделал структуру
    struct shit_arguments
    {
       int a;
       int b;
       int c;
       int d;
    };
    
    // И потом бы с конца заполнял это говно
    struct shit_arguments;
    shit_arguments.d = 13;
    shit_arguments.c = 666;
    shit_arguments.b = 1488;
    shit_arguments.a = 42;
    // и при полном заполнении этого говна просто б вызвал функцию
    // подставив туда накопившееся говно
    int somecrap = shit(shit_arguments.a, shit_arguments.b, shit_arguments.c, shit_arguments.d);
    
    // именно так эта крестовая дрисня и работает, она не может произвести частичное вычисление
    // не может сделать функцию с частично вычисленной дрисней в ней на основе частично переданной хуйни
    
    // если я например в функцию shit захочу частично подставить аргументы b,c,d как 1,2,3 то у меня не получится функции вида
    int shit_b1_c2_d3(int a)
    {
      return a*(7); // 1+2*3 = 7
    }
    // Нихуя подобного не будет. А если нихуя подобного нет, нахуй это бесполезное дерьмо вообще надо?
    // В крестах никак нельзя на основе каких-то готовых функций сгенерить
    // видоизмененные функции с частично сделанными вычислениями
    // Никакой нормальной рефлексии нет, просто какие-то тупые кривые костыли к сишечке налепили
    // И это программисты?

    Запостил: j123123, 15 Сентября 2019

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

    • показать все, что скрытоvanished
      Ответить
    • Слишком сложно
      Именно поэтому я пишу
      const curry = fn => (...args) => args.length >= fn.length ? fn(...args) : curry(fn.bind(fn, ...args))
      const add2 = (a, b, c) => a + b + c
      curry(add2)(1)(2)(3) //6

      и радуюсь жизни
      Ответить
    • Надо чтоб суперкомпиляция, частичные вычисления, специализация https://keldysh.ru/papers/2008/prep12/prep2008_12.html
      > Оптимизация программ на основе использования априорной информации о значении части переменных называется специализацией.
      И возможно даже чтоб JIT можно было запилить с таким вот. Типа есть функция с кучей принимаемых аргументов, и чтоб на основе такой функции можно было сделать новую функцию с меньшим числом принимаемых аргументов, четко и дерзко захардкоживая часть значений, получая в итоге новую откомпилированную функцию, с уже частично сделанными вычислениями.
      Ответить
      • Если часть аргументов известна в компайлтайме (чистые константы), то иногда компилятор даже оптимизирует такой код (например, в сишке это бывает, когда разрешено инлайнить функцию).

        Если же эти аргументы известны только в рантайме, то всё плохо. Чтобы оптимизировать, нужно в рантайм встраивать оптимизирующий компилятор, значит, рантайм распухнет. Даже если плюнуть на оптимизацию, всё равно для взятия указателя на такую функцию с частично применёнными аргументами придётся строить трамплин. В «gcc» трамплины приводят к снятию защиты от исполнения кода в стеке.
        Ответить
        • > Если же эти аргументы известны только в рантайме, то всё плохо. Чтобы оптимизировать, нужно в рантайм встраивать оптимизирующий компилятор, значит, рантайм распухнет.

          Необязательно, возможны промежуточные решения. Например:
          int shit(int a, int b, int c, int d)
          {
            return a*(b+c*d);
          }
          
          int b, c, d;
          scanf("%d %d %d\n", &b, &c, &d);
          
          auto newshit = shit(?, b, c, d); // специализируем по b, c, d которые известны на этапе исполнения

          такую newshit можно сделать так
          int newshit(int a, int b_c_d)
          {
            return a*(b_c_d);
          }

          Ну и вот эту дрисню b_c_d = (b+c*d) можно посчитать в момент исполнения, на основе кода функции shit
          и сгенерить все это говно исключительно в компилтайме

          Но в крестопарашной дрисне такого нет
          Ответить
          • >> такую newshit можно сделать так
            >> int newshit(int a, int b_c_d)

            Не всегда можно сделать именно так. Т. е. не всегда функцию можно свести к функции именно двух переменных. Если, например, в той же формуле a*(b+c*d) известны a, c, d, а переменная b остаётся свободной, то получим int newshit(int b, int a, int c_d). Если же известны a, b, c, а переменная d остаётся свободной, то получим int neswhit(int d, int a_b, int a_c). В самом же общем случае все аргументы придётся передавать отдельно.
            Ответить
            • > Не всегда можно сделать именно так. Т. е. не всегда функцию можно свести к функции именно двух переменных.
              Не, ну естественно есть разные варианты
              например, если у нас функция
              int shit(int a, int b, int c, int d, int e)
              {
                return a*(b+c*d)-(b*e);
              }

              И если мы специализируем по b, c, d, e то можно сделать так:
              int newshit(int a, int b_c_d, int b_e)
              {
                return a*(b_c_d)-b_e;
              }


              Смысл в том, что если в цикле такая частично специализированная функция вызывается много много раз, такое частичное вычисления по части известных аргументов лучше чем ничего. Можно и наинлайнить даже
              Ответить
    • показать все, что скрытоvanished
      Ответить
    • показать все, что скрытоvanished
      Ответить
    • Идите нахуй со своей крестопарашей.
      Ответить
    • Слишком сложно.

      То ли дело
      : 1+  1 + ;
      Именно поэтому я за S" Forth".
      Ответить
    • Крестовики реально поехавшие:

      >> простыня из спецсимволов, реализующая простейшую хуйню с сомнительной надобностью
      > Сейчас работаю в месте, где всё скорее так, и очень доволен.
      Ответить
    • А в крестовой метушне как-нибудь можно сделать структуру на основе хуйни, которая принимает функция?
      Типа есть функция
      int shit (int a, float b, double c, char *d);


      и я такой
      struct shit_arguments
      {
        PUT_ARGS(shit);
      };

      и оно туда всунуло хуйню которая та функция принимает, и будет как:
      struct shit_arguments
      {
        int a;
        float b;
        double c;
        char *d;
      };
      Ответить
    • показать все, что скрытоvanished
      Ответить
    • вот такую говнину можно написать:
      #include <stdio.h>
      #include <stdlib.h>
      #define STD_FUNCTION(a, ...) typeof( a (*) (__VA_ARGS__) )
      
      
      int shit(int a, int b)
      {
        return a*b;
      }
      
      int main (void)
      {
        auto STD_FUNCTION(int, int) shit_carry1(STD_FUNCTION(int, int, int) func, int b);
        
        printf("7*8 = %d", shit_carry1(shit, 8)(7) );
        return 0;
        
      //                  ret   a                            ret   a    b
        auto STD_FUNCTION(int, int) shit_carry1(STD_FUNCTION(int, int, int) func, int b)
        {
          int shit_b(int a)
          {
            return func(a, b);
          }
          return shit_b;
        }
      }

      Правда я не уверен что тут нет UB
      Ответить
    • А захуй вообще этот ваш кари нужен? Какая от него польза?
      Ответить
    • https://pikabu.ru/story/khitro_10593846
      Ответить
      • Анекдоты конечно такие прямо как с анекдот.ру. Скуф бухгалтерше на пятничной пьянке такие анекдоты травит
        Ответить

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