Functional Parsing with FParsec

Functional Parsing
with FParsec

A parser is an application or script
that takes in data, usually in the
form of text or a stream, and
produces a data structure to
represent syntactical relationship.

string input
“(419)-423-2781”
data structure output
{ AreaCode = 419
Prefix = 423
LineNumber = 2781 }

A parser combinator is a higher
order function that takes in two
or more parsers and combines
them to make a new parser

let pprefix = pint32
let plinenumber = pint32

let pprefix = pint32
let pdash = pchar ‘-’

let pphonenumber =
pprefix .>> pdash .>>. plinenumber

let pphonenumber =
pprefix_and_pdash .>>. plinenumber

string input
“423-2781”
(423, 2781)

type PhoneNumber =
{ AreaCode : int
Prefix : int
LineNumber : int }

let createPhoneNumber a p l =
{ AreaCode = a
Prefix = p
LineNumber = l }

let popenparens = pchar ‘(‘
let pcloseparens = pchar ‘)’
let pareacode =
popenparens >>. pint32 .>> pcloseparens

let pareacode =
between popenparens pcloseparens pint32

let pdash = pchar ‘-’
let pareacode =
between popenparens pcloseparens pint32 .>> pdash
let pprefix = pint32 .>> pdash

let pphonenumber =
pipe3 pareacode
pprefix
plinenumber
createPhoneNumber

string input
“(419)-423-2781” OR “419-423-2781”
{ AreaCode = 419
Prefix = 423
LineNumber = 2781 }

let A_and_B = pchar ‘A‘ .>>. pchar ‘B’

let A_and_B = pchar ‘A‘ .>>. pchar ‘B’
let A_or_B = pchar ‘A‘ <|> pchar ‘B’

let pareacode =
between popenparens pcloseparens pint32
<|> pint32 .>> pdash

How do you actually
run a parser against
input?

type Parser<’TResult, ‘TUserState> =
CharStream<‘TUserState> -> Reply<’TResult>

val run:
Parser<’a, unit> -> string -> ParserResult<’a,
unit>

val run:
Parser<’a, unit> -> string -> ParserResult<’a,
unit>
type ParserResult<’Result, ‘UserState> =
| Success of ’Result * ‘UserState * Position
| Failure of string * ParserError * ‘UserState

let test p str =
match run p str with
| Success(result, state, pos) -> ...
| Failure(errMsg, error, state) -> ...

let test p str =
match run p str with
| Success(result, _, _) ->
printfn “Success: %A” result
| Failure(errMsg, _, _) ->
printfn “Failure: %s” errMsg

runParserOnString parser
UserState.Default
“Name for the stream”
“Input string”

runParserOnStream parser
UserState.Default
“Name for the stream”
stream
Encoding.UTF8

How do you parse one
of several possible
types?

type State = OH | KY | IN | TN
type StreetAddress =
{ Street : int * string
City : string
State : State
Zipecode : int }

let createStreetAddress str c st zip =
{ Street = str
City = c
State = st
Zipcode = zip }

let isStreetName c = isLetter c || isAnyOf “ .” c
let pcomma = pchar ‘,‘ .>> spaces
let pstreet =
pint32
.>> spaces
.>>. (manySatisfy isStreetName)
.>> pcomma
|> attempt

let pcity = manySatisfy isLetter .>> pcomma
let pstate =
choice
[ stringReturn “OH” OH
stringReturn “KY” KY
stringReturn “IN” IN
stringReturn “TN” TN ]
.>> spaces
let pzipcode = pint32

let paddress =
pipe4 pstreet
pcity
pstate
pzipcode
createStreetAddress

string input
“(419)-423-2781
129 Pineview Dr., Indianapolis, IN 40118
512 Kirk Dr., Columbus, OH 54778
7009 Elm St., Lexington, KY 89776
657-322-6578
(513)-277-9856”

type ContactInfo =
| Phone of PhoneNumber
| Address of StreetAddress

let pphonenumber =
pipe3 pareacode
pprefix
plinenumber
createPhoneNumber
|>> Phone

let paddress =
pipe4 pstreet
pcity
pstate
pzipcode
createStreetAddress
|>> Address

let pcontactinfo =
[ paddress .>> spaces
pphonenumber .>> spaces ]
|> choice
|> many

type UserState =
{ PhoneCount: int
AddressCount: int }
with
static member Default =
{ PhoneCount = 0
AddressCount = 0 }

let incrementPhoneNumber =
let incrementPhone us =
{ us with PhoneCount = us.PhoneCount + 1 }
updateUserState incrementPhone

let incrementPhoneNumber =
let incrementPhone us =
{ us with PhoneCount = us.PhoneCount + 1 }
let incrementStreetAddress =
let incrementAddress us =
{ us with AddressCount = us.AddressCount + 1 }

let pcontactinfo =
[ paddress .>> incrementStreetAddress .>> spaces
phonenumber .>> incrementPhoneNumber .>> spaces ]
|> choice
|> many

● Download the .NetCore SDK
● Create a directory for your parser scripts
● While in the directory, download Paket *
*(Paket is an alternative solution to package management in dotnet)

● Run the dotnet paket init command
● Add nuget FParsec to the paket.dependencies
file created by paket
● Run dotnet paket install
● Run dotnet paket generate-load-scripts

Alternatively, you can add generate_load_scripts: true
at the top of your paket.dependencies file before
running dotnet paket install which will automatically
generate the load scripts.

● Create an F# script file in the parent directory of
your project (ex. parsers.fsx)
● At the top of the file add the following code to
load the dll references for FParsec and open the
FParsec namespace
#load @”.paketloadnetcoreapp3.0main.group.fsx”
open FParsec

Functional Parsing with FParsec

Recommended

Recommended

More Related Content

Recently uploaded

Recently uploaded (20)

Featured

Featured (20)

Functional Parsing with FParsec