• Яма плюс - справочьник - кусок 13.

  • Яма плюс - справочьник - кусок 10

  •  
    // куски справочьника ...

    // Логические операторы и Развилки
    // ----------------- 9

    Програма сушествует в двух видах..
    1. Застывшая полная схема проводки "маркера исполнения операторов".
    2. "Маркер" исполняет очередной оператор ожывшэй схемы - бежыт по схеме и можэт менять
    всё что предначертано - от возникшых перемен маркер можэт избирать свой путь, а если
    програмист плохо продумал схему проводки, то маркер можэт "зависнуть" (попасть в аварию).

    Когда придумываем програму (схему проводки), то у нас есть возможность намечять "развилки".

    Язык "Яма плюс" придумывается для использования в тесном сотрудничестве с авто-помошником.
    Програмист можэт сам напечятать сложный текст одной из развилок или вставить заготовку
    нужной развилки с помошию менюшных команд. А можэт авто-изменить развилку любого вида на
    другую структуру - правый клик на ключевом слове (которое и означяет Развилку)
    и всплывает менюшка, где видно "в какие формы можно конвертировать" эту развилку.

    Каждая развилка содержыт "условие" в круглых скобках
    и асоцыируется со своим ключевым словом.

    "п" // открытая техничька // не можэт сочетаться со знаком "подготовка".
    Произносится как "пусть", в смысле "предположым будет так".
    За этим следуют круглые скобки. Если внутри скобок "условие не нолевое", то
    считается, что выражэние после круглых скобок нужно исполнить.
    Это выражэние не можэт быть "блоком выражэний", хотя можно несколько
    выражэний запихнуть внутрь некой процэдуры и здесь вызвать исполнение той процэдуры.

    "ип" // открытая техничька // только в связке с ранее напечятаной "п".
    Произносится как "иначе пусть" (или "иначе пробуем").
    Круглые скобки здесь могут содержать только Единицу. Потому-что подразумеваются
    все варианты, которые не вошли в условие певрого выражэния (после "п").
    // Но можно здесь скобки не печятать - авто-пом сам их добавит вместе с единицэй
    // и нарисует бледным серым цветом, чтобы приглушыть эту формальность.

    п( условие ) первый_вариант( );
    ип остальные_варианты( );
    Пример вышэ показывает, что если маркер не исполнит "первый_вариант", то обязательно
    исполнит "остальные_варианты", и наоборот.
    // Условие можэт быть одной переменкой - если на момент проверки условия та переменка
    // хранит "ноль", то условие нолевое, а иначе "условие сработало и открыло ворота".

    "яма" // закрываемая техничька
    После этого ключевого слова можно сразу образовать блок выражэний (фигурные скобки),
    либо напечятать круглые скобки и оформить там условие по которым "маркер исполнения"
    сможэт попасть в этот блок. Дажэ если у нас одно короткое выражэние, то мы всё равно
    обязаны поставить фигурные скобки после круглых и этим оформить "блок выражэний".
    Здесь нет возможности "иначе". Либо маркер заходит в яму, либо обходит её стороной.
    Есть вариант "ямы", когда маркер не можэт выбраться и повторяет операторы ямы, пока
    условие "попадания в яму" не обнулится. Но про это чють позжэ.

    яма { некий_вариант( ); } // маркер всегда исполняет вызов процы "некий_вариант".
    яма(1){ некий_вариант( ); } // Это идэнтичьно строке вышэ.
    Если круглых скобок нет, то авто-помошник сам поставит эти скобки и внутри них Единицу.
    // Скобки и единица-константа внутри них должны рисоваться неким серым вариантом,
    // который намекает, что нет "условных преград" и эти скобки как открытые ворота.

    яма( условие
    ) { // расположэние любых скобок на разных строках не влияет на правильность.
    некий_вариант( );
    }

    "вилы" // закрываемая техничька
      ( первое_условие)
    {
    вариант1( );
    }
      ( второе_условие) // проверяем это, если первое условие оказалось нолевым.
    {
    вариант2( );
    }
      (1) // остальные условия // эта Единица в скобках обязательна.
    { // Эти фигурные скобки обязательны, хотя сам блок можэт оставаться пустым.
    }
    Это виртуальный "блок блоков" (нет фигурных скобок, которые поглашяют в себя блоки).
    Лиш один из этих блоков посетит "маркер исполнения операторов".
    Какое условие раньшэ окажэтся "не нолевым", тот блок и будет исполнен.
    Заглавием каждого блока являются круглые скобки. Блоков можэт быть сколько угодно,
    а чтобы определять "где кончяются вилы", нужно найти скобки с Единицэй.

    "турист" // открытая техничька.
      ( условие_как_половинка_пароля) // Некая переменка или результат вычислений.
    { // далее перечень "вторых половинок"
    лес 1.. // (ключевое слово) (константа) (двуточие или двоеточие) (любой код или пустота)
    лес 'А'.. первые_варианты( ); дом;
    лес константа.. доп_варианты( ); дом;
    лес .. остальные_варианты( ); дом; // не обязательный "лес", который подходит всем паролям.
    }
    // вот здесь (после скобки закрытия) нарисован "домик".
    Турист по лесам шол домой.
    В такой развилке "условие" не является "воротами", которые закрыты или открыты.
    Здесь пытаемся найти стрелку на подходяший условию лес, пройтись по тому лесу
    и образно "вернуться домой" (выйти из блока "турист").

    Эта развилка "блок блоков" (есть обшие фигурные скобки, хотя у блоков нет своих).
    Здесь каждый "лес" это консервированое условие в виде целого числа.
    Либо это литерал (констант-значение без имени), либо название константы.

    Русская буква "А" будет подразумеваться как число 192 и если такое значение
    будет в ячейке памяти "условие_как_половинка_пароля", то найдено совпадение
    и маркер исполнит вызов процэдуры "первые_варианты", а потом прыгнет "домой"
    (к месту сразу после закрытия блока "турист").
    Если "условие_как_половинка_пароля" будет нести Единицу, то совпадение найдено,
    а исполнять вроде-бы нечего, но и ключевого слова "дом" не встречено.
    Поэтому маркер просто игнорит все "леса" и пытается "далее" найти любое нормальное
    выражэние, чтобы его исполнить, и потом продолжать исполнять подобные выражэния,
    пока слово "дом" не заставит сделать "прыжок домой".

    Логический моно-оператор "обратка" (восклицательный знак).
    эн = ! ноль; // эн получит единицу // (эн) (получяет) (обратку) (ноля)
    Любое число он сводит к двум значениям и затем выдаёт обратное.
    Если в некой переменке хранится ноль, то этот ноль будет прочитан как ноль и результат
    будет выдан как единица (обратная нолю).
    Если переменка хранит число 25, то это будет прочитано как Единица
    (хранимое в переменке число не поменяется), а результат операцыи будет выдан как ноль.
    // Этот оператор исполняется раньшэ всех других.
    // Сочетание "обратка" и "негатив" является признаком глупости програмиста,
    // и подобное считается ошыбкой - авто-помошник заставляет выбрать какой-то
    // один моно-оператор, а все остальные стереть.

    Далее логические стерео-операторы, чтобы строить условия "на сравнениях".

    Сочетание знаков "получить_минус_получить" образно означяет равновесие - БАЛАНС.
    Подобные знаки, из нескольких других, следует называть только своим именем, а не
    перечислять те знаки из которых они составлены в текстовом виде.
    // Графически (в редакторе Маргинал) каждый знак имеит свою собственую картинку.
    ( шэ =-= бэ) // Баланс // шэ балАнс бэ
    Если обе "ячейки памяти" считаны и получено одинаковое число, то условие срабатывает
    и подразумевается как единица (правда). Иначе условие считается нолевым (фальш).

    ( шэ !~! бэ) // Дисбаланс // шэ дИсбаланс бэ
    Если числа разные, то "правда", иначе "фальш". // и везде далее есть "иначе фальш".

    ( шэ > бэ) // Большэ // Подразумевается отношэние певрого операнда ко второму
    Если число хранимое в левом операнде (шэ) большэ, чем хранимое в правом, то "правда".

    ( шэ >== бэ) // Большэ-баланс // Большэ или Баланс
    Если число в шэ большэ чем в бэ или одинаковое с ним, то "правда".

    ( шэ < бэ) // Меньшэ
    Если число шэ меньшэ бэ, то "правда".

    ( шэ <== бэ) // Меньшэ-баланс // Меньшэ или Баланс
    Если число шэ меньшэ бэ или числа одинаковые, то "правда".

    Оператором "обратка" можно обратить любое условие на противо-положное.
    ( ! (шэ =-= бэ) ) // эквивалент ( шэ !~! бэ)

    ( шэ =-= 3 + 4)
    Логические операторы исполняются после любых "нормальных вычислений", поэтому здесь
    подразумевается ( шэ =-= 7 ).
    Однако все шэсть вышэ упомянутых операторов исполняются раньшэ,
    чем доп-лог-операторы.. "и", "или".

    "и"
    ( фа > 1 и фа < 9)
    Если оба сравнения являются "правда", то стерео-оператор "и" тожэ "правда".
    Например, переменка "фа" можэт хранить 4 и обший результат будет "правда".

    "или"
    ( фа =-= 3 или фа =-= 7)
    Если одно из сравнений является "правда", то оператор "или" тожэ "правда".
    Например, переменка "фа" можэт хранить 7 и обший результат будет "правда".

    Результат логических операторов нельзя напрямую получять в какую-то переменку.
    п( ф =-= ы) эн = 1; ип эн = 0; // Вот пример, если нужно "получить логику".
    п( ф =-= ы) эн = правда; ип эн = фальш; // Тожэ правильно.

    // п( имя = 5 + 2) вызов_процы(); // получение и участие в условии пока считается ошыбкой.

    эн = п(а) б ? в; // п(а) эн = б; ип эн = в;
    вызов_процы( п(а) б ? в ); // п(а) эн = б; ип эн = в; вызов_процы( эн );
    Пока не ясно, разрешать-ли такой "пусть вопрос". (Это оператор кондицыи в С++)
    Как минимум, такое печятать можно. И авто-помошник заменит на нормальный вариант.

    // Вложэность развилок
    вилы
    ( первое_условие) {
      яма( икс > 5)
      {
      п( ф =-= ы) всякие_развилки( ); // яма( ф =-= ы) { всякие_развилки(); }
      }
    }
    ( второе_условие) {
      турист( икс)
      {
      лес 1.. яма( ф =-= ы) { эн = 1;}
      дом;
      лес 2.. вариант2( ); дом; // Вместо "вариант2" можно вложыть сюда какие-нибудь "вилы".
      }
    }
    (1) { }

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

    // Чтение и смысловое отражэние в мозг..
    п( ю2 >== нечто10 ) ю2 = 1;
    пусть
      когда //скобка открытия таким образом открывает образ условия
    ю2
    большэ-баланс
    нечто10
      тогда //скобка закрытия "когда что-то", "тогда то-то"
    ю2
    получит
    единицу
      здесь просто молчаливая пауза обозначит конец выражэния или части выражэния
    .

    // финиш кусок 9



















































































































































  • Яма плюс - справочьник - кусок 13.

  • Яма плюс - справочьник - кусок 10