(2020) Нейрокогнитивная основа знания об идентичности объекта и событиях: диссоциации отражают противоположные эффекты семантической согласованности и контроля. Philos Trans R Soc Lond B Biol Sci 375:201. doi:10.1098/rstb.2019.0300 pmid:31840592

2. Кузнецова А.,
3. Брокхофф П.Б.,
4. Christensen RHB

(2017) Пакет lmertest: тесты в линейных моделях смешанных эффектов. J Stat Software 82:1–26.

2. Ламбон Ральф М.А.,
3. Джеффрис Э.,
4. Паттерсон К.,
5. Роджерс Т.Т.

(2017) Нейронные и вычислительные основы семантического познания. Nat Rev Neurosci 18:42–55. doi:10.1038/nrn.2016.150 pmid:27881854

2. Lanzoni L,
3. Ravasio D,
4. Thompson H,
5. Vatansever D,
6. Margulies D,
7. Smallwood J,
8. Jefferies E

(2020) The role of default mode network in semantic cue интеграция. Нейроизображение 219:117019. doi:10.1016/j.neuroimage.2020.117019 pmid:32522664

2. Лю Б.,
3. Чой Х.С.,
4. Марслен-Уилсон В.Д.,
5. Кларк А.,
6. Рэндалл Б.,
7. Тайлер Л.К. Proc Natl Acad Sci USA 116:21318–21327. doi:10.1073/pnas.1
   2116 pmid:31570590

8. ↵
   2. Maris E,
   3. Oostenveld R

   (2007) Непараметрическое статистическое тестирование данных ЭЭГ и МЭГ. J Neurosci Methods 164:177–190. doi:10.1016/j.jneumeth.2007.03.024 pmid:17517438

9. ↵
   2. Martin A

   (2020) Композиционная нейронная архитектура для языка. J Cogn Neurosci 32:1407–1427. doi:10.1162/jocn_a_01552 pmid:32108553

10. ↵
    2. Мартин А.,
    3. Думас Л.

    (2017) Механизм коркового вычисления иерархической лингвистической структуры. PLoS Biol 15:e2000663. doi:10.1371/journal.pbio.2000663 pmid:28253256

11. ↵
    2. Мартин А.,
    3. Думас Л.

    (2020) Тензоры и композиционность в нейронных системах. Philos Trans R Soc Lond B Biol Sci 375:201

12. . doi:10.1098/rstb.2019.0306 pmid:31840579

13. ↵
    2. Матчин В.,
    3. Хикок Г.

    (2020) Корковая организация синтаксиса. Кора головного мозга 30:1481–1498. doi:10.1093/cercor/bhz180 pmid:31670779

14. ↵
    2. Matchin W,
    3. Liao C,
    4. Gaston P,
    5. Lau E

    (2019) Те же слова, разные структуры: фМРТ-исследование отношений аргументов и угловой извилины. Нейропсихология 125:116–128. doi:10.1016/j.neuropsychologia.2019.01.019 pmid:30735675

15. ↵
    2. Misaki M,
    3. Kim Y,
    4. Bandettini PA,
    5. Kriegeskorte N

    (2010) Сравнение многомерных классификаторов и нормализации ответа для фМРТ с информацией о шаблонах. Нейроизображение 53:103–118. doi:10.1016/j.neuroimage.2010.05.051

16. ↵
    2. Mitchell J,
    3. Lapata M

    (2008) Векторные модели семантической композиции. Материалы ACL-08: HLT. Колумбус, июнь 2008 г., стр. 236–244. Ассоциация компьютерной лингвистики.

17. ↵
    2. Молло Г.,
    3. Джеффрис Э.,
    4. Корнелиссен П.,
    5. Дженнари С.П. височная извилина. Брейн Ланг 177–178: 23–36. doi:10.1016/j.bandl.2018.01.001 pmid:269

    6. ↵
       2. Нестор П.Я.,
       3. Fryer TD,
       4. Hodges JR

       (2006) Декларативные нарушения памяти при болезни Альцгеймера и семантической деменции. Нейроизображение 30:1010–1020. doi:10.1016/j.neuroimage.2005.10.008 pmid:16300967

    7. ↵
       2. Nieuwenhuis I,
       3. Takashima A,
       4. Oostenveld R,
       5. McNaughton BL,
       6. Fernández G,
       7. Jensen O

       (2012) The neocortical network representing associative memory reorganizes with time in a process engaging the передняя височная доля. Кора головного мозга 22:2622–2633. doi:10.1093/cercor/bhr338 pmid:22139815

    8. ↵
       2. Oldfield RC

       (1971) Оценка и анализ ручности: Эдинбургская инвентаризация. Нейропсихология 9:97–113. doi:10.1016/0028-3932(71)-4 pmid:5146491

    9. ↵
       2. Паттерсон К.,
       3. Нестор П.,
       4. Роджерс Т.

       (2007) Откуда вы знаете то, что знаете? Представление семантических знаний в мозгу человека. Nat Rev Neurosci 8:976–987. doi:10.1038/nrn2277 pmid:18026167

    10. ↵
        2. Peirce J,
        3. Gray JR,
        4. Simpson S,
        5. MacAskill M,
        6. Höchenberger R,
        7. Sogo H,
        8. Kastman E,
        9. Lindeløv JK

        (2019) PsychoPy2: experiments in поведение стало проще. Behav Res Methods 51:195–203. doi:10.3758/s13428-018-01193-y pmid:30734206

    11. ↵
        2. Pennington J,
        3. Socher R,
        4. Manning C

        (2014) GloVe: глобальные векторы для представления слов. Материалы конференции 2014 г. по эмпирическим методам обработки естественного языка, Доха, стр. 1532–1543. Ассоциация компьютерной лингвистики.

    12. ↵
        2. Pobric G,
        3. Jefferies E,
        4. Lambon Ralph MA

        (2007) Передние височные доли опосредуют семантическое представление: имитация семантической деменции с помощью rTMS у нормальных участников. Proc Natl Acad Sci USA 104:20137–20141. doi:10.1073/pnas.0707383104 pmid:18056637

    13. ↵
        2. Price A,
        3. Bonner MF,
        4. Peelle JE,
        5. Grossman M

        (2015) Сходящиеся доказательства нейроанатомической основы комбинаторной семантики угловой извилины. J Neurosci 35:3276–3284. doi:10.1523/JNEUROSCI.3446-14.2015 pmid:25698762

    14. ↵
        2. Pylkkänen L

        (2019) Нейронная основа комбинаторного синтаксиса и семантики. Наука 366:62–66. doi:10.1126/science.aax0050 pmid:31604303

    15. ↵
        2. Sakai K,
        3. Miyashita Y

        (1991) Нейронная организация долговременной памяти парных партнеров. Природа 354:152–155. doi:10.1038/354152a0 pmid:1944594

    16. ↵
        2. Schölkopf B,
        3. Tsuda K,
        4. Vert JP

        (2004) Методы ядра в вычислительной биологии. Кембридж: MIT Press.

    17. ↵
        2. Саймон Д.А.,
        3. Льюис Г.,
        4. Маранц А.

        (2012) Устранение неоднозначности формы и эффектов лексической частоты в ответах МЭГ с использованием омонимов. Lang Cognitive Proc 27:275–287. дои: 10.1080/016

        .2011.607712

    18. ↵
        2. Смит С.М.,
        3. Николс Т.Е.

        (2009) Улучшение беспорогового кластера: решение проблем сглаживания, пороговой зависимости и локализации при выводе кластера. Нейроизображение 44:83–98.

    19. ↵
        2. Teige C,
        3. Cornelissen PL,
        4. Mollo G,
        5. Gonzalez Alam TRDJ,
        6. McCarty K,
        7. Smallwood J,
        8. Jefferies E

        (2019) Диссоциации в семантическом познании: колебательные доказательства противоположных эффектов семантического контроля и типа семантического отношения в передней и задней височной коре. Кортекс 120:308–325. doi:10.1016/j.cortex.2019.07.002 pmid:313

    21. ↵
        2. Teige C,
        3. Mollo G,
        4. Millman R,
        5. Savill N,
        6. Smallwood J,
        7. Cornelissen PL,
        8. Jefferies E

        (2018) Динамическое семантическое познание: характеристика когерентного и контролируемого концептуального поиска во времени с использованием магнитоэнцефалографии и хронометрической транскраниальной магнитной стимуляции. Кортекс 103:329–349. doi:10.1016/j.cortex.2018.03.024 pmid:29684752

    22. ↵
        2. van der Maaten LJP

        (2014) Ускорение t-SNE с использованием древовидных алгоритмов. J Mach Learn Res 15:3221–3245.

    23. ↵
        2. Wang X,
        3. Margulies DS,
        4. Smallwood J,
        5. Jefferies E

        (2020) Градиент от долговременной памяти к новому познанию: переходы через режим по умолчанию и исполнительную кору. Нейроизображение 220:117074. doi:10.1016/j.neuroimage.2020.117074 pmid:32574804

    24. ↵
        2. Ван Ю,
        3. Коллинз Дж. А.,
        4. Коски Дж.,
        5. Nugiel T,
        6. Metoki A,
        7. Olson IR

        (2017) Динамическая нейронная архитектура для поиска социальных знаний. Proc Natl Acad Sci USA 114:E3305–E3314. doi:10.1073/pnas.1621234114 pmid:28289200

    25. ↵
        2. Westerlund M,
        3. Pylkkänen L

        (2014) Роль левой передней височной доли в семантической композиции по сравнению с семантической памятью. Нейропсихология 57:59–70.

    26. ↵
        2. Westerlund M,
        3. Kastner I,
        4. Al Kaabi M,
        5. Pylkkänen L

        (2015) LATL как локус состава: данные MEG на английском и арабском языках. Брэйн Ланг 141:124–134. doi:10.1016/j.bandl.2014.12.003 pmid:25585277

    Наверх

    Общие сведения о комбинаторах парсеров | F# для удовольствия и выгоды

    ОБНОВЛЕНИЕ: Слайды и видео из моего выступления на эту тему

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

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

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

    В этой серии будет четыре поста:

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

    Очевидно, что здесь речь пойдет не о производительности или эффективности, но я надеюсь, что это даст вам понимание, которое позволит вам эффективно использовать такие библиотеки, как FParsec. И, кстати, большое спасибо Штефану Толксдорфу, создавшему FParsec. Вы должны сделать его своим первым портом захода для всех ваших потребностей синтаксического анализа .NET!

    ---

    Разбор жестко закодированного символа

    Для начала давайте создадим что-то, что просто анализирует один жестко закодированный символ, в данном случае букву «А». Вы не можете получить намного проще, чем это!

    Вот как это работает:

    • На вход синтаксического анализатора поступает поток символов. Мы могли бы использовать что-то сложное, но сейчас мы просто используем строку .
    • Если поток пуст, то вернуть пару, состоящую из false и пустая строка.
    • Если первым символом в потоке является A , то вернуть пару, состоящую из true и оставшегося потока символов.
    • Если первый символ в потоке не является A , то вернуть false и (неизменный) исходный поток символов.

    Вот код:

     let parseA str =
      если String.IsNullOrEmpty(str), то
        (ЛОЖЬ,"")
      иначе, если ул.[0] = 'А' тогда
        пусть остальные = str.[1..]
        (правда, осталось)
      еще
        (ложь, ул.)
     

    Подпись parseA :

     val parseA :
      строка -> (логическое * строка)
     

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

    Давайте проверим это сейчас — сначала с хорошим вводом:

     пусть inputABC = "ABC"
    parseA inputABC
     

    Результат:

     (правда, "BC")
     

    Как видите, A израсходовано, и осталось всего "БК" .

    А теперь с неправильным вводом:

     пусть inputZBC = "ZBC"
    parseA inputZBC
     

    , что дает результат:

     (ложь, "ZBC")
     

    И в этом случае первый символ был , а не , а оставшийся ввод по-прежнему "ZBC" .

    Итак, вот вам невероятно простой парсер. Если ты это поймешь, то все последующее будет легко!

    ---

    Разбор указанного символа

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

    И на этот раз вместо того, чтобы возвращать true или false, мы вернем сообщение о том, что произошло.

    Мы будем называть функцию pchar для «разбора символа». Это станет фундаментальным строительным блоком всех наших парсеров. Вот код для нашей первой попытки:

     let pchar (charToMatch,str) =
      если String.IsNullOrEmpty(str), то
        let msg = "Нет больше ввода"
        (сообщение, "")
      еще
        пусть сначала = ул. [0]
        если сначала = charToMatch, то
          пусть остальные = str.[1..]
          пусть msg = sprintf "Найдено %c" charToMatch
          (сообщение,осталось)
        еще
          let msg = sprintf "Ожидается '%c'.  Сначала получено '%c'" charToMatch
          (msg, стр)
     

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

    Подпись pchar :

     val pchar :
      (символ * строка) -> (строка * строка)
     

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

    Давайте проверим это сейчас – сначала с правильным вводом:

     let inputABC = "ABC"
    pchar('A',inputABC)
     

    Результат:

     ("Найдено A", "BC")
     

    Как и прежде, A было израсходовано, и осталось только "BC" .

    А теперь с неправильным вводом:

     пусть inputZBC = "ZBC"
    pchar('A',inputZBC)
     

    , что дает результат:

     ("Ожидание 'A'.  Получил 'Z'", "ZBC")
     

    И снова, как и раньше, первый символ был , а не , а оставшийся ввод по-прежнему "ZBC" .

    Если мы пройдём через Z , то синтаксический анализатор успешен:

     pchar('Z',inputZBC) // ("Найдено Z", "BC")
     

    ---

    Возврат успеха/неудачи

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

     type ParseResult<'a> =
      | Успех
      | Сбой строки
     

    Случай Success является общим и может содержать любое значение. Случай Failure содержит сообщение об ошибке.

    Подробнее об использовании подхода «успех/неудача» см. в моем докладе о функциональной обработке ошибок.

    Теперь мы можем переписать синтаксический анализатор, чтобы он возвращал один из случаев Result , например:

     let pchar (charToMatch,str) =
      если String.IsNullOrEmpty(str), то
        Ошибка «Нет больше ввода»
      еще
        пусть сначала = ул. [0]
        если сначала = charToMatch, то
          пусть остальные = str.[1..]
          Успех (charToMatch,осталось)
        еще
          let msg = sprintf "Ожидается '%c'. Сначала получено '%c'" charToMatch
          Сообщение об ошибке
     

    Подпись pchar теперь:

     val pchar :
      (char * строка) -> ParseResult
     

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

    Проверим еще раз — сначала с правильным вводом:

     let inputABC = "ABC"
    pchar('A',inputABC)
     

    Результат:

     Успех ("A", "BC")
     

    Как и прежде, A израсходовано, а оставшийся ввод равен "BC" . Мы также получаем фактических совпадающих символов (в данном случае A ).

    А теперь с неправильным вводом:

     пусть inputZBC = "ZBC"
    pchar('A',inputZBC)
     

    , что дает результат:

     Ошибка "Ожидание "A". Получил "Z""
     

    И в этом случае возвращается случай Сбой с соответствующим сообщением об ошибке.

    Теперь это схема входов и выходов функции:

    ---

    Переход на каррированную реализацию

    В предыдущей реализации входом в функцию был кортеж — пара. Это требует, чтобы вы передавали оба входа одновременно. В функциональных языках, таких как F#, более идиоматично использовать каррированную версию, например:

     let pchar charToMatch str =
      если String.IsNullOrEmpty(str), то
        Ошибка «Нет больше ввода»
      еще
        пусть сначала = ул. [0]
        если сначала = charToMatch, то
          пусть остальные = str.  кортеж
     9карри
     

    Вот каррированная версия pchar , представленная в виде диаграммы:

    Что такое карри?

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

    Другими словами, эта двухпараметрическая функция:

     пусть сложит x y =
      х + у
     

    с подписью:

     значение добавить : x:int -> y:int -> int
     

    можно записать как эквивалентную функцию с одним параметром, которая возвращает лямбду, например:

     пусть добавят x =
      fun y -> x + y // вернуть лямбду
     

    или как функция, которая возвращает внутреннюю функцию, например:

     давайте добавим x =
      пусть innerFn y = x + y
      innerFn // возвращаем innerFn
     

    Во втором случае, когда используется внутренняя функция, сигнатура выглядит несколько иначе:

     val add : x:int -> (int -> int)
     

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

     // оригинал (автоматическое каррирование двухпараметрической функции)
    val add : x:int -> y:int -> int
    // явное каррирование с помощью внутренней функции
    val add : x:int -> (int -> int)
     

    Переписывание с внутренней функцией

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

    Вот новая реализация с внутренней функцией с умным названием innerFn :

     let pchar charToMatch =
      // определяем вложенную внутреннюю функцию
      пусть innerFn ул =
        если String.IsNullOrEmpty(str), то
          Ошибка «Нет больше ввода»
        еще
          пусть сначала = ул. [0]
          если сначала = charToMatch, то
            пусть остальные = str.[1..]
            Успех (charToMatch,осталось)
          еще
            let msg = sprintf "Ожидается '%c'.  Сначала получено '%c'" charToMatch
            Сообщение об ошибке
      // возвращаем внутреннюю функцию
      внутреннийFn
     

    Сигнатура типа для этой реализации выглядит так:

     val pchar :
      charToMatch:char -> (string -> ParseResult)
     

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

     // реализация с двумя параметрами
    пусть pchar charToMatch ул =
        ...
    // реализация с одним параметром и внутренней функцией
    пусть pcharcharToMatch =
        пусть innerFn ул =
            ...
        // возвращаем внутреннюю функцию
        внутреннийFn
     

    Преимущества каррированной реализации

    Что хорошо в каррированной реализации, так это то, что мы можем частично применить символ, который хотим разобрать, чтобы получить новую функцию, например:

     let parseA = pchar 'A'
     

    Теперь мы можем указать второй параметр «входного потока» позже:

     let inputABC = «ABC»
    parseA inputABC //=> Успех ('A', "BC")
    пусть inputZBC = "ZBC"
    parseA inputZBC //=> Ошибка "Ожидается 'A'.  Получил 'Z'"
     

    На этом этапе давайте остановимся и посмотрим, что происходит:

    • Функция pchar имеет два входа
    • Мы можем предоставить один ввод (символ для сопоставления), и в результате будет возвращена функция .
    • Затем мы можем предоставить второй вход (поток символов) этой функции синтаксического анализа, и это создаст окончательное значение Result .

    Вот схема pchar снова, но на этот раз с акцентом на частичное применение:

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

    ---

    Инкапсуляция функции синтаксического анализа в тип

    Если мы посмотрим на parseA (из приведенного выше примера), то увидим, что он имеет тип функции:

     val parseA : string -> ParseResult
     

    Этот тип немного сложен в использовании, поэтому давайте инкапсулируем его в тип-оболочку с именем 9. 2364 Parser , например:

     type Parser<'T> = Parser of (string -> ParseResult<'T * string>)
     

    Путем его инкапсуляции мы перейдем от этого дизайна:

    к этому дизайну, где он возвращает значение Parser :

    В чем преимущества наличия этого дополнительного типа по сравнению с работой с «сырая» строка -> функция ParseResult напрямую?

    • Всегда полезно использовать типы для моделирования предметной области, и в этой предметной области мы имеем дело с «парсерами», а не с функциями (хотя за кулисами это одно и то же).
    • Это упрощает определение типа и помогает сделать комбинаторы парсера (которые мы создадим позже) более понятными (например, комбинатор, который принимает два параметра «Парсер», понятен, но комбинатор, принимающий два параметра типа string -> ParseResult <'a * string> трудно читать).
    • Наконец, он поддерживает скрытие информации (с помощью абстрактного типа данных), чтобы мы могли позже добавлять метаданные, такие как метка/строка/столбец и т.  д., без нарушения работы клиентов.

    Изменить реализацию просто. Нам просто нужно изменить способ возврата внутренней функции.

    То есть из этого:

     пусть pchar charToMatch =
        пусть innerFn ул =
            ...
        // возвращаем внутреннюю функцию
        внутреннийFn
     

    к этому:

     пусть pchar charToMatch =
        пусть innerFn ул =
            ...
        // возвращаем "завернутую" внутреннюю функцию
        Парсер innerFn
     

    Тестирование обернутой функции

    Хорошо, теперь давайте проверим снова:

     пусть parseA = pchar 'A'
    пусть inputABC = "ABC"
    parseA inputABC // ошибка компилятора
     

    Но теперь мы получаем ошибку компилятора:

     ошибка FS0003: Это значение не является функцией и не может быть применено.
     

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

    Итак, теперь нам нужна вспомогательная функция, которая может извлечь внутреннюю функцию и запустить ее для входного потока. Назовем это запустить ! Вот его реализация:

     позволить запустить парсер input =
      // разворачиваем парсер, чтобы получить внутреннюю функцию
      пусть (парсер innerFn) = парсер
      // вызов внутренней функции с вводом
      внутренний ввод Fn
     

    Теперь мы можем снова запустить анализатор parseA для различных входных данных:

     let inputABC = "ABC"
    запустить parseA inputABC // Успех ('A', "BC")
    пусть inputZBC = "ZBC"
    запустить parseA inputZBC // Ошибка «Ожидается 'A'. Получил 'Z'"
     

    Вот оно! У нас есть базовая Парсер типа ! Я надеюсь, что пока все это имеет смысл.

    ---

    Последовательное объединение двух парсеров

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

    Начнем с последовательного объединения двух парсеров. Например, предположим, что нам нужен синтаксический анализатор, который соответствует «А», а затем «Б». Мы могли бы попробовать написать что-то вроде этого:

     пусть parseA = pchar 'A'
    пусть parseB = pchar 'B'
    пусть parseAThenB = parseA >> parseB
     

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

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

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

    Логика реализации будет следующей:

    • Запустить первый парсер.
    • В случае сбоя вернуться.
    • В противном случае запустить второй синтаксический анализатор с оставшимися входными данными.
    • В случае сбоя вернуться.
    • Если оба синтаксических анализатора завершились успешно, вернуть пару (кортеж), содержащую оба проанализированных значения.

    Вот код для и Затем :

     пусть andThen парсер1 парсер2 =
      пусть внутренний вход Fn =
        // запускаем parser1 с вводом
        let result1 = запустить ввод parser1
        // проверка результата на неудачу/успех
        сопоставить результат1 с
        | Ошибка ошибки ->
          // возвращаем ошибку из parser1
          Ошибка ошибки
        | Успех (значение1,осталось1) ->
          // запускаем parser2 с оставшимися входными данными
          пусть результат2 = запустить парсер2 оставшийся1
          // проверка результата на неудачу/успех
          сопоставить результат2 с
          | Ошибка ошибки ->
            // возвращаем ошибку из parser2
            Ошибка ошибки
          | Успех (значение2,осталось2) ->
            // объединяем оба значения в пару
            пусть новое значение = (значение1, значение2)
            // возвращаем оставшийся ввод после parser2
            Успех (новое значение, оставшееся2)
      // возвращаем внутреннюю функцию
      Парсер innerFn
     

    Реализация следует описанной выше логике.

    Мы также определим инфиксную версию andThen , чтобы мы могли использовать ее как обычную >> композиция:

     let ( .>>. ) = andThen
     

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

    Если мы посмотрим на подпись и Затем :

     val и Тогда :
      parser1:Parser<'a> -> parser2:Parser<'b> -> Parser<'a * 'b>
     

    мы видим, что он работает для любых двух парсеров, и они могут быть разных типов ( 'a и 'b ).

    Тестирование «и тогда»

    Давайте проверим и посмотрим, работает ли это!

    Сначала создайте составной синтаксический анализатор:

     let parseA = pchar 'A'
    пусть parseB = pchar 'B'
    пусть parseAThenB = parseA .>>. parseB
     

    Если вы посмотрите на типы, вы увидите, что все три значения имеют тип Parser :

     val parseA : Parser
    val parseB : Парсер<знак>
    val parseAThenB : Parser
     

    parseAThenB имеет тип Parser , что означает, что анализируемое значение представляет собой пару символов.

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

     запустить parseAThenB "ABC" // Успех (('A', 'B'), "C")
    run parseAThenB "ZBC" // Ошибка "Ожидается "A". Получил "Z""
    run parseAThenB "AZC" // Ошибка "Ожидается 'B'. Получил 'Z'"
     

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

    ---

    Выбор между двумя парсерами

    Давайте рассмотрим еще один важный способ объединения парсеров — комбинатор or else.

    Например, нам нужен синтаксический анализатор, соответствующий «A» или «B». Как мы могли их объединить?

    Логика реализации будет следующей:

    • Запустить первый синтаксический анализатор.
    • В случае успеха вернуть проанализированное значение вместе с оставшимися входными данными.
    • В противном случае, в случае ошибки, запустить второй анализатор с исходным вводом…
    • …и в этом случае вернуть результат (успех или неудача) из второго парсера.

    Вот код для orElse :

     let orElse parser1 parser2 =
      пусть внутренний вход Fn =
        // запускаем parser1 с вводом
        let result1 = запустить ввод parser1
        // проверка результата на неудачу/успех
        сопоставить результат1 с
        | Результат успеха ->
          // в случае успеха возвращаем исходный результат
          результат1
        | Ошибка ошибки ->
          // в случае неудачи запускаем parser2 с входными данными
          let result2 = запустить ввод parser2
          // возвращаем результат parser2
          результат2
      // возвращаем внутреннюю функцию
      Парсер innerFn
     

    И мы также определим инфиксную версию orElse :

     let ( <|> ) = orElse
     

    Если мы посмотрим на подпись orElse :

     val orElse :
      parser1:Parser<'a> -> parser2:Parser<'a> -> Parser<'a>
     

    мы видим, что это работает для любых двух парсеров, но они оба должны быть одного типа 'a .

    Тестирование «или иначе»

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

     let parseA = pchar 'A'
    пусть parseB = pchar 'B'
    пусть parseAOrElseB = parseA <|> parseB
     

    Если вы посмотрите на типы, вы увидите, что все три значения имеют тип Parser :

     val parseA : Parser
    val parseB : Парсер<знак>
    val parseAOrElseB : Парсер<знак>
     

    Теперь, если мы запустим parseAOrElseB , мы увидим, что он успешно обрабатывает «A» или «B» в качестве первого символа.

     запустить parseAOrElseB "AZZ" // Успех ("A", "ZZ")
    запустить parseAOrElseB "BZZ" // Успех ("B", "ZZ")
    run parseAOrElseB "CZZ" // Ошибка "Ожидается 'B'. Получил 'C'"
     

    Сочетание «и тогда» и «или иначе»

    С помощью этих двух основных комбинаторов мы можем построить более сложные, например, «А, а затем (В или С)».

    Вот как построить aAndThenBorC из более простых синтаксических анализаторов:

     let parseA = pchar 'A'
    пусть parseB = pchar 'B'
    пусть parseC = pchar 'C'
    пусть bOrElseC = parseB <|> parseC
    пусть aAndThenBorC = parseA .>>. БОРЭЛСЕК
     

    И вот он в действии:

     запустить aAndThenBorC "ABZ" // Успех (('A', 'B'), "Z")
    запустить aAndThenBorC "ACZ" // Успех (('A', 'C'), "Z")
    run aAndThenBorC "QBZ" // Ошибка "Ожидается "A". Получил "Q""
    run aAndThenBorC "AQZ" // Ошибка "Ожидается 'C'. Получил 'Q'"
     

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

    ---

    Выбор из списка парсеров

    Именно здесь начинает проявляться мощь комбинаторов, потому что с или Else в нашем наборе инструментов мы можем использовать его для создания еще большего количества комбинаторов. Например, предположим, что мы хотим выбрать из списка 90 418 90 419 парсеров, а не только из двух.

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

     /// Выбираем любой из списка парсеров
    пусть выбор listOfParsers =
      List.reduce ( <|> ) listOfParsers
     

    Обратите внимание, что это не удастся, если входной список пуст, но мы пока проигнорируем это.

    Подпись выбор :

     val выбор :
      Список Parser<'a> -> Parser<'a>
     

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

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

    • Ввод представляет собой список символов
    • Каждый символ в списке преобразуется в синтаксический анализатор для этого символа с использованием pchar
    • Наконец, все парсеры объединяются с помощью выбора

    Вот код:

     /// Выберите любой из списка символов
    пусть anyOf listOfChars =
      listOfChars
      |> List. map pchar // преобразовать в парсеры
      |> выбор // объединить их
     

    Давайте проверим это, создав анализатор для любого символа нижнего регистра и любого символа цифры:

     let parseLowercase =
      любой из ['a'..'z']
    пусть parseDigit =
      любой из ['0'..'9']
     

    Если мы их протестируем, они будут работать как положено:

     run parseLowercase "aBC" // Успех ('a', "BC")
    run parseLowercase "ABC" // Ошибка "Ожидается 'z'. Получил 'A'"
    запустить parseDigit "1ABC" // Успех ("1", "ABC")
    запустить parseDigit "9ABC" // Успех ("9", "ABC")
    запустить parseDigit "|ABC" // Ошибка "Ожидается '9'. Получил '|'"
     

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

    Обзор

    Давайте пока остановимся и посмотрим, что мы сделали:

    • Мы создали тип Parser , который является оболочкой для функции синтаксического анализа.
    • Функция синтаксического анализа принимает ввод (например, строку) и пытается сопоставить ввод с использованием критериев, встроенных в функцию.
    • Если сопоставление выполнено успешно, функция синтаксического анализа возвращает Success с совпадающим элементом и оставшимися входными данными.
    • Если совпадение не удается, функция синтаксического анализа возвращает Ошибка с указанием причины ошибки.
    • И, наконец, мы увидели некоторые «комбинаторы» — способы, которыми Parser могут быть объединены для создания нового Parser : andThen и или Else и выбор .

    Список библиотеки парсера на данный момент

    Вот полный листинг библиотеки синтаксического анализа на данный момент — около 90 строк кода.

    Исходный код, использованный в этом посте, доступен здесь .

     открытая система
    /// Тип, представляющий успех/неудачу при синтаксическом анализе
    введите ParseResult<'a> =
      | Успех
      | Сбой строки
    /// Тип, обертывающий функцию разбора
    type Parser<'T> = Анализатор (string -> ParseResult<'T * string>)
    /// Разбираем один символ
    пусть pcharcharToMatch =
      // определяем вложенную внутреннюю функцию
      пусть innerFn ул =
        если String.IsNullOrEmpty(str), то
          Ошибка «Нет больше ввода»
        еще
          пусть сначала = ул. [0]
          если сначала = charToMatch, то
            пусть остальные = str.[1..]
            Успех (charToMatch,осталось)
          еще
            let msg = sprintf "Ожидается '%c'. Сначала получено '%c'" charToMatch
            Сообщение об ошибке
      // возвращаем "завернутую" внутреннюю функцию
      Парсер innerFn
    /// Запуск парсера с некоторыми входными данными
    запустить парсер input =
      // разворачиваем парсер, чтобы получить внутреннюю функцию
      пусть (парсер innerFn) = парсер
      // вызов внутренней функции с вводом
      внутренний ввод Fn
    /// Объединяем два парсера как "A andThen B"
    пусть andThen парсер1 парсер2 =
      пусть внутренний вход Fn =
        // запускаем parser1 с вводом
        let result1 = запустить ввод parser1
        // проверка результата на неудачу/успех
        сопоставить результат1 с
        | Ошибка ошибки ->
          // возвращаем ошибку из parser1
          Ошибка ошибки
        | Успех (значение1,осталось1) ->
          // запускаем parser2 с оставшимися входными данными
          пусть результат2 = запустить парсер2 оставшийся1
          // проверка результата на неудачу/успех
          сопоставить результат2 с
          | Ошибка ошибки ->
            // возвращаем ошибку из parser2
            Ошибка ошибки
          | Успех (значение2,осталось2) ->
            // объединяем оба значения в пару
            пусть новое значение = (значение1, значение2)
            // возвращаем оставшийся ввод после parser2
            Успех (новое значение, оставшееся2)
      // возвращаем внутреннюю функцию
      Парсер innerFn
    /// Инфиксная версия andThen
    пусть ( . >>. ) = и Тогда
    /// Объединить два парсера как "A orElse B"
    пусть orElse парсер1 парсер2 =
      пусть внутренний вход Fn =
        // запускаем parser1 с вводом
        let result1 = запустить ввод parser1
        // проверка результата на неудачу/успех
        сопоставить результат1 с
        | Результат успеха ->
          // в случае успеха возвращаем исходный результат
          результат1
        | Ошибка ошибки ->
          // в случае неудачи запускаем parser2 с входными данными
          let result2 = запустить ввод parser2
          // возвращаем результат parser2
          результат2
      // возвращаем внутреннюю функцию
      Парсер innerFn
    /// Инфиксная версия orElse
    пусть ( <|> ) = илииначе
    /// Выбираем любой из списка парсеров
    пусть выбор listOfParsers =
      List.reduce ( <|> ) listOfParsers
    /// Выбираем любого из списка символов
    пусть anyOf listOfChars =
      listOfChars
      |> List.map pchar // преобразовать в парсеры
      |> выбор
     

    Резюме

    В этом посте мы создали основы библиотеки синтаксического анализа и несколько простых комбинаторов.

    В следующем посте мы создадим библиотеку с большим количеством комбинаторов.

    • Если вам интересно использовать эту технику в производственной среде, обязательно изучите библиотеку FParsec для F#, который оптимизирован для реального использования.
    • Для получения дополнительной информации о комбинаторах синтаксических анализаторов в целом поищите в Интернете «Parsec», библиотеку Haskell, которая повлияла на FParsec (и этот пост).
    • Некоторые примеры использования FParsec можно найти в одном из следующих сообщений:
      • Реализация поискового запроса по фразе для FogCreek’s Kiln
      • Парсер ЛОГО
      • Малый базовый синтаксический анализатор
      • Синтаксический анализатор C# и создание компилятора C# в F#
      • Напишите себе схему за 48 часов на F#
      • Разбор GLSL, языка затенения OpenGL

    Исходный код, использованный в этом посте, доступен здесь .

    Руководство по синтаксическому анализу: алгоритмы и терминология

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

    В этой статье мы постарались быть практичными. Наша цель — помочь практикам, а не объяснить всю теорию. Мы просто объясняем, что вам нужно знать, чтобы понять и построить парсер.

    После определения парсинга статья делится на три части:

    1. Общая картина . Раздел, в котором мы описываем основные термины и компоненты парсера.
    2. Грамматика . В этой части мы объясняем основные форматы грамматики и наиболее распространенные проблемы при их написании.
    3. Алгоритмы синтаксического анализа . Здесь мы обсудим все наиболее используемые алгоритмы парсинга и скажем, для чего они хороши.

    Руководство по синтаксическому анализу в формате PDF

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

    Имя

    Адрес электронной почты

    Мы используем это поле для обнаружения спам-ботов. Если вы заполните это, вы будете отмечены как спамер.

    Работает на ConvertKit

    Определение синтаксического анализа

    Анализ ввода для организации данных в соответствии с правилом грамматики

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

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

    Фундаментальный синтаксический анализ необходим, поскольку разным объектам нужны данные в разных формах. Синтаксический анализ позволяет преобразовывать данные так, чтобы их могло понять конкретное программное обеспечение. Очевидным примером являются программы: они написаны людьми, но должны выполняться компьютерами. Поэтому люди записывают их в понятной им форме, а затем программное обеспечение преобразует их таким образом, чтобы их мог использовать компьютер.

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

    Общая картина

    В этом разделе мы собираемся описать основные компоненты парсера. Мы пытаемся дать вам не формальные объяснения, а практические.

    Регулярные выражения

    Последовательность символов, которая может быть определена шаблоном

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

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

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

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

    Регулярные выражения в грамматике

    Знакомство типичного программиста с регулярными выражениями часто позволяет использовать их для определения грамматики языка. Точнее, их синтаксис используется для определения правил лексера или парсера. Например, звезда Клини ( * ) используется в правиле, чтобы указать, что конкретный элемент может присутствовать ноль или бесконечное количество раз.

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

    Структура синтаксического анализатора

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

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

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

     437 + 734 

    Лексер сканирует текст и находит 4 , 3 , 7 , а затем пробел ( ) . Работа лексера состоит в том, чтобы распознать, что символы 437 составляют один токен типа NUM . Затем лексер находит символ + , который соответствует второму токену типа PLUS , и, наконец, он находит еще один токен типа NUM .

    Парсер обычно объединяет токены, созданные лексером, и группирует их.

    Входной поток преобразуется синтаксическим анализатором в токены, а затем в AST

    Определения, используемые лексерами и синтаксическими анализаторами, называются правилами или производит . В нашем примере правило лексера будет указывать, что последовательность цифр соответствует токену типа NUM, а правило синтаксического анализатора будет указывать, что последовательность токенов типа NUM, PLUS, NUM соответствует выражению sum .

    В настоящее время обычно можно найти наборы, которые могут генерировать как лексер, так и синтаксический анализатор. В прошлом было более распространено сочетание двух разных инструментов: один для создания лексера, а другой для создания синтаксического анализатора. Например, так было с преподобным 9.0393 lex и yacc пара: с помощью lex можно было сгенерировать лексер, а с помощью yacc можно было сгенерировать синтаксический анализатор.

    Анализаторы без сканирования

    Анализаторы без сканирования работают по-другому, поскольку они обрабатывают непосредственно исходный текст, а не список токенов, созданный лексером. То есть парсер без сканера работает как лексер и парсер вместе взятые.

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

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

    Грамматика

    Формальная грамматика — это набор правил, которые синтаксически описывают язык

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

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

     ПРИВЕТ: "Привет"
    ИМЯ: [a-zA-Z]+
    приветствие: HELLO NAME 

    Эта грамматика принимает такие входные данные, как "Hello Michael" и "Hello Programming" . Они оба синтаксически правильны, но мы знаем, что Programming это не имя. Таким образом, это семантически неправильно. Грамматика не определяет семантические правила, и они не проверяются синтаксическим анализатором. Вам нужно будет обеспечить действительность предоставленного имени другим способом, например, сравнив его с базой данных допустимых имен.

    Анатомия грамматики

    Чтобы определить элементы грамматики, давайте рассмотрим пример в наиболее часто используемом формате для описания грамматик: Форма Бэкуса-Наура (БНФ) . Этот формат имеет множество вариантов, в том числе расширенную форму Бэкуса-Наура . Преимущество расширенного варианта состоит в том, что он включает простой способ обозначения повторений. Другим примечательным вариантом является форма Augmented Backus-Naur Form , которая в основном используется для описания протоколов двунаправленной связи.

    Типичное правило грамматики Бэкуса-Наура выглядит следующим образом:

      ::= __expression__ 

    является нетерминалом , что означает, что его можно заменить группой элементов справа, __expression__ . Элемент __expression__ может содержать другие нетерминальные символы или терминальные. Терминальные символы — это просто те символы, которые нигде в грамматике не встречаются как . Типичным примером терминального символа является строка символов, например 9.2364 «Привет» .

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

    Типы грамматик

    В синтаксическом анализе используются в основном два вида грамматик: обычные грамматики и контекстно-свободные грамматики . Обычно виду грамматики соответствует такой же вид языка: регулярная грамматика определяет регулярный язык и т.д. Однако существует также более поздний вид грамматик, называемый 9.0393 Грамматика выражения синтаксического анализа (PEG), которая столь же мощна, как и контекстно-свободные грамматики, и, таким образом, определяет контекстно-свободный язык. Разница между ними заключается в обозначениях и интерпретации правил.

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

    Относительно простой способ различить две грамматики состоит в том, что __выражение__ регулярной грамматики, то есть правая часть правила, может быть только одним из:

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

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

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

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

    Лексер

    Лексер преобразует последовательность символов в последовательность токенов. Лексеры играют роль в синтаксическом анализе, потому что они преобразуют первоначальный ввод в форму, более подходящую для соответствующего синтаксического анализатора, который работает на более позднем этапе. Обычно лексеры написать проще, чем парсеры. Хотя есть особые случаи, когда и то, и другое довольно сложно, например, в случае C (см. лексер-хак).

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

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

    Где заканчивается лексер и начинается синтаксический анализатор

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

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

     IPv4: [0-9]+ "." [0-9]+ "." [0-9]+ "." [0-9]+ 

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

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

     ТОЧКА : "."
    ОКТЕТ: [0-9]+
    ipv4: ОКТЕТ ТОЧКА ОКТЕТ ТОЧКА ОКТЕТ ТОЧКА ОКТЕТ 

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

    Синтаксический анализатор

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

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

    Форма дерева выбрана потому, что это простой и естественный способ работы с кодом на разных уровнях детализации. Например, класс в C# имеет одно тело, это тело состоит из одного оператора, оператора блока, то есть списка операторов, заключенного в пару фигурных скобок, и так далее…

    Синтаксическая и семантическая корректность

    Синтаксический анализатор является фундаментальной частью компилятора или интерпретатора, но, конечно, может быть частью множества других программ. Например, в нашей статье Создание диаграмм из исходного кода C# с помощью Roslyn мы проанализировали файлы C# для создания диаграмм.

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

    Давайте посмотрим на пример кода, который синтаксически правильный, но семантически неверный.

     целое число х = 10
    int sum = x + y 

    Проблема в том, что одна переменная ( y ​​ ) никогда не определена и, таким образом, если она будет выполнена, программа завершится ошибкой. Однако синтаксический анализатор не имеет возможности узнать об этом, потому что он не отслеживает переменные, он просто смотрит на структуру кода.

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

    Безсканирующий синтаксический анализатор

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

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

    Проблемы с синтаксическим анализом реальных языков программирования

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

    Контекстно-зависимые компоненты

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

    Типичным примером контекстно-зависимых элементов являются так называемые программные ключевые слова , т. е. строки, которые могут считаться ключевыми словами в определенных местах, но в остальном могут использоваться как идентификаторы).

    Пробелы

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

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

    На практике пользовательская функция в лексере создает токены INDENT и DEDENT, когда отступ увеличивается или уменьшается. Эти токены играют ту роль, которую в C-подобных языках играют фигурные скобки: они обозначают начало и конец блоков кода.

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

    Множественный синтаксис

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

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

    Висячее Else

    Висячее else является распространенной проблемой при синтаксическом анализе, связанном с оператором if-then-else . Поскольку предложение else является необязательным, последовательность операторов if может быть неоднозначной. Например этот.

     если один
       то если два
           затем два
    еще ??? 

    Неясно, относится ли или к первому , если , или ко второму.

    Честно говоря, это по большей части проблема дизайна языка. Большинство решений на самом деле не сильно усложняют синтаксический анализ, например, требуют использования endif или требует использования блоков для разграничения оператора if , когда он включает предложение else.

    Однако есть также языки, которые не предлагают решения, то есть языки, разработанные неоднозначно, например (как вы уже догадались) C. Обычный подход состоит в том, чтобы связать else с ближайшим оператором if, что делает контекст синтаксического анализа чувствительный.

    Дерево синтаксического анализа и абстрактное синтаксическое дерево

    Существуют два взаимосвязанных термина, которые иногда используются взаимозаменяемо: Дерево синтаксического анализа и Абстрактное синтаксическое дерево (AST). Технически дерево синтаксического анализа также можно назвать конкретным синтаксическим деревом (CST), поскольку оно должно более конкретно отражать фактический синтаксис входных данных, по крайней мере, по сравнению с AST.

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

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

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

    От дерева синтаксического анализа к абстрактному синтаксическому дереву

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

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

    Давайте рассмотрим простой пример, чтобы показать разницу между деревом синтаксического анализа и AST. Начнем с примера грамматики.

     // лексер
    ПЛЮС: '+'
    WORD_PLUS: "плюс"
    НОМЕР: [0-9]+
    // парсер
    // труба | символ указывает на альтернативу между двумя
    сумма: ЧИСЛО (ПЛЮС | ​​СЛОВО_ПЛЮС) ЧИСЛО
     

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

     10 плюс 21 

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

    Дерево синтаксического анализа и абстрактное синтаксическое дерево

    В АСТ пропало указание конкретного оператора и осталась только выполняемая операция. Конкретный оператор является примером промежуточного правила.

    Графическое представление дерева

    Результат работы синтаксического анализатора — дерево, но это дерево также может быть представлено графически. Это сделано для облегчения понимания разработчиком. Некоторые инструменты генератора синтаксического анализа могут выводить файл на языке DOT, языке, предназначенном для описания графов (дерево — это особый вид графа). Затем этот файл передается в программу, которая может создать графическое представление, исходя из этого текстового описания (например, Graphviz).

    Давайте посмотрим текст .DOT на основе предыдущего примера с суммой.

     сумма орграфов {
         сумма -> 10;
         сумма -> 21;
    } 

    Соответствующий инструмент может создать следующее графическое представление.

    Пример изображения дерева, созданного graphviz

    Если вы хотите узнать немного больше о DOT, вы можете прочитать нашу статью «Протокол языкового сервера: языковой сервер для DOT с кодом Visual Studio». В этой статье мы покажем, как создать плагин Visual Studio Code, который может обрабатывать файлы DOT.

    Грамматики

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

    Типичные проблемы с грамматикой

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

    Отсутствующие лексемы

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

     ИМЯ: [a-zA-Z]+
    приветствие : "Hello" NAME 

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

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

    Леворекурсивные правила

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

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

     дополнение: выражение '+' выражение
    умножение : выражение '*' выражение
    // выражение может быть сложением, умножением или числом
    выражение : умножение | дополнение | [0-9]+ 

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

    Это описание также соответствует нескольким дополнениям, таким как 5 + 4 + 3 . Потому что это можно интерпретировать как выражение (5) ('+') выражение(4+3) (дополнение правила: первое выражение соответствует варианту [0-9]+, второе — другое дополнение ). И тогда само 4 + 3 можно разделить на две его составляющие: выражение(4) ('+') выражение(3) (добавление правила: и первому, и второму выражению соответствует вариант [0-9]+) .

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

     выражение : дополнение
    сложение : умножение ('+' умножение)*
    умножение: атом ('*' атом)*
    atom : [0-9]+ 

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

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

    Как преобразуются леворекурсивные правила

    Конкретный способ преобразования правил варьируется от одного генератора парсеров к другому, однако логика остается неизменной. Выражения делятся на две группы: с оператором и двумя операндами и атомарные. В нашем примере единственным атомарным выражением является число ( [0-9]+ ), но это также может быть выражение в скобках ( (5 + 4) ). Это потому, что в математике круглые скобки используются для увеличения приоритета выражения.

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

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

    Предикаты

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

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

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

    Встроенные действия

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

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

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

    Форматы

    Существует два основных формата грамматики: BNF (и его варианты) и PEG. Многие инструменты реализуют свои варианты этих идеальных форматов. Некоторые инструменты вообще используют пользовательские форматы. Часто настраиваемый формат состоит из трех частей грамматики: параметры вместе с пользовательским кодом, за которым следует раздел лексера и, наконец, раздел анализатора.

    Учитывая, что формат, подобный BNF, обычно является основой контекстно-свободной грамматики, вы также можете увидеть, что он идентифицируется как формат CFG.

    Форма Бэкуса-Наура и ее варианты

    Форма Бэкуса-Наура (BNF) является наиболее успешным форматом и даже легла в основу PEG. Однако он довольно прост, и поэтому не часто используется в своей основной форме. Обычно используется более мощный вариант.

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

     <буква> ::= "а" | "б" | "с" | "д" | "е" | "ф" | "г" | "ч" | "я" | "дж" | "к" | "л" | "м" | "н" | "о" | "п" | "к" | "р" | "с" | "т" | "у" | "в" | "ш" | "х" | "у" | "з"
    <цифра> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
    <символ> ::= <буква> | <цифра> 

    Символ <буква> может быть преобразован в любую из букв английского алфавита, хотя в нашем примере допустимы только строчные буквы. Аналогичный процесс происходит для <цифра> , что может указывать на любую из альтернативных цифр. Первая проблема заключается в том, что вы должны перечислить все альтернативы по отдельности; вы не можете использовать классы символов, как в регулярных выражениях. Это раздражает, но обычно решаемо, если, конечно, вам не нужно перечислять все символы Unicode.

    Гораздо сложнее проблема в том, что нет простого способа обозначить необязательные элементы или повторения. Поэтому, если вы хотите это сделать, вы должны полагаться на логическую логику и альтернативный символ ( | ).

     <текст> ::= <символ> |   

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

    Дерево синтаксического анализа для ‘dog’

    BNF имеет много других ограничений: усложняет использование пустых строк или символов, используемых форматом (например, ::= ) в грамматике, он имеет многословный синтаксис (например, вы должны включать терминалы между < и >) и т.д. синтаксическая запись.

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

    Давайте посмотрим, как бы вы написали предыдущий пример в EBNF.

     буква = "а" | "б" | "с" | "д" | "е" | "ф" | "г" | "ч" | "я" | "дж" | "к" | "л" | "м" | "н" | "о" | "п" | "к" | "р" | "с" | "т" | "у" | "в" | "ш" | "х" | "у" | "з" ;
    цифра = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
    символ = буква | цифра ;
    текст = символ, {символ}; 

    Текстовый символ теперь описывается проще с помощью оператора конкатенации ( , ) и опционального ( { . . } ). Результирующее дерево синтаксического анализа также будет проще. Стандартный EBNF все еще представляет некоторые проблемы, такие как незнакомый синтаксис. Чтобы решить эту проблему, большинство инструментов синтаксического анализа используют синтаксис, вдохновленный регулярными выражениями, а также поддерживают дополнительные элементы, такие как классы символов.

    Если вам нужно подробное описание формата, вы можете прочитать нашу статью о EBNF.

    ABNF

    Расширенный BNF (ABNF) — еще один вариант BNF, в основном разработанный для описания протоколов двунаправленной связи и оформленный IETF в нескольких документах (см. RFC 5234 и обновления).

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

    ABNF имеет синтаксис, отличный от EBNF, например, альтернативным оператором является косая черта ( / ), а иногда это явно лучше. Например, нет необходимости в операторе конкатенации. Он также имеет несколько больше функций, чем стандартный EBNF. Например, он позволяет вам определять числовые диапазоны, такие как %x30-39 , что эквивалентно [0-9] . Это также используется самими дизайнерами для включения стандартных классов символов, подобных базовым правилам, которые может использовать конечный пользователь. Примером такого правила является АЛЬФА, что эквивалентно [a-zA-Z] .

    PEG

    Грамматика выражения синтаксического анализа (PEG) — это формат, представленный Брайаном Фордом в статье 2004 года. Технически он происходит от старой формальной грамматики под названием Top-Down Parsing Language (TDPL). Однако простой способ описать это: EBNF в реальном мире.

    На самом деле он похож на EBNF, но также напрямую поддерживает широко используемые функции, такие как диапазоны символов (классы символов). Хотя у него также есть некоторые отличия, которые на самом деле не так уж прагматичны, например, использование более формального символа стрелки ( ← ) для присваивания вместо более распространенного символа равенства ( = ). Предыдущий пример можно было бы написать таким же образом с PEG.

     буква ← [a-z]
    цифра ← [0-9]
    символ ← буква / цифра
    text ← character+ 

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

    Прагматический подход лежит в основе формализма PEG: он был создан для более естественного описания языков программирования. Это потому, что контекстно-свободная грамматика берет свое начало в работе по описанию естественных языков. Теоретически CFG — это порождающая грамматика , а PEG — аналитическая грамматика .

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

    PEG против CFG

    Практические последствия этого теоретического различия ограничены: PEG более тесно связан с алгоритмом packrat , но в основном это все. Например, обычно PEG (packrat) не разрешает левую рекурсию. Хотя сам алгоритм можно изменить для его поддержки, это устраняет свойство синтаксического анализа за линейное время. Кроме того, синтаксические анализаторы PEG, как правило, являются синтаксическими анализаторами без сканера.

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

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

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

     dog ← 'dog' / 'doge' 

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

    Алгоритмы синтаксического анализа

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

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

    Обзор

    Давайте начнем с общего обзора функций и стратегий всех парсеров.

    Две стратегии

    Существует две стратегии синтаксического анализа: нисходящий анализ и восходящий анализ . Оба термина определены по отношению к дереву синтаксического анализа, сгенерированному синтаксическим анализатором. Проще говоря:

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

    Давайте рассмотрим пример, начиная с дерева синтаксического анализа.

    Пример дерева синтаксического анализа из Википедии

    Одно и то же дерево будет сгенерировано в разном порядке парсером «сверху вниз» и «снизу вверх». На следующих изображениях число указывает порядок, в котором создаются узлы.

    Порядок генерации дерева сверху вниз (из Википедии) Порядок генерации дерева снизу вверх (из Википедии)

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

    Концепция деривации тесно связана со стратегиями. Вывод указывает порядок, в котором нетерминальные элементы, встречающиеся в правиле справа, применяются для получения нетерминального символа слева. Используя терминологию БНФ, он указывает, как элементы, которые появляются в __expression__ используются для получения . Две возможности: крайнее левое производное и крайнее правое производное . Первое указывает на то, что правило применяется слева направо, а второе указывает на обратное.

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

     expr_one = .. // материал
    expr_two = .. // материал
    результат = expr_one 'оператор' expr_two 

    Можно сначала применить правило для символа expr_one , а затем expr_two или наоборот. В случае крайнего левого вывода вы выбираете первый вариант, а для крайнего правого вывода — второй.

    Важно понимать, что вывод применяется в глубину или рекурсивно. Другими словами, он применяется к начальному выражению, а затем снова применяется к полученному промежуточному результату. Так, в этом примере, если после применения правила, соответствующего expr_one есть новый нетерминал, он трансформируется первым. Нетерминал expr_two применяется только тогда, когда он становится первым нетерминалом и не следует порядку исходного правила.

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

    Общие элементы

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

    Упреждающий просмотр и поиск с возвратом

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

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

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

    Lookahead особенно актуален для алгоритмов синтаксического анализа LL , LR и LALR , потому что синтаксические анализаторы для языков, которым нужен только один токен просмотра вперед, легче создавать и быстрее запускать. Упреждающие токены, используемые такими алгоритмами, указываются в скобках после названия алгоритма (например, LL(1), LR( k )). Обозначение (*) указывает на то, что алгоритм может проверять бесконечные упреждающие токены, хотя это может повлиять на производительность.

    Анализаторы диаграмм

    Анализаторы диаграмм — это семейство анализаторов, которые могут быть восходящими (например, CYK) или нисходящими (например, Earley). Анализаторы диаграмм, по существу, пытаются избежать обратного отслеживания, которое может быть дорогостоящим, используя динамическое программирование . Динамическое программирование или динамическая оптимизация — это общий метод разбиения более крупной проблемы на более мелкие подзадачи.

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

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

    Автоматы

    Прежде чем обсуждать алгоритмы синтаксического анализа, мы хотели бы поговорить об использовании автоматов в алгоритмах синтаксического анализа. Автоматы — это семейство абстрактных машин, среди которых есть хорошо известные Машина Тьюринга .

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

    Поскольку они определяют абстрактные машины, обычно они не имеют прямого отношения к реальному алгоритму. Скорее, они описывают формальным образом уровень сложности, с которым должен иметь дело алгоритм. Если кто-то говорит, что для решения задачи X вам нужен DFA, он имеет в виду, что вам нужен алгоритм столь же мощный, как DFA.

    Однако, поскольку DFA являются конечными автоматами в случае лексера, различие часто является спорным. Это связано с тем, что конечные автоматы относительно просты в реализации (т. е. существуют готовые к использованию библиотеки), поэтому в большинстве случаев DFA реализуется с помощью конечного автомата. Вот почему мы собираемся кратко рассказать о DFA и о том, почему они часто используются для лексеров.

    Лексирование с детерминированным конечным автоматом

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

    Они используются по нескольким причинам:

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

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

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

    Таблицы алгоритмов синтаксического анализа

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

    В таблице перечислены:

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

    Алгоритм	Формальное описание	Объяснение	Пример реализации
    CYK	Эффективный алгоритм распознавания и синтаксического анализа для контекстно-свободных языков (PDF)	Алгоритмы CKY и Earley (PDF)	Алгоритм CYK в Golang/парсерах диаграмм Алгоритм (PDF)	Объяснение синтаксического анализа Earley	Nearley
    LL	LL(*): The Foundation of the ANTLR Parser Generator (PDF)	LL Parser в Википедии / LL-9parser.js3878	ll(1) parser / ANTLR
    LR	On the Translation of Languages ​​from Left to Right (PDF)	Compiler Course	Jison / Bison
    Packrat (PEG)	Packrat Parsing: Практический алгоритм линейного времени с возвратом (PDF)	Анализ Packrat: простой, мощный, ленивый, линейный анализ TimePackrat в Scala (PDF)	Сопутствующий код диссертации / Canopy
    Комбинатор парсеров	Создание переводчиков естественного языка на ленивом функциональном языке (PDF)	Объединенные комбинаторы парсера. Синтаксический анализатор в Python/JSLint

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

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

    Алгоритмы «сверху вниз»

    Стратегия «сверху вниз» является наиболее распространенной из двух стратегий, и существует несколько успешных алгоритмов, использующих ее.

    LL Parser

    LL ( L чтение ввода слева направо, L вывод слева) — это парсеры на основе таблиц без обратного отслеживания, но с просмотром вперед. На основе таблиц означает, что они полагаются на таблицу синтаксического анализа, чтобы решить, какое правило применить. В таблице синтаксического анализа в качестве строк и столбцов используются нетерминалы и терминалы соответственно.

    Чтобы найти правильное правило для применения:

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

    Концепция синтаксического анализатора LL относится не к конкретному алгоритму, а скорее к классу синтаксических анализаторов. Они определяются в отношении к грамматикам. Другими словами, синтаксический анализатор LL — это тот, который может анализировать грамматику LL. В свою очередь, LL-грамматики определяются в зависимости от количества упреждающих токенов, необходимых для их анализа. Этот номер указывается в скобках рядом с LL в виде LL( к ).

    Синтаксический анализатор LL( k ) использует k токенов упреждающего просмотра и, таким образом, он может проанализировать максимум грамматику, для анализа которой требуется k токенов упреждающего просмотра. По сути, концепция грамматики LL( k ) используется более широко, чем соответствующий синтаксический анализатор. Это означает, что грамматики LL( k ) используются в качестве измерителя при сравнении различных алгоритмов. Например, вы могли прочитать, что синтаксические анализаторы PEG могут обрабатывать грамматики LL(*).

    Значение грамматики английского языка

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

    Потеря производительности связана с необходимостью писать грамматику особым образом, что требует времени. Мощность ограничена, потому что грамматике, которой может потребоваться 1 токен просмотра вперед, если она написана с помощью леворекурсивного правила, может потребоваться 2-3 токена просмотра вперед, если она написана нерекурсивным способом. Таким образом, это ограничение не просто раздражает, оно ограничивает возможности алгоритма, т. е. грамматики, для которых его можно использовать.

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

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

    В StackOverflow вы можете прочитать простое сравнение между парсерами LL и парсерами рекурсивного спуска или между парсерами LL и парсерами LR.

    Анализатор Earley

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

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

     // пример грамматики
    Привет привет"
    ИМЯ : [a-zA-Z]+
    приветствие : ПРИВЕТ ИМЯ
    // Парсер Earley разбивает приветствие, как это
    // . ПРИВЕТ ИМЯ
    // ПРИВЕТ . ИМЯ
    // ЗДРАВСТВУЙТЕ, ИМЯ. 

    Затем, работая над этими сегментами, которые можно соединить точкой ( . ), пытается достичь завершенного состояния, то есть состояния с точкой в ​​конце.

    Преимущество синтаксического анализатора Эрли заключается в том, что он гарантированно способен анализировать все контекстно-свободные языки, в то время как другие известные алгоритмы (например, LL, LR) могут анализировать только их подмножество. Например, у него нет проблем с леворекурсивными грамматиками. В более общем смысле синтаксический анализатор Эрли также может работать с недетерминированными и неоднозначными грамматиками.

    Это может произойти с риском ухудшения производительности (O(n ³ )), в худшем случае. Однако он имеет линейную производительность по времени для обычных грамматик. Загвоздка в том, что нас обычно интересует набор языков, разбираемых более традиционными алгоритмами. быть более эффективным. Т. е. построение грамматики LL(1) может быть сложнее для разработчика, но синтаксический анализатор может применить ее очень эффективно. С Earley вы делаете меньше работы, поэтому синтаксический анализатор делает ее больше.

    Короче говоря, Earley позволяет вам использовать грамматики, которые легче писать, но которые могут быть неоптимальными с точки зрения производительности.

    Варианты использования Earley

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

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

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

    Packrat (PEG)

    Packrat часто ассоциируется с формальной грамматикой PEG, поскольку они были изобретены одним и тем же человеком: Брайаном Фордом. Пакрат был впервые описан в его диссертации: Анализ Пакрата: практический алгоритм линейного времени с возвратом. Название говорит почти обо всем, что нас волнует: оно имеет линейное время выполнения, в том числе потому, что оно не использует возврат.

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

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

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

    Анализатор рекурсивного спуска

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

    Термин прогнозирующий синтаксический анализатор используется по-разному: некоторые люди имеют в виду его как синоним нисходящего синтаксического анализатора, некоторые как рекурсивный нисходящий синтаксический анализатор, который никогда не отступает.

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

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

    Хвостовая рекурсия per se — это просто рекурсия, которая происходит в конце функции. Однако хвостовая рекурсия используется в сочетании с преобразованиями правил грамматики. Комбинация преобразования правил грамматики и добавления рекурсии в конце процесса позволяет иметь дело с леворекурсивными правилами.

    Анализатор Пратта

    Анализатор Пратта — широко неиспользуемый, но очень ценимый (теми, кто его знает) алгоритм разбора, определенный Воаном Праттом в статье под названием Приоритет оператора сверху вниз. Сама статья начинается с полемики о грамматиках БНФ, которые, как ошибочно утверждает автор, являются исключительной заботой исследований синтаксического анализа. Это одна из причин отсутствия успеха. На самом деле алгоритм не опирается на грамматику, а работает непосредственно с токенами, что делает его необычным для экспертов по разбору.

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

    Где алгоритм Пратта сияет, так это в выражениях. На самом деле, концепция приоритета делает невозможным понимание структуры входных данных, просто взглянув на порядок, в котором представлены токены.

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

    Хотя алгоритм Пратта не был явно успешным, он используется для синтаксического анализа выражений. Он также был принят Дугласом Крокфордом (известным в JSON) для JSLint.

    Комбинатор парсеров

    Комбинатор синтаксического анализатора — это функция более высокого порядка, которая принимает функции синтаксического анализа в качестве входных данных и возвращает новую функцию синтаксического анализа в качестве выходных данных. Функция синтаксического анализатора обычно означает функцию, которая принимает строку и выводит дерево синтаксического анализа.

    Комбинатор синтаксических анализаторов является модульным и простым в сборке, но он также медленнее (в худшем случае имеет сложность O(n ⁴ )) и менее сложен. Обычно они используются для упрощения задач синтаксического анализа или для создания прототипов. В некотором смысле пользователь комбинатора синтаксических анализаторов создает синтаксический анализатор частично вручную, но полагаясь на жесткое слово, сделанное тем, кто создал комбинатор синтаксических анализаторов.

    Как правило, они не поддерживают леворекурсивные правила, но есть более продвинутые реализации, которые делают именно это. См., например, статью Parser Combinators for Ambiguous Left-Recursive Grammars, в которой также удается описать алгоритм с полиномиальным временем выполнения.

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

    Самый простой пример — монада Maybe . Это оболочка для нормального типа, такого как целое число, которое возвращает само значение, когда значение допустимо (например, 567), и специальное значение Ничего , когда оно не является допустимым (например, не определено или деление на ноль). Таким образом, вы можете избежать использования значения null и бесцеремонного сбоя программы. Вместо этого значение Nothing управляется нормально, как и любое другое значение.

    Восходящие алгоритмы

    Основным успехом восходящей стратегии является семейство множества различных парсеров LR. Причина их относительной непопулярности заключается в том, что исторически их было сложнее построить, хотя синтаксические анализаторы LR также более мощные, чем традиционные грамматики LL(1). Поэтому мы в основном сосредоточимся на них, за исключением краткого описания парсеров CYK.

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

    Мы только говорим, что алгоритмы сдвига-уменьшения работают в два этапа:

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

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

    Анализатор CYK

    Анализатор Cocke-Younger-Kasami (CYK) был разработан независимо тремя авторами. Его известность обусловлена ​​отличной производительностью в худшем случае (O(n ³ )), хотя ему мешает сравнительно низкая производительность в большинстве распространенных сценариев.

    Однако реальным недостатком алгоритма является то, что он требует, чтобы грамматики были выражены в нормальной форме Хомского.

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

    Алгоритм CYK используется в основном для конкретных задач. Например, проблема принадлежности: определить, совместима ли строка с определенной грамматикой. Его также можно использовать при обработке естественного языка, чтобы найти наиболее вероятный анализ множества вариантов.

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

    LR Parser

    LR ( L чтение ввода слева направо, R самая правая производная) — это восходящие анализаторы, которые могут обрабатывать детерминированные контекстно-свободные языки за линейное время, с просмотром вперед и без возврата. Изобретение синтаксических анализаторов LR приписывают известности Дональду Кнуту.

    Традиционно их сравнивали и конкурировали с парсерами LL. Таким образом, существует аналогичный анализ, связанный с количеством предвосхищающих токенов, необходимых для анализа языка. Парсер LR( k ) может анализировать грамматики, которым требуется k токенов просмотра вперед для анализа. Однако грамматики LR менее ограничительны и, следовательно, более эффективны, чем соответствующие грамматики LL. Например, нет необходимости исключать леворекурсивные правила.

    Технически, грамматики LR являются надмножеством грамматик LL. Одним из следствий этого является то, что вам нужны только грамматики LR(1), поэтому обычно ( k ) опускается.

    Они также основаны на таблицах, как и LL-парсеры, но им нужны две сложные таблицы. Проще говоря:

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

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

    Простой LR и Lookahead LR

    Генераторы синтаксического анализа позволяют избежать проблемы создания таких таблиц вручную, но они не решают проблему стоимости их создания и навигации по ним. Таким образом, существуют более простые альтернативы синтаксическому анализатору Canonical LR(1) , описанному Кнутом. Эти альтернативы менее эффективны, чем исходная. Это: Простой синтаксический анализатор LR (SLR) и Упреждающий синтаксический анализатор LR (LALR). Таким образом, в порядке мощности мы имеем: LR (1) > LALR (1) > SLR (1) > LR (0).

    Названия двух синтаксических анализаторов, изобретенных Фрэнком ДеРемером, несколько вводят в заблуждение: один на самом деле не так прост, а другой не единственный, использующий просмотр вперед. Можно сказать, что один проще, а другой в большей степени опирается на прогнозирование для принятия решений.

    В основном они различаются таблицами, которые они используют, в основном они меняют часть «что делать» и наборы прогнозов. Что, в свою очередь, накладывает различные ограничения на грамматики, которые они могут анализировать. Другими словами, они используют разные алгоритмы для получения таблиц синтаксического анализа из грамматики.

    Синтаксический анализатор SLR довольно ограничен с практической точки зрения и не очень широко используется. Вместо этого синтаксический анализатор LALR работает с большинством практических грамматик и широко используется. На самом деле популярные инструменты yacc и bison работают с таблицами парсера LALR.

    В отличие от LR-грамматик, LALR- и SLR-грамматики не являются надмножеством LL-грамматик. Их нелегко сравнивать: некоторые грамматики могут относиться к одному классу, а не к другому, или наоборот.

    Обобщенный анализатор LR

    Обобщенные синтаксические анализаторы LR (GLR) — это более мощные варианты синтаксических анализаторов LR. Они были описаны Бернардом Лэндом в 1974 году и впервые реализованы Масару Томита в 1984 году. Причиной существования GLR является необходимость анализа недетерминированных и неоднозначных грамматик.

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

    Сложность синтаксического анализатора GLR в наихудшем случае такая же, как и у синтаксического анализатора Эрли (O(n ³ )), хотя он может иметь лучшую производительность с лучшим случаем детерминированных грамматик. Анализатор GLR также сложнее построить, чем анализатор Эрли.

    Резюме

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

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

    Если вы просто интересуетесь синтаксическим анализом, вы можете прочитать «Техники синтаксического анализа» — книгу, столь же всеобъемлющую, сколь и дорогую. Очевидно, что он гораздо глубже, чем мы могли бы, а также охватывает менее используемые алгоритмы синтаксического анализа.

    Мы благодарим Димитриоса Куркулиса за редактуру статьи и помощь в ее улучшении.

    Мы также хотели бы поблагодарить Дастина Уитни за то, что он заметил опечатку.

    6.2.2: Анализ составляющих предложения, построение предложения

    1. Последнее обновление

    2. Сохранить как PDF

    Идентификатор страницы

    74525

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

    Почему важно изменять структуру предложения?

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

    Каковы некоторые распространенные способы построения предложения?

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

    Использование параллельной структуры

    Что такое параллельная структура?

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

    Почему важно использовать параллельную структуру?

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

    Давайте рассмотрим пример

    • Не параллельно: Президент посетил несколько городов, чтобы встретиться с избирателями, произнести речи и попросить средства на предвыборную кампанию.
      
    • Параллель: Президент посетил несколько городов, встречаясь с избирателями, произнося речи и запрашивая средства на предвыборную кампанию.

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

    1. Найдите список в предложении: Найдите слова или фразы равной важности, которые разделены запятыми и соединены союзом

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

    2. Оцените словоформы в списке.

    1. Глаголы появляются как инфинитив (от до + глагол ) или герундий (- слов )? Как настоящее время или прошедшее время? (Выберите залог и время глагола, соответствующие окружающим предложениям.)
    2. Имеют ли существительные или местоимения и их модификаторы постоянную форму?

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

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

    Избегайте предложений в стиле букваря

    Как эффективно комбинировать короткие предложения

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

    Рассмотрим несколько примеров

    Пересмотр предложений для букваря:

    • Предложений для букваря: Президент Кеннеди был застрелен 22 ноября 1963 года. Это произошло в Далласе, штат Техас. Это событие сильно повлияло на всю страну.
      
    • Пересмотрено: Убийство президента Кеннеди 22 ноября 1963 года в Далласе, штат Техас, сильно повлияло на нацию.

    Исправление коротких связанных предложений:

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

    • Серия связанных предложений: Центральный парк — городской парк площадью 843 акра.