Все сравнения, будь то сравнительные (1) или превосходные (4), должны указать их контекст. В сравнительном случае это означает выявление конкретное лицо (2) или группа лиц, к которым относится объект сравниваются (3).Когда проводится сравнительная оценка с набором, полученное утверждение легко перефразировать в превосходное сравнение. Таким образом (3) является перефразированием (4).

22. Буквальное и идиоматическое употребление

Каждое слово в первом предложении выполняет традиционный синтаксис. функция; `on ‘начинается с предложной фразы, которая указывает, где вращение происходит.Во втором предложении «включить» — это идиома, в которой частица `on ‘указывает направление вращения. (4) и (5) показывают, как одно и то же предложение можно изменить, чтобы выбрать между буквальным и идиоматическим чувства.

Здесь возникает дилемма. Синтаксический анализатор, который обрабатывает (2) как глагол + преп, будет неправильно понять это, всегда беря максимально длинную строку из ввода (т.е. идиоматическое использование) означает, что (1) никогда не будет правильно распознан.

23. Интенсивное и широкое использование

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

24. Универсальная и специфическая количественная оценка

Первый пример иллюстрирует проблему; неясно, искомый человек — это конкретная личность или вообще любой мужчина.Второй и третий примеры демонстрируют, что как определенные, так и неопределенные кванторы могут испытайте такую ​​двусмысленность. «Кошка» — универсальный, а «тамаринд» может быть; «мужчина», однако, следует толковать конкретно, потому что никто не может держите всех мужчин. Четвертое и пятое предложения показывают, что количественные двусмысленность может возникнуть в напряженных глаголах. Учитывая, что я нахожусь в комнате, мужской Увидение меня должно предшествовать его выходу из комнаты. Следовательно, «видит» может быть только понимается как общее видение на регулярной основе, а не как конкретное однократное зрение.Поскольку оба глагола в пятом предложении — прошедшее время, временной порядок не установлен, и слово «пила» может относиться к количественная оценка.

Не было обнаружено никакого общего метода разрешения количественной неоднозначности. Однако, если количественная фраза строго определена по определению или через В контексте, разумно предположить, что ссылка относится к определенной сущности. Таким образом, при отсутствии противоположного контекста (например, при чтении тематических объявлений) «Я ищу красный Мустанг 1977 года» предполагает, что говорящий ищет конкретная машина себе известная.Точно так же «Человек, который видел меня на троих недели в 9 часов вышел из комнаты «предполагает, что осмотр — это акт не имеет отношения к отъезду.

25. Двусмысленность

присущий (многозначность и омонимия)

Слова могут быть как многозначными, так и омонимичными. «Право» имеет одноименное название чувства праведности и правши. Каждое из этих чувств само по себе многозначный. Когда используется в «правильных поступках» и «поступать правильно», -righteous- имеет гомологи правильных-при-обстоятельствах и -абсолютно правильно-.Гомологи -правой- демонстрируются в правая »и« моя правая рука ». Они где-то справа и на правой стороне моего тела.

«Правильно» также может занимать разные синтаксические категории: «Могущество делает правильным». (существительное), «я выпиваю бутылку» (глагол), `правильная вещь ‘(прилагательное) и« делай правильно «(наречие)

автоантонимия

Подмножество неоднозначных слов несут пары смыслов, которые являются анотными. Этот Это явление известно под разными названиями, включая аутоантонимию.См. Обсуждение списка LINGUIST с начала 1995 г. и далее.

в количественном смысле

Эти предложения вводят двусмысленность, потому что «каждый» означает как универсальный квантор all и экзистенциальный квантор some. Как результат первый пример оставляет неясным, должны ли поезда ехать во все города или только один из них для включения в список. Следующие примеры показывают, что отрицание может взаимодействовать с неоднозначностью квантора.«Не все» экзистенциально один ‘и, следовательно, кто-то, и повсеместно’ не все ‘, и поэтому один.

26. Грамматичность. (для помощи в общении)

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

Ссылка на «это» в (2) — это опущенная фраза «его победа» или «что он оговорка о выигрыше. Наличие любого из них создает неудобную конструкцию: «Хотя было предсказано, что он выиграет, Голдуотер не (выиграл) »;« Хотя его победа было предсказано, Голдуотер не (выиграл) ». Третий случай аналогичен второй. Его можно перефразировать так: «Если мужчина заслуживает награды и показывает, что он хочет, он получит приз «, но это не отражает необходимости показать желание подчеркнуто в (3).

27. Эффект пассивизации.

В первом примере (1) подчеркивается нехватка прожорливых читателей. в то время как его пассивное преобразование (2) подчеркивает изобилие плохо читаемых книги. Кажется, что первая фраза предложения занимает важное место.(1) и (2) делать разные заявления, потому что акцент смещается с «книги» в «читатели», когда голос превращается из пассивного в активный. Хотя проблема исчезает, когда количественная оценка смещается к нейтральной `some ‘во втором примере (3, 4),` some’ в этом случае оказывается квалификатор идентичности, а не количественный показатель меры, потому что проблема сохраняется, когда кванторы универсальны (5, 6).

28. Ссылочная непрозрачность / наклонность

(2) не может быть выведено из (1), потому что первое предложение не прямо сказать, что Росс знает породу собаки Нади. Индивидуальный личные знания обязательно ограничены, и нельзя предполагать, что объективные факты субъективно известны каждому. Ссылка на субъективное знание встречается в таких словах, как «верить», «говорить», «думать», что сообщать косвенно дискурс и умственная деятельность.

29. Обычная двусмысленность

Оба первых двух примера содержат неоднозначные элементы. `Готов к есть ‘может быть истолковано как идиома, означающая «полностью приготовленный», или как конструкция означает -голодный-. Во втором примере изменение train с помощью «Бостон» оставляет неясным, идет ли поезд или оттуда. город. Эти двусмысленности возникают из-за условностей, которые мы обычно предполагаем из контекст, когда мы читаем любое из утверждений. Однако первый пример должен вообще не быть двусмысленным.Его полностью подготовленный смысл может быть только понимается из-за неправильного чтения; сделать это утверждение в правильной грамматике быть «Цыплята готовы к употреблению». Рекламная практика сделала «готов к употреблению» означает «готов к употреблению».

Путаница -to- или -from- во втором примере основана на аналогичном предположение, но то, которое формально не преподается через СМИ. «Бостон» в данном случае также может означать -сделано-в-Бостоне-, названо в честь Бостона или даже -владельцем-корпорацией-метро Бостона.Направленные чувства выбраны как те, которые следует запутать, потому что движение и путешествие — это Первое, что у большинства людей ассоциируется с поездами. Приходит неоднозначность (если это делает) благодаря знанию расписания.

Все пять «человеческих» примеров используют прилагательное для обозначения различных отношения между его объектом и людьми: потомки людей, расы, состоящие из людей, потребление людьми, эксперименты на людях, собаки с человеческими чертами. Точно так же, хотя оба слова в последнем примере индивидуально недвусмысленно, при совместном использовании неясно, означают ли они мясо в корм собаке или мясо собаки.

30. Дополнительные или копулятивные глаголы.

Двадцать связок — это особый случай отношений. Они используются в заявление, позволяющее квалифицировать объект потенциально сложным образом а не для выражения официальных отношений. Несмотря на это, эти глаголы делают определить наличие их дополнения.

Достаточно исчерпывающий список копулятивных глаголов: субъективные дополнения: `быть ‘,` становиться’, `расти ‘,` получать’, `чувствовать ‘,` казаться’, `проявляться ‘,` вкушать’, `звучать ‘, «запах», «смотри», «оставаться», «действовать», «идти», «поворачивать», «делать»; объективные дополнения: «сделать», «доказать», «представить», «рассмотреть».

31. Необоснованная ссылка

Референты для «они» и «оно» предоставляются по соглашению, а не контекст; ничего не будет найдено в повествовании.

32. Значение «Сдвиг через расширение»

В этом примере есть элементы садовой дорожки и идиомы, но конструкция, на которой он основан, может быть уникальной.В первом предложении «осциллограф» — прямой объект; во втором — инструмент и «радио» — это прямой объект. Виноград (1983) полагает, что разные смыслы «привыкшие» используются. В первом предложении фраза, которую он представляет как useta, идиоматически выражает прошедшее время; во втором — инструментальность.

33. Ссылка через синоним

Мы понимаем, что «эти три мальчика» означает «дети», потому что двое словосочетания с существительными в высшей степени синонимичны (хотя и не совсем так; маленькие девочки могут быть дети тоже). Менее синонимичные пары и ссылки через отрицательные антонимы являются труднее понять.

Синонимы и длинный диапазон вместе — рецепт дорогостоящей обработки в случаях ссылки. Если `мужчина ‘или` Мистер Смит заменяется на «он» в последнем предложении второго примера предыдущие четыре предложения или 15 слов будут необходимо протестировать, чтобы поймать намеченную ссылку.

34. Диексис в диалоге

Первое заявленное утверждение невозможно понять без контекста. В во втором мы делаем вывод, что лобовое стекло автомобиля было непрозрачным из-за трещин и звезды, и что, хотя шины не спущены, часть крыла или рама прижимается к одному из них.

Произнесенные слова могут идентифицировать вещи в сцене, которые не упоминаются в высказывание. Тот же эффект может быть достигнут в письменном повествовании, только если идентифицированный элемент явно или неявно вводится в непосредственной близости от диалог.

35. Диалог Атрибуция

Содержание этих трех предложений подразумевает трех говорящих, а не два человека по очереди, что иначе можно было бы предположить.

Письменный английский ни разу не определяет носителей напрямую цитируемого диалога они были представлены. Кавычки используются для разграничения высказываний и предполагается, что выступающие по очереди. Это соглашение становится проблематичным, когда в разговоре участвует более двух человек; тогда мы должны полагаться на наши модели интересы, мотивации и перспективы участников для определения атрибуции. В диалоге существует явный риск неправильного толкования. среди трех и более человек.

36. Речевые акты.

Речевые акты можно разделить на те, в которых словарный смысл несовместим с контекстом и с теми, в которых он совпадает. Первое Случай, проиллюстрированный (1), охватывает то, что обычно известно термином Остина (1962). Интерес локатора к физическим возможностям одитора не имеет отношения к его физическим возможностям. текущая активность приема пищи.

Второй случай более контекстный. В (2) все стороны знают, что женщина выражая предпочтение чему-то большему, чем подарок. Хотя второе высказывание внешне похож на метонимию (в том, что речевой акт состоит из цветы понимаются как символ мужчины, который их предлагает), это отличается в этом смысле подразумевается буквально; без сомнения, женщина действительно ожидает и получает цветы. Поэтому ее высказывание не только образное.

37.de re vs de dicto Scope

«Уверенно» относится к действию хождения в рамках утверждения и развивает его смысл; «очевидно» относится ко всему утверждению и квалифицирует предложение, которое он сообщает. Первый — de re , а последний de dicto . Рамка для различения этих два падежа переводят слова-кандидаты в их родственную форму существительного: «Это очевидно, что… «. Любое утверждение, которое можно разумно перефразировать таким образом это de dicto.

37. Модальное и гипотетическое существование

Модальные глаголы — это замкнутый набор, определяющий возможность, способность и необходимость совершения определенного действия или класса действий (1). Кроме того, модальные параметры определяют волю, намерение, предсказание, разрешение и обязательство живого агента для выполнения действия (2).

Слагательное наклонение используется для выражения утверждений, которые имеют воображаемый или гипотетическое существование (3).

38. Необходимое против случайного следствия.

В отсутствие явных коннекторов, таких как «потому что», «однако» и «поскольку» (разговорный) мы должны использовать здравый смысл, чтобы сделать вывод о том, что причинно-следственная связь следствие сопровождает временную последовательность.Первый пример открыт для любого необходимое или случайное толкование. На мой взгляд, он слегка наклоняется в сторону причинности, потому что это приводит к трудностям упоминания событий. В Второй пример, очевидно, следует понимать причинно. Третий и четвертый Примеры включают события, а также состояние и событие соответственно. Читатели вряд ли можно подумать, что падение яблока в любом случае произошло из-за удара Тома действие или состояние.

39. Неопределенное членство в множестве

Прочитав приведенные выше предложения, невозможно узнать, какие из члены семьи освистали, ушли, начали разговаривать между собой или продолжили смотреть спектакль. Языковые высказывания обычно определяют группы и выполняют операции над ними: 1) конъюнкция («банда и я»), 2) дизъюнкция («Это они или мы «), 3) член и 4) идентификация и выбор подмножества (» все семья была среди зрителей… «,` один из сотрудников ‘. Результатом этих операций в спецификации групп или индивидуумов, идентичность которых неизвестна. Пользователи языка верят, что им сообщат состав группы, когда это важно.

andreaferretti / factor-tutorial: От композиции функций к распределенному программированию

Factor — зрелый язык с динамической типизацией, основанный на конкатенативной парадигме. Начало работы с Factor может быть пугающим, поскольку парадигма конкатенации отличается от большинства основных языков.Это руководство познакомит вас с основами Factor, чтобы вы могли оценить его простоту и мощь. Я предполагаю, что вы опытный программист, знакомый с функциональным языком, и предполагаю, что вы понимаете такие концепции, как сворачивание, функции высшего порядка и каррирование.

Несмотря на то, что Factor является нишевым языком, он является зрелым и имеет обширную стандартную библиотеку, охватывающую задачи от сериализации JSON до программирования сокетов и создания шаблонов HTML. Он работает на собственной оптимизированной виртуальной машине с очень высокой производительностью для динамически типизированного языка.Он также имеет гибкую объектную систему, FFI to C и асинхронный ввод-вывод, который немного похож на Node.js, но с гораздо более простой моделью для совместной многопоточности.

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

• рефакторинг очень прост, что приводит к коротким и содержательным определениям функций;
• он чрезвычайно лаконичен, позволяя программисту сосредоточиться на том, что важно, а не на шаблонном;
• он обладает мощными возможностями метапрограммирования, превосходящими даже LISP;
• идеально подходит для создания DSL;
• легко интегрируется с мощными инструментами.

Перед тем, как начать это руководство, загрузите копию Factor, чтобы вы могли следовать примерам в слушателе (Factor REPL).

Я предполагаю, что вы используете Mac OS X или какой-либо дистрибутив Linux, но все должно работать так же в других системах, при условии, что вы измените пути к файлам в примерах.

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

Конкатенативные языки

Factor — это конкатенативный язык программирования в духе Forth. Что это вообще значит?

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

Это требует некоторого объяснения, поскольку мы знаем, что функции часто имеют несколько входов и выходов, и не всегда выход f совпадает с входом g . Например, g может потребоваться доступ к значениям, вычисленным более ранними функциями. Но единственное, что может видеть g , — это вывод f , поэтому вывод f — это состояние всего мира в отношении g . Чтобы это работало, функции должны распределять глобальное состояние потоками, передавая его друг другу.

Существуют различные способы кодирования этого глобального состояния. Самые наивные будут использовать хэш-карту, которая сопоставляет имена переменных с их значениями. Это оказывается слишком гибким: если каждая функция может получить доступ к любой части глобального состояния, мало контроля над тем, что функции могут делать, мало инкапсуляции, и в конечном итоге программы превращаются в неструктурированный беспорядок подпрограмм, изменяющих глобальные переменные.

На практике хорошо работает представление состояния мира в виде стека. Функции могут ссылаться только на самый верхний элемент стека, поэтому элементы ниже него фактически находятся вне области видимости.Если несколько примитивов заданы для управления несколькими элементами в стеке (например, swap , который меняет местами два верхних элемента в стеке), тогда становится возможным ссылаться на значения в стеке, но чем дальше значение вниз по стеку, тем труднее к нему обращаться.

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

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

Это оставляет конкатенативные языки, такие как Factor, в странном положении, они оба чрезвычайно функциональны — позволяют объединять только более простые функции в более сложные — и в значительной степени обязательны — описывают операции в изменяемом стеке.

Игра со стеком

Давайте начнем смотреть, что на самом деле чувствует Фактор. Наши первые слова будут буквальными, например 3 , 12,58 или «Чак Норрис» . Литералы можно рассматривать как функции, которые помещаются в стек. Попробуйте написать в слушателе 5 , а затем нажмите Enter для подтверждения. Вы увидите, что стек, изначально пустой, теперь выглядит как

Вы можете ввести несколько чисел, разделенных пробелами, например 7 3 1 , и получить

(интерфейс показывает верх стека снизу).А как насчет операций? Если вы напишете + , вы запустите функцию + , которая выталкивает два самых верхних элемента и подталкивает их сумму, в результате чего остается

Вы можете поместить дополнительные входные данные в одну строку, так, например, - * оставит единственное число 15 в стеке (вы понимаете, почему?).

Функция . (точка или точка) печатает элемент наверху стопки, выталкивая его из стопки, оставляя стопку пустой.

Если мы напишем все в одну строку, наша программа пока выглядит как

, который показывает особый способ выполнения арифметических операций Factor, помещая аргументы первыми, а оператор — последним — соглашение, которое называется обратной польской нотацией (RPN). Обратите внимание, что RPN не требует скобок, в отличие от полированной нотации Lisps, где оператор стоит первым, а RPN не требует правил приоритета, в отличие от инфиксной нотации, используемой в большинстве языков программирования и в повседневной арифметике. Например, в любом Лиспе одно и то же вычисление будет записано как

и в знакомой инфиксной нотации

Также обратите внимание, что мы смогли разбить наши вычисления на множество строк или объединить их на меньшее количество строк довольно произвольно, и что каждая строка имеет смысл сама по себе.

Определение нашего первого слова

Теперь мы определим нашу первую функцию. У Factor несколько странное наименование функций: поскольку функции читаются слева направо, они называются просто слов , и теперь мы будем называть их именно так. Модули в Factor определяют слова в терминах предыдущих слов, и эти наборы слов затем называются словарями .

Предположим, мы хотим вычислить факториал. Чтобы начать с конкретного примера, мы вычислим факториал 10 , поэтому мы начнем с записи 10 в стек.Теперь факториал — это произведение чисел от 1 до 10 , поэтому мы должны сначала составить такой список чисел.

Слово для создания диапазона называется [a, b] (токенизация тривиальна в Factor, потому что слова всегда разделяются пробелами, поэтому это позволяет вам использовать любую комбинацию непробельных символов в качестве имени слова; нет семантики для [, , и ] в [a, b] , поскольку это просто токен вроде foo или bar ).

Диапазон, который нам нужен, начинается с 1 , поэтому мы можем использовать более простое слово [1, b] , которое предполагает, что диапазон начинается с 1 и ожидает, что значение в верхней части диапазона будет в стеке. . Если вы напишете в слушателе [1, b] , Factor предложит вам выбор, потому что слово [1, b] не импортируется по умолчанию. Фактор может предложить вам импортировать словарь math.ranges , поэтому выберите этот вариант и продолжайте.

Теперь у вас в стеке должна быть довольно непрозрачная структура, которая выглядит как

Это потому, что наши функции диапазона ленивы и создают диапазон только тогда, когда мы пытаемся его использовать.Чтобы подтвердить, что мы действительно создали список чисел от 1 до 10 , мы конвертируем отложенный ответ в стеке в массив, используя слово > массив . Введите это слово, и ваша стопка теперь должна выглядеть как

, что многообещающе!

Затем мы хотим получить произведение этих чисел. Во многих функциональных языках это можно сделать с помощью функции под названием reduce или fold. Давай поищем. Нажатие F1 в слушателе откроет контекстную справочную систему, где вы можете найти уменьшить .Оказывается, что уменьшить — это на самом деле слово, которое мы ищем, но на данный момент может быть не очевидно, как его использовать.

Попробуйте написать 1 [*] reduce и посмотрите на результат: это действительно факториал 10 . Итак, reduce обычно принимает три аргумента: последовательность (а один у нас был в стеке), начальное значение (это 1 , которое мы помещаем в стек следующим) и двоичная операция. Это, безусловно, должно быть * , но как насчет квадратных скобок вокруг * ?

Если бы мы написали только * , Factor попытался бы применить умножение к двум самым верхним элементам в стеке, а это не то, что мы хотели.Нам нужен способ поместить слово в стек, не применяя его. Если придерживаться нашей текстовой метафоры, этот механизм называется цитата . Чтобы процитировать одно или несколько слов, вы просто окружаете их [ и ] (оставляя пробелы!). То, что вы получаете, похоже на анонимную функцию на других языках.

Давайте наберем слово drop в слушателе, чтобы очистить стек, и попробуем записать то, что мы сделали до сих пор, в одной строке: 10 [1, b] 1 [*] reduce .Как и ожидалось, в стеке останется 3628800 .

Теперь мы хотим определить слово для факториала, которое можно использовать всякий раз, когда нам нужен факториал. Мы будем называть наше слово факт (хотя ! обычно используется как символ факториала, в Факторе ! — это слово, используемое для комментариев). Чтобы определить его, нам сначала нужно использовать слово : . Затем мы помещаем имя определяемого слова, затем стек , эффекты и, наконец, тело, заканчивающееся ; слово:

 : fact (n - n!) [1, b] 1 [*] уменьшить;
  

Что такое стековые эффекты? В нашем случае это (n - n!) .Эффекты стека — это то, как вы документируете входные данные из стека и выходы в стек для вашего слова. Вы можете использовать любой идентификатор для именования элементов стека, здесь мы используем n . Фактор выполнит проверку согласованности, чтобы количество указанных вами входов и выходов соответствовало тому, что делает тело.

Если попробовать написать

 : fact (m n - n!) [1, b] 1 [*] уменьшить;
  

будет сигнализировать об ошибке, что 2 входа ( m и n ) не соответствуют тексту слова.Чтобы восстановить предыдущее правильное определение, нажмите Ctrl + P два раза, чтобы вернуться к предыдущему вводу, а затем введите его.

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

В любом случае, вы успешно определили свое первое слово: если вы напишете 10 fact в слушателе, вы сможете это доказать.

Обратите внимание, что часть определения 1 [*] reduce имеет смысл сама по себе, будучи продуктом последовательности.В конкатенативном языке хорошо то, что мы можем просто выделить эту часть и написать

 : prod ({x1, ..., xn} - x1 * ... * xn) 1 [*] уменьшить;
: fact (n - n!) [1, b] prod;
  

Наши определения стали проще, и не было необходимости передавать параметры, переименовывать локальные переменные или делать что-либо еще, что было бы необходимо для рефакторинга нашей функции на большинстве языков.

Конечно, в Factor уже есть слово для факториала (на самом деле существует целая math.факториалы словарный запас, включая множество вариантов обычного факториала) и слово для продукта ( продукт в последовательностях словаря), но, как это часто бывает, вводные примеры частично совпадают со стандартной библиотекой.

Разбор слов

Если вы до сих пор уделяли пристальное внимание, вы понимаете, что я солгал вам. Я сказал, что каждое слово действует в стеке по порядку, но есть несколько слов вроде [, ] , : и ; , которые, похоже, не следуют этому правилу.

Это слов синтаксического анализа , и они ведут себя иначе, чем более простые слова, такие как 5 , [1, b] или drop . Мы рассмотрим их более подробно, когда будем говорить о метапрограммировании, но пока достаточно знать, что слова синтаксического анализа являются особенными.

Они определяются не словом : , а словом SYNTAX: . Когда встречается синтаксический анализ слов, он может взаимодействовать с синтаксическим анализатором, используя четко определенный API, чтобы влиять на то, как анализируются последовательные слова.Например, : запрашивает следующие токены от парсеров до ; обнаружен и пытается скомпилировать этот поток токенов в определение слова.

Обычно слова синтаксического анализа используются для определения литералов. Например, { — слово синтаксического анализа, которое начинает определение массива и заканчивается } . Все, что находится между ними, является частью массива. Примером массива, который мы видели ранее, является {1 2 3 4 5 6 7 8 9 10} .

Существуют также литералы для хэш-карт, H {{"Perl" "Ларри Уолл"} {"Фактор" "Слава Пестов"} {"Scala" "Мартин Одерски"}} и байтовые массивы, B {1 14 18 23} .

Другие варианты использования слова синтаксического анализа включают модульную систему, объектно-ориентированные функции Factor, перечисления, мемоизированные функции, модификаторы конфиденциальности и многое другое. Теоретически даже SYNTAX: можно определить в терминах самого себя, хотя, конечно, систему нужно каким-то образом настроить.

Перемешивание стека

Теперь, когда вы знаете основы Factor, вы можете начать собирать более сложные слова. Иногда может потребоваться использовать переменные, которые не находятся на вершине стека, или использовать переменные более одного раза.Есть несколько слов, которые могут помочь в этом. Я упоминаю о них сейчас, так как вы должны знать о них, но предупреждаю вас, что использование слишком большого количества этих слов для управления стеком приведет к тому, что ваш код быстро станет труднее читать и писать. Перестановка стека требует мысленного моделирования перемещения значений в стеке, что не является естественным способом программирования. В следующем разделе мы увидим гораздо более эффективный способ удовлетворить большинство потребностей.

Вот список наиболее часто используемых слов с указанием их влияния на стек.Попробуйте их в слушателе, чтобы почувствовать, как они манипулируют стеком, и изучите онлайн-справку, чтобы узнать больше.

  дуп (x - x x)
капля (х -)
своп (x y - y x)
над (x y - x y x)
dupd (х у - х х у)
swapd (x y z - y x z)
зажим (x y - y)
гниль (x y z - y z x)
-rot (x y z - z x y)
2dup (x y - x y x y)
  

Комбинаторы

Хотя слова, упомянутые в предыдущем абзаце, иногда бывают полезными (особенно более простые dup , drop и swap ), вы должны написать код, который делает как можно меньше перетасовки стека.Это требует практики, чтобы аргументы функции располагались в правильном порядке. Тем не менее, есть определенные общие шаблоны необходимых манипуляций со стеком, которые лучше абстрагировать их собственными словами.

Предположим, мы хотим определить слово, чтобы определить, является ли данное число n простым. Простой алгоритм состоит в том, чтобы проверить каждое число от 2 до квадратного корня из n и посмотреть, является ли оно делителем n . В этом случае n используется в двух местах: как верхняя граница последовательности и как число для проверки делимости.

Слово bi применяет две разные кавычки к одному элементу в стеке над ними, и это именно то, что нам нужно. Например, 5 [2 *] [3 +] bi дает

bi применяет котировку [2 *] к значению 5 , а затем котировку [3 +] к значению 5 , оставляя в стеке 10 , а затем 8 ​​. Без bi нам пришлось бы сначала dup 5 , затем умножить, а затем поменять местами результат умножения на второй 5 , чтобы мы могли выполнить сложение

Вы можете видеть, что bi заменяет общий шаблон dup , затем вычисляет, затем меняет местами и снова вычисляет.

Чтобы продолжить наш основной пример, нам нужен способ сделать диапазон, начиная с 2 . Мы можем определить собственное слово для этого [2, b] , используя слово диапазона [a, b] , которое мы обсуждали ранее

 : [2, b] (n - {2, ..., n}) 2 поменять местами [a, b]; в соответствии
  

Что случилось с этим встроенным словом ? Это один из модификаторов, который мы можем использовать после определения слова, еще один — рекурсивный . Это позволит нам иметь определение короткого слова, встроенного везде, где оно используется, вместо того, чтобы вызывать вызов функции.

Попробуйте наше новое слово [2, b] и убедитесь, что оно работает

Использовать [2, b] для получения диапазона чисел от 2 до квадратного корня из n , который уже находится в стеке, просто: sqrt floor [2, b] (технически floor здесь не требуется, так как [a, b] работает для нецелочисленных границ). Давайте попробуем

Теперь нам нужно слово для проверки делимости. Быстрый поиск в онлайн-справке показывает, что делитель ? — это то слово, которое мы хотим.Это поможет иметь аргументы в пользу проверки делимости в другом направлении, поэтому мы определяем multiple?

 : несколько? (a b -?) поменять местами делитель? ; в соответствии
  

Оба они возвращают т

  9 3 делитель? .
3 9 кратный? .
  

Если мы собираемся использовать bi в нашем определении prime , как мы подразумевали выше, нам нужна вторая цитата. Наша вторая цитата должна проверить, является ли значение в диапазоне делителем n — другими словами, нам нужно частично применить слово multiple? .Это можно сделать с помощью слова curry , например: [несколько? ] карри .

Наконец, когда у нас есть диапазон потенциальных делителей и тестовая функция в стеке, мы можем проверить, удовлетворяет ли какой-либо элемент делимости с любым? , а затем отрицайте этот ответ , а не . Наше полное определение простое выглядит как

 : простое? (n -?) [sqrt [2, b]] [[несколько? ] карри] би любой? нет ;
  

Хотя определение простого сложно, перетасовка стека минимальна и используется только в небольших вспомогательных функциях, которые проще рассуждать о простом числе ? .

Обратите внимание, что prime? использует два уровня вложенности цитат, поскольку bi оперирует двумя кавычками, а наша вторая цитата содержит слово curry , которое также оперирует цитатой. В общем, факторные слова имеют тенденцию быть довольно мелкими, используя один уровень вложенности для каждой функции более высокого порядка, в отличие от Lisps или более общих языков, основанных на лямбда-исчислении, которые используют один уровень вложенности для каждой функции, высшего порядка или нет. .

Существует гораздо больше комбинаторов, кроме bi (и его родственника tri ), и вам следует познакомиться хотя бы с bi , tri , bi * и bi @ , прочитав о них в онлайн-справку и опробовать их в слушателе.

Словари

Пришло время начать записывать свои функции в файлы и научиться импортировать их в слушатель. Factor организует слова во вложенные пространства имен, называемые словарями . Вы можете импортировать все имена из словаря с помощью слова USE: . На самом деле, вы могли видеть что-то вроде

, когда вы попросили слушателя импортировать за вас слово [1, b] . Вы также можете использовать более одного словаря одновременно со словом USING: , за которым следует список словарей и завершается словом ; , как

  ИСПОЛЬЗОВАНИЕ: математ.диапазоны последовательностей.deep;
  

Наконец, вы определяете словарь, в котором хранятся ваши определения, с помощью слова IN: . Если вы выполните поиск в онлайн-справке по слову, которое вы уже определили, например, prime? , вы увидите, что ваши определения сгруппированы в словарь по умолчанию блокнота . Кстати, это показывает, что онлайн-справка автоматически собирает информацию о ваших собственных словах, что является очень полезной функцией.

Есть еще несколько слов, например QUALIFIED: , FROM: , EXCLUDE: и RENAME: , которые позволяют более детально контролировать импорт, но USING: является наиболее распространенным.

На диске словари хранятся в нескольких корневых каталогах, как и путь к классам в языках JVM. По умолчанию система начинает поиск в каталогах basic , core , extra , work под Factor home. Вы можете добавить больше, как во время выполнения с помощью слова add-vocab-root , так и путем создания файла конфигурации .factor-rc , но пока мы будем хранить наши словари в каталоге work , который зарезервирован для пользователя.

Создание шаблона для написания словаря

  ПРИМЕНЕНИЕ: tools.scaffold
"github.tutorial" строительные леса
  

Вы найдете файл work / github / tutorial / tutorial.factor , содержащий пустой словарь. Factor интегрируется со многими редакторами, поэтому вы можете попробовать «github.tutorial» отредактировать : вам будет предложено выбрать свой любимый редактор и использовать этот редактор для открытия вновь созданного словаря.

Вы можете добавить определения из предыдущего абзаца, чтобы он выглядел как

 ! Авторское право (C) 2014 Андреа Ферретти.! См. Http://factorcode.org/license.txt для получения лицензии BSD.
С ИСПОЛЬЗОВАНИЕМ: ;
IN: github.tutorial

: [2, b] (n - {2, ..., n}) 2 поменять местами [a, b]; в соответствии

: несколько? (a b -?) поменять местами делитель? ; в соответствии

: основной? (n -?) [sqrt [2, b]] [[несколько? ] карри] би любой? нет ;
  

Поскольку словарь уже был загружен, когда вы его создали, нам нужен способ обновить его с диска. Вы можете сделать это с помощью обновления "github.tutorial" . Также есть слово обновить все с ярлыком F2 .

Вам будет несколько раз предложено использовать словари, поскольку ваш оператор USING: пуст. После принятия всех из них Factor предлагает вам новый заголовок со всем необходимым импортом:

  ИСПОЛЬЗОВАНИЕ: ядро ​​math.functions math.ranges последовательности;
IN: github.tutorial
  

Теперь, когда в вашем словаре есть несколько слов, вы можете отредактировать, скажем, кратное число ? слово с \ кратным? отредактировать . Вы найдете свой редактор открытым в соответствующей строке нужного файла.Это также работает для слов в Факторном распределении, хотя изменять их может быть плохой идеей.

Это слово \ требует небольшого пояснения. Это работает как своего рода побег, позволяя нам поместить ссылку на следующее слово в стеке, не выполняя его. Это именно то, что нам нужно, потому что edit — это слово, которое принимает сами слова в качестве аргументов. Этот механизм похож на цитаты, но, хотя цитата создает новую анонимную функцию, здесь мы напрямую ссылаемся на слово multiple? .

Возвращаясь к нашей задаче, вы можете заметить, что слова [2, b] и кратны? — это просто вспомогательные функции, которые вы, возможно, не захотите раскрывать напрямую. Чтобы скрыть их от просмотра, вы можете заключить их в приватный блок, например,

  <ЧАСТНЫЙ

: [2, b] (n - {2, ..., n}) 2 поменять местами [a, b]; в соответствии

: несколько? (a b -?) поменять местами делитель? ; в соответствии

ЧАСТНЫЙ>
  

После внесения этого изменения и обновления словаря вы увидите, что слушатель больше не может ссылаться на такие слова, как [2, b] .Слово работает, помещая все определения в частный блок в другой словарь, в нашем случае github.tutorial.private .

По-прежнему можно ссылаться на слова в частных словарях, что вы можете подтвердить, выполнив поиск по запросу [2, b] в онлайн-справке, но, конечно, это не рекомендуется, поскольку люди не гарантируют стабильность API для частных слов . Слова под github.tutorial могут относиться к словам в github.tutorial.private напрямую, например, prime? делает.

Тесты и документация

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

  scaffold-тесты "github.tutorial"
  

Вы должны найти сгенерированный файл в work / github / tutorial / tutorial-tests.factor , который вы можете открыть с помощью "github.tutorial" edit-tests . Обратите внимание на строку

  ИСПОЛЬЗОВАНИЕ: tools.test github.руководство ;
  

, который импортирует модуль модульного тестирования, а также ваш собственный. Будем тестировать только публичный prime? функция.

Тесты написаны с использованием слова unit-test , которое предполагает две кавычки: первая содержит ожидаемые результаты, а вторая — слова, которые необходимо выполнить, чтобы получить этот результат. Добавьте эти строки в github.tutorial-tests :

  [т] [2 простых? ] модульный тест
[t] [13 простых? ] модульный тест
[t] [29 простое? ] модульный тест
[f] [15 простых? ] модульный тест
[f] [377 простое? ] модульный тест
[f] [1 простое число? ] модульный тест
[t] [20750750228539 простое? ] модульный тест
  

Теперь вы можете запускать тесты с "github.учебник "test . Вы увидите, что мы действительно допустили ошибку, и нажатие F3 покажет более подробную информацию. Кажется, что наши утверждения не работают для 2 .

Фактически, если вы вручную попытаетесь запустить наши функции для 2 , вы увидите, что наше определение [2, b] возвращает {2} для 2 sqrt , поскольку квадрат корень из двух меньше двух, поэтому мы получаем интервал по убыванию. Попробуйте исправить, чтобы тесты прошли.

Есть еще несколько слов для проверки ошибок и вывода эффектов стека. unit-test пока достаточно, но позже вы можете захотеть проверить must-fail и must-infer .

Мы также можем добавить некоторую документацию к нашему словарю. Автоматически сгенерированная документация всегда доступна для пользовательских слов (даже в слушателе), но мы можем написать несколько полезных комментариев вручную или даже добавить пользовательские статьи, которые появятся в онлайн-справке. Как и ожидалось, начнем с "гитхаба".учебник "scaffold-docs , а затем " github.tutorial "edit-docs .

Сгенерированный файл work / github / tutorial-docs.factor импортирует help.markup и help.syntax . Эти два словаря определяют слова для создания документации. Фактическая страница справки генерируется синтаксическим словом HELP: .

Аргументы HELP: представляют собой вложенный массив формы {$ directive content ...} . В частности, вы видите здесь директивы $, значения и $, описание , но существует еще несколько, например $ ошибок , $ примеры и $ см. Также .

Обратите внимание, что тип вывода ? Предполагается, что является логическим. Измените первые строки, чтобы они выглядели как

  ИСПОЛЬЗОВАНИЕ: help.markup help.syntax kernel math;
IN: github.tutorial

СПРАВКА: премьер?
{$ values
    {"n" fixnum}
    {"?" логическое}
}
{$ description "Проверяет, является ли n простым. Предполагается, что n - положительное целое число." };
  

и обновите словарь github.tutorial . Если теперь посмотреть справку по prime? , например с \ prime? help , вы увидите обновленную документацию.

Вы также можете отображать директивы в слушателе для более быстрой обратной связи. Например, попробуйте написать

  {$ values
    {"n" целое число}
    {"?" логическое}
} print-content
  

Разметка справки содержит множество возможных директив, и вы можете использовать их для написания отдельных статей в справочной системе. Взгляните на еще несколько с справкой "типы элементов" .

Объектная система и протоколы

Хотя это не очевидно из того, что мы сказали до сих пор, Factor имеет объектно-ориентированные функции, и многие ключевые слова на самом деле являются вызовами методов.Чтобы лучше понять, как объекты ведут себя в Factor, приведем цитату:

Я придумал термин «объектно-ориентированный» и могу сказать, что не имел в виду C ++.

Алан Кей

Термин «объектно-ориентированный» имеет столько же значений, сколько и люди, которые его используют. Одна из точек зрения — которая на самом деле была центральной в работе Алана Кея — состоит в том, что речь идет о позднем связывании имен функций. В Smalltalk, языке, на котором родилась эта концепция, люди не говорят о вызове метода, а скорее об отправке сообщения объекту.Объект должен решить, как ответить на это сообщение, а вызывающий не должен знать о реализации. Например, можно отправить сообщение map как в массив, так и в связанный список, но внутренне итерация будет обрабатываться по-разному.

Связывание имени сообщения с реализацией метода является динамическим, и это рассматривается как основная сила объектов. В результате довольно сложные системы могут развиться из взаимодействия независимых объектов, которые не вмешиваются друг в друга.

Честно говоря, Factor сильно отличается от Smalltalk, но все же существует концепция классов, и общие слова могут быть определены с разными реализациями в разных классах.

Некоторые классы встроены в Factor, например string , boolean , fixnum или word . Далее, наиболее распространенный способ определения класса — это кортеж . Кортежи определяются с помощью слова синтаксического анализа TUPLE: , за которым следуют имя кортежа и поля класса, который мы хотим определить, которые называются слотами на языке Factor.

Определим класс для фильмов:

  ШАБЛОН: название фильма режиссер актеры;
  

Это также генерирует сеттеры >> название , >> режиссер и >> актеры и геттеры название >> , режиссер >> и актеры >> . Например, мы можем создать новый фильм с

  фильм новый "Престиж" >> название
  "Кристофер Нолан" >> режиссер
  {"Хью Джекман" "Кристиан Бэйл" "Скарлетт Йоханссон"} >> актеры
  

Мы также можем сократить это до

  «Престиж» «Кристофер Нолан»
{"Хью Джекман" "Кристиан Бэйл" "Скарлетт Йоханссон"}
фильм удав
  

Слово boa означает «по порядку аргументов» и является конструктором, который заполняет слоты кортежа элементами в стеке по порядку. фильм удав называется конструктором удава , каламбур на удаве Констриктор. Принято определять наиболее распространенный конструктор с именем , который в нашем случае может быть просто

 : <фильм> (название режиссера, актеры - фильм), фильм удав;
  

На самом деле конструкторы удавов настолько распространены, что указанную выше строку можно сократить до

В других случаях вы можете использовать некоторые значения по умолчанию или вычислить некоторые поля.

Функционально мыслящие люди будут беспокоиться об изменчивости кортежей.Фактически, слоты могут быть объявлены доступными только для чтения с помощью {slot-name read-only} . В этом случае установщик поля не будет сгенерирован, и значение должно быть установлено в начале с помощью конструктора boa. Другие допустимые модификаторы слота: initial: — для объявления значения по умолчанию — и слово класса, например integer , для ограничения значений, которые могут быть вставлены.

В качестве примера мы определяем другой класс кортежей для рок-групп

  ТУПЛ: группа
  {строка клавиатуры только для чтения}
  {гитарная струна только для чтения}
  {басовая струна только для чтения}
  {барабанная струна только для чтения};
: <группа> (клавишные гитара бас-барабаны - группа) группа boa;
  

вместе с одним экземпляром

  «Ричард Райт» «Дэвид Гилмор» «Роджер Уотерс» «Ник Мейсон» <группа>
  

Теперь, конечно, всем известно, что звезда в кино — это первый актер, а в рок-группе — басист.Чтобы кодировать это, мы сначала определяем общее слово

  GENERIC: звездочка (элемент - звезда)
  

Как вы можете видеть, он объявлен с помощью слова синтаксического анализа GENERIC: и объявляет свои эффекты стека, но в настоящее время он не имеет реализации, поэтому нет необходимости в закрывающем ; . Общие слова используются для динамической отправки. Мы можем определить реализации для различных классов, используя слово M:

  M: кинозвезды актеры >> первый;
M: группа звездных басов >>;
  

Если написать звездочка. два раза, вы можете увидеть различный эффект вызова универсального слова для экземпляров разных классов.

Встроенные классы и классы кортежей — это еще не все, что есть в объектной системе: можно определить больше классов с помощью операций над множествами, например UNION: и INTERSECTION: . Другой способ определить класс — это миксин .

миксинов определяются с помощью слова MIXIN: , и существующие классы могут быть добавлены к миксину, написав

Методы, определенные в миксине, будут доступны для всех классов, которые принадлежат миксину.Если вы знакомы с классами типов Haskell, вы заметите сходство, хотя Haskell обеспечивает во время компиляции, что экземпляры классов типов реализуют определенные функции, в то время как в Factor это неофициально указано в документации.

Двумя важными примерами миксинов являются последовательность и assoc . Первый определяет протокол, который доступен для всех конкретных последовательностей, таких как строки, связанные списки или массивы, а второй определяет протокол для ассоциативных массивов, таких как хэш-таблицы или списки ассоциаций.

Это позволяет воздействовать на все последовательности в Factor с помощью общего набора слов, в то же время различаясь по реализации и минимизируя повторение кода (поскольку требуется только несколько примитивов, а другие операции определены для класса последовательности ). Наиболее распространенные операции, которые вы будете использовать с последовательностями, — это map , filter и reduce , но их гораздо больше — как вы можете видеть с помощью «последовательностей» help .

Изучение инструментов

Большая часть продуктивности Factor достигается за счет глубокой интеграции языка и библиотек с окружающими их инструментами, которые воплощены в слушателе.Многие функции слушателя можно использовать программно и наоборот. Вы видели несколько примеров:

• справка доступна для навигации в Интернете, но вы также можете вызвать ее с помощью help и распечатать элементы справки с помощью print-content ;
• ярлык F2 или слова обновить и обновить все можно использовать для обновления словарей с диска, продолжая работу в слушателе;
• edit word обеспечивает интеграцию с редактором, но вы также можете щелкнуть имена файлов на страницах справки для словарей, чтобы открыть их.

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

 : инкр (х - у) 1 +;
: inc-print (x -) inc. ;
5 вкл-принт
  

, а затем

 : инкр (х - у) 2+;
5 вкл-принт
  

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

Вы также можете сохранить все состояние Factor с помощью слова save-image и позже восстановить его, запустив Factor с

  ./factor -i = путь к изображению
  

Фактически, Factor основан на изображениях и использует файлы только при загрузке и обновлении словарей.

Сила слушателя на этом не заканчивается. Элементы стека можно просмотреть, щелкнув по ним или вызвав слово инспектор . Например, попробуйте написать

  TUPLE: трилогия первая вторая третья;
: <трилогия> (первая вторая треть - трилогия) трилогия удав;
«Новая надежда» «Империя наносит ответный удар» «Возвращение джедая» <трилогия>
"Джордж Лукас" 2массив
  

Вы получите предмет, который выглядит как

  {~ трилогия ~ "Джордж Лукас"}
  

в стеке.Попробуйте щелкнуть по нему: вы сможете увидеть слоты массива и сосредоточиться на трилогии или на строке, дважды щелкнув по ним. Это чрезвычайно полезно для интерактивного прототипирования. Специальные объекты могут настраивать инспектор, реализуя метод content-gadget .

Есть еще один инспектор ошибок. Всякий раз, когда возникает ошибка, ее можно проверить с помощью F3 . Это позволяет вам исследовать исключения, объявления плохих эффектов стека и так далее. Отладчик позволяет вам переходить к коду как вперед, так и назад, и вам следует немного познакомиться с ним.Вы также можете запустить отладчик вручную, введя некоторый код в прослушиватель и нажав Ctrl + w .

Еще одна функция слушателя позволяет тестировать код. В качестве примера мы пишем намеренно неэффективное значение Фибоначчи:

  DEFER: fib-rec
: fib (n - f (n)) dup 2 <[] [fib-rec] если;
: fib-rec (n - f (n)) [1 - fib] [2 - fib] bi +;
  

(обратите внимание на использование DEFER: для определения двух взаимно рекурсивных слов).Вы можете измерить время выполнения, написав 40 fib , а затем нажав Ctrl + t вместо Enter. Вы получите информацию о времени, а также другую статистику. Программно вы можете использовать слово , время в цитате, чтобы сделать то же самое.

Вы также можете добавить часы по словам, чтобы распечатать входы и выходы при входе и выходе. Попробуйте написать

, а затем запустите 10 fib , чтобы посмотреть, что произойдет. Затем вы можете снять часы с помощью \ fib reset .

Другой очень полезный инструмент - словарь lint .Это сканирует определения слов, чтобы найти повторяющийся код, который можно исключить. В качестве примера давайте определим слово, чтобы проверить, начинается ли строка с другого. Создать тестовый словарь

и добавьте следующее определение

  ИСПОЛЬЗОВАНИЕ: последовательности ядра;
IN: lintme

: начинается с? (str sub -?) длина dup swapd head =;
  

Загрузите инструмент для удаления ворса с помощью USE: lint и напишите «lintme» lint-vocab . Вы получите отчет, в котором упоминается, что последовательность слов length swapd уже используется в слове (split) из разбиения.частный , следовательно, его можно вычесть.

Конечно, вы не захотите изменять источник слова в стандартной библиотеке, не говоря уже о частной библиотеке, но в более сложных случаях инструмент lint может находить фактические повторы. Рекомендуется время от времени обновлять словарный запас, чтобы избежать дублирования кода и как хороший способ обнаружить слова из библиотеки, которые вы могли случайно переопределить.

Наконец, есть несколько утилит для проверки слов. Вы можете увидеть определение слова в справке, но более быстрый способ - см. .Или, наоборот, вы можете использовать . , чтобы проверить вызывающих данное слово. Попробуйте \ обратное использование и \ обратное использование. .

Метапрограммирование

Теперь мы отправляемся в мир метапрограммирования и пишем наше первое слово для синтаксического анализа. К настоящему времени вы видели много слов синтаксического анализа, например [. {, H {, ИСПОЛЬЗОВАНИЕ: , IN: , <ЧАСТНОЕ , ОБЩЕЕ: и т. Д. Каждый из них определяется словом синтаксического анализа SYNTAX: и взаимодействует с синтаксическим анализатором Factor.

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

В качестве примера мы определим литерал для последовательностей ДНК.Последовательность ДНК - это последовательность одного из оснований цитозина, гуанина, аденина и тимина, которую мы будем обозначать буквами c, g, a, t. Поскольку существует четыре возможных базиса, мы можем кодировать каждую двумя битами. Позвольте использовать определение слова

 : dna> bits (токен - биты) {
  {"а" [{ж е}]}
  {"с" [{т т}]}
  {"г" [{ф т}]}
  {"т" [{т ф}]}
} дело ;
  

, где первый бит указывает, является ли основание пурином или пиримидином, а второй идентифицирует основания, которые образуют пару вместе.

Наша цель - прочитать последовательность букв a, c, g, t - возможно, с пробелами - и преобразовать их в битовый массив. Фактор поддерживает битовые массивы, а литеральные битовые массивы выглядят как ? {F f t} .

Наш синтаксис для ДНК начинается с ДНК { и получает все токены до тех пор, пока не будет найден закрывающий токен } . Промежуточные токены будут помещены в строку, и с помощью нашей функции dna> bits мы сопоставим эту строку с битовым массивом. Для чтения токенов мы будем использовать слово parse-tokens .Есть несколько слов более высокого уровня для взаимодействия с анализатором, например parse-until и parse-literal , но мы не можем применить их в нашем случае, поскольку найденные нами токены представляют собой просто последовательности acgt. допустимых слов фактора. Давайте начнем с простого приближения, которое просто считывает токены между нашими разделителями и выводит строку, полученную путем конкатенации

  СИНТАКСИС: суффикс конкатенации маркеров синтаксического анализа ДНК {"}"!
  

Вы можете проверить эффект, выполнив DNA {a ccg t a g} , что должно вывести «accgtag» .Во втором приближении мы преобразовываем каждую букву в логическую пару:

  СИНТАКСИС: соединение синтаксических анализаторов ДНК {"}"
  [1string dna> bits] {} суффикс map-as! ;
  

Обратите внимание на использование map-as вместо map . Поскольку целевая коллекция не является строкой, мы не использовали карту , которая сохраняет тип, а карту как , которая принимает в качестве дополнительного аргумента пример целевой коллекции - здесь {} . Наша последняя версия сглаживает массив пар с помощью concat и, наконец, превращается в битовый массив:

  СИНТАКСИС: соединение синтаксических анализаторов ДНК {"}"
  [ДНК 1-го кольца> биты] {} map-as
  concat> суффикс битового массива! ;
  

Если вы попробуете это с DNA {a ccg t a g} , вы должны получить

  `? {F f t t t t f t t f f f f t}`
  

Давайте приведем еще один очень простой пример, украденный у Джона Бенедиктссона, который касается синтаксиса инфиксных значений для диапазонов.До сих пор мы использовали [a, b] для создания диапазона. Мы можем сделать синтаксис, более удобный для людей, переходящих с других языков, используя ... в качестве инфиксного слова.

Мы можем использовать scan-object , чтобы запросить у синтаксического анализатора следующий анализируемый объект, и unclip-last , чтобы получить верхний элемент из вектора аккумулятора. Таким образом, мы можем определить ... просто с помощью

  СИНТАКСИС: ... суффикс [a, b] объекта сканирования unclip-last! ;
  

Вы можете попробовать это с 12... 18> массив .

Мы только прикоснулись к синтаксическому анализу слов; в общем, они позволяют выполнять произвольные вычисления во время компиляции, обеспечивая мощные формы метапрограммирования.

В некотором смысле синтаксис Factor является полностью плоским, а синтаксический анализ слов позволяет вам вводить синтаксис, более сложный, чем поток токенов для локального использования. Это позволяет расширить язык Factor, добавив много новых функций в виде библиотек. В принципе, можно было бы даже скомпилировать внешний язык для Factor - скажем, JavaScript - и встроить его как Factor DSL внутри границ парсинг слова. Нужен некоторый вкус, чтобы не злоупотреблять этим слишком много для введения стилей, которые слишком чужды конкатенативному миру.

Когда стека не хватает

До сих пор я немного жульничал и старался избегать написания примеров, которые были бы слишком сложными для написания в конкатенативном стиле. По правде говоря, вы найдете случаи, когда это слишком ограничительно. К счастью, синтаксический анализ слов позволяет вам обойти эти ограничения, и Factor предлагает некоторые из них, чтобы справиться с наиболее распространенными неприятностями.

Возможно, вы захотите дать имя локальным переменным. Слово :: работает аналогично : , но позволяет вам фактически связывать имя параметров стека с переменными, чтобы вы могли использовать их несколько раз в нужном вам порядке. Например, давайте определим слово для решения квадратных уравнений. Я избавлю вас от версии, основанной исключительно на стеке, и представлю вам версию с локальными переменными (для этого потребуется словарь locals ):

  :: решить q (a b c - x)
  b neg
  б б * 4 а в * * - sqrt
  +
  2 а * /;
  

В этом случае мы выбрали знак +, но мы можем сделать лучше и вывести оба решения:

  :: решить q (a b c - x1 x2)
  b neg
  б б * 4 а в * * - sqrt
  [+] [-] 2bi
  [2 a * /] bi @;
  

Вы можете проверить, работает ли это определение с чем-то вроде 2 -16 30 resolveq , которое должно выводить как 3.0 и 5,0 . Помимо написания в стиле RPN, наша первая версия resolveq выглядит точно так же, как и на языке с локальными переменными. Для второго определения мы применяем операции + и - к -b и delta, используя комбинатор 2bi , а затем делим оба результата на 2a, используя bi @ .

Также есть поддержка местных жителей в котировках - с помощью [| - и методы - с использованием M :: - и можно также создать область для привязки локальных переменных вне определений с помощью [let .Конечно, все они на самом деле компилируются в конкатенативный код с некоторой перетасовкой стека. Я рекомендую вам просмотреть примеры этих слов, но имейте в виду, что их использование на практике гораздо менее заметно, чем можно было бы ожидать - около 1% собственной кодовой базы Factor.

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

Пример из документации, вероятно, говорит больше, чем приведенное выше предложение: попробуйте написать 1 {1 2 3} [/] с картой .

Разрешите еще раз взять прайм? , но на этот раз напишите его без вспомогательных слов:

 : простое? (n -?) [sqrt 2 swap [a, b]] [[поменять местами делитель? ] карри] би любой? нет ;
  

Используя с вместо карри , это упрощается до

 : простое? (n -?) 2 над sqrt [a, b] [divisor? ] с любой? нет ;
  

Если вы не представляете себе, что происходит, вы можете рассмотреть словарь fry .Он определяет жареных котировок ; это цитаты, в которых есть дыры, отмеченные цифрами _ , которые заполнены значениями из стека.

Первая цитата переписывается проще как

  ['[2 _ sqrt [a, b]] call]
  

Здесь мы используем жареную цитату - начиная с '[ - для вставки элемента в верхнюю часть стека во вторую позицию, а затем используем вызов для оценки результирующей цитаты. Вторая цитата становится просто

так что альтернативное определение prime? это

 : простое? (n -?) ['[2 _ sqrt [a, b]] call] [' [_ делитель подкачки? ]] би любой? нет ;
  

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

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

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

  СИМВОЛ: любимый язык
  

Затем можно использовать слово set для привязки переменной и get для получения ее значений, например

  Набор любимых языков "Фактор"
любимый язык получить
  

Области действия вложены, и можно создавать новые области с помощью слова with-scope .Попробуйте например

 : on-the-jvm (-) [
  Набор любимых языков "Scala"
  любимый язык получить.
] с областью действия;
  

Если вы запустите on-the-jvm , вы получите напечатанное «Scala» , но все равно после выполнения favourite-language get верните «Factor» .

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

Ввод / вывод

Теперь мы завершаем экскурсию по языку и начинаем исследовать, как взаимодействовать с внешним миром. Я начну в этом разделе с некоторых примеров ввода / вывода, но это неизбежно приведет к обсуждению асинхронности. Затем в оставшейся части учебника будет более подробно рассказано о параллельных и распределенных вычислениях.

Factor реализует эффективные средства асинхронного ввода / вывода, аналогичные NIO на JVM или Node.js системы ввода-вывода. Это означает, что операции ввода и вывода выполняются в фоновом режиме, оставляя задачу переднего плана свободной для выполнения работы, пока диск вращается или сеть буферизует пакеты. Фактор в настоящее время является однопоточным, но асинхронность позволяет ему быть достаточно производительным для приложений, привязанных к вводу-выводу.

Все слова ввода / вывода фактора сосредоточены на потоках . Потоки - это ленивые последовательности, которые можно читать или записывать, типичными примерами являются файлы, сетевые порты или стандартный ввод и вывод.Фактор содержит пару динамических переменных, называемых входным потоком и выходным потоком , которые используются большинством слов ввода-вывода. Эти переменные могут быть восстановлены локально, используя with-input-stream , with-output-stream и with-streams . Когда вы находитесь в слушателе, потоки по умолчанию пишут и читают в слушателе, но как только вы развертываете свое приложение как исполняемый файл, они обычно привязываются к стандартному вводу и выводу вашей консоли.

Слова и (или ) могут использоваться для создания потока чтения или записи в файл, учитывая его путь и кодировку.Собирая все вместе, мы делаем простой пример слова, которое читает каждую строку файла, закодированного в UTF8, и записывает первую букву строки в слушатель.

Во-первых, нам нужно безопасное слово , которое работает как head , но возвращает ввод, если последовательность слишком короткая. Для этого мы будем использовать слово recovery , которое позволяет нам объявить блок try-catch. Для этого требуются две цитаты: первая выполняется, а в случае неудачи вторая выполняется с ошибкой в ​​качестве входных данных.Следовательно, мы можем определить

 : безопасная голова (seq n - seq ') [head] [2drop] recovery;
  

Это в основном повод показать пример исключений, поскольку Factor определяет короткое слово , которое принимает последовательность и число и возвращает минимум между длиной последовательности и числом. Это позволяет нам просто написать

 : безопасная головка (seq n - seq ') короткая головка;
  

С этим определением мы можем сделать слово, читающее первый символ первой строки:

 : первые буквы чтения (путь -)
  utf8 <файл-читатель> [
    readln 1 безопасная запись nl
  ] с потоком ввода;
  

Используя вспомогательное слово with-file-reader , мы также можем сократить его до

 : первые буквы чтения (путь -)
  utf8 [
    readln 1 безопасная запись nl
  ] с файловым ридером;
  

К сожалению, мы ограничены одной строкой.Чтобы прочитать больше строк, мы должны связать вызовы с readln до тех пор, пока один из них не вернет f . Фактор помогает нам со словом файл-строки , которое лениво перебирает строки. Наше окончательное определение становится

 : первые буквы чтения (путь -)
  utf8 строки файла [1 безопасная запись nl] каждая;
  

Когда файл маленький, можно также использовать file-contents для чтения всего содержимого файла в одной строке. Фактор определяет гораздо больше слов для ввода / вывода, которые охватывают гораздо больше случаев, таких как двоичные файлы или сокеты.

Мы заканчиваем этот раздел, исследуя некоторые слова для обхода файловой системы. Наша цель - минимальная реализация команды ls .

Слово каталогов-записей перечисляет содержимое каталога, давая список элементов кортежа, каждый из которых имеет слоты с именем и типа . Вы можете убедиться в этом, попробовав записей каталога "/ home" [имя >>] map . Если вы проверите записи каталога, вы увидите, что это либо + directory + , либо + regular-file + (ну, есть и символические ссылки, но для простоты мы их проигнорируем).Следовательно, мы можем определить слово, в котором перечислены файлы и каталоги с

 : list-files-and-dirs (путь - каталоги файлов)
    каталог-записей [тип >> + обычный-файл + =] раздел;
  

С его помощью мы можем определить слово ls , которое будет печатать содержимое каталога следующим образом:

 : ls (путь -)
  список файлов и каталогов
  "СПРАВОЧНИКИ:" напишите nl
  "------------" напишите nl
  [имя >> написать nl] каждый
  "ФАЙЛЫ:" напишите nl
  "------" написать nl
  [имя >> напишите nl] каждый;
  

Попробуйте ввести слово в своем домашнем каталоге, чтобы увидеть эффект.В следующем разделе мы рассмотрим, как создать исполняемый файл для нашей простой программы.

Развертывание программ

Есть два способа запускать программы Factor вне слушателя: как сценарии, которые интерпретируются Factor, или как автономный исполняемый файл, скомпилированный для вашей платформы. Оба требуют, чтобы вы определили словарь с точкой входа (хотя для скриптов есть еще более простой способ), так что давайте сделаем это в первую очередь.

Начните с создания нашего словаря ls с помощью scaffold-work "ls" и сделайте его таким:

 ! Авторское право (C) 2014 Андреа Ферретти.! См. Http://factorcode.org/license.txt для получения лицензии BSD.
ИСПОЛЬЗОВАНИЕ: командная строка аксессоров io io.directories io.files.types
  последовательности пространств имен ядра;
IN: ls

<ЧАСТНЫЙ

: list-files-and-dirs (путь - каталоги файлов)
    каталог-записей [тип >> + обычный-файл + =] раздел;

ЧАСТНЫЙ>

: ls (путь -)
  список файлов и каталогов
  "СПРАВОЧНИКИ:" напишите nl
  "------------" напишите nl
  [имя >> написать nl] каждый
  "ФАЙЛЫ:" напишите nl
  "------" написать nl
  [имя >> напишите nl] каждый;
  

Когда мы запустим наш словарь, нам нужно будет прочитать аргументы из командной строки.Аргументы командной строки хранятся в динамической переменной командной строки , которая содержит массив строк. Следовательно - забывая о проверке ошибок - мы можем определить слово, которое запускает ls в первом аргументе командной строки с

 : командная строка ls-run (-) получить сначала ls;
  

Наконец, мы используем слово MAIN: , чтобы объявить главное слово нашего словаря:

Добавив эти две строчки в свой словарь, теперь вы готовы к его запуску.Самый простой способ - запустить словарь как скрипт с флагом -run , переданным в Factor. Например, чтобы перечислить содержимое моего дома, я могу сделать

  ./factor -run = ls / home / andrea
  

Чтобы создать исполняемый файл, мы должны установить некоторые параметры и вызвать слово deploy . Самый простой способ сделать это графически - вызвать слово средства развертывания . Если вы напишете «ls» deploy-tool , вам будет представлено окно для выбора вариантов развертывания.В нашем простом случае мы оставим параметры по умолчанию и выберем «Развернуть».

Через некоторое время вам должен быть представлен исполняемый файл, который вы можете запустить как

Попробуйте сделать программу ls более устойчивой, обрабатывая отсутствующие аргументы командной строки и несуществующие аргументы или аргументы, не относящиеся к каталогу.

Многопоточность

Как мы уже сказали, среда выполнения Factor является однопоточной, как и Node. Тем не менее, можно имитировать параллелизм в однопоточном режиме, используя сопрограмм .По сути, это кооперативные потоки, которые периодически освобождают управление с помощью слова и дают слов, чтобы планировщик мог решить, какую сопрограмму запустить следующей.

Хотя совместные потоки не позволяют использовать несколько ядер, они все же имеют некоторые преимущества:

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

Для случаев, когда нужно использовать несколько ядер, Factor предлагает возможность порождения других процессов и взаимодействия между ними с использованием каналов , как мы увидим в следующем разделе.

Threads in Factors создаются из цитаты и имени, с порождением слова. Давайте воспользуемся этим, чтобы напечатать первые несколько строк «Звездных войн», по одной в секунду, причем каждая строка печатается внутри своего собственного потока. Во-первых, давайте запишем эти строки внутри динамической переменной:

  СИМВОЛ: звездные войны

"Давным-давно, в далекой-далекой галактике....

Это период гражданской войны. Бунтарь
космические корабли, поражающие из скрытого
база, одержали свою первую победу
против злой Галактической Империи.

Во время боя шпионам повстанцев удалось
украсть секретные планы Империи
абсолютное оружие, ЗВЕЗДА СМЕРТИ,
бронированная космическая станция с достаточным
власть уничтожить целую планету.

Преследуемые зловещими агентами Империи,
Принцесса Лея мчится домой на ее борту
звездолет, хранитель украденных планов
что может спасти ее людей и восстановить
свобода галактики.... "
"\ n" набор разделенных звездных войн
  

Мы создадим 18 потоков, каждый из которых будет печатать строку. Операция, которую должен выполнить поток, составляет

 : печать в строке (i -) Звездные войны получают-й отпечаток;
  

  18 [0, б) [
  [[print-a-line] карри]
  [число> строка]
  би спаун
] каждый
  

 : ожидание и печать (i -) dup секунд спящий режим печати строки;
  

  18 [0, б) [
  [[подождите и распечатайте] карри]
  [число> строка]
  би спаун
] каждый
  

  18 [0, б) [
  [wait-and-print] карри в потоке
] каждый
  

  "resource: extra / time-server / time-server.factor" файл редактирования
  

  TUPLE: эхо-ответчик;

: <эхо-ответчик> (- ответчик) эхо-ответчик новый;

M: эхо-ответчик на вызов-ответчик *
  уронить
  <ответ>
    200 >> код
    «Документ следует» >> сообщение
    "текст / обычный" >> тип-содержимого
    поменять местами concat >> body;
  

   основной набор-ответчик глобальный
  

  диспетчер new-диспетчер
   "echo" - ответчик добавления
  "/ home / andrea"  "домашний" ответчик
  главный респондент set-global
  

 ! Авторское право (C) 2014 Андреа Ферретти.
! См. Http://factorcode.org/license.txt для получения лицензии BSD.
ИСПОЛЬЗОВАНИЕ: аксессор печи. Действия http http.server
  http.server.dispatchers http.server.static последовательности ядра;
В: привет-печь


ТУП: эхо-ответчик;

: <эхо-ответчик> (- ответчик) эхо-ответчик новый;

M: эхо-ответчик на вызов-ответчик *
  уронить
  <ответ>
    200 >> код
    «Документ следует» >> сообщение
    "текст / обычный" >> тип-содержимого
    поменять местами concat >> body;

ТУП: привет-диспетчер <диспетчер;

:  (- респондент)
  привет-диспетчер новый-диспетчер
     "echo" - ответчик добавления
    "/ home / andrea"  "домашний" ответчик
    
      {привет-диспетчер "привет"} >> шаблон
    ответчик "хлоя";
  

  


  
 Привет от Хлои 

  

  ОТ: concurrency.messaging => отправить получить;
  

 : повторная печать (-) получение. печать-повторно;
[печать-повторно] порождение "принтера"
  

  СИМВОЛ: ch
<канал> набор каналов
  

  ["hello" ch get to] внутри потока
  

  [ч получить от. ] в потоке
"привет"
  

  ИСПОЛЬЗОВАНИЕ: параллелизм.распределен
f 9000  <узел-сервер> start-server
  

  ОТ: concurrency.messaging => отправить получить;
: добавить (x - y) получить + dup. Добавлять ;
[0 добавить] порождение "гадюки"
  

  дублирующее имя >> регистр-удаленный-поток
  

  f 9000  "сумматор" 
  

  ОТ: параллелизм.обмен сообщениями => отправить получить;
  

  ИСПОЛЬЗОВАНИЕ: каналы channels.remote;
 дублирующая публикация
  

  f 9000  72581372615274718877978895122231284308489678564344087
03359628058956 
"Привет, каналы" на
 

  ИСПОЛЬЗОВАНИЕ: images.http
http-изображение "http://factorcode.org/logo.png".