Tutorial

This example demonstrates using this library to construct incremental parser for arithmetical expressions.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33:

#r "FsGll.dll"
open FsGll.Parsers.Incremental.Pure

// utilities
let isPartial = function Partial(_) -> true 
                       | _          -> false
let getPartial = List.tryFind isPartial
let parse p s = runParser<_,_> p (stringStream s)

// construct parser
let e, er = createParserForwardedToRef<_>()
let t, tr = createParserForwardedToRef<_>()
let chr c = satisfy ((=)c) 
let op = chr '+' <|> chr '-' 
     <|> chr '*' <|> chr '/'
let num = satisfy (Char.IsDigit) |>> Int32.Parse
let f = num <|> (chr '(' >>. e .>> chr')')

let sem l x r = 
    match x with 
    | '+' -> l + r 
    | '-' -> l - r
    | '*' -> l + r 
    | '/' -> l - r
    
er := pipe3 e op t sem <|> t
tr := pipe3 t op f sem <|> f

// run
let f = parse e "1+2*" |> getPartial 
let g = parse f "(3" |> getPartial
let h1 = parse f "3+4"
let h2 = parse g "+4)"

h1 = (e "1+2*") "3+4"
h2 = ((e "1+2*") "(3") "+4)"

val isPartial : (obj -> bool)

Full name: Tutorial.isPartial

val getPartial : (obj list -> obj option)

Full name: Tutorial.getPartial

Multiple items
module List

from Microsoft.FSharp.Collections

--------------------
type List<'T> =
  | ( [] )
  | ( :: ) of Head: 'T * Tail: 'T list
  interface IEnumerable
  interface IEnumerable<'T>
  member GetSlice : startIndex:int option * endIndex:int option -> 'T list
  member Head : 'T
  member IsEmpty : bool
  member Item : index:int -> 'T with get
  member Length : int
  member Tail : 'T list
  static member Cons : head:'T * tail:'T list -> 'T list
  static member Empty : 'T list

Full name: Microsoft.FSharp.Collections.List<_>

val tryFind : predicate:('T -> bool) -> list:'T list -> 'T option

Full name: Microsoft.FSharp.Collections.List.tryFind

val parse : p:'a -> s:'b -> 'c

Full name: Tutorial.parse

val p : 'a

val s : 'a

val e : obj

Full name: Tutorial.e

val er : obj ref

Full name: Tutorial.er

val t : obj

Full name: Tutorial.t

val tr : obj ref

Full name: Tutorial.tr

val chr : c:'a -> 'b

Full name: Tutorial.chr

val c : 'a

val op : obj

Full name: Tutorial.op

val num : obj

Full name: Tutorial.num

val f : obj

Full name: Tutorial.f

val sem : l:int -> x:char -> r:int -> int

Full name: Tutorial.sem

val l : int

val x : char

val r : int

val f : obj option

Full name: Tutorial.f

val g : obj option

Full name: Tutorial.g

val h1 : 'a

Full name: Tutorial.h1

val h2 : 'a

Full name: Tutorial.h2