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

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

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

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

В синтаксическом анализаторе заголовка это приводит к изменению определения предикат между/4. Вместо простого целого числа сравнения, теперь нам нужно проверить, что вывод из P0 в P может быть расширен до вывода от E0 до E с помощью проверка наличия путей в словесном графе от E0 до P0 и от P до E.

Предикат между/4 реализуется с помощью мемоизации как следует. Предполагается, что имена состояний являются целыми числами; чтобы исключить Для циклических слов-графов мы также требуем, чтобы для всех переходов от P0 к P выполнялось условие P0 < P. Переходы в словесном графе представлены предложениями вида wordgraph:trans(P0,Sym,P,Score), которые указывают на наличие переход из состояния P0 в P с символом Sym и Оценка вероятности.

между(L0,R0,L,R):- связь(L,L0), связь(R0,R).
соединение(А,Б):-
        ( вар(А) -> истина
        ; переменная (B) -> истина
        ; А=:=В -> правда
        ; B < A -> fail % словесные графы ацикличны
        ; ok_conn(A,B) -> истина
        ; fail_conn(A,B) -> сбой
        ; словограф:транс(A,_,X,_),
           соединение (X, B) -> assertz (ok_conn (A, B))
        ; assertz (fail_conn (A, B)),
           потерпеть неудачу
        ). 
 

CSCI 131 Spring '18 — Разбор с применением

Инструктор: Майкл Гринберг Класс: TTh 9:35 – 10:50 в Милликене 2099 Часы работы инструктора: четверг с 11:00 до 12:00 в Милликене 2099; 2 среда – 17:00 в Edmunds 225 (или по предварительной записи)

Дом

Учебный план

Пьяцца

Представление

Эта лекция написана на грамотном Haskell; вы можете скачать необработанный исходный код.

Мы записали простой экземпляр для Может быть и более интересный пример для Либо e :

 экземпляр Applicative (Ethere e), где
  чистый х = правый х, потому что левый х будет плохо напечатан!
  (Право f) <*> (Право v) = Право $ f v
  err@(Left e) <*> _ = ошибка
  _ <*> err@(Left e) = err 

Затем мы прошлись по Applicative определениям списков. Было два варианта: декартово произведение…

 instance Applicative [] где
  чистый х = [х]
  [] <*> _ = []
  _ <*> [] = []
  (f:fs) <*> xs = map f xs ++ fs <*> xs 

…и сжатие:

 newtype ZipList a = ZipList { getZipList :: [a] }
  вывод (Eq, Show, Functor)
экземпляр Applicative ZipList, где
  чистый = ZipList. повторение
  ZipList fs <*> ZipList xs = ZipList (zipWith ($) fs xs) 

Читатели

Мы также определяем экземпляр для читателей… своего рода прелюдия к определению наших парсеров.

 экземпляр Прикладной ((->) r), где
  чистый v р = v
  frab <*> fra = \r -> frab r (fra r) 

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

 eogth = (&&) <$> even <*> (> 100)
aos = (||) <$> isAlpha <*> isSpace 

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

Соблюдайте законы

Как и Functor , класс типов Applicative регулируется законами.

Идентичность: pure id <*> v = v Состав: pure (.) <*> u <*> v <*> w = u <*> (v <*> w) Гомоморфизм: чистый f <*> чистый x = чистый (f x) Перестановка: u <*> чистый y = чистый ($ y) <*> u

Обратите внимание, что тождество является обобщением id <$> v = v из Functor, поскольку f <$> x = pure f <*> x`.

Мы определили синтаксические анализаторы «классического стиля» с точки зрения лексера ( String -> [Token] ) и синтаксического анализатора ( [Token] -> AST ), но большую часть занятия мы потратили на рассмотрение альтернативной модели: Аппликативный разбор.

 импорт Data.Char
импортировать Control.Applicative
Парсер нового типа a = Парсер { parse :: String -> Maybe (a, String) }
буква :: Char -> Parser Char
буква c = парсер $\s ->
  дело с
    с':с' | c == c' -> Just (c,s')
    _ -> Ничего
Letters :: Строка -> Строка парсера
буквы str = Parser $ \s ->
  если взять (длина ул) s == ул
  затем Just (str,drop (length str) s)
  иначе ничего 

EG parse (буква 'c') "chocolate"

 instance Functor Parser где
  fmap f p = Парсер $ \s ->
    разбор случая p s of
      Ничего -> Ничего
      Just (v,s') -> Just (f v,s') 

Обратите внимание, если вы прищуритесь, то увидите, что этот Functor экземпляр Parser представляет собой комбинацию экземпляров для Maybe и для читатели:

 instance Functor Может где
  fmap f Ничего = Ничего
  fmap f (просто v) = просто (f v)
instance Functor ((->) r), где
  -- (а -> б) -> (г -> а) -> (г -> б)
  fmap f g x = f (g x) 

 экземпляр Applicative Parser, где
  чистый a = Parser $ \s -> Just (a,s)
  f <*> a = Parser $ \s -> -- f :: Parser (a -> b), a :: Parser a
    case parse f s of
      Ничего -> Ничего
      Просто (g,s') -> parse (fmap g a) s' -- g :: a -> b, fmap g a :: Parser b 

(Наш экземпляр Applicative - это , а также комбинация экземпляров для Возможно и читатель. Можете поверить мне на слово... или проверить сами.)

EG parse ((\x -> [x,x,x]) <$> буква 'c') "шоколад"

 буква C = буква 'c'
strCH = (\c h -> [c,h]) <$> буква 'c' <*> буква 'h' 

EG parse strCH "chocolate"

 string :: String -> Parser String
строка [] = чистый ""
string (c:s) = (:) <$> (буква c) <*> string s 

EG parse (string "choco") "chocolate"

EG parse (string "vanilla") "chocolate"

 eof :: Парсер ()
eof = Parser $ \s -> если null s, то просто ((),"") иначе ничего
strCH' = (\c h _ -> [c,h]) <$> буква 'c' <*> буква 'h' <*> eof 

EG 'parse strCH' "ch" is Just ("ch ",[])`

EG разбор strCH' "шоколад" дает Ничего .

Обратите внимание, что мы проигнорировали значение eof . Мы можем использовать (<*) и (*>) , ​​чтобы избавить себя от некоторых проблем, написав, например,

 strCH'' = (\c h -> [c,h]) <$> буква 'c' <*> буква 'h' <* eof
обеспечить :: (a -> Bool) -> Парсер a -> Парсер a
убедитесь, что pred p = Parser $\s ->
  разбор случая p s of
    Ничего -> Ничего
    Just (a,s') -> если пред a, то Just (a,s') else Ничего
удовлетворять :: (Char -> Bool) -> Parser Char
удовлетворять p = Parser f
  где f [] = ничего
        f (x:xs) = если p x then Just (x,xs) else Nothing 

Обратите внимание, что буква c эквивалентна удовлетворить (==c) .

 просмотр вперед :: Parser (возможно, Char)
просмотр вперед = синтаксический анализатор f
  где f [] = Просто (Ничего, [])
        f (c:s) = Just (Just c,c:s) 

Мы могли бы вручную определить целочисленный анализ:

 integer :: Parser Int
целое число = Парсер $ \s ->
  let (digits,rest) = span isDigit s in
  если нулевые цифры, то ничего другого Просто (читать цифры, остальные) 

Но будет лучше, если мы определим понятие выбора:

 class Applicative f => Alternative f где
  пустой :: ф а
  (<|>) :: f a -> f a -> f a
  многие, некоторые :: Альтернатива f => f a -> f [a]
  некоторые p = (:) <$> p <*> многие p
  многие p = некоторые p <|> чистый []
Экземпляр Альтернатива Возможно, где
  -- пусто :: ф а
  пусто = ничего
  -- (<|>) :: f a -> f a -> f a
  Просто х <|> _ = Просто х
  Ничего <|> r = r
  -- пусто <|> f == f
  -- f <|> пусто == f 

 экземпляр Альтернативный анализатор, где
  пустой = Парсер $ \s -> Ничего
  p1 <|> p2 = Парсер $\s ->
    разбор случая p1 s of
      Просто (а,с') -> Просто (а,с')
      Ничего -> разобрать p2 s
integer' :: Строка синтаксического анализатора
целое число' = читать <$> некоторые цифры
  где someDigits = (:) <$> удовлетворяет isDigit <*> moreDigits
        moreDigits = someDigits <|> чистый []
int :: Парсер Int
int = читать <$> некоторые (удовлетворить isDigit) 

EG разбор int "8675309"

EG разбор int "5551212zoop"

EG разбор int "KL51212"

 threeInts = (\n1 n2 n3 -> [n1,n2,n3]) <$char> ($char> ') <*> (int <* char ',') <*> (убедитесь, что (>0) int) 

EG разбор threeInts "1,2,3"

EG разбор threeInts "1,2, 0"

Давайте построим парсер для арифметических выражений.