1. Pascal / Говнокод #26502

    0

    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
    Type
      ONETWO = 1 .. 2;
    
    var I: ONETWO;
    begin
    	I:=1;
    	I:=I+1;
    	writeln(I); //2
    	I:=1+I;     
    	writeln(I); //3
    	inc(I);
    	writeln(I); //4
    	inc(I);
    	writeln(I);	//5
    end.

    https://ideone.com/mtmPPq
    Всё что нужно знать о продвинутой тупизации в «Паскале».

    Запостил: 3.14159265, 13 Марта 2020

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

    • Данный пример — моча в рожи сектантов пасцаля.
      Отребье годами блеяло, что у них там супер-типизация, ошибки ищет компилятор и никаких проблем нет. Но как всегда обделались.
      Ответить
    • Тут ещё вопрос, можно ли в «Пасцале» сделать wrap-around логику на енумах?

      type
        XT = (ONE,TWO); 
      var x: XT;
      begin
      	x:=ONE;
      	writeln(succ(x));
      	writeln(succ(x));//runtime exception

      Вообще хуйня полная. Там где я хочу иметь saturation arithmetic — получи wrap-around.
      Где я хочу иметь wrap-around — получи runtime error.
      Ответить
    • let me fix that for you
      https://ideone.com/kkuVbl
      Ответить
      • Ну какая-то магическая анскильная питушня.

        Почему succ для енумов бросает ошибку, а inc для subrange нет?

        А флага для wrap around для таких типов нет?
        Ответить
        • {$MAKE_XOPOWO ON}
          Ответить
        • > succ для енумов бросает ошибку, а inc
          На вопрос почему я уже не помню, но там была какая-то хрень с inc из-за которой вся эта защитная кокодогенерация не действовала.
          Ответить
          • >На вопрос почему я уже не помню, но там была какая-то хрень
            Вот именно что хрень.
            Во всех пасцалевских туториалах по енумам в пример приводятся дни недели, или месяцы:
            type TWeekDays = (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

            Я делаю succ(Sunday) и получаю блять, то чего ожидал меньше всего: ошибку и краш программы!
            https://ideone.com/uVCEcB
            Даже дети знают что после Sunday идёт Monday, а не Runtime error.
            Ответить
            • Зацикленных типов в «Паскале» нет, к сожалению. Нужно писа́ть свою функцию succ...

              function SuccMod(x: TWeekDays): TWeekDays;
              begin
                  if x = High(TWeekDays) then SuccMod := Low(TWeekDays) else SuccMod := Succ(x)
              end;
              Ответить
              • Раньше в паскале не было обобщённых функций, шаблонов и женериков.

                >function SuccMod(x: TWeekDays): TWeekDays;
                А можно написать для всех перечислений? Чтобы городить на каждый енум такое.

                Именно из-за подобных мелочей Паскаль производит впечатление сырого недоделанного говнища: кругое таскаем, квадратное катаем.
                Ответить
                • Обобщённое программирование в «FPC» и в «Delphi» в зачаточном состоянии.

                  1. Можно реализовать через RTTI (run-time type info). Однако, RTTI для скалярных типов не генерируется (для пирфоманса), поэтому енум нужно завернуть в класс. К тому же в этом случае проверка будет в рантайме, что слишком анскильно.

                  2. Типы Variant и array of const в качестве параметра аргумента функции не годятся, потому что они поддерживают либо базовые типы, либо классы, и не поддерживают кастомные енумы.

                  3. Генерики в данном примере не работают, потому что они слишком обобщённые. Если описать generic <T>, то он будет ожидать в качестве T произвольный тип, а не только перечислимый. Говно в функциях High, Low: для массива она вернёт не массив, а скаляр, т. е. тип результата не всегда совпадает с типом аргумента, поэтому High и Low нельзя использовать в генериках. Функции же Succ и Pred на генериках работают. Как ограничить генерик, чтобы запретить ему принимать массивы, я не знаю. Значит, нам нужен вменяемый заменитель функции High.

                  Как же реализованы функции High, Low, Succ, Pred в модуле System? Они используют хак, недоступный простым смертным. Костыль, который зовёт на помощь компилятор для определённых функций. Тот же костыль разворачивает вызов Write/Writeln с несколькими аргументами в несколько вызовов Write с одним аргументом. Чтобы добавить свою волшебную функцию, нужно патчить таблицу хаков.
                  Ответить
                • >А можно написать для всех перечислений?
                  А зачем? У каждого энума своя логика, не для всех зацикливание (да и вообще succ) имеет смысл.
                  Ответить
                  • Ну не копипастить же её для каждого такого енума?

                    В крестах, к примеру, можно написать эту функцию один раз. И дальше просто помечать нужные енумы соответствующим трейтом.
                    Ответить
                    • Приведи реальный пример кода.
                      Ответить
                      • Влом.

                        Если много крестушиться - можно разума лишиться. Если разума лишиться - нечем будет крестушиться.
                        Ответить
                      • ну типа он сделает экстеншен функцию для них, и в ней логику напишет.
                        В котлине я тоже так могу, например

                        enum class Foo {
                            MNDAY,
                            TUSDAY,
                            WNSDAY
                        }
                        
                        
                        fun <T : Enum<T>> cycle(value: T, values: Array<T>): T {
                            return if (value.ordinal == values.size - 1) values[0] else values[value.ordinal + 1]
                        }
                        
                        val Foo.next get():Foo = cycle(this, Foo.values())
                        
                        
                        fun main() {
                            println(Foo.MNDAY.next) //Tuesday
                            println(Foo.WNSDAY.next) //Monday
                            println(Foo.WNSDAY.next.next.next.next.next.next.next.next.next.next.next.next.next) //mndy
                        }
                        Ответить
                  • А зачем во всех туториалах демонстрируют перечислимые типы на примерах дней недели и месяцев в году?

                    type TWeekDays = (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);
                    
                    type TMonthType = (January, February, March, April,May, June, July, August, September, October, November, December);


                    https://wiki.lazarus.freepascal.org/Enumerated_types
                    https://wiki.freepascal.org/Subranges


                    Зачем? Зачем?
                    Ответить
                    • Датам зацикленный тип не поможет. Переход через границу года требует обновления года. После декабря нужно не только выставить январь, но и увеличить номер года.

                      А с днями месяца вообще беда: там сброс может происходить после 28, после 29, после 30, после 31 в зависимости от месяца, а иногда и от года. Как решать эту проблему? Вводить типы «дни января», «дни февраля простого года», «дни февраля високосного года»?
                      Ответить
                      • >Переход через границу года требует обновления года

                        Считаю, должны быть дальние даты, и ближние даты.
                        Угадаешь, чем они отличаются?
                        Ответить
                        • Намёк на дальние и ближние указатели. Ближний без сегмента.

                          А переключатель линии А20 будет, чтобы выбирать между зацикливанием и переполнением?
                          Ответить
                          • >Ближний без сегмента.
                            ну без года же.

                            Ближние даты будут перепрыгивать на 1-е января того же года, а дальне оргомные -- преворачивать год.

                            Да, и хардварный A20
                            Ответить
                      • > Вводить типы «дни января», «дни февраля простого года», «дни февраля високосного года»?
                        Какая-та уже компилтушня выходит, если продолжать. Календарь на шаблонах.
                        Ответить
                • Ты хочешь, чтобы компилятор Паскаля был в курсе всех концепций реального мира?

                  Тогда ещё круто было бы, чтобы

                  type TWeekDays = (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);


                  при ru локали, зато при en

                  type TWeekDays = (Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday);


                  because every pupil knows that week begins with/on Sunday
                  Ответить
                  • >pupil
                    Только для en_GB
                    для en_US всё таки student
                    Ответить
                  • >Тогда ещё круто было бы, чтобы
                    >type TWeekDays = (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);

                    Это не круто. Это дублирование кода.
                    Для локали можно просто задать начальный день недели.

                    >Ты хочешь, чтобы компилятор Паскаля был в курсе всех концепций реального мира?

                    Множество концепций реального мира сводятся к одной простой: конец — это новое начало.
                    А я всего-лишь прошу нормальный wrap around для кастомных типов.
                    Ответить
                    • Тут, во-первых, зачем тебе этот "нормальный wrap around", перечисление дней недели такой себе use case.

                      Во-вторых, видимо, по мнению авторов паскаля большее количество людей ожидает при инкременте последнего значения энама исключение.
                      Ответить
                • Попробовал сделать через RTTI и генерики, но обломался: в RTTI добавляются только свойства из секции published, а шаблонные свойства «FPC» публиковать не хочет, он публикует только конкретные.

                  {$mode objfpc}
                  uses
                    classes, typinfo;
                  
                  {$M+}
                  type 
                    generic Petuh<T> = class(TPersistent)
                    public
                      class function SuccMod(x: T): T; static;
                    private
                      mirror: T;
                    published
                      property enum: T read mirror write mirror; // Error: This kind of property cannot be published
                    end;
                  {$M-}
                  
                  class function Petuh.SuccMod(x: T): T;
                  type
                    SpecialPetuh = specialize Petuh<T>;
                  begin
                    if x = T(GetEnumNameCount(GetPropInfo(SpecialPetuh, 'enum')^.PropType) - 1) then 
                      Result := T(0)
                    else
                      Result := Succ(x);
                  end;
                  
                  type
                    TWeekDays = (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday);
                  
                    WeekPetuh = specialize Petuh<Tweekdays>;
                  
                  begin
                    Writeln(Ord(WeekPetuh.SuccMod(Monday)));
                    Writeln(Ord(WeekPetuh.SuccMod(Saturday)));
                    Writeln(Ord(WeekPetuh.SuccMod(Sunday)));
                  end.
                  Ответить
            • А с чего ты взял, что 255 + 1 == 0?
              Ответить
            • > Во всех пасцалевских туториалах по енумам в пример приводятся дни недели
              > во всех туториалах демонстрируют перечислимые типы на примерах дней недели
              Насчет всех ты обосрался, в американских туториалах первым мембером был бы зоннтаг.
              Ответить
    • Все современные ЯВУ — бездарная питушня.
      По сути ничего высокоуровневого в них нет.

      Например нигде нет нормальной арифметики, и примитивных типов которые не переполняются.

      Почти нигде нестандартных типов, в N бит. Везде надо дрочить clamp и проверять не переполнилось ли очередное арифметическое действие.

      А реально высокоуровневые вещи есть в ассемблере, типа комманд SSE
      paddsb - Adds 16 8bit integers with saturation.
      paddsw - Adds 8 16bit integers using saturation.
      Ответить
      • На Царей не угодишь.

        Если нет защиты от переполнения, то Цари ноют, что язык недостаточно высокоуровневый.

        Если защита от переполнения есть, то Цари ноют, что пирфоманс на 12,5% ниже, чем в божественной сишке.
        Ответить
      • Почему в ЯВУ не стали включать операции с сатурацией? Испугались, что кроссплатформенно сделать не получится и на процессорах без аппаратной сатурации просядет пирфоманс?
        Ответить
        • Наверное, посчитали, что в общем случае более интуитивным поведением будет сохранение хотя бы части «классического» поведения арифметических операций — той, в которой (x + y) - y == x.
          Ответить
          • Для обычных арифметических операций сатурация даже вредна. Сатурация вообще нужна в экзотических случаях. Например, она используется для вычисления цвета пикселей.

            Но для неё можно было бы ввести отдельные операторы. Есть же языки программирования, в которых для целочисленного деления и для деления в плавающих питухах разные значки.
            Ответить
            • Ну хз. Отдельный набор операторов для сатурационной арифметики — это ещё плюс четыре значка, как минимум (+, -, /, *). Лучше уж, ИМХО, ввести отдельные типы под неё — что-то вроде int_sat. Так, вдобавок, появляется возможность обобщённой сатурации: int_sat<-100, +200>.
              Ответить
              • Ну да, там ведь не только сложения, но и присваивание из бОльшего типа может вызвать сатурацию.
                Ответить
              • В общем я за отдельные типы: saturating<int> (с сатурацией), checked<int> (с исключением), twos_complement<int> (как в джаве) и unsafe<int> (как сейчас). Кому какая семантика нужна, пусть ту и юзает.
                Ответить
                • >unsafe<int> (как сейчас)
                  Он не unsafe.
                  uint8_t можно рассматривать как группу из 256 перестановок Галуа
                  Или modulo arithmetic с основанием 256.

                  Наоборот пасцалистам можно завезти safe<int>, который кидает в рантайме ошибки, при переполнении.
                  Ответить
                  • Заметь, что я знаковый int в примере юзаю. А он unsafe, ибо последствия от переполнения абсолютно непредсказуемы. Зато он быстрее предсказуемого twos_complement.

                    > safe

                    В моём примере он назван checked.
                    Ответить
                  • Там был еще {$Q+} который такое и делал
                    Ответить
              • З.Ы. Операторы с сатурнацией: =(-)=, =(+)=, =(*)= и =(/)=
                Ответить
            • >Для обычных арифметических операций сатурация даже вредна. Сатурация вообще нужна в экзотических случаях.

              https://arstechnica.com/tech-policy/2017/06/sorry-maam-you-didnt-win-43m-there-was-a-slot-machine-malfunction/
              Imagine, if you would, how absolutely giddy you'd be if you won a $43 million jackpot while playing a casino slot machine. You could burn a lot of bridges with that amount of cash.

              Then imagine the opposite feeling you'd get when the casino tells you there was a "malfunction" and you're not getting that jackpot, even though the slot machine lit up and said it was "printing cash ticket $42,949,672.76."

              That really happened in August 2016 to Katrina Bookman, who is now suing the Resorts World Casino in Queens County Supreme Court, demanding that she get her payout from the Sphinx slot machine.

              This isn't the first time a slot machine has malfunctioned, resulting in a gambler being denied serious cash. An 87-year-old Illinois woman gambling in Iowa had hit a nearly $42 million payout from the Hello Kitty slot machine. But she was denied payment because of a computer glitch.

              Iowa's top court ruled in 2015 the slot machine's user-agreement, available on the touchscreen, said the maximum payout was $10,000.

              "Any message appearing on the screen indicating the patron would receive a $41 million bonus was a gratuitous promise and the casino's failure to pay it could not be challenged as a breach of contract," the Iowa Court ruled.

              After news broke of Bookman's plight, the casino said in a statement that "Machine malfunctions are rare, and we would like to extend our apologies to Ms. Bookman for any inconvenience this may have caused." The New York State Gaming Commission has sided with the Resorts World Casino, ruling the there was "clearly a display malfunction" and that the machine's maximum payout was programmed for $6,500. The slot machine was fixed and operating the following day.


              Какое переполнение )))
              Ответить
              • -20 центов что ли это число означает?
                Ответить
              • Кстати, в osu на некоторых очень длинных и быстрых картах счёт может переполниться и уйти в минус.

                Какой знаковый int )))
                Ответить
                • В четырнадцатой фикалочке вообще для хила и дамага был int16. Уже после второго экспаншена случилось ОЙ.
                  https://www.reddit.com/r/ffxiv/comments/58nc1e/critical_healing_values_and_potions/
                  Ответить
                • Блядь, блядь, блядь

                  Меня всегда интересовало, почему size/count/length во всех известных мне языках возвращает знаковый int? Ну хер там с индексом, я ещё могу понять, но как размер может быть отрицательным?
                  Ответить
                  • > почему size/count/length во всех известных языках возвращает знаковый int?

                    Почему во всех? Только в анскильных.
                    В жабе других просто нету. Шарп слизали с жабы.

                    В божественных сишках и крестах есть size_type.
                    Member type size_type is an unsigned integral type.

                    According to the 1999 ISO C standard (C99), size_t is an unsigned integer type of at least 16 bit (see sections 7.17 and 7.18.3).

                    size_t is an unsigned data type defined by several C/C++ standards, e.g. the C99 ISO/IEC 9899 standard, that is defined in stddef.h.1 It can be further imported by inclusion of stdlib.h as this file internally sub includes stddef.h.

                    This type is used to represent the size of an object. Library functions that take or return sizes expect them to be of type or have the return type of size_t. Further, the most frequently used compiler-based operator sizeof should evaluate to a constant value that is compatible with size_t.

                    size_t is a type guaranteed to hold any array index.
                    Ответить
                    • Я опечатался. Добавил уже, что мне известных.

                      Кроме как тяжёлым наследием сижки это никак не объясняется, ну я так и думал, в принципе.

                      Я окончательно запутался
                      Ответить
                      • >тяжёлым наследием сижки

                        Наоборот же: в сишке всё хорошо сделали. Типы возвращаемые size беззнаковые.
                        Кресты это унаследовали.
                        В остальных же языках — говно.
                        Ответить
                        • Вообще местами всё очень странно.

                          Например, в обжектив си [NSArray count] возвращает NSUInteger (https://developer.apple.com/documentation/foundation/nsarray/1409982-count?language=objc), а в Свифте ВНЕЗАПНО уже Int (https://developer.apple.com/documentation/foundation/nsarray/1409982-count)

                          Пиздец консистентность
                          Ответить
                          • На самом деле всё логично.

                            >в обжектив си [NSArray count] возвращает NSUInteger

                            Потому что это в первую очередь «си». А в «си» как уже сказано выше: unsigned.
                            Ответить
                            • А потом в середине 2010-ых что-то стрельнуло в голову и решили в той же инфраструктуре поменять знаковость? Логично, да.
                              Ответить
                              • А Int в Swift signed?
                                Получается, что раньше можно было более большие массивы иметь?:)

                                В джаве вот нету unsigned: считалось, что не нужно нагружать java программистов такими сложными и непонятными большинству из них концепциями.

                                Но потом ввели элегантное решение, вполне в духе джавы
                                https://docs.oracle.com/javase/8/docs/api/java/lang/Integer.html#compareUnsigned-int-int-
                                Ответить
                                • > compareUnsigned
                                  Пиздец, конечно. Странно, что не завезли фабрику компараторов.
                                  Ответить
                                • Ну да, signed. Есть ещё UInt, разумеется.

                                  Более большие массивы да, только в те лохматые годы, когда писался Foundation, в ходу были 32 и даже 16-битные рахитектуры, так что в 2014-ом никто не заметил подмены
                                  Ответить
                                • https://books.google.com.ua/books?id=LATVBQAAQBAJ&pg=PA11&lpg=PA11&d q=swift+nsuinteger+and+array+count&sourc e=bl&ots=QVzW9Lb_ev&sig=ACfU3U0zu66ENM2R 1Kg_qSptkf4rUlW3Tw&hl=uk&sa=X&ved=2ahUKE wj82PjkzZfoAhXKo4sKHcgFAoQQ6AEwA3oECAgQA Q#v=onepage

                                  This helps you avoid converting to convert one Int type to another. Apple has modified classes to follow this guideline.

                                  Ненуашо
                                  Ответить
                                  • Ну блядь, я бы понял, если можно было делать обращение по отрицательному индексу (зачем-то), но сука же ж:

                                    let a = [1, 3, 4]
                                    a[-1]


                                    Sosi fatal pisos: Index out of range
                                    Ответить
                                    • То ли дело пистон!

                                      Кстати, в сишке в файлушне позиции в файле знаковые. Это значит, что в число, обозначающее позицию, вставлено однобитовое число со счётчиком ошибок. И функции могут возвращать код козврата, пока они возвращают значение.
                                      Ответить
                                    • То ли дело «Python»!
                                      >>> arr = [1, 2, 3, 4, 5]
                                      >>> arr[-1], arr[-2], arr[-3]
                                      (5, 4, 3)


                                      А профессионалы упоротые делают вот так:
                                      >>> arr = [1, 2, 3, 4, 5]
                                      >>> arr[0], arr[2], arr[4]
                                      (1, 3, 5)
                                      >>> arr[~0], arr[~2], arr[~4]
                                      (5, 3, 1)
                                      Ответить
                                      • Да, у пистона есть отрицательный индекс, и это одна из многих неинтуитивных и непонятных нормальным людям конструкций в этом запутанном и странном языке
                                        Ответить
                                        • Хз, по-моему, именно [-1] как раз достаточно интуитивен: [-1] <- [0] -> [1]. Хотя, возможно, это я просто привык.

                                          А вот хак с битовым отрицанием — это пиздец, конечно. Причём, ЧСХ, для посвящённых оно выглядит максимально интуитивно: просто нумерация массива в обратном порядке, [~0] — первый элемент с конца, [~1] — второй элемент с конца, etc. У меня даже иногда возникают порывы вместо разворота массива проходиться по нему таким вот способом, но приходится их давить — не поймут-с :(.
                                          Ответить
                                          • Не знаю что унтутивного в закольцованности списка, может я анскилен просто
                                            Ответить
                                            • Ну а какой ещё элемент может стоять перед начальным?
                                              Ответить
                                              • эррей аут оф баундс там стоять должегн

                                                Впрочем, в перле, руби, и питоне всё работает именно так, как ты сказал. А в жабаскрипте там undefined
                                                Ответить
                                                • >А в жабаскрипте там undefined
                                                  var arr=[1,2,3]
                                                  arr[-1]='undefined'
                                                  Ответить
                                                  • > [1,2,3][-1] === undefined
                                                    true
                                                    Ответить
                                                    • Я к тому что в жс, можно случайно обнаружить элементы за началом массива.
                                                      Ответить
                                                      • > let foo = [1,2,3];
                                                        undefined
                                                        > foo[-1] = 'lol';
                                                        'lol'
                                                        > foo[-1];
                                                        'lol'
                                                        > foo.length
                                                        3
                                                        >


                                                        блядь

                                                        Из за тебя я теперь знаю такой пиздец((
                                                        Ответить
                                                      • > let js = [];
                                                        undefined
                                                        > for (let i = 1; i < 1000; i++){
                                                        ... bar[i * -1] = 'a';
                                                        ... }
                                                        'a'
                                                        > bar.length;
                                                        1
                                                        > bar[-22];
                                                        'a'


                                                        зачем? зачем?!
                                                        Ответить
                                                        • Всё просто. Элементы с целыми неотрицательными индексами хранятся в массиве, остальные - на массиве.

                                                          https://bigpicture.ru/wp-content/uploads/2016/03/big_india1.jpg
                                                          Ответить
                                      • В «.NET Core 3»/«C# 8» кстати тоже завезли индекс с конца.
                                        var arr = new[] { 1, 2, 3, 4, 5 };
                                        Console.WriteLine((arr[^1], arr[^2], arr[^3])); //(5, 4, 3)
                                        Ответить
                                • > В джаве вот нету unsigned: считалось, что не нужно нагружать java программистов такими сложными и непонятными большинству из них концепциями.

                                  Так и не нужна эта питушня. Очень мало ситуаций, когда ты упираешься именно в один бит, и расширение числа на этот бит как-то надолго спасёт.

                                  За счёт питух-кода операции над теми и другими интами одинаковые, цари могут написать библиотеку по интерпретации знакушни как беззнакушни.

                                  А нормальные люди не будут себе трахать мозг лишними кастами-хуястами.
                                  Ответить
                                  • > Очень мало ситуаций
                                    Любая криптушня, любая работа с бинарными данными — это всё unsigned. Это далеко не «очень мало», что и подтверждают разработчики «Java», добавившие анскильный compareUnsigned.
                                    Ответить
                                    • Сёма спрашивает какому проценту жавоебов надо иметь дело с бинарными данными и криптушней?
                                      Ответить
                                    • Почему? Это работа с битами. Если битовый сдвиг не косплеит арифмушню, всё будет работать.
                                      Ответить
                                      • Во-первых, семантика: видеть отрицательные числа там, где по определению идёт работа в поле [0; 2^N) — костыльная питушня. Во-вторых, сравнения.
                                        Ответить
                                        • > видеть отрицательные числа там, где по определению идёт работа в поле [0; 2^N) — костыльная питушня.
                                          видеть неотрицательные числа там, где по определению идёт работа в поле [-2^(N-1); 2^(N-1)-1) — костыльная питушня.

                                          В криптушне и бинушне обычно используются числа [0, 2), а они влезают в переменную.

                                          > сравнения
                                          -1 == 1 // работает
                                          0 == 1 // работает
                                          -1 != 1 // работает

                                          Операторы сравнения криптушни/бинушни работают, если числа отрицательные. Всё нормально.
                                          Ответить
                                          • > в поле [-2^(N-1); 2^(N-1)-1)
                                            А я и не предлагаю все инты заменять на беззнаковые. Там, где используются отрицательные числа, нужно использовать знаковые типы. Там, где отрицательных чисел быть попросту не может, надо использовать беззнаковые.

                                            > В криптушне и бинушне обычно используются числа [0, 2)
                                            Нет. Хэши, различные ГПСЧ в большинстве случаев используют именно [0; 2^N).

                                            > Всё нормально.
                                            А потом ты делаешь x < y и получаешь эпичный багор.
                                            Ответить
                                            • > ты делаешь x < y и получаешь эпичный багор

                                              Только потому что в няшной и крестах дрочили на пирфоманс и заботливо разложили грабли, кастуя signed int в unsigned int...

                                              В более безопасном языке можно раскрывать signed < unsigned во что-то в духе signed < 0 || signed < unsigned и всё будет вполне интуитивно.
                                              Ответить
                                              • В «Java» нет никаких «unsigned», именно поэтому…
                                                Ответить
                                              • Меня, кстати, удивляет, что конпелятор на x <= 0 или x < 0 для unsigned начинает плеваться предупреждениями и вместо надёжного кода даёт писать какую-то хрупкую питушню.
                                                А что если я переделаю unsigned в signed?
                                                Ответить
                                                • Это что за анскильный конпелятор такое говорит? Я в крестах всегда «<=» пишу, ворнингов не видел.
                                                  Ответить
                                                  • GCC такое говорит
                                                    Ответить
                                                    • Проверил, на «<=» молчит: https://gcc.godbolt.org/z/s3Y_Kh.
                                                      А вот на «< 0» бурчит про «expression is always false», но, в принципе, его понять можно, потому что это действительно с равной вероятностью может быть как перестраховка программиста, так и его же ошибка.
                                                      Ответить
                                            • Нормальные ГПСЧ выдают действительное число от 0 до 1. Вы что, методичку по методам Монте Карло не читали?

                                              В криптушне и битушне абстракции настолько далеки от реальности, что сила ремаппинга высока и там одинаково подходят как знаковые, так и беззнаковые числа.
                                              Ответить
                                              • > Нормальные ГПСЧ выдают действительное число от 0 до 1.
                                                Это питушарские анскильные ГПСЧ.

                                                >> Если я использую гаммирование/сдвиг/преестановку битов в криптушне, я использую операции с данными как они есть, а не с числами.
                                                А я говорю о семантике. Если я сдвигаю неотрицательное число влево — я ожидаю получить неотрицательное число, а не какую-то хуйню с минусом.
                                                Ответить
                                                • > Это питушарские анскильные ГПСЧ.
                                                  Это абстрактные математические ГПСЧ, используемые для описания всех достойных алгоритмов.

                                                  > Если я сдвигаю неотрицательное число влево
                                                  А в криптушне сдвигаются не числа, а биты. Для чисел же либо нужна длинная арифметика, либо отрицательный хвост не мешает, достаточно не использовать отрицашню.
                                                  Ответить
                                                  • Математику изучают только в рашке. Я использую «Mersenne Twister» и теку. Плавающие питухи не нужны.

                                                    Я в третий раз повторяю: семантика! Чтение, отладка, вывод, сериализация, передача, сохранение.
                                                    Использование знаковых питухов для беззнаковых задач — это лютый костыль. Да, он даёт правильные результаты (пока не начнёшь сравнивать через «<»). Да, его можно использовать. Но нахуя, когда есть гораздо более удобный и семантичный инструмент?
                                                    Ответить
                                                    • >Использование знаковых питухов для беззнаковых задач — это лютый костыль.

                                                      Я вот никак не могу понять почему хеш, ГСПЧ или крипто стали вдруг беззнаковой задачей?

                                                      Генерирация случайного числа в диапазоне [-128,128) — это что-то противозаконное?

                                                      А про крипту, 1024-- правильно говорит, что важны сами биты.

                                                      Любой int в крипте считается не числом, но массивом бит.
                                                      Ответить
                                                      • Да уж хеш точно содережит не цифры, а байты
                                                        Ответить
                                                      • > Генерирация случайного числа в диапазоне [-128,128) — это что-то противозаконное?
                                                        Генерировать ГПСЧ может что угодно. Важно, что внутри у него — беззнаковые числа из кольца [0; 2^N).

                                                        > важны сами биты
                                                        Да. И поэтому иметь тридцать один нормальный бит и ещё один, который внезапно интерпретируется совершенно по-другому — ущербный костыль.

                                                        > Любой int в крипте считается не числом, но массивом бит.
                                                        …до тех пор, пока не понадобится его сравнить или сдвинуть вправо. Это, кстати, хороший детектор костыля: если всё работает почти правильно, проёбываясь только на каких-то «незначительных» мелочах — с большой вероятностью мы имеем перед собой костыль.

                                                        И да, я в четвёртый раз повторюсь: семантика. Программы не существуют как обособленные сферические исходные коды в вакууме. Программы кто-то пишет, программы кто-то читает, программы кто-то отлаживает. Программы что-то пишут: в лог, в вывод, в конфиг, программы обмениваются данными по сети. Чем больше в программе элементов, которые означают не то, чем они являются (как знаковый питух, прикидывающийся беззнаковым), тем более она говно.

                                                        Реальный пример говна:
                                                        The program 'huj.exe' has exited with code -1073741819
                                                        Ответить
                                                        • >…до тех пор, пока не понадобится его сравнить или сдвинуть вправо

                                                          Для сдвига в яве с первых версий есть >>>

                                                          А зачем в крипте их сравнивать на больше/меньше — ума не приложу.

                                                          >Программы что-то пишут: в лог, в вывод, в конфиг, программы обмениваются данными по сети.

                                                          Тоже повторюсь: это массив бит. Криптовое говно никто в здравом уме не печатает в десятичных. Их печатают в хексах или побитово.

                                                          >The program 'huj.exe' has exited with code 1073741819
                                                          Если бы там было 3073741819 стало бы сильно лучше?
                                                          Ещё раз: hex или побитовый вывод.
                                                          Печатать побитовые массивы в десятичных числах — анскилл и безумие.
                                                          Ответить
                                                          • > Для сдвига в яве есть >>>
                                                            Об этом я и говорю: эмулирование беззнаковых чисел знаковыми питухами — костыль, который для нормальной работы требует ещё больше костылей типа этого. Кстати, это до боли напоминает жабаскриптовские и пхпшные «==»/«===».

                                                            > А зачем в крипте их сравнивать на больше/меньше — ума не приложу.
                                                            А беззнак нужен не только в крипте, это просто удобный реальный пример. Очевидно, если бы сравнение беззнаковых чисел было никому не нужно — никто и не делал бы ущербный compareUnsigned().
                                                            Ответить
                                                            • >костыль, который для нормальной работы требует ещё больше костылей типа этого

                                                              Нет. Не больше. На самом деле отказ от беззнаковых всё значительно упростил.

                                                              >>> это единственное что долгие годы связывало жабу с беззнаковым миром.

                                                              Костыль — это иметь 2 миллиона стандартных типов и кучу ёбнутных правил для неявных и полуявных конвертаций между собой.

                                                              >никто и не делал бы ущербный compareUnsigned()

                                                              Его сделали аж в 8ой итерации, по принципу: «чего бы ещё впихнуть» . В принципе ни разу не видел, чтобы кто-то им пользовался.
                                                              Ответить
                                                              • > Нет. Не больше.
                                                                1 > 0. А с восьмой джавы — 2.

                                                                > Костыль — это иметь 2 миллиона типов и кучу ёбнутных правил для конвертации между собой.
                                                                С тем же успехом можно заявить, что типы вообще не нужны, инта хватит всем. А массив — единственная нужная структура данных.
                                                                Ответить
                                                                • >Об этом я и говорю: эмулирование беззнаковых чисел знаковыми питухами — костыль

                                                                  >>> даже не эмулирование беззнаковых, а больше работа с числом как с массивом бит.

                                                                  >типы вообще не нужны, инта хватит всем. А массив — единственная нужная структура данных.

                                                                  А я это и так постоянно говорю :)
                                                                  К тому же инт — сам по себе массив бит.
                                                                  Потому инты являются частной формой массива.
                                                                  Ответить
                                                                  • > даже не эмулирование беззнаковых, а больше работа с числом как с массивом бит.
                                                                    >>> И поэтому иметь тридцать один нормальный бит и ещё один, который внезапно интерпретируется совершенно по-другому — ущербный костыль.

                                                                    > А я это и так постоянно говорю :)
                                                                    Это не ты, это царескрипт за тебя говорит.
                                                                    Ответить
                                                                    • Для криптухи и хешей эти compareUnskilled (int,int) compareUnskilled (long,long) вообще бесполезны.

                                                                      Поскольку в яве хеши и остальное это тупо массивы байт.

                                                                      А интерпретировать массив битов, как децимал число повторюсь безумие.

                                                                      > который внезапно интерпретируется совершенно по-другому — ущербный костыль

                                                                      В жабе фактически всегда было только 2 интерпретации чисел: как знаковое и как массив бит.
                                                                      В массиве все биты равноправны.

                                                                      >>> оператор сдвига массива бит.
                                                                      Ответить
                                                                      • > Для криптухи и хешей эти compareUnskilled (int,int) compareUnskilled (long,long) вообще бесполезны.
                                                                        А для каких-нибудь бигинтов?

                                                                        > В жабе фактически всегда было только 2 интерпретации чисел: как знаковое и как массив бит.
                                                                        В жабе есть только одна интерпретация чисел: как знакового питуха. «compareUnskilled», «>>>» — это просто костыли, ничем не отличающиеся от «===».
                                                                        Ответить
                                                              • > Костыль — это иметь 2 миллиона стандартных типов и кучу ёбнутных правил для неявных и полуявных конвертаций между собой.

                                                                > saturating<int> (с сатурацией), checked<int> (с исключением), twos_complement<int> (как в джаве) и unsafe<int>

                                                                - как можно в одном треде топить за взаимоисключающие параграфы))
                                                                Ответить
                                                                • > как можно в одном треде топить за взаимоисключающие параграфы))
                                                                  Это ГК, привыкай.

                                                                  А вообще, нет неявных преобразований — нет кучи ёбнутых правил.
                                                                  Ответить
                                                                • > - как можно в одном треде топить за взаимоисключающие параграфы))

                                                                  bormand в http://govnokod.ru/26502#comment533554 написал:
                                                                  > В общем я за отдельные типы: saturating<int> (с сатурацией), checked<int> (с исключением), twos_complement<int> (как в джаве) и unsafe<int> (как сейчас). Кому какая семантика нужна, пусть ту и юзает.

                                                                  3.14159265 в http://govnokod.ru/26502#comment533877 написал:
                                                                  > Костыль — это иметь 2 миллиона стандартных типов и кучу ёбнутных правил для неявных и полуявных конвертаций между собой.

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

                                                                    Не совсем.
                                                                    Я говорю: из коробки не стоит лепить много базовых типов. Их должна быть самая малость. Самых необходимых для реализации стандартной либы. И с продуманной системой конверсии туда-сюда.

                                                                    Однако должен быть удобный конструктор, которым я смогу настрогать себе произвольный тип. Написанное бормандом, я рассматриваю как конструктор.
                                                                    Ответить
                                                                  • Из обсуждения показалось, что оба утверждения принадлежат одному человеку.

                                                                    И да, ходил только на личный форум, потому предъявите документы, прописку, результаты теста на коровавирус и справку о прохождении натализации.
                                                                    Ответить
                                                                    • Так я полностью согласен с бормандом.

                                                                      Просто typedef PLAYER_HP saturated<int8>[0,100] — это явно пользовательский тип с шаблонами и питушнёй.

                                                                      А вот базовых я бы сделал поменьше.

                                                                      Это же зоопарк ебаный
                                                                      signed type	unsigned type	
                                                                      intmax_t	uintmax_t	
                                                                      int8_t		uint8_t	
                                                                      int16_t 	uint16_t
                                                                      int32_t 	uint32_t
                                                                      int64_t 	uint64_t
                                                                      int_least8_t	uint_least8_t	
                                                                      
                                                                      int_least16_t	uint_least16_t
                                                                      int_least32_t	uint_least32_t
                                                                      int_least64_t	uint_least64_t
                                                                      int_fast8_t	uint_fast8_t	
                                                                      
                                                                      int_fast16_t	uint_fast16_t
                                                                      int_fast32_t	uint_fast32_t
                                                                      int_fast64_t	uint_fast64_t
                                                                      intptr_t	uintptr_t


                                                                      https://www.cplusplus.com/reference/cstdint/

                                                                      Вот в сишке нет базового типа: трёхбитный int, но его можно легко сделать через struct.

                                                                      А в жабе его тоже нет. Но сделать сложнее. Так вот нужно, чтобы нужный тип было просто сделать, но не нужно иметь говно в списке базовых.
                                                                      Ответить
                                                                • > это иметь 2 миллиона стандартных типов и кучу ёбнутных правил для неявных и полуявных конвертаций между собой

                                                                  Тут нужно пояснить. Не можешь сделать нормальную систему типов — не мучай жопу.

                                                                  Лучше никак, чем хуёво. В Java сделали никак. И это лучше, чем хуёво в С++.

                                                                  > saturating<int> (с сатурацией), checked<int> (с исключением), twos_complement<int> (как в джаве) и unsafe<int>

                                                                  Мне это виделось как принципиально разные типы. И в целом редкоиспользуемые штуки, а не базовые примитивы языка.

                                                                  Типа BigDecimal в жабе или классов Ratio, Complex.
                                                                  Ответить
                                            • > А я и не предлагаю все инты заменять на беззнаковые. Там, где используются отрицательные числа, нужно использовать знаковые типы. Там, где отрицательных чисел быть попросту не может, надо использовать беззнаковые.

                                              Интересно сделали с char. Он вроде как символ, поэтому о знаке говорить бессмысленно, что и отразили в стандарте.

                                              Если я использую гаммирование/сдвиг/преестановку битов в криптушне, я использую операции с данными как они есть, а не с числами.
                                              Ответить
                                      • >Если битовый сдвиг не косплеит арифмушню, всё будет работать.
                                        Причём, напомню в java/javascript извечно был особый тип сдвига >>> для unsigned чисел.
                                        Ответить
                                  • >Так и не нужна эта питушня. Очень мало ситуаций, когда ты упираешься именно в один бит, и расширение числа на этот бит как-то надолго спасёт.

                                    >А нормальные люди не будут себе трахать мозг лишними кастами-хуястами.


                                    Поддерживаю.
                                    Ответить
                                  • >Очень мало ситуаций, когда ты упираешься именно в один бит, и расширение числа на этот бит как-то надолго спасёт.

                                    Опытные крестовики (в т.ч. Роман на ГК) неоднократно сообщали мне что отсутствие питушни с signed/unsigned это благо, а не проблема.

                                    Это раз.
                                    Сплошной кусок памяти в 2 гига — говно.

                                    Это два.

                                    Да и физически он вряд ли он будет последовательным. Из-за фрагментации памяти.
                                    * Такие объемы могут быть полезны в случае виртуальной памяти, или memory mapped files. Но это не тот случай.
                                    Ответить
                    • Ага. А потом варнинги вылезают типа signed unsigned mismatch при сравнении. И я не могу обычный int использовать, для того чтобы просто указать количество чего-то - нужно думать, будет ли это соответствовать размеру какого-нибудь массива, и не нужно ли использовать size_t.
                      Либо уж size_t и index_t (потому что индекс может быть и -1) сделать несовместимыми с int и разрешить только явные касты.
                      Ответить
                      • Если так подумать, а зачем тебе использовать знаковый тип для количества.
                        Ответить
                    • C#, конечно, слизали с жабы, но uint там есть, в отличие от. Но вот в API его не используют, потому что он не является CLS-совместимым.
                      Ответить
                      • А в C# сравнение int и uint адекватно работает?
                        Ответить
                        • > int x = -100;
                          > uint y = 100;
                          > x < y
                          true
                          > x == y
                          false

                          Или ты что-то другое подразумеваешь?
                          Ответить
                          • > -100 < 100 вывело true

                            Ну значит нормально.
                            Ответить
                          • При срании знакового и бес знакого разве не плюется ворнингом и не расширяет операнды?
                            Ответить
                            • Нет, если только беззнаковый целый не ulong.
                              Ответить
                              • Т.е. тупо пытается свести типы к long'у?
                                Ответить
                                • Ага. Для сравнения short/ushort к int.
                                  https://github.com/dotnet/csharplang/blob/master/spec/types.md#integral-types
                                  > For the binary +, -, *, /, %, &, ^, |, ==, !=, >, <, >=, and <= operators, the operands are converted to type T, where T is the first of int, uint, long, and ulong that can fully represent all possible values of both operands. The operation is then performed using the precision of type T, and the type of the result is T (or bool for the relational operators). It is not permitted for one operand to be of type long and the other to be of type ulong with the binary operators.
                                  Ответить
                                  • Ну и заебись сделали, одобряю. Именно поэтому я за «C#».
                                    Ответить
                          • А если -100 > 4294967096 (ну или 18446744073709551416, если 64 бит)?
                            Ответить
                            • В первом случае нет никаких проблем
                              > int a = -100;
                              > uint b = 4294967096;
                              > a > b
                              false

                              А вот второй:
                              > long a = -100;
                              > ulong b = 18446744073709551416;
                              > a > b
                              (1,1): error CS0034: Operator '>' is ambiguous on operands of type 'long' and 'ulong'

                              Какой багор )))
                              UInt64 нельзя сравнивать со знаковыми целыми, зато с десималами-флоатами можно:
                              > (decimal)a > b
                              false
                              > (float)a > b
                              false

                              Ну и конечно же, да:
                              > (ulong)a > b
                              true
                              Ответить
                    • >> Шарп слизали с жабы.

                      В Калифорнии запрещено вето харам слизывать с жаб.

                      Дело в том, что на юго-западе США водится колорадская жаба (Incilius alvarius), околоушные железы которой выделяют мощный галлюциноген, действие которого похоже на ЛСД.

                      https://ru.wikipedia.org/wiki/Колорадская_жаба
                      Ответить
                      • налижутся жаб, и ипут друг друга в жопы

                        >Колорадская жаба
                        какой украинизм :))
                        Ответить
                        • >> A 2010 study utilized a mass spectrometry approach to detect levels of bufotenin in the urine of individuals with severe autism spectrum disorder (ASD), schizophrenia, and asymptomatic subjects. Their results indicate significantly higher levels of bufotenin in the urine of the ASD and schizophrenic groups when compared to asymptomatic individuals.

                          Такие дела.
                          Ответить
                  • https://www.freepascal.org/docs-html/rtl/system/length.html

                    Length -- Returns length of a string or array.
                    function Length(  S: AStringType ):SizeInt;

                    https://www.freepascal.org/docs-html/rtl/system/sizeint.html
                    SizeInt is used to describe sizes of structures in FPC using a signed integer.
                    И эти люди хвастались что у них продвинутая типизация.

                    Какой позор )))
                    Ответить
                    • Этот позор — следствие обратной совместимости. Функции для поиска чего-нибудь в строке возвращали «минус адын», если не могли ничего найти. Ради этого «минус адын» и взяли знаковый тип.
                      Ответить
                      • >Ради этого «минус адын» и взяли знаковый тип.

                        Так а что мешало оставить сигнатуры для поиска знаковыми, а Length поменять на беззнаковое?
                        Ответить
                        • Потому что из-за этого начнутся сравнения и касты между числами разной знаковости. И лучше уж ограничение на 2 гига и проверка на отрицательность, чем это...
                          Ответить
                          • В qt кстати даунгрейднулись обратно на int.

                            А в целом, свои взгляды на индексацию массивов и строк я уже высказывал здесь:
                            https://govnokod.ru/25987#comment512968

                            Возвращаемый тип должен выводиться компилятором и быть [0,length)
                            Ответить
                            • >быть [0,length)

                              Соответственно всякие substring, slice и array[index] должны принимать этот тип [0,length).

                              Поскольку длина массива/строки фиксирована, типы можно выводить на этапе компиляции и рантайм проверки не нужны.
                              Ответить
                        • Тяжёлые наркотики.

                          Может быть, отрицательные значения зарезервировали на случай, когда нужно вернуть ошибку? Хотя это говно, потому что каждый раз придётся проверять неотрицательность результата. Логичнее было бы возвращать ноль и кидать исключения.
                          Ответить
                      • Лишнехромосомный, в пассале сроки 1-басед, поэтому результат нихуя == 0, а твои порядком подзаебавшие познания в старом говне опять под себя.
                        Ответить
                    • Все правильно, самый базовый тип должен быть знаковым вне зависимости от всякого.
                      Ответить
                  • Тарас некогда писал, что это удобно.
                    В частности, становится тривиальным обратный обход массива циклом с предусловием.
                    Ответить
                    • >В частности, становится тривиальным обратный обход массива циклом с предусловием.
                      Это как?

                      Зачем тут знаковость?
                      for (uint i=size; i--> 0 ;)
                      Ответить
                      • Интересно. Тут сравнение с побочным эффектом. Т. е. до сравнения мы производим некоторые действия (декремент счётчика). Если переписать на чистые (по отношению к счётчику) функции, то это ни предусловие, ни постусловие. Это цикл общего вида:
                        for(uint i= size;;) {
                        i--;
                        if (i<=0) break;
                        ...
                        Ответить
                      • Да, действительно. Я думал, совсем пердолинг будет, а тут даже короче, чем обычный for.
                        Но тут одновременно -- и > - тонкая питушня, спасает только идеоматичность.
                        Ответить
        • >ЯВУ
          >на процессорах без аппаратной сатурации просядет пирфоманс
          >кроссплатформенно сделать не получится

          ЯВУ — язык высокого уровня.
          Пиздец тогда.

          >Почему в ЯВУ не стали включать длинную арифметику? Испугались, что кроссплатформенно сделать не получится и на процессорах без аппаратной сатурации просядет пирфоманс?
          Ответить
          • Имхо, все нынешние ЯВУ - говно. Ибо они смешивают в кучу абстрактные типы данных (число от 0 до 255) и их физическое представление (uint8_t).

            Поэтому, если бы я проектировал свой язык, я бы разделил эти концепции. Тогда можно вообще не указывать physical layout для типа, и пусть конпелятор сам пердолится с реализацией, даже если ему придётся длинную арифметику заюзать. А можно наоборот - указать несколько physical layout'ов для типа и юзать их в местах где нужен пирфоманс или маппинг...
            Ответить
            • >Имхо, все нынешние ЯВУ - говно. Ибо они смешивают в кучу абстрактные типы данных
              Так и есть.

              >Поэтому, если бы я проектировал свой язык
              То я бы начал с базовых понятий алгебры: кольца и поля.
              Потом на основании поля я бы ввёл типы с модульной арифметикой [0,256) и дал возможность выбора их поведения.

              >за отдельные типы: saturating<int> (с сатурацией), checked<int> (с исключением), twos_complement<int> (как в джаве) и wrapped<int> (c переполнением)

              Потом для wrapped<int> я бы ввёл группы подстановок Галуа.
              Допустим 1-битный тип может быть [0,1]. А может быть [1,2]
              Любой сдвиг в принципе. [123,124]
              Или тип с 256 значениями может быть [-128,128), а может быть [0,256)

              Соответственно наиболее частоиспользуемые типы были бы явно определены в стандартной либе как диапазон значений с понятной семантикой переполнения.

              Но при желании кодер мог бы задать свой тип: typedef ONETWO wrapped<int> [1..2]
              Ответить
              • Такой язык программирования не будет популярен за пределами СНГ, потому что математику изучают только в рашке.
                Ответить
                • Эти концепты будут по большей части под капотом.

                  >не будет популярен за пределами СНГ, потому что математику изучают только в рашке
                  Какой Сёма )))
                  Ответить
              • эмм.. а поддержка json там в стандартной библитеке будет??
                Ответить
                • И это... поддержка SMB будет?
                  Ответить
                • >а поддержка json там в стандартной библитеке будет??

                  [0,255] — это же закрытый интервал.

                  Можно сочинить какую-то compile-time перегрузку [a,b] = (a-1,b+1)

                  Полуоткрытые нельзя будет сделать. Но для дискретных целых не особо нужно.
                  Ответить
                  • да, в json все массивы закрытые, потому что с квадратной скобочкой
                    а с круглой были бы открытые

                    а там можно будет написать бота вконтакте??
                    Ответить
              • > наиболее частоиспользуемые типы были бы явно определены в стандартной либе
                Это язык зожатия вореций. Все кобенации кода собераются, зожимаются эффективно коэффициенты 1 2 3 вставляются в стандарт. Код на таком языке после перевода с C++ становится короче, чем при переводе на "винрар".
                Ответить
      • >и примитивных типов которые не переполняются
        а что они должны делать? быть бесконечными, как в реале?
        Ответить
        • Да. А потом, чтобы с этой бородой работать, они изобретут ленивость. А потом окажется, что ленивость и производительность вместе за ручку не ходят. А потом...
          Ответить
          • В общем я знаю только два стула: на одном летит "OverflowException", на другом типы тупо переполняются.
            Ответить
        • >а что они должны делать?
          Тред не читай — сразу отвечай.

          >я за отдельные типы: saturating<int> (с сатурацией), checked<int> (с исключением), twos_complement<int> (как в джаве) и unsafe<int> (как сейчас). Кому какая семантика нужна, пусть ту и юзает.
          Ответить
          • Понятно, спасибо.

            У ГК неудобный интерфейс, я правда не увидел твое сообщение. Я согласен с этим подходом, правда такого не видел, и пока не очень понятно, какие могут быть с этим проблемы
            Ответить
            • >пока не очень понятно, какие могут быть с этим проблемы

              Сложность в реализациях компиляторов. Но это фигня, в сравнении с modern C++.

              А если какие-то экзотические диапазоны, тогда конвертация вереницы этих типов туда-сюда.
              Неявные касты — источник багров.
              Явные преобразования — черезчур многословно.

              Ответить
    • USE $R+, Luke!

      https://ideone.com/hJUQXe

      На строчке, где должно вывести 3, падает с ошибкой 201.

      Режим $R+ не стали включать по умолчанию из-за сишников, которые ноют, что проверки снижают пирфоманс.
      Ответить
      • Именно поэтому я против Сей
        Ответить
      • Программы падающие из-за мелочей в рантайме это прекрасно.
        Опять же вопрос, почему для енумов succ — выдаёт ошибку без флажков, а для subrange нужно их включать? Контринтиутивное говно.
        Ответить
    • succ(succ(x)) падает с Runtime error 107, кстати (почему снова не с 201?)
      Ответить
      • >почему снова не с 201?
        suck(suck(pascal))
        Ответить
        • https://there10han.wordpress.com/programming/pascal/free-pascal-exitcoderuntime-error-code/

          https://www.freepascal.org/docs-html/rtl/system/ioresult.html

          Ха-ха, 201 здесь есть (range error), а 107 нет в принципе.
          Ответить
    • ну а как ты это проверишь в рантайме?:)
      Ответить
      • Посмотри, какой код генерируют реализации «Паскаля» с директивой $R+. Компилятор на этапе компиляции знает границы диапазона. Он вместе с каждой арифметической операцией втыкает код для проверки границ. Этот код будет производить проверки в рантайме, а границы ему подставил компилятор.
        Ответить
    • Переведи на пхп, я не обязан знать язык для школьников.
      Ответить
      • Пусть A принадлежит множеству [1..2]
        Пусть A равно 1
        Увеличим A
        Увеличим A
        Увеличим A
        Выражение "A равно 3" теперь истинно

        Перевел
        или тебе на пхп?
        Ответить
        • > множеству
          Он не обязан знать математику.
          Ответить
          • он разве не из ращ-ки
            Ответить
            • Какой багор со стеснительными гостями8 по поводу стоп-слов. Каждый раз чи-та-ю э-тот те-ле-фун-кен.
              Ответить
              • рашка можно говорить
                а рус-ня -- нет
                "Failed to send a request. Try again."
                Ответить
                • И вроде бы сделал Страйкер ГК. Пользуйся, говори "русня" сколько хочешь. Нет, хотим жрать анимешный кактус. Рус-ня, неко, ня , неко, ня, ня, рус-ня.
                  Ответить
                  • > анимешный кактус
                    Но-но! Не гони на аниме!
                    Ответить
                  • У страйкера нелзя писить под гостём.
                    Вернее можно, но нельзя в понедельник, вторник, среду, четверг, пятницу, субботу и воскресение
                    Ответить
                    • И что? А потом-то можно! В году больше 300 дней.
                      Кстати, guest8 - не гость.
                      Ответить
              • Самоцен-зура генет-ически при-суща рус-не в рез-ультате отрица-тельного отбо-ра.
                Ответить
        • Сразу видно, что ты математик из рашки.
          Ответить

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