Simple C# Parser

Simple prototype C# AST and parser using the FParsec parser combinator library. Parses a subset of C# 1.1 constructs.

Abstract Syntax Tree

 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: 
34: 
35: 
36: 
37: 
38: 
39: 
40: 
41: 
42: 
43: 
44: 
45: 
46: 
47: 
48: 
49: 
50: 
51: 
52: 
53: 
54: 
55: 
56: 
57: 
58: 
59: 
60: 
61: 
62: 
63: 
64: 
65: 
66: 
67: 
68: 
69: 
70: 
71: 
72: 
73: 
74: 
75: 
76: 
77: 
78: 
79: 
80: 
81: 
82: 
83: 
84: 
85: 
86: 
87: 
88: 
89: 
90: 
91:

// Base type abbreviations
type Name = string
type VarName = Name
type TypeName = Name
type MemberName = Name
type LabelName = Name
type Value = obj
type Literal = Literal of Value
// Expressions
type ArgType = ValueArg | RefArg | OutArg
type Expr = 
    | Value of Literal
    | Variable of VarName
    | MethodInvoke of MemberName * Arg list
    | PropertyGet of MemberName
    | Cast of TypeName * Expr
    | InfixOp of Expr * string * Expr
    | PrefixOp of string * Expr
    | PostfixOp of Expr * string
    | TernaryOp of Expr * Expr * Expr
and Arg = Arg of ArgType * Expr
// Statements
type Define = Define of TypeName * VarName
type Init = 
    | Assign of Name * (* =,+=, etc. *) Expr
    | Construct of TypeName * Name * Expr
type Condition = Expr
type Iterator = Expr
type Statement =
    | Definition of Define
    | Assignment of Init
    | PropertySet of MemberName * Expr
    | Action of Expr
    //| Block/Scope of Statement list
    | If of Expr * Block
    | IfElse of Expr * Block * Block
    | Switch of Expr * Case list
    | For of Init list * Condition * Iterator list * Block
    | ForEach of Define * Expr * Block
    | While of Expr * Block
    | DoWhile of Block * Expr
    | Throw of Expr
    | Try of Block
    | Catch of TypeName * Block
    | Finally of Block
    | Lock of Expr * Block    
    | Using of Expr * Block
    | Label of LabelName
    | Goto of LabelName
    | Break
    | Continue
    | Return of Expr
    //| Directive of Name
and Case = 
    | Case of Literal * Block
    | Default of Block
and Block = Statement list
// Modifiers
type Access = Public | Private | Protected | Internal
type Modifier = Static | Sealed | Override | Virtual | Abstract
// Members
type ReturnType = TypeName
type MemberInfo = MemberInfo of Access * Modifier option * ReturnType * Name
type IsReadOnly = bool
type ParamType = ByValue | ByRef | Out | Params
type Param = Param of ParamType * TypeName * VarName
type PreConstruct = PreConstruct of Name * Param list
type Member =
    | Field of Access * Modifier option * IsReadOnly * 
               ReturnType * Name * Expr option
    | Property of MemberInfo * Block option * Block option
    | Method of MemberInfo * Param list * Block
    | Constructor of Access * Modifier option * Name * Param list * 
                     PreConstruct option * Block
// Types
type Members = Member list
type Implements = Name list
type EnumValue = EnumValue of Name * Value
type CSharpType = 
    | Class of Access * Modifier option * Name * Implements * Members
    | Struct of Access * Name * Member list
    | Interface of Access * Name * Implements * Member list
    | Enum of Access * TypeName * EnumValue list
    | Delegate of Access * Name * ReturnType * Param list    
// Namespace scopes
type Import = 
    | Import of Name list
    | Alias of Name * Name list
type NamespaceScope =
    | Namespace of Import list * Name list * NamespaceScope list
    | Types of Import list * CSharpType list

Parser

open FParsec

// White space

let maxCount = System.Int32.MaxValue
let pcomment = pstring "//" >>. many1Satisfy ((<>) '\n') 
let pspaces = spaces >>. many (spaces >>. pcomment >>. spaces)
let pmlcomment = pstring "/*" >>. skipCharsTillString "*/" true (maxCount)

let ws = pspaces >>. many (pspaces >>. pmlcomment >>. pspaces) |>> (fun _ -> ())
let ws1 = spaces1
let str_ws s = pstring s .>> ws
let str_ws1 s = pstring s .>> ws1

// Literals

type Lit = NumberLiteralOptions
let numberFormat = Lit.AllowMinusSign ||| Lit.AllowFraction ||| Lit.AllowExponent
let pnumber : Parser<Literal, unit> =
    numberLiteral numberFormat "number"
    |>> fun nl ->
            if nl.IsInteger then Literal(int nl.String)
            else Literal(float nl.String)
let ptrue = str_ws "true" |>> fun _ -> Literal(true)
let pfalse = str_ws "false" |>> fun _ -> Literal(false)
let pbool = ptrue <|> pfalse
let pstringliteral =
    let normalChar = satisfy (fun c -> c <> '\\' && c <> '"')
    let unescape c = match c with
                     | 'n' -> '\n'
                     | 'r' -> '\r'
                     | 't' -> '\t'
                     | c   -> c
    let escapedChar = pstring "\\" >>. (anyOf "\\nrt\"" |>> unescape)
    between (pstring "\"") (pstring "\"")
            (manyChars (normalChar <|> escapedChar))
    |>> fun s -> Literal(s)

let pliteral = pnumber <|> pbool <|> pstringliteral

// Expressions

let pexpr, pexprimpl = createParserForwardedToRef ()

let reserved = ["for";"do"; "while";"if";"switch";"case";"default";"break" (*;...*)]
let pidentifierraw =
    let isIdentifierFirstChar c = isLetter c || c = '_'
    let isIdentifierChar c = isLetter c || isDigit c || c = '_'
    many1Satisfy2L isIdentifierFirstChar isIdentifierChar "identifier"
let pidentifier =
    pidentifierraw 
    >>= fun s -> 
        if reserved |> List.exists ((=) s) then fail "keyword" 
        else preturn s
let pidentifier_ws = pidentifier .>> ws
let pvar = pidentifier |>> fun x -> Variable(x)

let pargref = str_ws1 "ref" |>> fun _ -> RefArg
let pargout = str_ws1 "out" |>> fun _ -> OutArg
let pargtype = (opt pargref <|> opt pargout) 
               |>> function Some x -> x | None -> ValueArg
let parg = pargtype .>>. pexpr |>> fun (by,e) -> Arg(by,e)
let pinvoke =
    pidentifier_ws .>>.
    between (str_ws "(") (str_ws ")") (many parg)
    |>> fun (name,args) -> MethodInvoke(name,args)

let pcast =
    let ptypecast = between (str_ws "(") (str_ws ")") pidentifier_ws
    ptypecast .>>. pexpr |>> fun (name,e) -> Cast(name,e)

let pvalue = (pliteral |>> fun x -> Value(x)) <|> 
             attempt pinvoke <|> attempt pvar <|> attempt pcast

type Assoc = Associativity

let opp = OperatorPrecedenceParser<Expr,unit,unit>()
pexprimpl := opp.ExpressionParser
let term = pvalue .>> ws <|> between (str_ws "(") (str_ws ")") pexpr
opp.TermParser <- term
let inops = ["+";"-";"*";"/";"%"
             "&&"; "||"; ">>"; "<<"; "&"; "|"; "^"
             "==";"!=";"<=";">=";"<";">";"??"
             "."]
for op in inops do
    opp.AddOperator(InfixOperator(op, ws, 1, Assoc.Left, fun x y -> InfixOp(x, op, y)))
let preops = ["-";"++";"--"]
for op in preops do
    opp.AddOperator(PrefixOperator(op, ws, 1, true, fun x -> PrefixOp(op, x)))
opp.AddOperator(PrefixOperator("new", ws1, 1, true, fun x -> PrefixOp("new", x)))
let postops = ["++";"--"]
for op in postops do
    opp.AddOperator(PostfixOperator(op, ws, 1, true, fun x -> PostfixOp(x, op)))

let pexpr' = between (str_ws "(") (str_ws ")") pexpr

// Statement blocks

let pstatement, pstatementimpl = createParserForwardedToRef()
let psinglestatement = pstatement |>> fun statement -> [statement]
let pstatementblock =
    psinglestatement <|>
    between (str_ws "{") (str_ws "}") (many pstatement) 

// Assignement statements

let pdefine = pipe2 (pidentifier .>> ws1) (pidentifier)
                (fun ty name -> Define(ty,name))

let pdefinition = pdefine |>> fun d -> Definition(d)

let passign = pipe3 pidentifier_ws (str_ws "=") pexpr
               (fun var _ expr -> Assign(var,expr))

let pconstruct = 
    pipe4
        (pidentifier .>> ws1)
        pidentifier_ws
        (str_ws "=")
        pexpr
        (fun ty name _ e -> Construct(ty, name, e))

let passignment = attempt passign <|> attempt pconstruct |>> fun c -> Assignment(c)

// Selection statements

let pif =
    pipe2 (str_ws "if" >>. pexpr') pstatementblock
        (fun e block -> If(e,block))

let pifelse =
    pipe3 (str_ws "if" >>. pexpr') pstatementblock (str_ws "else" >>. pstatementblock)
        (fun e t f -> IfElse(e,t,f))

let pcase = str_ws1 "case" >>. pliteral .>> str_ws ":" 
let pcaseblock = pipe2 pcase (many pstatement) (fun case block -> Case(case,block))
let pdefault = str_ws "default" >>. str_ws ":" 
let pdefaultblock = pdefault >>. (many pstatement) |>> fun block -> Default(block)
let pcases' = many pcaseblock .>>. opt pdefaultblock 
              |>> fun (cases,d) -> cases@(Option.toList d)
let pcases = between (str_ws "{") (str_ws "}") pcases'

let pswitch =
    pipe2 (str_ws "switch" >>. pexpr') pcases
        (fun e cases -> Switch(e, cases))

// Iteration statements

let pforargs =
    let pinit = attempt passign <|> attempt pconstruct
    pipe3 
        (sepBy pinit (str_ws ",") .>> str_ws ";")
        (pexpr .>> str_ws ";")
        (sepBy pexpr (str_ws ","))
        (fun from until steps -> from, until, steps)

let pfor =
    pipe2 
        (str_ws "for" >>. between (str_ws "(") (str_ws ")") pforargs)
        pstatementblock
        (fun (inits,until,iterators) block -> For(inits,until,iterators,block))

let pforeachargs =
    pipe3 pdefine (str_ws1 "in") pexpr
        (fun define _ collection -> define, collection)

let pforeach =
    pipe2 (str_ws "foreach" >>. pforeachargs) pstatementblock
        (fun (define,collection) block -> ForEach(define,collection,block))

let pwhile = 
    pipe2 (str_ws "while" >>. pexpr') pstatementblock
        (fun e block -> While(e,block))

let pdowhile =
    pipe2
        (str_ws "do" >>. pstatementblock)
        (str_ws "while" >>. pexpr')
        (fun block e -> DoWhile(block, e))

// Jump statements

let preturn = str_ws1 "return" >>. pexpr |>> fun e -> Return(e)

let pbreak = str_ws "break" |>> fun _ -> Break

let pcontinue = str_ws "continue" |>> fun _ -> Continue

let pgoto = str_ws1 "goto" >>. pidentifier_ws |>> fun label -> Goto(label)

let plabel = 
    pidentifier_ws .>> str_ws ":" 
    |>> fun label -> Label(label)

// Exception statements

let pthrow = str_ws1 "throw" >>. pexpr |>> fun e -> Throw(e)

let ptry = str_ws "try" >>. pstatementblock |>> fun block -> Try(block)

let pfinally = str_ws "finally" >>. pstatementblock |>> fun block-> Finally(block)

let pexception = between (str_ws "(") (str_ws ")") pidentifier_ws
let pcatch = str_ws "catch" >>. pexception .>>. pstatementblock 
             |>> fun (ex,block) -> Catch(ex, block)

// Lock statement

let plock = 
    str_ws "lock" >>. pexpr' .>>. pstatementblock 
    |>> (fun (e,block) -> Lock(e,block))

// Statement implementation

let paction = pexpr |>> fun e -> Action(e)

pstatementimpl :=
    attempt (preturn .>> str_ws ";") <|>
    attempt (pbreak .>> str_ws ";") <|>
    attempt (pcontinue .>> str_ws ";") <|>
    attempt (pgoto .>> str_ws ";") <|>  
    attempt (pdefinition .>> str_ws ";") <|>
    attempt (passignment .>> str_ws ";") <|> 
    attempt (paction .>> str_ws ";") <|>
    attempt plabel <|>
    attempt pifelse <|> attempt pif <|> 
    attempt pswitch <|>
    attempt pfor <|> attempt pforeach <|>
    attempt pwhile <|> attempt pdowhile <|>
    attempt pthrow <|>
    attempt ptry <|> attempt pcatch <|> attempt pfinally
    attempt plock

// Access

let ppublic = str_ws1 "public" |>> fun _ -> Public
let pprivate = str_ws1 "private" |>> fun _ -> Private
let pprotected = str_ws1 "protected" |>> fun _ -> Protected
let pinternal = str_ws1 "internal" |>> fun _ -> Internal
let paccess = 
    opt (ppublic <|> pprivate <|> pprotected <|> pinternal)
    |>> (fun access -> defaultArg access Internal)

// Modifiers

let psealed = str_ws1 "sealed" |>> fun _ -> Sealed
let pstatic = str_ws1 "static" |>> fun _ -> Static
let pmodifier = psealed <|> pstatic

// Parameters

let pref = str_ws "ref" |>> fun _ -> ByRef
let pout = str_ws1 "out" |>> fun _ -> Out
let pparams = str_ws1 "params" |>> fun _ -> Params
let pby = (opt pout <|> opt pref <|> opt pparams) 
          |>> function Some x -> x | None -> ByValue
let pparam = 
    pipe3 pby pidentifier_ws pidentifier_ws 
      (fun by ty name -> Param(by,ty,name)) 
let pparamlist= str_ws "(" >>. sepBy pparam (str_ws ",") .>> str_ws ")"

// Members

let pmemberinfo = 
    pipe4 paccess (opt pmodifier) pidentifier_ws pidentifier_ws
     (fun access modifier ty name -> MemberInfo(access,modifier,ty,name))

let preadonly = str_ws1 "readonly"
let pfieldpreamble =
    pipe3 paccess (opt pmodifier) (opt preadonly)
     (fun access modifier ro -> (access, modifier, Option.isSome ro))
let pfield = 
    pipe4 pfieldpreamble pidentifier_ws pidentifier_ws (str_ws ";")
     (fun (access,modifier,ro) rt name _ -> Field(access, modifier, ro, rt, name, None))
let pget = str_ws "get" >>. pstatementblock
let pset = str_ws "set" >>. pstatementblock
let ppropertyblock =
    between (str_ws "{") (str_ws "}") ((opt pget) .>>. (opt pset))
let pproperty = 
    pipe2 pmemberinfo ppropertyblock
     (fun mi (gblock,sblock) -> Property(mi,gblock,sblock))
let pmethod =
    pipe3 pmemberinfo pparamlist pstatementblock 
     (fun mi ps block -> Method(mi,ps,block))
let pconstructor = 
    pipe5 paccess (opt pmodifier) pidentifier_ws pparamlist pstatementblock
     (fun access modifier name ps block ->
       Constructor(access, modifier, name, ps, None, block))

let pmember = 
    attempt pfield <|> attempt pmethod <|> attempt pproperty <|> attempt pconstructor

let pmembersblock = between (str_ws "{") (str_ws "}") (many pmember) 
                   |>> (fun members -> members)
let penumblock = 
    between (str_ws "{") (str_ws "}") (sepBy pidentifier_ws (str_ws ","))
    |>> fun names -> names |> List.mapi (fun i name -> EnumValue(name,i))

// Types

let pclasspreamble =
    paccess .>>. (opt pmodifier) .>> (str_ws1 "class")
let pimplements =
    opt (str_ws ":" >>. sepBy1 (pidentifier_ws) (str_ws ","))
    |>> function Some xs -> xs | None -> []
let pclass = 
    pipe4 pclasspreamble pidentifier_ws pimplements pmembersblock
     (fun (access,modifier) name implements block -> 
        Class(access, modifier, name, implements, block))
let pstruct =
    pipe4 paccess (str_ws1 "struct") pidentifier_ws pmembersblock
     (fun access _ name block -> Struct(access, name, block))
let pinterface =
    pipe5 paccess (str_ws1 "interface") pidentifier_ws pimplements pmembersblock
     (fun access _ name implements block -> 
        Interface(access, name, implements, block))
let penum =
    pipe4 paccess (str_ws1 "enum") pidentifier_ws penumblock
     (fun access _ name block -> Enum(access, name, block))
let pdelegate =
    pipe5 paccess (str_ws1 "delegate") pidentifier_ws pidentifier_ws pparamlist
     (fun access _ ty name ps -> Delegate(access, ty, name, ps))

let ptypedeclaration = 
    pclass <|> pstruct <|> pinterface <|> penum <|> pdelegate

// Scopes

let pnsscope, pscopeimpl = createParserForwardedToRef()
let pnsscopesblock = between (str_ws "{") (str_ws "}") (many pnsscope)

let pns = sepBy1 pidentifier_ws (str_ws ".")
let palias = str_ws1 "using" >>. pidentifier_ws >>. str_ws "=" .>>. pns
             |>> fun (alias,name) -> Alias(alias,name)
let popen = str_ws1 "using" >>. pns |>> fun name -> Import(name)
let pimport = (attempt popen <|> attempt palias) .>> str_ws ";"

let pnsblock =
    pipe3 (many pimport) (str_ws1 "namespace" >>. pns) pnsscopesblock
     (fun imports name block -> 
        let types = Types([],[])
        Namespace(imports,name,block))

let ptypes = 
    pipe2 (many pimport) (many1 ptypedeclaration)
     (fun imports classes -> Types(imports, classes))

pscopeimpl := ws >>. (pnsblock <|> ptypes)

Example

 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: 
34: 
35:

let program = """
using System; 
namespace CompanyName { 
  namespace ProjectName.FolderName {
  /* My class */
  class MyClass : IMarker {
    float y;
    // My foo
    bool MyMethod(string arg) {
      string s = (string) "hello"; // assign string lit
      for(int i = 1; i<=100; i++) {
        if (i % 15 == 0) Console.WriteLine("FizzBuzz");
      }
      switch(y) { case 0: break; case 1: y = 1; default: }
      bool x;   
      x = true;  
      while(x) { 
        if (true) { x = false; } else if (false) { goto end; }
      }
end:
      return true;
    }
    bool MyProp {
      get { }
      set { y = value; }
    }
  } 
  struct MyStruct { }
  interface IMarker { }
  enum MyEnum { One, Two, Three }
  } 
}
"""

run pnsscope program

Multiple items
val string : value:'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------
type string = System.String

Full name: Microsoft.FSharp.Core.string

type VarName = Name

Full name: Script.VarName

type Name = string

Full name: Script.Name

type TypeName = Name

Full name: Script.TypeName

type MemberName = Name

Full name: Script.MemberName

type LabelName = Name

Full name: Script.LabelName

type Value = obj

Full name: Script.Value

type obj = System.Object

Full name: Microsoft.FSharp.Core.obj

Multiple items
union case Literal.Literal: Value -> Literal

--------------------
type Literal = | Literal of Value

Full name: Script.Literal

--------------------
type LiteralAttribute =
inherit Attribute
new : unit -> LiteralAttribute

Full name: Microsoft.FSharp.Core.LiteralAttribute

--------------------
new : unit -> LiteralAttribute

type ArgType =
  | ValueArg
  | RefArg
  | OutArg

Full name: Script.ArgType

union case ArgType.ValueArg: ArgType

union case ArgType.RefArg: ArgType

union case ArgType.OutArg: ArgType

Multiple items
union case Expr.Value: Literal -> Expr

--------------------
type Value = obj

Full name: Script.Value

union case Expr.Variable: VarName -> Expr

union case Expr.MethodInvoke: MemberName * Arg list -> Expr

type Arg = | Arg of ArgType * Expr

Full name: Script.Arg

type 'T list = List<'T>

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

union case Expr.PropertyGet: MemberName -> Expr

union case Expr.Cast: TypeName * Expr -> Expr

union case Expr.InfixOp: Expr * string * Expr -> Expr

union case Expr.PrefixOp: string * Expr -> Expr

union case Expr.PostfixOp: Expr * string -> Expr

union case Expr.TernaryOp: Expr * Expr * Expr -> Expr

Multiple items
union case Arg.Arg: ArgType * Expr -> Arg

--------------------
type Arg = | Arg of ArgType * Expr

Full name: Script.Arg

Multiple items
union case Define.Define: TypeName * VarName -> Define

--------------------
type Define = | Define of TypeName * VarName

Full name: Script.Define

type Init =
| Assign of Name * Expr
| Construct of TypeName * Name * Expr

Full name: Script.Init

union case Init.Assign: Name * Expr -> Init

union case Init.Construct: TypeName * Name * Expr -> Init

type Condition = Expr

Full name: Script.Condition

type Iterator = Expr

Full name: Script.Iterator

union case Statement.Definition: Define -> Statement

union case Statement.Assignment: Init -> Statement

union case Statement.PropertySet: MemberName * Expr -> Statement

union case Statement.Action: Expr -> Statement

union case Statement.If: Expr * Block -> Statement

type Block = Statement list

Full name: Script.Block

union case Statement.IfElse: Expr * Block * Block -> Statement

union case Statement.Switch: Expr * Case list -> Statement

type Case =
| Case of Literal * Block
| Default of Block

Full name: Script.Case

union case Statement.For: Init list * Condition * Iterator list * Block -> Statement

union case Statement.ForEach: Define * Expr * Block -> Statement

union case Statement.While: Expr * Block -> Statement

union case Statement.DoWhile: Block * Expr -> Statement

union case Statement.Throw: Expr -> Statement

union case Statement.Try: Block -> Statement

union case Statement.Catch: TypeName * Block -> Statement

union case Statement.Finally: Block -> Statement

union case Statement.Lock: Expr * Block -> Statement

union case Statement.Using: Expr * Block -> Statement

union case Statement.Label: LabelName -> Statement

union case Statement.Goto: LabelName -> Statement

union case Statement.Break: Statement

union case Statement.Continue: Statement

union case Statement.Return: Expr -> Statement

Multiple items
union case Case.Case: Literal * Block -> Case

--------------------
type Case =
| Case of Literal * Block
| Default of Block

Full name: Script.Case

union case Case.Default: Block -> Case

type Access =
  | Public
  | Private
  | Protected
  | Internal

Full name: Script.Access

union case Access.Public: Access

union case Access.Private: Access

union case Access.Protected: Access

union case Access.Internal: Access

union case Modifier.Static: Modifier

Multiple items
union case Modifier.Sealed: Modifier

--------------------
type SealedAttribute =
  inherit Attribute
  new : unit -> SealedAttribute
  new : value:bool -> SealedAttribute
  member Value : bool

Full name: Microsoft.FSharp.Core.SealedAttribute

--------------------
new : unit -> SealedAttribute
new : value:bool -> SealedAttribute

union case Modifier.Override: Modifier

union case Modifier.Virtual: Modifier

union case Modifier.Abstract: Modifier

type ReturnType = TypeName

Full name: Script.ReturnType

Multiple items
union case MemberInfo.MemberInfo: Access * Modifier option * ReturnType * Name -> MemberInfo

--------------------
type MemberInfo = | MemberInfo of Access * Modifier option * ReturnType * Name

Full name: Script.MemberInfo

type 'T option = Option<'T>

Full name: Microsoft.FSharp.Core.option<_>

type IsReadOnly = bool

Full name: Script.IsReadOnly

type bool = System.Boolean

Full name: Microsoft.FSharp.Core.bool

type ParamType =
  | ByValue
  | ByRef
  | Out
  | Params

Full name: Script.ParamType

union case ParamType.ByValue: ParamType

union case ParamType.ByRef: ParamType

union case ParamType.Out: ParamType

union case ParamType.Params: ParamType

Multiple items
union case Param.Param: ParamType * TypeName * VarName -> Param

--------------------
type Param = | Param of ParamType * TypeName * VarName

Full name: Script.Param

Multiple items
union case PreConstruct.PreConstruct: Name * Param list -> PreConstruct

--------------------
type PreConstruct = | PreConstruct of Name * Param list

Full name: Script.PreConstruct

type Member =
  | Field of Access * Modifier option * IsReadOnly * ReturnType * Name * Expr option
  | Property of MemberInfo * Block option * Block option
  | Method of MemberInfo * Param list * Block
  | Constructor of Access * Modifier option * Name * Param list * PreConstruct option * Block

Full name: Script.Member

union case Member.Field: Access * Modifier option * IsReadOnly * ReturnType * Name * Expr option -> Member

union case Member.Property: MemberInfo * Block option * Block option -> Member

union case Member.Method: MemberInfo * Param list * Block -> Member

union case Member.Constructor: Access * Modifier option * Name * Param list * PreConstruct option * Block -> Member

type Members = Member list

Full name: Script.Members

type Implements = Name list

Full name: Script.Implements

Multiple items
union case EnumValue.EnumValue: Name * Value -> EnumValue

--------------------
type EnumValue = | EnumValue of Name * Value

Full name: Script.EnumValue

type CSharpType =
  | Class of Access * Modifier option * Name * Implements * Members
  | Struct of Access * Name * Member list
  | Interface of Access * Name * Implements * Member list
  | Enum of Access * TypeName * EnumValue list
  | Delegate of Access * Name * ReturnType * Param list

Full name: Script.CSharpType

Multiple items
union case CSharpType.Class: Access * Modifier option * Name * Implements * Members -> CSharpType

--------------------
type ClassAttribute =
inherit Attribute
new : unit -> ClassAttribute

Full name: Microsoft.FSharp.Core.ClassAttribute

--------------------
new : unit -> ClassAttribute

Multiple items
union case CSharpType.Struct: Access * Name * Member list -> CSharpType

--------------------
type StructAttribute =
inherit Attribute
new : unit -> StructAttribute

Full name: Microsoft.FSharp.Core.StructAttribute

--------------------
new : unit -> StructAttribute

Multiple items
union case CSharpType.Interface: Access * Name * Implements * Member list -> CSharpType

--------------------
type InterfaceAttribute =
inherit Attribute
new : unit -> InterfaceAttribute

Full name: Microsoft.FSharp.Core.InterfaceAttribute

--------------------
new : unit -> InterfaceAttribute

union case CSharpType.Enum: Access * TypeName * EnumValue list -> CSharpType

union case CSharpType.Delegate: Access * Name * ReturnType * Param list -> CSharpType

Multiple items
union case Import.Import: Name list -> Import

--------------------
type Import =
| Import of Name list
| Alias of Name * Name list

Full name: Script.Import

union case Import.Alias: Name * Name list -> Import

type NamespaceScope =
| Namespace of Import list * Name list * NamespaceScope list
| Types of Import list * CSharpType list

Full name: Script.NamespaceScope

union case NamespaceScope.Namespace: Import list * Name list * NamespaceScope list -> NamespaceScope

union case NamespaceScope.Types: Import list * CSharpType list -> NamespaceScope

namespace FParsec

val maxCount : int

Full name: Script.maxCount

namespace System

type Int32 =
  struct
    member CompareTo : value:obj -> int + 1 overload
    member Equals : obj:obj -> bool + 1 overload
    member GetHashCode : unit -> int
    member GetTypeCode : unit -> TypeCode
    member ToString : unit -> string + 3 overloads
    static val MaxValue : int
    static val MinValue : int
    static member Parse : s:string -> int + 3 overloads
    static member TryParse : s:string * result:int -> bool + 1 overload
  end

Full name: System.Int32

field int.MaxValue = 2147483647

val pcomment : Parser<string,unit>

Full name: Script.pcomment

val pstring : string -> Parser<string,'u>

Full name: FParsec.CharParsers.pstring

val many1Satisfy : (char -> bool) -> Parser<string,'u>

Full name: FParsec.CharParsers.many1Satisfy

val pspaces : Parser<unit list,unit>

Full name: Script.pspaces

val spaces : Parser<unit,'u>

Full name: FParsec.CharParsers.spaces

val many : Parser<'a,'u> -> Parser<'a list,'u>

Full name: FParsec.Primitives.many

val pmlcomment : Parser<unit,unit>

Full name: Script.pmlcomment

val skipCharsTillString : string -> skipString:bool -> maxCount:int -> Parser<unit,'u>

Full name: FParsec.CharParsers.skipCharsTillString

val ws : Parser<unit,unit>

Full name: Script.ws

val ws1 : Parser<unit,'a>

Full name: Script.ws1

val spaces1 : Parser<unit,'u>

Full name: FParsec.CharParsers.spaces1

val str_ws : s:string -> Parser<string,unit>

Full name: Script.str_ws

val s : string

val str_ws1 : s:string -> Parser<string,'a>

Full name: Script.str_ws1

type Lit = NumberLiteralOptions

Full name: Script.Lit

val numberFormat : NumberLiteralOptions

Full name: Script.numberFormat

NumberLiteralOptions.AllowMinusSign: NumberLiteralOptions = 2

NumberLiteralOptions.AllowFraction: NumberLiteralOptions = 8

NumberLiteralOptions.AllowExponent: NumberLiteralOptions = 32

val pnumber : Parser<Literal,unit>

Full name: Script.pnumber

type Parser<'Result,'UserState> = CharStream<'UserState> -> Reply<'Result>

Full name: FParsec.Primitives.Parser<_,_>

type unit = Unit

Full name: Microsoft.FSharp.Core.unit

val numberLiteral : NumberLiteralOptions -> string -> Parser<NumberLiteral,'u>

Full name: FParsec.CharParsers.numberLiteral

val nl : NumberLiteral

property NumberLiteral.IsInteger: bool

Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>

property NumberLiteral.String: string

Multiple items
val float : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------
type float = System.Double

Full name: Microsoft.FSharp.Core.float

--------------------
type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>

val ptrue : Parser<Literal,unit>

Full name: Script.ptrue

val pfalse : Parser<Literal,unit>

Full name: Script.pfalse

val pbool : Parser<Literal,unit>

Full name: Script.pbool

val pstringliteral : Parser<Literal,unit>

Full name: Script.pstringliteral

val normalChar : Parser<char,unit>

val satisfy : (char -> bool) -> Parser<char,'u>

Full name: FParsec.CharParsers.satisfy

val c : char

val unescape : (char -> char)

val escapedChar : Parser<char,unit>

val anyOf : seq<char> -> Parser<char,'u>

Full name: FParsec.CharParsers.anyOf

val between : Parser<'a,'u> -> Parser<'b,'u> -> Parser<'c,'u> -> Parser<'c,'u>

Full name: FParsec.Primitives.between

val manyChars : Parser<char,'u> -> Parser<string,'u>

Full name: FParsec.CharParsers.manyChars

val pliteral : Parser<Literal,unit>

Full name: Script.pliteral

val pexpr : Parser<Expr,unit>

Full name: Script.pexpr

val pexprimpl : Parser<Expr,unit> ref

Full name: Script.pexprimpl

val createParserForwardedToRef : unit -> Parser<'a,'u> * Parser<'a,'u> ref

Full name: FParsec.Primitives.createParserForwardedToRef

val reserved : string list

Full name: Script.reserved

val pidentifierraw : Parser<string,unit>

Full name: Script.pidentifierraw

val isIdentifierFirstChar : (char -> bool)

val isLetter : char -> bool

Full name: FParsec.CharParsers.isLetter

val isIdentifierChar : (char -> bool)

val isDigit : char -> bool

Full name: FParsec.CharParsers.isDigit

val many1Satisfy2L : (char -> bool) -> (char -> bool) -> string -> Parser<string,'u>

Full name: FParsec.CharParsers.many1Satisfy2L

val pidentifier : Parser<string,unit>

Full name: Script.pidentifier

Multiple items
module List

from Microsoft.FSharp.Collections

--------------------
type List<'T> =
  | ( [] )
  | ( :: ) of Head: 'T * Tail: 'T list
  interface IEnumerable
  interface IEnumerable<'T>
  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 exists : predicate:('T -> bool) -> list:'T list -> bool

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

val fail : string -> Parser<'a,'u>

Full name: FParsec.Primitives.fail

val preturn : 'a -> Parser<'a,'u>

Full name: FParsec.Primitives.preturn

val pidentifier_ws : Parser<string,unit>

Full name: Script.pidentifier_ws

val pvar : Parser<Expr,unit>

Full name: Script.pvar

val x : string

val pargref : Parser<ArgType,unit>

Full name: Script.pargref

val pargout : Parser<ArgType,unit>

Full name: Script.pargout

val pargtype : Parser<ArgType,unit>

Full name: Script.pargtype

val opt : Parser<'a,'u> -> Parser<'a option,'u>

Full name: FParsec.Primitives.opt

union case Option.Some: Value: 'T -> Option<'T>

val x : ArgType

union case Option.None: Option<'T>

val parg : Parser<Arg,unit>

Full name: Script.parg

val by : ArgType

val e : Expr

val pinvoke : Parser<Expr,unit>

Full name: Script.pinvoke

val name : string

val args : Arg list

val pcast : Parser<Expr,unit>

Full name: Script.pcast

val ptypecast : Parser<string,unit>

val pvalue : Parser<Expr,unit>

Full name: Script.pvalue

val x : Literal

val attempt : Parser<'a,'u> -> Parser<'a,'u>

Full name: FParsec.Primitives.attempt

type Assoc = Associativity

Full name: Script.Assoc

type Associativity =
  | None = 0
  | Left = 1
  | Right = 2

Full name: FParsec.Associativity

val opp : OperatorPrecedenceParser<Expr,unit,unit>

Full name: Script.opp

Multiple items
type OperatorPrecedenceParser<'TTerm,'TAfterString,'TUserState> =
  inherit FSharpFunc<CharStream<'TUserState>, Reply<'TTerm>>
  new : unit -> OperatorPrecedenceParser<'TTerm, 'TAfterString, 'TUserState>
  member AddOperator : op:Operator<'TTerm, 'TAfterString, 'TUserState> -> unit
  member ExpressionParser : FSharpFunc<CharStream<'TUserState>, Reply<'TTerm>>
  member Invoke : stream:CharStream<'TUserState> -> Reply<'TTerm>
  member MissingTernary2ndStringErrorFormatter : FSharpFunc<Tuple<Position, Position, TernaryOperator<'TTerm, 'TAfterString, 'TUserState>, 'TAfterString>, ErrorMessageList> with get, set
  member OperatorConflictErrorFormatter : FSharpFunc<Tuple<Position, Operator<'TTerm, 'TAfterString, 'TUserState>, 'TAfterString>, FSharpFunc<Tuple<Position, Operator<'TTerm, 'TAfterString, 'TUserState>, 'TAfterString>, ErrorMessageList>> with get, set
  member Operators : IEnumerable<Operator<'TTerm, 'TAfterString, 'TUserState>>
  member RemoveInfixOperator : opString:string -> bool
  member RemoveOperator : op:Operator<'TTerm, 'TAfterString, 'TUserState> -> bool
  member RemovePostfixOperator : opString:string -> bool
  ...

Full name: FParsec.OperatorPrecedenceParser<_,_,_>

--------------------
OperatorPrecedenceParser() : unit

property OperatorPrecedenceParser.ExpressionParser: CharStream<unit> -> Reply<Expr>

val term : Parser<Expr,unit>

Full name: Script.term

property OperatorPrecedenceParser.TermParser: CharStream<unit> -> Reply<Expr>

val inops : string list

Full name: Script.inops

val op : string

OperatorPrecedenceParser.AddOperator(op: Operator<Expr,unit,unit>) : unit

Multiple items
type InfixOperator<'TTerm,'TAfterString,'TUserState> =
inherit Operator<'TTerm, 'TAfterString, 'TUserState>
new : operatorString:string * afterStringParser:FSharpFunc<CharStream<'TUserState>, Reply<'TAfterString>> * precedence:int * associativity:Associativity * mapping:FSharpFunc<'TTerm, FSharpFunc<'TTerm, 'TTerm>> -> InfixOperator<'TTerm, 'TAfterString, 'TUserState> + 1 overload

Full name: FParsec.InfixOperator<_,_,_>

--------------------
InfixOperator(operatorString: string, afterStringParser: CharStream<'TUserState> -> Reply<'TAfterString>, precedence: int, associativity: Associativity, mapping: 'TTerm -> 'TTerm -> 'TTerm) : unit
InfixOperator(operatorString: string, afterStringParser: CharStream<'TUserState> -> Reply<'TAfterString>, precedence: int, associativity: Associativity, dummy: Unit, mapping: 'TAfterString -> 'TTerm -> 'TTerm -> 'TTerm) : unit

field Associativity.Left = 1

val x : Expr

val y : Expr

val preops : string list

Full name: Script.preops

Multiple items
type PrefixOperator<'TTerm,'TAfterString,'TUserState> =
inherit Operator<'TTerm, 'TAfterString, 'TUserState>
new : operatorString:string * afterStringParser:FSharpFunc<CharStream<'TUserState>, Reply<'TAfterString>> * precedence:int * isAssociative:bool * mapping:FSharpFunc<'TTerm, 'TTerm> -> PrefixOperator<'TTerm, 'TAfterString, 'TUserState> + 1 overload

Full name: FParsec.PrefixOperator<_,_,_>

--------------------
PrefixOperator(operatorString: string, afterStringParser: CharStream<'TUserState> -> Reply<'TAfterString>, precedence: int, isAssociative: bool, mapping: 'TTerm -> 'TTerm) : unit
PrefixOperator(operatorString: string, afterStringParser: CharStream<'TUserState> -> Reply<'TAfterString>, precedence: int, isAssociative: bool, dummy: Unit, mapping: 'TAfterString -> 'TTerm -> 'TTerm) : unit

val postops : string list

Full name: Script.postops

Multiple items
type PostfixOperator<'TTerm,'TAfterString,'TUserState> =
inherit Operator<'TTerm, 'TAfterString, 'TUserState>
new : operatorString:string * afterStringParser:FSharpFunc<CharStream<'TUserState>, Reply<'TAfterString>> * precedence:int * isAssociative:bool * mapping:FSharpFunc<'TTerm, 'TTerm> -> PostfixOperator<'TTerm, 'TAfterString, 'TUserState> + 1 overload

Full name: FParsec.PostfixOperator<_,_,_>

--------------------
PostfixOperator(operatorString: string, afterStringParser: CharStream<'TUserState> -> Reply<'TAfterString>, precedence: int, isAssociative: bool, mapping: 'TTerm -> 'TTerm) : unit
PostfixOperator(operatorString: string, afterStringParser: CharStream<'TUserState> -> Reply<'TAfterString>, precedence: int, isAssociative: bool, dummy: Unit, mapping: 'TAfterString -> 'TTerm -> 'TTerm) : unit

val pexpr' : Parser<Expr,unit>

Full name: Script.pexpr'

val pstatement : Parser<Statement,unit>

Full name: Script.pstatement

val pstatementimpl : Parser<Statement,unit> ref

Full name: Script.pstatementimpl

val psinglestatement : Parser<Statement list,unit>

Full name: Script.psinglestatement

val statement : Statement

val pstatementblock : Parser<Statement list,unit>

Full name: Script.pstatementblock

val pdefine : Parser<Define,unit>

Full name: Script.pdefine

val pipe2 : Parser<'a,'u> -> Parser<'b,'u> -> ('a -> 'b -> 'c) -> Parser<'c,'u>

Full name: FParsec.Primitives.pipe2

val ty : string

val pdefinition : Parser<Statement,unit>

Full name: Script.pdefinition

val d : Define

val passign : Parser<Init,unit>

Full name: Script.passign

val pipe3 : Parser<'a,'u> -> Parser<'b,'u> -> Parser<'c,'u> -> ('a -> 'b -> 'c -> 'd) -> Parser<'d,'u>

Full name: FParsec.Primitives.pipe3

val var : string

val expr : Expr

val pconstruct : Parser<Init,unit>

Full name: Script.pconstruct

val pipe4 : Parser<'a,'u> -> Parser<'b,'u> -> Parser<'c,'u> -> Parser<'d,'u> -> ('a -> 'b -> 'c -> 'd -> 'e) -> Parser<'e,'u>

Full name: FParsec.Primitives.pipe4

val passignment : Parser<Statement,unit>

Full name: Script.passignment

val c : Init

val pif : Parser<Statement,unit>

Full name: Script.pif

val block : Statement list

val pifelse : Parser<Statement,unit>

Full name: Script.pifelse

val t : Statement list

val f : Statement list

val pcase : Parser<Literal,unit>

Full name: Script.pcase

val pcaseblock : Parser<Case,unit>

Full name: Script.pcaseblock

val case : Literal

val pdefault : Parser<string,unit>

Full name: Script.pdefault

val pdefaultblock : Parser<Case,unit>

Full name: Script.pdefaultblock

val pcases' : Parser<Case list,unit>

Full name: Script.pcases'

val cases : Case list

val d : Case option

module Option

from Microsoft.FSharp.Core

val toList : option:'T option -> 'T list

Full name: Microsoft.FSharp.Core.Option.toList

val pcases : Parser<Case list,unit>

Full name: Script.pcases

val pswitch : Parser<Statement,unit>

Full name: Script.pswitch

val pforargs : Parser<(Init list * Expr * Expr list),unit>

Full name: Script.pforargs

val pinit : Parser<Init,unit>

val sepBy : Parser<'a,'u> -> Parser<'b,'u> -> Parser<'a list,'u>

Full name: FParsec.Primitives.sepBy

val from : Init list

val until : Expr

val steps : Expr list

val pfor : Parser<Statement,unit>

Full name: Script.pfor

val inits : Init list

val iterators : Expr list

val pforeachargs : Parser<(Define * Expr),unit>

Full name: Script.pforeachargs

val define : Define

val collection : Expr

val pforeach : Parser<Statement,unit>

Full name: Script.pforeach

val pwhile : Parser<Statement,unit>

Full name: Script.pwhile

val pdowhile : Parser<Statement,unit>

Full name: Script.pdowhile

val preturn : Parser<Statement,unit>

Full name: Script.preturn

val pbreak : Parser<Statement,unit>

Full name: Script.pbreak

val pcontinue : Parser<Statement,unit>

Full name: Script.pcontinue

val pgoto : Parser<Statement,unit>

Full name: Script.pgoto

val label : string

val plabel : Parser<Statement,unit>

Full name: Script.plabel

val pthrow : Parser<Statement,unit>

Full name: Script.pthrow

val ptry : Parser<Statement,unit>

Full name: Script.ptry

val pfinally : Parser<Statement,unit>

Full name: Script.pfinally

val pexception : Parser<string,unit>

Full name: Script.pexception

val pcatch : Parser<Statement,unit>

Full name: Script.pcatch

val ex : string

val plock : Parser<Statement,unit>

Full name: Script.plock

val paction : Parser<Statement,unit>

Full name: Script.paction

val ppublic : Parser<Access,unit>

Full name: Script.ppublic

val pprivate : Parser<Access,unit>

Full name: Script.pprivate

val pprotected : Parser<Access,unit>

Full name: Script.pprotected

val pinternal : Parser<Access,unit>

Full name: Script.pinternal

Multiple items
union case Access.Internal: Access

--------------------
namespace FParsec.Internal

val paccess : Parser<Access,unit>

Full name: Script.paccess

val access : Access option

val defaultArg : arg:'T option -> defaultValue:'T -> 'T

Full name: Microsoft.FSharp.Core.Operators.defaultArg

val psealed : Parser<Modifier,unit>

Full name: Script.psealed

val pstatic : Parser<Modifier,unit>

Full name: Script.pstatic

val pmodifier : Parser<Modifier,unit>

Full name: Script.pmodifier

val pref : Parser<ParamType,unit>

Full name: Script.pref

val pout : Parser<ParamType,unit>

Full name: Script.pout

val pparams : Parser<ParamType,unit>

Full name: Script.pparams

val pby : Parser<ParamType,unit>

Full name: Script.pby

val x : ParamType

val pparam : Parser<Param,unit>

Full name: Script.pparam

val by : ParamType

val pparamlist : Parser<Param list,unit>

Full name: Script.pparamlist

val pmemberinfo : Parser<MemberInfo,unit>

Full name: Script.pmemberinfo

val access : Access

val modifier : Modifier option

val preadonly : Parser<string,unit>

Full name: Script.preadonly

val pfieldpreamble : Parser<(Access * Modifier option * bool),unit>

Full name: Script.pfieldpreamble

val ro : string option

val isSome : option:'T option -> bool

Full name: Microsoft.FSharp.Core.Option.isSome

val pfield : Parser<Member,unit>

Full name: Script.pfield

val ro : bool

val rt : string

val pget : Parser<Statement list,unit>

Full name: Script.pget

val pset : Parser<Statement list,unit>

Full name: Script.pset

val ppropertyblock : Parser<(Statement list option * Statement list option),unit>

Full name: Script.ppropertyblock

val pproperty : Parser<Member,unit>

Full name: Script.pproperty

val mi : MemberInfo

val gblock : Statement list option

val sblock : Statement list option

val pmethod : Parser<Member,unit>

Full name: Script.pmethod

val ps : Param list

val pconstructor : Parser<Member,unit>

Full name: Script.pconstructor

val pipe5 : Parser<'a,'u> -> Parser<'b,'u> -> Parser<'c,'u> -> Parser<'d,'u> -> Parser<'e,'u> -> ('a -> 'b -> 'c -> 'd -> 'e -> 'f) -> Parser<'f,'u>

Full name: FParsec.Primitives.pipe5

val pmember : Parser<Member,unit>

Full name: Script.pmember

val pmembersblock : Parser<Member list,unit>

Full name: Script.pmembersblock

val members : Member list

val penumblock : Parser<EnumValue list,unit>

Full name: Script.penumblock

val names : string list

val mapi : mapping:(int -> 'T -> 'U) -> list:'T list -> 'U list

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

val i : int

val pclasspreamble : Parser<(Access * Modifier option),unit>

Full name: Script.pclasspreamble

val pimplements : Parser<string list,unit>

Full name: Script.pimplements

val sepBy1 : Parser<'a,'u> -> Parser<'b,'u> -> Parser<'a list,'u>

Full name: FParsec.Primitives.sepBy1

val xs : string list

val pclass : Parser<CSharpType,unit>

Full name: Script.pclass

val implements : string list

val block : Member list

val pstruct : Parser<CSharpType,unit>

Full name: Script.pstruct

val pinterface : Parser<CSharpType,unit>

Full name: Script.pinterface

val penum : Parser<CSharpType,unit>

Full name: Script.penum

val block : EnumValue list

val pdelegate : Parser<CSharpType,unit>

Full name: Script.pdelegate

val ptypedeclaration : Parser<CSharpType,unit>

Full name: Script.ptypedeclaration

val pnsscope : Parser<NamespaceScope,unit>

Full name: Script.pnsscope

val pscopeimpl : Parser<NamespaceScope,unit> ref

Full name: Script.pscopeimpl

val pnsscopesblock : Parser<NamespaceScope list,unit>

Full name: Script.pnsscopesblock

val pns : Parser<string list,unit>

Full name: Script.pns

val palias : Parser<Import,unit>

Full name: Script.palias

val alias : string

val name : string list

val popen : Parser<Import,unit>

Full name: Script.popen

val pimport : Parser<Import,unit>

Full name: Script.pimport

val pnsblock : Parser<NamespaceScope,unit>

Full name: Script.pnsblock

val imports : Import list

val block : NamespaceScope list

val types : NamespaceScope

val ptypes : Parser<NamespaceScope,unit>

Full name: Script.ptypes

val many1 : Parser<'a,'u> -> Parser<'a list,'u>

Full name: FParsec.Primitives.many1

val classes : CSharpType list

val program : string

Full name: Script.program

val run : Parser<'Result,unit> -> string -> ParserResult<'Result,unit>

Full name: FParsec.CharParsers.run

Previous Version Next Version Raw view Test code New version

More information

Link:	http://fssnip.net/lf
Posted:	4 years ago
Author:	Phillip Trelford
Tags:	c# , fparsec , parsing , ast