Парсинг
Парсинг - це процес перетворення тексту на значущі дані.
Функції з пакета String тут обмежені, а регулярні вирази складні у використанні, тож ідіоматичний спосіб парсингу в Elm - це пакет elm/parser.
Розгляньмо приклад написання парсера для (підмножини) мови програмування LOLCODE.
Погляньмо на таку програму з коментарями:
HAI 1 # program version 1
CAN HAS STDIO? # import stdio
VISIBLE "HAI WORLD!" # print "HAI WORLD!"
KTHXBYE # end of program
Спочатку напишімо тип Elm, який представлятиме можливі команди:
type Command
= Version Int
| Import String
| Print String
Тоді нашу програму на LOLCODE можна змоделювати як List Command.
Почнімо з парсера для рядка HAI 1:
versionP : Parser Command
versionP =
Parser.succeed Version
|. Parser.keyword "HAI"
|. Parser.spaces
|= Parser.int
versionP побудовано за допомогою конвеєра парсерів.
Оператор (|.) означає «розібрати рядок тексту (англ. string), але відкинути результат», а (|=) означає «розібрати рядок тексту і зберегти результат».
У цьому прикладі Parser.keyword "HAI" споживе «HAI», але цей результат буде проігноровано.
Parser.spaces споживе будь-яку кількість символів ' ', '\n' і '\r', але це теж буде проігноровано.
Parser.int розбере ціле число, і значення цього числа (скажімо, 1) буде передано найвищому Parser.succeed Version, і парсер успішно поверне значення Version 1.
Якщо якийсь із парсерів у конвеєрі зазнає невдачі, він поверне Parser.DeadEnd, і весь парсер зазнає невдачі.
Парсер можна запустити за допомогою Parser.run:
Parser.run versionP "HAI 1"
--> Ok (Version 1)
Parser.run versionP "HAI 2"
--> Ok (Version 2)
Parser.run versionP "BYE 2"
--> Err [{ problem = ExpectingKeyword "HAI", col = 1, row = 1 }]
Parser.run versionP "HAI MOM"
--> Err [{ problem = ExpectingInt, col = 5, row = 1 }]
Візьмімося за рядок «CAN HAS STDIO?» ось так:
importP : Parser Command
importP =
Parser.succeed Import
|. Parser.keyword "CAN HAS"
|. Parser.spaces
|= packageP
|. Parser.symbol "?"
importP теж побудовано як конвеєр парсерів, але цього разу він завершується Parser.symbol, який підходить для розбору таких символів, як «?».
Значення, яке ми хочемо зберегти (назва пакета для імпорту), розбирається так:
packageP : Parser String
packageP =
Parser.chompWhile Char.isAlphaNum
|> Parser.getChompedString
|> Parser.map String.toLower
Оскільки ми не знаємо, якою буде назва пакета, ми не можемо використати Parser.keyword, тож натомість використовуємо Parser.chompWhile, який захоплюватиме окремі символи, доки вони задовольняють умову (тут - бути буквено-цифровим символом).
Потім ці захоплені символи збирає Parser.getChompedString, який повертає Parser String.
У цьому разі ми хочемо нормалізувати назви пакетів, тож використовуємо Parser.map, щоб змінити рядок тексту, який міститься в парсері, і перевести його в нижній регістр.
Parser.run importP "CAN HAS STDIO?"
--> Ok (Import "stdio")
Parser.run importP "CAN HAS StDiO?"
--> Ok (Import "stdio")
Parser.run importP "CAN HAS STDIO"
--> Err [{ problem = ExpectingSymbol "?", col = 14, row = 1 }]
Далі VISIBLE "HAI WORLD!" розбирається так:
printP : Parser Command
printP =
Parser.succeed Print
|. Parser.keyword "VISIBLE"
|. Parser.spaces
|. Parser.symbol "\""
|= stringP
|. Parser.symbol "\""
stringP : Parser String
stringP =
Parser.chompWhile (\c -> c /= '"')
|> Parser.getChompedString
Parser.run printP "VISIBLE \"HAI WORLD!\""
--> Ok (Print "HAI WORLD!")
Тепер у нас є парсер для кожної команди.
Звісно, у загальній програмі передбачити порядок цих команд неможливо, тож ми будуємо узагальнений парсер команд
commandP : Parser Command
commandP =
Parser.oneOf
[ versionP
, importP
, printP
]
Parser.oneOf пробуватиме парсери по черзі, у заданому порядку.
Якщо парсер зазнає невдачі, пробується наступний, але якщо він досягає успіху, його результат повертається без спроби решти парсерів.
Якщо всі парсери зазнають невдачі, Parser.oneOf зазнає невдачі.
Parser.run commandP "HAI 2"
--> Ok (Version 2)
Parser.run commandP "CAN HAS STDIO?"
--> Ok (Import "stdio")
Parser.run commandP "VISIBLE \"HAI WORLD!\""
--> Ok (Print "HAI WORLD!")
Parser.run commandP "O NOES"
--> Err [ { problem = ExpectingKeyword "HAI", col = 1, row = 1 }
-- , { problem = ExpectingKeyword "CAN HAS", col = 1, row = 1 }
-- , { problem = ExpectingKeyword "VISIBLE", col = 1, row = 1 }
-- ]
Звернімо увагу, як кожна невдала спроба породжує Parser.DeadEnd, який збирає Parser.oneOf.
Щоб розібрати повну програму, нам потрібно послідовно розібрати кілька команд ось так:
programP : Parser (List Command)
programP =
Parser.sequence
{ start = ""
, separator = "\n"
, end = "KTHXBYE"
, spaces = Parser.succeed ()
, item = commandP
, trailing = Parser.Optional
}
Parser.sequence - це дуже налаштовуваний парсер із низкою опцій.
start, separator й end приймають рядки тексту, що розділяють елементи послідовності; для розбору масиву Elm ми б використали «[», «,» і «]».
spaces дає гнучкість, приймаючи парсер, який оброблятиме можливі пробіли між елементами та розділювачами; для розбору масиву Elm ми б використали Parser.spaces, але в цьому разі ми не приймаємо жодних пробілів, тож використовуємо Parser.succeed (), який одразу досягає успіху, фактично нічого не споживаючи.
item приймає парсер елемента, а trailing нарешті дає нам вирішити, чи є кінцеві розділювачі Parser.Forbidden, Parser.Mandatory або Parser.Optional.
Parser.run programP "HAI 2\nCAN HAS STDIO?\nKTHXBYE"
--> Ok [Version 2, Import "stdio"]
Parser.run programP "KTHXBYE"
--> Ok []
Parser.run programP "HAI 2\nCAN HAS STDIO?\n"
--> Err [ { problem = ExpectingKeyword "HAI", col = 1, row = 3 }
-- , { problem = ExpectingKeyword "CAN HAS", col = 1, row = 3 }
-- , { problem = ExpectingKeyword "VISIBLE", col = 1, row = 3 }
-- , { problem = Expecting "KTHXBYE", col = 1, row = 3 }
-- ]
Коли парсери досягають успіху, вони перестають споживати рядок тексту
Parser.run Parser.int "1"
--> Ok 1
Parser.run Parser.int "1 BTW VISIBLE \"U SEE NOTHING\""
--> Ok 1
Тож якщо нам потрібно переконатися, що ми розібрали все в рядку тексту, можна використати Parser.end
fullProgramP : Parser (List Command)
fullProgramP =
programP
|. Parser.spaces
|. Parser.end
Parser.run fullProgramP "HAI 2\nCAN HAS STDIO?\nKTHXBYE"
--> Ok [Version 2, Import "stdio"]
Parser.run fullProgramP "HAI 2\nCAN HAS STDIO?\nKTHXBYE\nBTW VISIBLE \"U SEE NOTHING\""
--> Err [{ problem = ExpectingEnd, col = 1, row = 4 }]
Нарешті, іноді нам потрібно вирішити, чи провалити парсер, залежно від його розібраного вмісту.
Наприклад, якби нам був потрібен парсер, який провалював би програми, що починаються з двох команд «HAI» підряд, ми могли б зробити так:
singleVersionProgramP : Parser (List Command)
singleVersionProgramP =
fullProgramP
|> Parser.andThen
(\commands ->
case commands of
(Version _) :: (Version _) :: _ ->
Parser.problem "Multiple versions defined"
_ ->
Parser.succeed commands
)
Parser.andThen може переглянути вміст парсера і повертає новий парсер залежно від його значення.
Тут ми в одному випадку провалили парсер із власним повідомленням за допомогою Parser.problem, а в іншому повернули початкове значення.
Parser.run singleVersionProgramP "HAI 2\nCAN HAS STDIO?\nKTHXBYE"
--> Ok [Version 2, Import "stdio"]
Parser.run singleVersionProgramP "HAI 1\nHAI 2\nCAN HAS STDIO?\nKTHXBYE"
--> Err [{ problem = Problem "Multiple versions defined", col = 8, row = 4 }]
Навчальна вправа
