Formula Calculator

Simple formula calculator including dynamic unit of measure support. Run as a script in Try F#, and try formula with units like 3m * 3m.

Copy Source
Copy Link
Tools:
  1: #if INTERACTIVE
  2: #else
  3: namespace global
  4: #endif
  5: 
  6: type UnitType = 
  7:     | Empty
  8:     | Unit of string * int 
  9:     | CompositeUnit of UnitType list     
 10:     static member Create(s,n) =
 11:         if n = 0 then Empty else Unit(s,n)
 12:     override this.ToString() =
 13:         let exponent = function
 14:             | Empty -> 0
 15:             | Unit(_,n) -> n
 16:             | CompositeUnit(_) -> invalidOp ""
 17:         let rec toString = function        
 18:             | Empty -> ""
 19:             | Unit(s,n) when n=0 -> ""
 20:             | Unit(s,n) when n=1 -> s
 21:             | Unit(s,n)          -> s + " ^ " + n.ToString()            
 22:             | CompositeUnit(us) ->               
 23:                 let ps, ns =
 24:                     us |> List.partition (fun u -> exponent u >= 0)
 25:                 let join xs = 
 26:                     let s = xs |> List.map toString |> List.toArray             
 27:                     System.String.Join(" ",s)
 28:                 match ps,ns with
 29:                 | ps, [] -> join ps
 30:                 | ps, ns ->
 31:                     let ns = ns |> List.map UnitType.Reciprocal
 32:                     join ps + " / " + join ns
 33:         match this with
 34:         | Unit(_,n) when n < 0 -> " / " + (this |> UnitType.Reciprocal |> toString)
 35:         | _ -> toString this    
 36:     static member ( * ) (v:ValueType,u:UnitType) = UnitValue(v,u)    
 37:     static member ( * ) (lhs:UnitType,rhs:UnitType) =       
 38:         let text = function
 39:             | Empty -> ""                 
 40:             | Unit(s,n) -> s
 41:             | CompositeUnit(us) -> us.ToString()
 42:         let normalize us u =
 43:             let t = text u
 44:             match us |> List.tryFind (fun x -> text x = t), u with
 45:             | Some(Unit(s,n) as v), Unit(_,n') ->
 46:                 us |> List.map (fun x -> if x = v then UnitType.Create(s,n+n') else x)                 
 47:             | Some(_), _ -> raise (new System.NotImplementedException())
 48:             | None, _ -> us@[u]
 49:         let normalize' us us' =
 50:             us' |> List.fold (fun (acc) x -> normalize acc x) us
 51:         match lhs,rhs with
 52:         | Unit(u1,p1), Unit(u2,p2) when u1 = u2 ->
 53:             UnitType.Create(u1,p1+p2)
 54:         | Empty, _ -> rhs
 55:         | _, Empty -> lhs 
 56:         | Unit(u1,p1), Unit(u2,p2) ->            
 57:             CompositeUnit([lhs;rhs])
 58:         | CompositeUnit(us), Unit(_,_) ->
 59:             CompositeUnit(normalize us rhs)
 60:         | Unit(_,_), CompositeUnit(us) ->
 61:             CompositeUnit(normalize' [lhs]  us)
 62:         | CompositeUnit(us), CompositeUnit(us') ->
 63:             CompositeUnit(normalize' us us')
 64:         | _,_ -> raise (new System.NotImplementedException())
 65:     static member Reciprocal x =
 66:         let rec reciprocal = function
 67:             | Empty -> Empty
 68:             | Unit(s,n) -> Unit(s,-n)
 69:             | CompositeUnit(us) -> CompositeUnit(us |> List.map reciprocal)
 70:         reciprocal x
 71:     static member ( / ) (lhs:UnitType,rhs:UnitType) =        
 72:         lhs * (UnitType.Reciprocal rhs)
 73:     static member ( + ) (lhs:UnitType,rhs:UnitType) =       
 74:         if lhs = rhs then lhs                
 75:         else invalidOp "Unit mismatch"   
 76: and ValueType = decimal
 77: and UnitValue (v:ValueType,u:UnitType) =
 78:     new(v:ValueType) = UnitValue(v,Empty)
 79:     new(v:ValueType,s:string) = UnitValue(v,Unit(s,1))
 80:     member this.Value = v
 81:     member this.Unit = u
 82:     override this.ToString() = sprintf "%O %O" v u
 83:     static member (~-) (v:UnitValue) =
 84:         UnitValue(-v.Value,v.Unit)
 85:     static member (+) (lhs:UnitValue,rhs:UnitValue) =
 86:         UnitValue(lhs.Value+rhs.Value, lhs.Unit+rhs.Unit)         
 87:     static member (-) (lhs:UnitValue,rhs:UnitValue) =
 88:         UnitValue(lhs.Value-rhs.Value, lhs.Unit+rhs.Unit) 
 89:     static member (*) (lhs:UnitValue,rhs:UnitValue) =                    
 90:         UnitValue(lhs.Value*rhs.Value,lhs.Unit*rhs.Unit)                
 91:     static member (*) (lhs:UnitValue,rhs:ValueType) =        
 92:         UnitValue(lhs.Value*rhs,lhs.Unit)      
 93:     static member (*) (v:UnitValue,u:UnitType) = 
 94:         UnitValue(v.Value,v.Unit*u)  
 95:     static member (/) (lhs:UnitValue,rhs:UnitValue) =                    
 96:         UnitValue(lhs.Value/rhs.Value,lhs.Unit/rhs.Unit)
 97:     static member (/) (lhs:UnitValue,rhs:ValueType) =
 98:         UnitValue(lhs.Value/rhs,lhs.Unit)  
 99:     static member (/) (v:UnitValue,u:UnitType) =
100:         UnitValue(v.Value,v.Unit/u)
101:     static member Pow (lhs:UnitValue,rhs:UnitValue) =
102:         let isInt x = 0.0M = x - (x |> int |> decimal)
103:         let areAllInts =
104:             List.forall (function (Unit(_,p)) -> isInt (decimal p*rhs.Value) | _ -> false)      
105:         let toInts =            
106:             List.map (function (Unit(s,p)) -> Unit(s, int (decimal p * rhs.Value)) | _ -> invalidOp "" )
107:         match lhs.Unit, rhs.Unit with
108:         | Empty, Empty -> 
109:             let x = (float lhs.Value) ** (float rhs.Value)           
110:             UnitValue(decimal x)
111:         | _, Empty when isInt rhs.Value ->
112:             pown lhs (int rhs.Value)
113:         | Unit(s,p1), Empty when isInt (decimal p1*rhs.Value) ->
114:             let x = (float lhs.Value) ** (float rhs.Value)
115:             UnitValue(x |> decimal, Unit(s,int (decimal p1*rhs.Value)))       
116:         | CompositeUnit us, Empty when areAllInts us -> 
117:             let x = (float lhs.Value) ** (float rhs.Value)
118:             UnitValue(x |> decimal, CompositeUnit(toInts us))
119:         | _ -> invalidOp "Unit mismatch"
120:     static member One = UnitValue(1.0M,Empty) 
121:     override this.Equals(that) =
122:         let that = that :?> UnitValue
123:         this.Unit = that.Unit && this.Value = that.Value
124:     override this.GetHashCode() = hash this 
125:     interface System.IComparable with
126:         member this.CompareTo(that) =
127:             let that = that :?> UnitValue
128:             if this.Unit = that.Unit then
129:                 if this.Value < that.Value then -1
130:                 elif this.Value > that.Value then 1
131:                 else 0
132:             else invalidOp "Unit mismatch"
133: 
134: [<AutoOpen>]
135: module Tokenizer =
136: 
137:     type token =
138:         | WhiteSpace
139:         | Symbol of char
140:         | OpToken of string
141:         | StrToken of string
142:         | NumToken of string
143: 
144:     let (|Match|_|) pattern input =
145:         let m = System.Text.RegularExpressions.Regex.Match(input, pattern)
146:         if m.Success then Some m.Value else None
147: 
148:     let matchToken = function
149:         | Match @"^\s+" s -> s, WhiteSpace
150:         | Match @"^\+|^\-|^\*|^\/|^\^"  s -> s, OpToken s
151:         | Match @"^=|^<>|^<=|^>=|^>|^<"  s -> s, OpToken s   
152:         | Match @"^\(|^\)|^\,|^\:" s -> s, Symbol s.[0]
153:         | Match @"^[A-Za-z]+" s -> s, StrToken s
154:         | Match @"^\d+(\.\d+)?|\.\d+" s -> s, s |> NumToken
155:         | _ -> invalidOp "Failed to match token"
156: 
157:     let tokenize s =
158:         let rec tokenize' index (s:string) =
159:             if index = s.Length then [] 
160:             else
161:                 let next = s.Substring index 
162:                 let text, token = matchToken next
163:                 token :: tokenize' (index + text.Length) s
164:         tokenize' 0 s
165:         |> List.choose (function WhiteSpace -> None | t -> Some t)
166: 
167: [<AutoOpen>]
168: module Parser =
169: 
170:     type arithmeticOp = Add | Sub | Mul | Div
171:     type formula =
172:         | Neg of formula
173:         | Exp of formula * formula
174:         | ArithmeticOp of formula * arithmeticOp * formula
175:         | Num of UnitValue
176: 
177:     let rec (|Term|_|) = function
178:         | Exponent(f1, t) ->      
179:             let rec aux f1 = function        
180:                 | SumOp op::Exponent(f2, t) -> aux (ArithmeticOp(f1,op,f2)) t               
181:                 | t -> Some(f1, t)      
182:             aux f1 t  
183:         | _ -> None
184:     and (|SumOp|_|) = function 
185:         | OpToken "+" -> Some Add | OpToken "-" -> Some Sub 
186:         | _ -> None
187:     and (|Exponent|_|) = function
188:         | Factor(b, OpToken "^"::Exponent(e,t)) -> Some(Exp(b,e),t)
189:         | Factor(f,t) -> Some (f,t)
190:         | _ -> None
191:     and (|Factor|_|) = function  
192:         | OpToken "-"::Factor(f, t) -> Some(Neg f, t)
193:         | Atom(f1, ProductOp op::Factor(f2, t)) ->
194:             Some(ArithmeticOp(f1,op,f2), t)       
195:         | Atom(f, t) -> Some(f, t)  
196:         | _ -> None    
197:     and (|ProductOp|_|) = function
198:         | OpToken "*" -> Some Mul | OpToken "/" -> Some Div
199:         | _ -> None
200:     and (|Atom|_|) = function    
201:         | Symbol '('::Term(f, Symbol ')'::t) -> Some(f, t)
202:         | Number(n,t) -> Some(n,t)
203:         | Units(u,t) -> Some(Num u,t)  
204:         | _ -> None
205:     and (|Number|_|) = function
206:         | NumToken n::Units(u,t) -> Some(Num(u * decimal n),t)
207:         | NumToken n::t -> Some(Num(UnitValue(decimal n)), t)      
208:         | _ -> None
209:     and (|Units|_|) = function
210:         | Unit'(u,t) ->
211:             let rec aux u1 =  function
212:                 | OpToken "/"::Unit'(u2,t) -> aux (u1 / u2) t
213:                 | Unit'(u2,t) -> aux (u1 * u2) t
214:                 | t -> Some(u1,t)
215:             aux u t
216:         | _ -> None
217:     and (|Int|_|) s = 
218:         match System.Int32.TryParse(s) with
219:         | true, n -> Some n
220:         | false,_ -> None
221:     and (|Unit'|_|) = function  
222:         | StrToken u::OpToken "^"::OpToken "-"::NumToken(Int p)::t -> 
223:             Some(UnitValue(1.0M,UnitType.Create(u,-p)),t)  
224:         | StrToken u::OpToken "^"::NumToken(Int p)::t -> 
225:             Some(UnitValue(1.0M,UnitType.Create(u,p)),t)
226:         | StrToken u::t ->
227:             Some(UnitValue(1.0M,u), t)
228:         | _ -> None
229: 
230:     let parse s = 
231:         match tokenize s with
232:         | Term(f,[]) -> f 
233:         | _ -> failwith "Failed to parse formula"
234: 
235:     let evaluate formula =
236:         let rec eval = function
237:             | Neg f -> - (eval f)
238:             | Exp(b,e) -> (eval b) ** (eval e)
239:             | ArithmeticOp(f1,op,f2) -> arithmetic op (eval f1) (eval f2)        
240:             | Num d -> d
241:         and arithmetic = function
242:             | Add -> (+) | Sub -> (-) | Mul -> (*) | Div -> (/)      
243:         eval formula
244: 
245: open System.Windows
246: open System.Windows.Controls
247: open System.Windows.Input
248: open System.Windows.Media
249: 
250: [<AutoOpen>]
251: module Collection =
252:     let toDoubleCollection xs =
253:         let collection = DoubleCollection()
254:         xs |> Seq.iter collection.Add
255:         collection
256: 
257: [<AutoOpen>]
258: module Resources =
259:     open System.Windows.Shapes
260: 
261:     let createBorder color =
262:         Rectangle(
263:             Stretch=Stretch.Fill,
264:             RadiusX=6.0,
265:             RadiusY=6.0,
266:             Stroke=SolidColorBrush(color),
267:             StrokeThickness=6.0,
268:             StrokeLineJoin=PenLineJoin.Round
269:         )
270: 
271:     let createDashedBorder color =
272:         let border = createBorder color
273:         border.StrokeDashCap <- PenLineCap.Round
274:         border.StrokeDashArray <- [4.0;3.0] |> toDoubleCollection
275:         border        
276: 
277: type Calculator () as this =
278:     inherit UserControl ()
279:     
280:     let label = 
281:         TextBlock(
282:             Text="Formula Calculator",
283:             Foreground=SolidColorBrush(Colors.Purple),
284:             FontWeight=FontWeights.Bold,
285:             FontSize=18.0,
286:             Margin=Thickness(8.0,8.0,8.0,0.0),
287:             HorizontalAlignment=HorizontalAlignment.Center
288:         )
289:     
290:     let formulaText = 
291:         TextBox(Text="Enter Formula Here",
292:                 BorderThickness=Thickness(0.0),
293:                 Margin=Thickness(8.0),                               
294:                 SelectionBackground=SolidColorBrush(Colors.Gray),
295:                 SelectionForeground=SolidColorBrush(Colors.White)
296:         )
297: 
298:     let makeBorder parent child =
299:         let border = Grid()
300:         do  border.Children.Add parent
301:         do  border.Children.Add child
302:         border
303: 
304:     let (+.) (panel:#Panel) (item) =
305:         panel.Children.Add item |> ignore; panel
306: 
307:     let (+@) (grid:Grid) (item,col,row) =
308:         grid.Children.Add item
309:         Grid.SetColumn(item,col)
310:         Grid.SetRow(item,row)
311:         grid
312: 
313:     let computeButton = 
314:         Button(Content=" = ",
315:                Margin=Thickness(8.0),
316:                HorizontalAlignment=HorizontalAlignment.Right
317:         )
318: 
319:     let formulaPanel =        
320:         Grid()
321:             +@ (formulaText,0,0)
322:             +@ (computeButton,1,0)    
323:     do  [GridLength(); GridLength(1.0,GridUnitType.Star)]
324:         |> List.iter (fun x -> 
325:             ColumnDefinition(Width=x) 
326:             |> formulaPanel.ColumnDefinitions.Add
327:         )
328: 
329:     let dashedBorder = createDashedBorder Colors.Red
330:     let formulaPanel = makeBorder dashedBorder formulaPanel
331:     do  formulaPanel.Margin <- Thickness(8.0)
332: 
333:     let resultBlock = 
334:         TextBlock(Text="Result",Margin=Thickness(12.0))
335:     let resultPanel =
336:         resultBlock |> makeBorder (createBorder Colors.Blue)
337:     do  resultPanel.Margin <- Thickness(8.0)
338: 
339:     let solidBorder = createBorder Colors.Magenta
340:     let layout =
341:         StackPanel() 
342:             +. label 
343:             +. formulaPanel
344:             +. resultPanel
345:         |> makeBorder solidBorder
346:     
347:     let compute _ =
348:         try
349:         parse formulaText.Text
350:         |> evaluate
351:         |> sprintf "%O"
352:         with e -> e.Message
353:         |> (fun s -> resultBlock.Text <- s)
354: 
355:     do  formulaText.KeyDown.Add (fun e ->
356:             if e.Key = Key.Enter
357:             then compute ()
358:         )
359:     do  computeButton.Click.Add compute
360:     do  this.Content <- layout
361: 
362: #if INTERACTIVE
363: open Microsoft.TryFSharp
364: App.Dispatch (fun() -> 
365:     App.Console.ClearCanvas()
366:     Calculator() |> App.Console.Canvas.Children.Add
367:     App.Console.CanvasPosition <- CanvasPosition.Right
368: )
369: #endif
union case UnitType.Empty: UnitType
union case UnitType.Unit: string * int -> UnitType
Multiple items
val string : 'T -> string

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

--------------------

type string = System.String

Full name: Microsoft.FSharp.Core.string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
Multiple items
val int : 'T -> int (requires member op_Explicit)

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

--------------------

type int<'Measure> = int

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

  type: int<'Measure>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<int<'Measure>>
  implements: System.IEquatable<int<'Measure>>
  inherits: System.ValueType


--------------------

type int = int32

Full name: Microsoft.FSharp.Core.int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
union case UnitType.CompositeUnit: UnitType list -> UnitType
type UnitType =
  | Empty
  | Unit of string * int
  | CompositeUnit of UnitType list
  with
    override ToString : unit -> string
    static member Create : s:string * n:int -> UnitType
    static member Reciprocal : x:UnitType -> UnitType
    static member ( + ) : lhs:UnitType * rhs:UnitType -> UnitType
    static member ( / ) : lhs:UnitType * rhs:UnitType -> UnitType
    static member ( * ) : v:ValueType * u:UnitType -> UnitValue
    static member ( * ) : lhs:UnitType * rhs:UnitType -> UnitType
  end

Full name: Snippet.UnitType

  type: UnitType
  implements: System.IEquatable<UnitType>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<UnitType>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
type 'T list = List<'T>

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

  type: 'T list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<'T>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<'T>
  implements: System.Collections.IEnumerable
static member UnitType.Create : s:string * n:int -> UnitType

Full name: Snippet.UnitType.Create
val s : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
val n : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val this : UnitType

  type: UnitType
  implements: System.IEquatable<UnitType>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<UnitType>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
override UnitType.ToString : unit -> string

Full name: Snippet.UnitType.ToString
val exponent : (UnitType -> int)
val invalidOp : string -> 'T

Full name: Microsoft.FSharp.Core.Operators.invalidOp
val toString : (UnitType -> string)
Multiple overloads
System.Object.ToString() : string
System.Int32.ToString(provider: System.IFormatProvider) : string
System.Int32.ToString(format: string) : string
System.Int32.ToString(format: string, provider: System.IFormatProvider) : string
val us : UnitType list

  type: UnitType list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<UnitType>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<UnitType>
  implements: System.Collections.IEnumerable
val ps : UnitType list

  type: UnitType list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<UnitType>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<UnitType>
  implements: System.Collections.IEnumerable
val ns : UnitType list

  type: UnitType list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<UnitType>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<UnitType>
  implements: System.Collections.IEnumerable
Multiple items
module List

from Microsoft.FSharp.Collections

--------------------

type List<'T> =
  | ( [] )
  | ( :: ) of 'T * 'T list
  with
    interface System.Collections.IEnumerable
    interface System.Collections.Generic.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
  end

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

  type: List<'T>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<'T>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<'T>
  implements: System.Collections.IEnumerable
val partition : ('T -> bool) -> 'T list -> 'T list * 'T list

Full name: Microsoft.FSharp.Collections.List.partition
val u : UnitType

  type: UnitType
  implements: System.IEquatable<UnitType>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<UnitType>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val join : (UnitType list -> string)
val xs : UnitType list

  type: UnitType list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<UnitType>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<UnitType>
  implements: System.Collections.IEnumerable
val s : string []

  type: string []
  implements: System.ICloneable
  implements: System.Collections.IList
  implements: System.Collections.ICollection
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.IStructuralEquatable
  implements: System.Collections.Generic.IList<string>
  implements: System.Collections.Generic.ICollection<string>
  implements: seq<string>
  implements: System.Collections.IEnumerable
  inherits: System.Array
val map : ('T -> 'U) -> 'T list -> 'U list

Full name: Microsoft.FSharp.Collections.List.map
val toArray : 'T list -> 'T []

Full name: Microsoft.FSharp.Collections.List.toArray
namespace System
type String =
  class
    new : char -> string
    new : char * int * int -> string
    new : System.SByte -> string
    new : System.SByte * int * int -> string
    new : System.SByte * int * int * System.Text.Encoding -> string
    new : char [] * int * int -> string
    new : char [] -> string
    new : char * int -> string
    member Chars : int -> char
    member Clone : unit -> obj
    member CompareTo : obj -> int
    member CompareTo : string -> int
    member Contains : string -> bool
    member CopyTo : int * char [] * int * int -> unit
    member EndsWith : string -> bool
    member EndsWith : string * System.StringComparison -> bool
    member EndsWith : string * bool * System.Globalization.CultureInfo -> bool
    member Equals : obj -> bool
    member Equals : string -> bool
    member Equals : string * System.StringComparison -> bool
    member GetEnumerator : unit -> System.CharEnumerator
    member GetHashCode : unit -> int
    member GetTypeCode : unit -> System.TypeCode
    member IndexOf : char -> int
    member IndexOf : string -> int
    member IndexOf : char * int -> int
    member IndexOf : string * int -> int
    member IndexOf : string * System.StringComparison -> int
    member IndexOf : char * int * int -> int
    member IndexOf : string * int * int -> int
    member IndexOf : string * int * System.StringComparison -> int
    member IndexOf : string * int * int * System.StringComparison -> int
    member IndexOfAny : char [] -> int
    member IndexOfAny : char [] * int -> int
    member IndexOfAny : char [] * int * int -> int
    member Insert : int * string -> string
    member IsNormalized : unit -> bool
    member IsNormalized : System.Text.NormalizationForm -> bool
    member LastIndexOf : char -> int
    member LastIndexOf : string -> int
    member LastIndexOf : char * int -> int
    member LastIndexOf : string * int -> int
    member LastIndexOf : string * System.StringComparison -> int
    member LastIndexOf : char * int * int -> int
    member LastIndexOf : string * int * int -> int
    member LastIndexOf : string * int * System.StringComparison -> int
    member LastIndexOf : string * int * int * System.StringComparison -> int
    member LastIndexOfAny : char [] -> int
    member LastIndexOfAny : char [] * int -> int
    member LastIndexOfAny : char [] * int * int -> int
    member Length : int
    member Normalize : unit -> string
    member Normalize : System.Text.NormalizationForm -> string
    member PadLeft : int -> string
    member PadLeft : int * char -> string
    member PadRight : int -> string
    member PadRight : int * char -> string
    member Remove : int -> string
    member Remove : int * int -> string
    member Replace : char * char -> string
    member Replace : string * string -> string
    member Split : char [] -> string []
    member Split : char [] * int -> string []
    member Split : char [] * System.StringSplitOptions -> string []
    member Split : string [] * System.StringSplitOptions -> string []
    member Split : char [] * int * System.StringSplitOptions -> string []
    member Split : string [] * int * System.StringSplitOptions -> string []
    member StartsWith : string -> bool
    member StartsWith : string * System.StringComparison -> bool
    member StartsWith : string * bool * System.Globalization.CultureInfo -> bool
    member Substring : int -> string
    member Substring : int * int -> string
    member ToCharArray : unit -> char []
    member ToCharArray : int * int -> char []
    member ToLower : unit -> string
    member ToLower : System.Globalization.CultureInfo -> string
    member ToLowerInvariant : unit -> string
    member ToString : unit -> string
    member ToString : System.IFormatProvider -> string
    member ToUpper : unit -> string
    member ToUpper : System.Globalization.CultureInfo -> string
    member ToUpperInvariant : unit -> string
    member Trim : unit -> string
    member Trim : char [] -> string
    member TrimEnd : char [] -> string
    member TrimStart : char [] -> string
    static val Empty : string
    static member Compare : string * string -> int
    static member Compare : string * string * bool -> int
    static member Compare : string * string * System.StringComparison -> int
    static member Compare : string * string * System.Globalization.CultureInfo * System.Globalization.CompareOptions -> int
    static member Compare : string * string * bool * System.Globalization.CultureInfo -> int
    static member Compare : string * int * string * int * int -> int
    static member Compare : string * int * string * int * int * bool -> int
    static member Compare : string * int * string * int * int * System.StringComparison -> int
    static member Compare : string * int * string * int * int * bool * System.Globalization.CultureInfo -> int
    static member Compare : string * int * string * int * int * System.Globalization.CultureInfo * System.Globalization.CompareOptions -> int
    static member CompareOrdinal : string * string -> int
    static member CompareOrdinal : string * int * string * int * int -> int
    static member Concat : obj -> string
    static member Concat : obj [] -> string
    static member Concat<'T> : System.Collections.Generic.IEnumerable<'T> -> string
    static member Concat : System.Collections.Generic.IEnumerable<string> -> string
    static member Concat : string [] -> string
    static member Concat : obj * obj -> string
    static member Concat : string * string -> string
    static member Concat : obj * obj * obj -> string
    static member Concat : string * string * string -> string
    static member Concat : obj * obj * obj * obj -> string
    static member Concat : string * string * string * string -> string
    static member Copy : string -> string
    static member Equals : string * string -> bool
    static member Equals : string * string * System.StringComparison -> bool
    static member Format : string * obj -> string
    static member Format : string * obj [] -> string
    static member Format : string * obj * obj -> string
    static member Format : System.IFormatProvider * string * obj [] -> string
    static member Format : string * obj * obj * obj -> string
    static member Intern : string -> string
    static member IsInterned : string -> string
    static member IsNullOrEmpty : string -> bool
    static member IsNullOrWhiteSpace : string -> bool
    static member Join : string * string [] -> string
    static member Join : string * obj [] -> string
    static member Join<'T> : string * System.Collections.Generic.IEnumerable<'T> -> string
    static member Join : string * System.Collections.Generic.IEnumerable<string> -> string
    static member Join : string * string [] * int * int -> string
  end

Full name: System.String

  type: System.String
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
Multiple overloads
System.String.Join(separator: string, values: seq<string>) : string
System.String.Join<'T>(separator: string, values: seq<'T>) : string
System.String.Join(separator: string, values: obj []) : string
System.String.Join(separator: string, value: string []) : string
System.String.Join(separator: string, value: string [], startIndex: int, count: int) : string
static member UnitType.Reciprocal : x:UnitType -> UnitType
val v : ValueType

  type: ValueType
  implements: System.IFormattable
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.IDeserializationCallback
  implements: System.IComparable<decimal>
  implements: System.IEquatable<decimal>
  inherits: System.ValueType
type ValueType = decimal

Full name: Snippet.ValueType

  type: ValueType
  implements: System.IFormattable
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.IDeserializationCallback
  implements: System.IComparable<decimal>
  implements: System.IEquatable<decimal>
  inherits: System.ValueType
type UnitValue =
  class
    interface System.IComparable
    new : v:ValueType -> UnitValue
    new : v:ValueType * u:UnitType -> UnitValue
    new : v:ValueType * s:string -> UnitValue
    override Equals : that:obj -> bool
    override GetHashCode : unit -> int
    override ToString : unit -> string
    member Unit : UnitType
    member Value : ValueType
    static member Pow : lhs:UnitValue * rhs:UnitValue -> UnitValue
    static member One : UnitValue
    static member ( + ) : lhs:UnitValue * rhs:UnitValue -> UnitValue
    static member ( / ) : lhs:UnitValue * rhs:UnitValue -> UnitValue
    static member ( / ) : lhs:UnitValue * rhs:ValueType -> UnitValue
    static member ( / ) : v:UnitValue * u:UnitType -> UnitValue
    static member ( * ) : lhs:UnitValue * rhs:UnitValue -> UnitValue
    static member ( * ) : lhs:UnitValue * rhs:ValueType -> UnitValue
    static member ( * ) : v:UnitValue * u:UnitType -> UnitValue
    static member ( - ) : lhs:UnitValue * rhs:UnitValue -> UnitValue
    static member ( ~- ) : v:UnitValue -> UnitValue
  end

Full name: Snippet.UnitValue

  type: UnitValue
  implements: System.IComparable
val lhs : UnitType

  type: UnitType
  implements: System.IEquatable<UnitType>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<UnitType>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val rhs : UnitType

  type: UnitType
  implements: System.IEquatable<UnitType>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<UnitType>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val text : (UnitType -> string)
System.Object.ToString() : string
val normalize : (UnitType list -> UnitType -> UnitType list)
val t : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
val tryFind : ('T -> bool) -> 'T list -> 'T option

Full name: Microsoft.FSharp.Collections.List.tryFind
val x : UnitType

  type: UnitType
  implements: System.IEquatable<UnitType>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<UnitType>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
union case Option.Some: 'T -> Option<'T>
val v : UnitType

  type: UnitType
  implements: System.IEquatable<UnitType>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<UnitType>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val n' : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
static member UnitType.Create : s:string * n:int -> UnitType
val raise : System.Exception -> 'T

Full name: Microsoft.FSharp.Core.Operators.raise
type NotImplementedException =
  class
    inherit System.SystemException
    new : unit -> System.NotImplementedException
    new : string -> System.NotImplementedException
    new : string * System.Exception -> System.NotImplementedException
  end

Full name: System.NotImplementedException

  type: System.NotImplementedException
  implements: System.Runtime.Serialization.ISerializable
  implements: System.Runtime.InteropServices._Exception
  inherits: System.SystemException
  inherits: exn
union case Option.None: Option<'T>
val normalize' : (UnitType list -> UnitType list -> UnitType list)
val us' : UnitType list

  type: UnitType list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<UnitType>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<UnitType>
  implements: System.Collections.IEnumerable
val fold : ('State -> 'T -> 'State) -> 'State -> 'T list -> 'State

Full name: Microsoft.FSharp.Collections.List.fold
val acc : UnitType list

  type: UnitType list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<UnitType>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<UnitType>
  implements: System.Collections.IEnumerable
val u1 : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
val p1 : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val u2 : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
val p2 : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
static member UnitType.Reciprocal : x:UnitType -> UnitType

Full name: Snippet.UnitType.Reciprocal
val reciprocal : (UnitType -> UnitType)
Multiple items
val decimal : 'T -> decimal (requires member op_Explicit)

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

--------------------

type decimal<'Measure> = decimal

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

  type: decimal<'Measure>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<decimal<'Measure>>
  implements: System.IEquatable<decimal<'Measure>>
  inherits: System.ValueType


--------------------

type decimal = System.Decimal

Full name: Microsoft.FSharp.Core.decimal

  type: decimal
  implements: System.IFormattable
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.IDeserializationCallback
  implements: System.IComparable<decimal>
  implements: System.IEquatable<decimal>
  inherits: System.ValueType
val this : UnitValue

  type: UnitValue
  implements: System.IComparable
member UnitValue.Value : ValueType

Full name: Snippet.UnitValue.Value
member UnitValue.Unit : UnitType

Full name: Snippet.UnitValue.Unit
override UnitValue.ToString : unit -> string

Full name: Snippet.UnitValue.ToString
val sprintf : Printf.StringFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.sprintf
val v : UnitValue

  type: UnitValue
  implements: System.IComparable
property UnitValue.Value: ValueType
property UnitValue.Unit: UnitType
val lhs : UnitValue

  type: UnitValue
  implements: System.IComparable
val rhs : UnitValue

  type: UnitValue
  implements: System.IComparable
val rhs : ValueType

  type: ValueType
  implements: System.IFormattable
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.IDeserializationCallback
  implements: System.IComparable<decimal>
  implements: System.IEquatable<decimal>
  inherits: System.ValueType
static member UnitValue.Pow : lhs:UnitValue * rhs:UnitValue -> UnitValue

Full name: Snippet.UnitValue.Pow
val isInt : (decimal -> bool)
val x : decimal

  type: decimal
  implements: System.IFormattable
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.Runtime.Serialization.IDeserializationCallback
  implements: System.IComparable<decimal>
  implements: System.IEquatable<decimal>
  inherits: System.ValueType
val areAllInts : (UnitType list -> bool)
val forall : ('T -> bool) -> 'T list -> bool

Full name: Microsoft.FSharp.Collections.List.forall
val p : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val toInts : (UnitType list -> UnitType list)
val x : float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
Multiple items
val float : 'T -> float (requires member op_Explicit)

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

--------------------

type float<'Measure> = float

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

  type: float<'Measure>
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IFormattable
  implements: System.IComparable<float<'Measure>>
  implements: System.IEquatable<float<'Measure>>
  inherits: System.ValueType


--------------------

type float = System.Double

Full name: Microsoft.FSharp.Core.float

  type: float
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<float>
  implements: System.IEquatable<float>
  inherits: System.ValueType
val pown : 'T -> int -> 'T (requires member get_One and member ( * ) and member ( / ))

Full name: Microsoft.FSharp.Core.Operators.pown
static member UnitValue.One : UnitValue

Full name: Snippet.UnitValue.One
override UnitValue.Equals : that:obj -> bool

Full name: Snippet.UnitValue.Equals
val that : obj
val that : UnitValue

  type: UnitValue
  implements: System.IComparable
override UnitValue.GetHashCode : unit -> int

Full name: Snippet.UnitValue.GetHashCode
val hash : 'T -> int (requires equality)

Full name: Microsoft.FSharp.Core.Operators.hash
Multiple items
type IComparable<'T> =
  interface
    member CompareTo : 'T -> int
  end

Full name: System.IComparable<_>

--------------------

type IComparable =
  interface
    member CompareTo : obj -> int
  end

Full name: System.IComparable

--------------------

System.IComparable

--------------------

System.IComparable
override UnitValue.CompareTo : that:obj -> int

Full name: Snippet.UnitValue.CompareTo
type AutoOpenAttribute =
  class
    inherit System.Attribute
    new : unit -> AutoOpenAttribute
    new : path:string -> AutoOpenAttribute
    member Path : string
  end

Full name: Microsoft.FSharp.Core.AutoOpenAttribute

  type: AutoOpenAttribute
  implements: System.Runtime.InteropServices._Attribute
  inherits: System.Attribute
type token =
  | WhiteSpace
  | Symbol of char
  | OpToken of string
  | StrToken of string
  | NumToken of string

Full name: Snippet.Tokenizer.token

  type: token
  implements: System.IEquatable<token>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<token>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
union case token.WhiteSpace: token
union case token.Symbol: char -> token
Multiple items
val char : 'T -> char (requires member op_Explicit)

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

--------------------

type char = System.Char

Full name: Microsoft.FSharp.Core.char

  type: char
  implements: System.IComparable
  implements: System.IConvertible
  implements: System.IComparable<char>
  implements: System.IEquatable<char>
  inherits: System.ValueType
union case token.OpToken: string -> token
union case token.StrToken: string -> token
union case token.NumToken: string -> token
val pattern : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
val input : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
val m : System.Text.RegularExpressions.Match

  type: System.Text.RegularExpressions.Match
  inherits: System.Text.RegularExpressions.Group
  inherits: System.Text.RegularExpressions.Capture
namespace System.Text
namespace System.Text.RegularExpressions
type Regex =
  class
    new : string -> System.Text.RegularExpressions.Regex
    new : string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Regex
    member GetGroupNames : unit -> string []
    member GetGroupNumbers : unit -> int []
    member GroupNameFromNumber : int -> string
    member GroupNumberFromName : string -> int
    member IsMatch : string -> bool
    member IsMatch : string * int -> bool
    member Match : string -> System.Text.RegularExpressions.Match
    member Match : string * int -> System.Text.RegularExpressions.Match
    member Match : string * int * int -> System.Text.RegularExpressions.Match
    member Matches : string -> System.Text.RegularExpressions.MatchCollection
    member Matches : string * int -> System.Text.RegularExpressions.MatchCollection
    member Options : System.Text.RegularExpressions.RegexOptions
    member Replace : string * string -> string
    member Replace : string * System.Text.RegularExpressions.MatchEvaluator -> string
    member Replace : string * string * int -> string
    member Replace : string * System.Text.RegularExpressions.MatchEvaluator * int -> string
    member Replace : string * string * int * int -> string
    member Replace : string * System.Text.RegularExpressions.MatchEvaluator * int * int -> string
    member RightToLeft : bool
    member Split : string -> string []
    member Split : string * int -> string []
    member Split : string * int * int -> string []
    member ToString : unit -> string
    static member CacheSize : int with get, set
    static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo [] * System.Reflection.AssemblyName -> unit
    static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo [] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder [] -> unit
    static member CompileToAssembly : System.Text.RegularExpressions.RegexCompilationInfo [] * System.Reflection.AssemblyName * System.Reflection.Emit.CustomAttributeBuilder [] * string -> unit
    static member Escape : string -> string
    static member IsMatch : string * string -> bool
    static member IsMatch : string * string * System.Text.RegularExpressions.RegexOptions -> bool
    static member Match : string * string -> System.Text.RegularExpressions.Match
    static member Match : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.Match
    static member Matches : string * string -> System.Text.RegularExpressions.MatchCollection
    static member Matches : string * string * System.Text.RegularExpressions.RegexOptions -> System.Text.RegularExpressions.MatchCollection
    static member Replace : string * string * string -> string
    static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator -> string
    static member Replace : string * string * string * System.Text.RegularExpressions.RegexOptions -> string
    static member Replace : string * string * System.Text.RegularExpressions.MatchEvaluator * System.Text.RegularExpressions.RegexOptions -> string
    static member Split : string * string -> string []
    static member Split : string * string * System.Text.RegularExpressions.RegexOptions -> string []
    static member Unescape : string -> string
  end

Full name: System.Text.RegularExpressions.Regex

  type: System.Text.RegularExpressions.Regex
  implements: System.Runtime.Serialization.ISerializable
Multiple overloads
System.Text.RegularExpressions.Regex.Match(input: string, pattern: string) : System.Text.RegularExpressions.Match
System.Text.RegularExpressions.Regex.Match(input: string, pattern: string, options: System.Text.RegularExpressions.RegexOptions) : System.Text.RegularExpressions.Match
property System.Text.RegularExpressions.Group.Success: bool
property System.Text.RegularExpressions.Capture.Value: string
val matchToken : string -> string * token

Full name: Snippet.Tokenizer.matchToken
active recognizer Match: string -> string -> string option

Full name: Snippet.Tokenizer.( |Match|_| )
val tokenize : string -> token list

Full name: Snippet.Tokenizer.tokenize
val tokenize' : (int -> string -> token list)
val index : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
property System.String.Length: int
val next : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
Multiple overloads
System.String.Substring(startIndex: int) : string
System.String.Substring(startIndex: int, length: int) : string
val text : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
Multiple items
val token : token

  type: token
  implements: System.IEquatable<token>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<token>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable


--------------------

type token =
  | WhiteSpace
  | Symbol of char
  | OpToken of string
  | StrToken of string
  | NumToken of string

Full name: Snippet.Tokenizer.token

  type: token
  implements: System.IEquatable<token>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<token>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val choose : ('T -> 'U option) -> 'T list -> 'U list

Full name: Microsoft.FSharp.Collections.List.choose
val t : token

  type: token
  implements: System.IEquatable<token>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<token>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
type arithmeticOp =
  | Add
  | Sub
  | Mul
  | Div

Full name: Snippet.Parser.arithmeticOp

  type: arithmeticOp
  implements: System.IEquatable<arithmeticOp>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<arithmeticOp>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
union case arithmeticOp.Add: arithmeticOp
union case arithmeticOp.Sub: arithmeticOp
union case arithmeticOp.Mul: arithmeticOp
union case arithmeticOp.Div: arithmeticOp
type formula =
  | Neg of formula
  | Exp of formula * formula
  | ArithmeticOp of formula * arithmeticOp * formula
  | Num of UnitValue

Full name: Snippet.Parser.formula

  type: formula
  implements: System.IEquatable<formula>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<formula>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
union case formula.Neg: formula -> formula
union case formula.Exp: formula * formula -> formula
union case formula.ArithmeticOp: formula * arithmeticOp * formula -> formula
union case formula.Num: UnitValue -> formula
active recognizer Exponent: token list -> (formula * token list) option

Full name: Snippet.Parser.( |Exponent|_| )
val f1 : formula

  type: formula
  implements: System.IEquatable<formula>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<formula>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val t : token list

  type: token list
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<List<token>>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
  implements: System.Collections.Generic.IEnumerable<token>
  implements: System.Collections.IEnumerable
val aux : (formula -> token list -> (formula * token list) option)
active recognizer SumOp: token -> arithmeticOp option

Full name: Snippet.Parser.( |SumOp|_| )
val op : arithmeticOp

  type: arithmeticOp
  implements: System.IEquatable<arithmeticOp>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<arithmeticOp>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val f2 : formula

  type: formula
  implements: System.IEquatable<formula>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<formula>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
active recognizer Factor: token list -> (formula * token list) option

Full name: Snippet.Parser.( |Factor|_| )
val b : formula

  type: formula
  implements: System.IEquatable<formula>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<formula>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val e : formula

  type: formula
  implements: System.IEquatable<formula>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<formula>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val f : formula

  type: formula
  implements: System.IEquatable<formula>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<formula>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
active recognizer Atom: token list -> (formula * token list) option

Full name: Snippet.Parser.( |Atom|_| )
active recognizer ProductOp: token -> arithmeticOp option

Full name: Snippet.Parser.( |ProductOp|_| )
active recognizer Term: token list -> (formula * token list) option

Full name: Snippet.Parser.( |Term|_| )
active recognizer Number: token list -> (formula * token list) option

Full name: Snippet.Parser.( |Number|_| )
val n : formula

  type: formula
  implements: System.IEquatable<formula>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<formula>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
active recognizer Units: token list -> (UnitValue * token list) option

Full name: Snippet.Parser.( |Units|_| )
val u : UnitValue

  type: UnitValue
  implements: System.IComparable
val n : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
active recognizer Unit': token list -> (UnitValue * token list) option

Full name: Snippet.Parser.( |Unit'|_| )
val aux : (UnitValue -> token list -> (UnitValue * token list) option)
val u1 : UnitValue

  type: UnitValue
  implements: System.IComparable
val u2 : UnitValue

  type: UnitValue
  implements: System.IComparable
type Int32 =
  struct
    member CompareTo : obj -> int
    member CompareTo : int -> int
    member Equals : obj -> bool
    member Equals : int -> bool
    member GetHashCode : unit -> int
    member GetTypeCode : unit -> System.TypeCode
    member ToString : unit -> string
    member ToString : string -> string
    member ToString : System.IFormatProvider -> string
    member ToString : string * System.IFormatProvider -> string
    static val MaxValue : int
    static val MinValue : int
    static member Parse : string -> int
    static member Parse : string * System.Globalization.NumberStyles -> int
    static member Parse : string * System.IFormatProvider -> int
    static member Parse : string * System.Globalization.NumberStyles * System.IFormatProvider -> int
    static member TryParse : string * int -> bool
    static member TryParse : string * System.Globalization.NumberStyles * System.IFormatProvider * int -> bool
  end

Full name: System.Int32

  type: System.Int32
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
Multiple overloads
System.Int32.TryParse(s: string, result: byref<int>) : bool
System.Int32.TryParse(s: string, style: System.Globalization.NumberStyles, provider: System.IFormatProvider, result: byref<int>) : bool
val u : string

  type: string
  implements: System.IComparable
  implements: System.ICloneable
  implements: System.IConvertible
  implements: System.IComparable<string>
  implements: seq<char>
  implements: System.Collections.IEnumerable
  implements: System.IEquatable<string>
active recognizer Int: string -> int option

Full name: Snippet.Parser.( |Int|_| )
val parse : string -> formula

Full name: Snippet.Parser.parse
val failwith : string -> 'T

Full name: Microsoft.FSharp.Core.Operators.failwith
val evaluate : formula -> UnitValue

Full name: Snippet.Parser.evaluate
Multiple items
val formula : formula

  type: formula
  implements: System.IEquatable<formula>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<formula>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable


--------------------

type formula =
  | Neg of formula
  | Exp of formula * formula
  | ArithmeticOp of formula * arithmeticOp * formula
  | Num of UnitValue

Full name: Snippet.Parser.formula

  type: formula
  implements: System.IEquatable<formula>
  implements: System.Collections.IStructuralEquatable
  implements: System.IComparable<formula>
  implements: System.IComparable
  implements: System.Collections.IStructuralComparable
val eval : (formula -> UnitValue)
val arithmetic : (arithmeticOp -> UnitValue -> UnitValue -> UnitValue)
val d : UnitValue

  type: UnitValue
  implements: System.IComparable
namespace System.Windows
namespace System.Windows.Controls
namespace System.Windows.Input
namespace System.Windows.Media
val toDoubleCollection : seq<float> -> DoubleCollection

Full name: Snippet.Collection.toDoubleCollection
val xs : seq<float>

  type: seq<float>
  inherits: System.Collections.IEnumerable
val collection : DoubleCollection

  type: DoubleCollection
  implements: ISealable
  implements: System.IFormattable
  implements: System.Collections.IList
  implements: System.Collections.ICollection
  implements: System.Collections.Generic.IList<float>
  implements: System.Collections.Generic.ICollection<float>
  implements: seq<float>
  implements: System.Collections.IEnumerable
  inherits: Freezable
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type DoubleCollection =
  class
    inherit System.Windows.Freezable
    new : unit -> System.Windows.Media.DoubleCollection
    new : int -> System.Windows.Media.DoubleCollection
    new : System.Collections.Generic.IEnumerable<float> -> System.Windows.Media.DoubleCollection
    member Add : float -> unit
    member Clear : unit -> unit
    member Clone : unit -> System.Windows.Media.DoubleCollection
    member CloneCurrentValue : unit -> System.Windows.Media.DoubleCollection
    member Contains : float -> bool
    member CopyTo : float [] * int -> unit
    member Count : int
    member GetEnumerator : unit -> Enumerator
    member IndexOf : float -> int
    member Insert : int * float -> unit
    member Item : int -> float with get, set
    member Remove : float -> bool
    member RemoveAt : int -> unit
    member ToString : unit -> string
    member ToString : System.IFormatProvider -> string
    static member Parse : string -> System.Windows.Media.DoubleCollection
    type Enumerator =
      struct
        member Current : float
        member MoveNext : unit -> bool
        member Reset : unit -> unit
      end
  end

Full name: System.Windows.Media.DoubleCollection

  type: DoubleCollection
  implements: ISealable
  implements: System.IFormattable
  implements: System.Collections.IList
  implements: System.Collections.ICollection
  implements: System.Collections.Generic.IList<float>
  implements: System.Collections.Generic.ICollection<float>
  implements: seq<float>
  implements: System.Collections.IEnumerable
  inherits: Freezable
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
module Seq

from Microsoft.FSharp.Collections
val iter : ('T -> unit) -> seq<'T> -> unit

Full name: Microsoft.FSharp.Collections.Seq.iter
DoubleCollection.Add(value: float) : unit
namespace System.Windows.Resources
namespace System.Windows.Shapes
val createBorder : Color -> Rectangle

Full name: Snippet.Resources.createBorder
val color : Color

  type: Color
  implements: System.IFormattable
  implements: System.IEquatable<Color>
  inherits: System.ValueType
type Rectangle =
  class
    inherit System.Windows.Shapes.Shape
    new : unit -> System.Windows.Shapes.Rectangle
    member GeometryTransform : System.Windows.Media.Transform
    member RadiusX : float with get, set
    member RadiusY : float with get, set
    member RenderedGeometry : System.Windows.Media.Geometry
    static val RadiusXProperty : System.Windows.DependencyProperty
    static val RadiusYProperty : System.Windows.DependencyProperty
  end

Full name: System.Windows.Shapes.Rectangle

  type: Rectangle
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  inherits: Shape
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type Stretch =
  | None = 0
  | Fill = 1
  | Uniform = 2
  | UniformToFill = 3

Full name: System.Windows.Media.Stretch

  type: Stretch
  inherits: System.Enum
  inherits: System.ValueType
field Stretch.Fill = 1
type SolidColorBrush =
  class
    inherit System.Windows.Media.Brush
    new : unit -> System.Windows.Media.SolidColorBrush
    new : System.Windows.Media.Color -> System.Windows.Media.SolidColorBrush
    member Clone : unit -> System.Windows.Media.SolidColorBrush
    member CloneCurrentValue : unit -> System.Windows.Media.SolidColorBrush
    member Color : System.Windows.Media.Color with get, set
    static val ColorProperty : System.Windows.DependencyProperty
    static member DeserializeFrom : System.IO.BinaryReader -> obj
  end

Full name: System.Windows.Media.SolidColorBrush

  type: SolidColorBrush
  implements: ISealable
  implements: Animation.IAnimatable
  implements: System.IFormattable
  implements: Composition.DUCE.IResource
  inherits: Brush
  inherits: Animation.Animatable
  inherits: Freezable
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type PenLineJoin =
  | Miter = 0
  | Bevel = 1
  | Round = 2

Full name: System.Windows.Media.PenLineJoin

  type: PenLineJoin
  inherits: System.Enum
  inherits: System.ValueType
field PenLineJoin.Round = 2
val createDashedBorder : Color -> Rectangle

Full name: Snippet.Resources.createDashedBorder
val border : Rectangle

  type: Rectangle
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  inherits: Shape
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
property Shape.StrokeDashCap: PenLineCap
type PenLineCap =
  | Flat = 0
  | Square = 1
  | Round = 2
  | Triangle = 3

Full name: System.Windows.Media.PenLineCap

  type: PenLineCap
  inherits: System.Enum
  inherits: System.ValueType
field PenLineCap.Round = 2
property Shape.StrokeDashArray: DoubleCollection
type Calculator =
  class
    inherit UserControl
    new : unit -> Calculator
  end

Full name: Snippet.Calculator

  type: Calculator
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: UserControl
  inherits: ContentControl
  inherits: Control
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val this : Calculator

  type: Calculator
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: UserControl
  inherits: ContentControl
  inherits: Control
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type UserControl =
  class
    inherit System.Windows.Controls.ContentControl
    new : unit -> System.Windows.Controls.UserControl
  end

Full name: System.Windows.Controls.UserControl

  type: UserControl
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: ContentControl
  inherits: Control
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val label : TextBlock

  type: TextBlock
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: IContentHost
  implements: Markup.IAddChildInternal
  implements: Markup.IAddChild
  implements: System.IServiceProvider
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type TextBlock =
  class
    inherit System.Windows.FrameworkElement
    new : unit -> System.Windows.Controls.TextBlock
    new : System.Windows.Documents.Inline -> System.Windows.Controls.TextBlock
    member Background : System.Windows.Media.Brush with get, set
    member BaselineOffset : float with get, set
    member BreakAfter : System.Windows.LineBreakCondition
    member BreakBefore : System.Windows.LineBreakCondition
    member ContentEnd : System.Windows.Documents.TextPointer
    member ContentStart : System.Windows.Documents.TextPointer
    member FontFamily : System.Windows.Media.FontFamily with get, set
    member FontSize : float with get, set
    member FontStretch : System.Windows.FontStretch with get, set
    member FontStyle : System.Windows.FontStyle with get, set
    member FontWeight : System.Windows.FontWeight with get, set
    member Foreground : System.Windows.Media.Brush with get, set
    member GetPositionFromPoint : System.Windows.Point * bool -> System.Windows.Documents.TextPointer
    member Inlines : System.Windows.Documents.InlineCollection
    member IsHyphenationEnabled : bool with get, set
    member LineHeight : float with get, set
    member LineStackingStrategy : System.Windows.LineStackingStrategy with get, set
    member Padding : System.Windows.Thickness with get, set
    member ShouldSerializeBaselineOffset : unit -> bool
    member ShouldSerializeInlines : System.Windows.Markup.XamlDesignerSerializationManager -> bool
    member ShouldSerializeText : unit -> bool
    member Text : string with get, set
    member TextAlignment : System.Windows.TextAlignment with get, set
    member TextDecorations : System.Windows.TextDecorationCollection with get, set
    member TextEffects : System.Windows.Media.TextEffectCollection with get, set
    member TextTrimming : System.Windows.TextTrimming with get, set
    member TextWrapping : System.Windows.TextWrapping with get, set
    member Typography : System.Windows.Documents.Typography
    static val BaselineOffsetProperty : System.Windows.DependencyProperty
    static val TextProperty : System.Windows.DependencyProperty
    static val FontFamilyProperty : System.Windows.DependencyProperty
    static val FontStyleProperty : System.Windows.DependencyProperty
    static val FontWeightProperty : System.Windows.DependencyProperty
    static val FontStretchProperty : System.Windows.DependencyProperty
    static val FontSizeProperty : System.Windows.DependencyProperty
    static val ForegroundProperty : System.Windows.DependencyProperty
    static val BackgroundProperty : System.Windows.DependencyProperty
    static val TextDecorationsProperty : System.Windows.DependencyProperty
    static val TextEffectsProperty : System.Windows.DependencyProperty
    static val LineHeightProperty : System.Windows.DependencyProperty
    static val LineStackingStrategyProperty : System.Windows.DependencyProperty
    static val PaddingProperty : System.Windows.DependencyProperty
    static val TextAlignmentProperty : System.Windows.DependencyProperty
    static val TextTrimmingProperty : System.Windows.DependencyProperty
    static val TextWrappingProperty : System.Windows.DependencyProperty
    static val IsHyphenationEnabledProperty : System.Windows.DependencyProperty
    static member GetBaselineOffset : System.Windows.DependencyObject -> float
    static member GetFontFamily : System.Windows.DependencyObject -> System.Windows.Media.FontFamily
    static member GetFontSize : System.Windows.DependencyObject -> float
    static member GetFontStretch : System.Windows.DependencyObject -> System.Windows.FontStretch
    static member GetFontStyle : System.Windows.DependencyObject -> System.Windows.FontStyle
    static member GetFontWeight : System.Windows.DependencyObject -> System.Windows.FontWeight
    static member GetForeground : System.Windows.DependencyObject -> System.Windows.Media.Brush
    static member GetLineHeight : System.Windows.DependencyObject -> float
    static member GetLineStackingStrategy : System.Windows.DependencyObject -> System.Windows.LineStackingStrategy
    static member GetTextAlignment : System.Windows.DependencyObject -> System.Windows.TextAlignment
    static member SetBaselineOffset : System.Windows.DependencyObject * float -> unit
    static member SetFontFamily : System.Windows.DependencyObject * System.Windows.Media.FontFamily -> unit
    static member SetFontSize : System.Windows.DependencyObject * float -> unit
    static member SetFontStretch : System.Windows.DependencyObject * System.Windows.FontStretch -> unit
    static member SetFontStyle : System.Windows.DependencyObject * System.Windows.FontStyle -> unit
    static member SetFontWeight : System.Windows.DependencyObject * System.Windows.FontWeight -> unit
    static member SetForeground : System.Windows.DependencyObject * System.Windows.Media.Brush -> unit
    static member SetLineHeight : System.Windows.DependencyObject * float -> unit
    static member SetLineStackingStrategy : System.Windows.DependencyObject * System.Windows.LineStackingStrategy -> unit
    static member SetTextAlignment : System.Windows.DependencyObject * System.Windows.TextAlignment -> unit
  end

Full name: System.Windows.Controls.TextBlock

  type: TextBlock
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: IContentHost
  implements: Markup.IAddChildInternal
  implements: Markup.IAddChild
  implements: System.IServiceProvider
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
namespace Microsoft.FSharp.Text
type Colors =
  class
    static member AliceBlue : System.Windows.Media.Color
    static member AntiqueWhite : System.Windows.Media.Color
    static member Aqua : System.Windows.Media.Color
    static member Aquamarine : System.Windows.Media.Color
    static member Azure : System.Windows.Media.Color
    static member Beige : System.Windows.Media.Color
    static member Bisque : System.Windows.Media.Color
    static member Black : System.Windows.Media.Color
    static member BlanchedAlmond : System.Windows.Media.Color
    static member Blue : System.Windows.Media.Color
    static member BlueViolet : System.Windows.Media.Color
    static member Brown : System.Windows.Media.Color
    static member BurlyWood : System.Windows.Media.Color
    static member CadetBlue : System.Windows.Media.Color
    static member Chartreuse : System.Windows.Media.Color
    static member Chocolate : System.Windows.Media.Color
    static member Coral : System.Windows.Media.Color
    static member CornflowerBlue : System.Windows.Media.Color
    static member Cornsilk : System.Windows.Media.Color
    static member Crimson : System.Windows.Media.Color
    static member Cyan : System.Windows.Media.Color
    static member DarkBlue : System.Windows.Media.Color
    static member DarkCyan : System.Windows.Media.Color
    static member DarkGoldenrod : System.Windows.Media.Color
    static member DarkGray : System.Windows.Media.Color
    static member DarkGreen : System.Windows.Media.Color
    static member DarkKhaki : System.Windows.Media.Color
    static member DarkMagenta : System.Windows.Media.Color
    static member DarkOliveGreen : System.Windows.Media.Color
    static member DarkOrange : System.Windows.Media.Color
    static member DarkOrchid : System.Windows.Media.Color
    static member DarkRed : System.Windows.Media.Color
    static member DarkSalmon : System.Windows.Media.Color
    static member DarkSeaGreen : System.Windows.Media.Color
    static member DarkSlateBlue : System.Windows.Media.Color
    static member DarkSlateGray : System.Windows.Media.Color
    static member DarkTurquoise : System.Windows.Media.Color
    static member DarkViolet : System.Windows.Media.Color
    static member DeepPink : System.Windows.Media.Color
    static member DeepSkyBlue : System.Windows.Media.Color
    static member DimGray : System.Windows.Media.Color
    static member DodgerBlue : System.Windows.Media.Color
    static member Firebrick : System.Windows.Media.Color
    static member FloralWhite : System.Windows.Media.Color
    static member ForestGreen : System.Windows.Media.Color
    static member Fuchsia : System.Windows.Media.Color
    static member Gainsboro : System.Windows.Media.Color
    static member GhostWhite : System.Windows.Media.Color
    static member Gold : System.Windows.Media.Color
    static member Goldenrod : System.Windows.Media.Color
    static member Gray : System.Windows.Media.Color
    static member Green : System.Windows.Media.Color
    static member GreenYellow : System.Windows.Media.Color
    static member Honeydew : System.Windows.Media.Color
    static member HotPink : System.Windows.Media.Color
    static member IndianRed : System.Windows.Media.Color
    static member Indigo : System.Windows.Media.Color
    static member Ivory : System.Windows.Media.Color
    static member Khaki : System.Windows.Media.Color
    static member Lavender : System.Windows.Media.Color
    static member LavenderBlush : System.Windows.Media.Color
    static member LawnGreen : System.Windows.Media.Color
    static member LemonChiffon : System.Windows.Media.Color
    static member LightBlue : System.Windows.Media.Color
    static member LightCoral : System.Windows.Media.Color
    static member LightCyan : System.Windows.Media.Color
    static member LightGoldenrodYellow : System.Windows.Media.Color
    static member LightGray : System.Windows.Media.Color
    static member LightGreen : System.Windows.Media.Color
    static member LightPink : System.Windows.Media.Color
    static member LightSalmon : System.Windows.Media.Color
    static member LightSeaGreen : System.Windows.Media.Color
    static member LightSkyBlue : System.Windows.Media.Color
    static member LightSlateGray : System.Windows.Media.Color
    static member LightSteelBlue : System.Windows.Media.Color
    static member LightYellow : System.Windows.Media.Color
    static member Lime : System.Windows.Media.Color
    static member LimeGreen : System.Windows.Media.Color
    static member Linen : System.Windows.Media.Color
    static member Magenta : System.Windows.Media.Color
    static member Maroon : System.Windows.Media.Color
    static member MediumAquamarine : System.Windows.Media.Color
    static member MediumBlue : System.Windows.Media.Color
    static member MediumOrchid : System.Windows.Media.Color
    static member MediumPurple : System.Windows.Media.Color
    static member MediumSeaGreen : System.Windows.Media.Color
    static member MediumSlateBlue : System.Windows.Media.Color
    static member MediumSpringGreen : System.Windows.Media.Color
    static member MediumTurquoise : System.Windows.Media.Color
    static member MediumVioletRed : System.Windows.Media.Color
    static member MidnightBlue : System.Windows.Media.Color
    static member MintCream : System.Windows.Media.Color
    static member MistyRose : System.Windows.Media.Color
    static member Moccasin : System.Windows.Media.Color
    static member NavajoWhite : System.Windows.Media.Color
    static member Navy : System.Windows.Media.Color
    static member OldLace : System.Windows.Media.Color
    static member Olive : System.Windows.Media.Color
    static member OliveDrab : System.Windows.Media.Color
    static member Orange : System.Windows.Media.Color
    static member OrangeRed : System.Windows.Media.Color
    static member Orchid : System.Windows.Media.Color
    static member PaleGoldenrod : System.Windows.Media.Color
    static member PaleGreen : System.Windows.Media.Color
    static member PaleTurquoise : System.Windows.Media.Color
    static member PaleVioletRed : System.Windows.Media.Color
    static member PapayaWhip : System.Windows.Media.Color
    static member PeachPuff : System.Windows.Media.Color
    static member Peru : System.Windows.Media.Color
    static member Pink : System.Windows.Media.Color
    static member Plum : System.Windows.Media.Color
    static member PowderBlue : System.Windows.Media.Color
    static member Purple : System.Windows.Media.Color
    static member Red : System.Windows.Media.Color
    static member RosyBrown : System.Windows.Media.Color
    static member RoyalBlue : System.Windows.Media.Color
    static member SaddleBrown : System.Windows.Media.Color
    static member Salmon : System.Windows.Media.Color
    static member SandyBrown : System.Windows.Media.Color
    static member SeaGreen : System.Windows.Media.Color
    static member SeaShell : System.Windows.Media.Color
    static member Sienna : System.Windows.Media.Color
    static member Silver : System.Windows.Media.Color
    static member SkyBlue : System.Windows.Media.Color
    static member SlateBlue : System.Windows.Media.Color
    static member SlateGray : System.Windows.Media.Color
    static member Snow : System.Windows.Media.Color
    static member SpringGreen : System.Windows.Media.Color
    static member SteelBlue : System.Windows.Media.Color
    static member Tan : System.Windows.Media.Color
    static member Teal : System.Windows.Media.Color
    static member Thistle : System.Windows.Media.Color
    static member Tomato : System.Windows.Media.Color
    static member Transparent : System.Windows.Media.Color
    static member Turquoise : System.Windows.Media.Color
    static member Violet : System.Windows.Media.Color
    static member Wheat : System.Windows.Media.Color
    static member White : System.Windows.Media.Color
    static member WhiteSmoke : System.Windows.Media.Color
    static member Yellow : System.Windows.Media.Color
    static member YellowGreen : System.Windows.Media.Color
  end

Full name: System.Windows.Media.Colors
property Colors.Purple: Color
type FontWeight =
  struct
    member Equals : System.Windows.FontWeight -> bool
    member Equals : obj -> bool
    member GetHashCode : unit -> int
    member ToOpenTypeWeight : unit -> int
    member ToString : unit -> string
    static member Compare : System.Windows.FontWeight * System.Windows.FontWeight -> int
    static member FromOpenTypeWeight : int -> System.Windows.FontWeight
  end

Full name: System.Windows.FontWeight

  type: FontWeight
  implements: System.IFormattable
  inherits: System.ValueType
type FontWeights =
  class
    static member Black : System.Windows.FontWeight
    static member Bold : System.Windows.FontWeight
    static member DemiBold : System.Windows.FontWeight
    static member ExtraBlack : System.Windows.FontWeight
    static member ExtraBold : System.Windows.FontWeight
    static member ExtraLight : System.Windows.FontWeight
    static member Heavy : System.Windows.FontWeight
    static member Light : System.Windows.FontWeight
    static member Medium : System.Windows.FontWeight
    static member Normal : System.Windows.FontWeight
    static member Regular : System.Windows.FontWeight
    static member SemiBold : System.Windows.FontWeight
    static member Thin : System.Windows.FontWeight
    static member UltraBlack : System.Windows.FontWeight
    static member UltraBold : System.Windows.FontWeight
    static member UltraLight : System.Windows.FontWeight
  end

Full name: System.Windows.FontWeights
property FontWeights.Bold: FontWeight
type Thickness =
  struct
    new : float -> System.Windows.Thickness
    new : float * float * float * float -> System.Windows.Thickness
    member Bottom : float with get, set
    member Equals : obj -> bool
    member Equals : System.Windows.Thickness -> bool
    member GetHashCode : unit -> int
    member Left : float with get, set
    member Right : float with get, set
    member ToString : unit -> string
    member Top : float with get, set
  end

Full name: System.Windows.Thickness

  type: Thickness
  implements: System.IEquatable<Thickness>
  inherits: System.ValueType
type HorizontalAlignment =
  | Left = 0
  | Center = 1
  | Right = 2
  | Stretch = 3

Full name: System.Windows.HorizontalAlignment

  type: HorizontalAlignment
  inherits: System.Enum
  inherits: System.ValueType
field HorizontalAlignment.Center = 1
val formulaText : 'a (requires 'a :> UIElement)

  type: 'a
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IInputElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type TextBox =
  class
    inherit System.Windows.Controls.Primitives.TextBoxBase
    new : unit -> System.Windows.Controls.TextBox
    member CaretIndex : int with get, set
    member CharacterCasing : System.Windows.Controls.CharacterCasing with get, set
    member Clear : unit -> unit
    member GetCharacterIndexFromLineIndex : int -> int
    member GetCharacterIndexFromPoint : System.Windows.Point * bool -> int
    member GetFirstVisibleLineIndex : unit -> int
    member GetLastVisibleLineIndex : unit -> int
    member GetLineIndexFromCharacterIndex : int -> int
    member GetLineLength : int -> int
    member GetLineText : int -> string
    member GetNextSpellingErrorCharacterIndex : int * System.Windows.Documents.LogicalDirection -> int
    member GetRectFromCharacterIndex : int -> System.Windows.Rect
    member GetRectFromCharacterIndex : int * bool -> System.Windows.Rect
    member GetSpellingError : int -> System.Windows.Controls.SpellingError
    member GetSpellingErrorLength : int -> int
    member GetSpellingErrorStart : int -> int
    member LineCount : int
    member MaxLength : int with get, set
    member MaxLines : int with get, set
    member MinLines : int with get, set
    member ScrollToLine : int -> unit
    member Select : int * int -> unit
    member SelectedText : string with get, set
    member SelectionLength : int with get, set
    member SelectionStart : int with get, set
    member ShouldSerializeText : System.Windows.Markup.XamlDesignerSerializationManager -> bool
    member Text : string with get, set
    member TextAlignment : System.Windows.TextAlignment with get, set
    member TextDecorations : System.Windows.TextDecorationCollection with get, set
    member TextWrapping : System.Windows.TextWrapping with get, set
    member Typography : System.Windows.Documents.Typography
    static val TextWrappingProperty : System.Windows.DependencyProperty
    static val MinLinesProperty : System.Windows.DependencyProperty
    static val MaxLinesProperty : System.Windows.DependencyProperty
    static val TextProperty : System.Windows.DependencyProperty
    static val CharacterCasingProperty : System.Windows.DependencyProperty
    static val MaxLengthProperty : System.Windows.DependencyProperty
    static val TextAlignmentProperty : System.Windows.DependencyProperty
    static val TextDecorationsProperty : System.Windows.DependencyProperty
  end

Full name: System.Windows.Controls.TextBox

  type: TextBox
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  implements: ITextBoxViewHost
  inherits: Primitives.TextBoxBase
  inherits: Control
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
property Colors.Gray: Color
property Colors.White: Color
val makeBorder : (UIElement -> UIElement -> Grid)
val parent : UIElement

  type: UIElement
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IInputElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val child : UIElement

  type: UIElement
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IInputElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val border : Grid

  type: Grid
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: Panel
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type Grid =
  class
    inherit System.Windows.Controls.Panel
    new : unit -> System.Windows.Controls.Grid
    member ColumnDefinitions : System.Windows.Controls.ColumnDefinitionCollection
    member RowDefinitions : System.Windows.Controls.RowDefinitionCollection
    member ShouldSerializeColumnDefinitions : unit -> bool
    member ShouldSerializeRowDefinitions : unit -> bool
    member ShowGridLines : bool with get, set
    static val ShowGridLinesProperty : System.Windows.DependencyProperty
    static val ColumnProperty : System.Windows.DependencyProperty
    static val RowProperty : System.Windows.DependencyProperty
    static val ColumnSpanProperty : System.Windows.DependencyProperty
    static val RowSpanProperty : System.Windows.DependencyProperty
    static val IsSharedSizeScopeProperty : System.Windows.DependencyProperty
    static member GetColumn : System.Windows.UIElement -> int
    static member GetColumnSpan : System.Windows.UIElement -> int
    static member GetIsSharedSizeScope : System.Windows.UIElement -> bool
    static member GetRow : System.Windows.UIElement -> int
    static member GetRowSpan : System.Windows.UIElement -> int
    static member SetColumn : System.Windows.UIElement * int -> unit
    static member SetColumnSpan : System.Windows.UIElement * int -> unit
    static member SetIsSharedSizeScope : System.Windows.UIElement * bool -> unit
    static member SetRow : System.Windows.UIElement * int -> unit
    static member SetRowSpan : System.Windows.UIElement * int -> unit
  end

Full name: System.Windows.Controls.Grid

  type: Grid
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: Panel
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
property Panel.Children: UIElementCollection
UIElementCollection.Add(element: UIElement) : int
val panel : #Panel

  type: #Panel
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: Panel
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type Panel =
  class
    inherit System.Windows.FrameworkElement
    member Background : System.Windows.Media.Brush with get, set
    member Children : System.Windows.Controls.UIElementCollection
    member IsItemsHost : bool with get, set
    member ShouldSerializeChildren : unit -> bool
    static val BackgroundProperty : System.Windows.DependencyProperty
    static val IsItemsHostProperty : System.Windows.DependencyProperty
    static val ZIndexProperty : System.Windows.DependencyProperty
    static member GetZIndex : System.Windows.UIElement -> int
    static member SetZIndex : System.Windows.UIElement * int -> unit
  end

Full name: System.Windows.Controls.Panel

  type: Panel
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val item : UIElement

  type: UIElement
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IInputElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val ignore : 'T -> unit

Full name: Microsoft.FSharp.Core.Operators.ignore
val grid : Grid

  type: Grid
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: Panel
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val col : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
val row : int

  type: int
  implements: System.IComparable
  implements: System.IFormattable
  implements: System.IConvertible
  implements: System.IComparable<int>
  implements: System.IEquatable<int>
  inherits: System.ValueType
Grid.SetColumn(element: UIElement, value: int) : unit
Grid.SetRow(element: UIElement, value: int) : unit
val computeButton : Button

  type: Button
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  implements: ICommandSource
  inherits: Primitives.ButtonBase
  inherits: ContentControl
  inherits: Control
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type Button =
  class
    inherit System.Windows.Controls.Primitives.ButtonBase
    new : unit -> System.Windows.Controls.Button
    member IsCancel : bool with get, set
    member IsDefault : bool with get, set
    member IsDefaulted : bool
    static val IsDefaultProperty : System.Windows.DependencyProperty
    static val IsCancelProperty : System.Windows.DependencyProperty
    static val IsDefaultedProperty : System.Windows.DependencyProperty
  end

Full name: System.Windows.Controls.Button

  type: Button
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  implements: ICommandSource
  inherits: Primitives.ButtonBase
  inherits: ContentControl
  inherits: Control
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
field HorizontalAlignment.Right = 2
val formulaPanel : Grid

  type: Grid
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: Panel
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type GridLength =
  struct
    new : float -> System.Windows.GridLength
    new : float * System.Windows.GridUnitType -> System.Windows.GridLength
    member Equals : obj -> bool
    member Equals : System.Windows.GridLength -> bool
    member GetHashCode : unit -> int
    member GridUnitType : System.Windows.GridUnitType
    member IsAbsolute : bool
    member IsAuto : bool
    member IsStar : bool
    member ToString : unit -> string
    member Value : float
    static member Auto : System.Windows.GridLength
  end

Full name: System.Windows.GridLength

  type: GridLength
  implements: System.IEquatable<GridLength>
  inherits: System.ValueType
type GridUnitType =
  | Auto = 0
  | Pixel = 1
  | Star = 2

Full name: System.Windows.GridUnitType

  type: GridUnitType
  inherits: System.Enum
  inherits: System.ValueType
field GridUnitType.Star = 2
val iter : ('T -> unit) -> 'T list -> unit

Full name: Microsoft.FSharp.Collections.List.iter
val x : GridLength

  type: GridLength
  implements: System.IEquatable<GridLength>
  inherits: System.ValueType
type ColumnDefinition =
  class
    inherit System.Windows.Controls.DefinitionBase
    new : unit -> System.Windows.Controls.ColumnDefinition
    member ActualWidth : float
    member MaxWidth : float with get, set
    member MinWidth : float with get, set
    member Offset : float
    member Width : System.Windows.GridLength with get, set
    static val WidthProperty : System.Windows.DependencyProperty
    static val MinWidthProperty : System.Windows.DependencyProperty
    static val MaxWidthProperty : System.Windows.DependencyProperty
  end

Full name: System.Windows.Controls.ColumnDefinition

  type: ColumnDefinition
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IQueryAmbient
  inherits: DefinitionBase
  inherits: FrameworkContentElement
  inherits: ContentElement
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
property Grid.ColumnDefinitions: ColumnDefinitionCollection
ColumnDefinitionCollection.Add(value: ColumnDefinition) : unit
val dashedBorder : Shapes.Rectangle

  type: Shapes.Rectangle
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  inherits: Shapes.Shape
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val createDashedBorder : Color -> Shapes.Rectangle

Full name: Snippet.Resources.createDashedBorder
property Colors.Red: Color
property FrameworkElement.Margin: Thickness
val resultBlock : TextBlock

  type: TextBlock
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: IContentHost
  implements: Markup.IAddChildInternal
  implements: Markup.IAddChild
  implements: System.IServiceProvider
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val resultPanel : Grid

  type: Grid
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: Panel
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val createBorder : Color -> Shapes.Rectangle

Full name: Snippet.Resources.createBorder
property Colors.Blue: Color
val solidBorder : Shapes.Rectangle

  type: Shapes.Rectangle
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  inherits: Shapes.Shape
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
property Colors.Magenta: Color
val layout : Grid

  type: Grid
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  inherits: Panel
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
type StackPanel =
  class
    inherit System.Windows.Controls.Panel
    new : unit -> System.Windows.Controls.StackPanel
    member CanHorizontallyScroll : bool with get, set
    member CanVerticallyScroll : bool with get, set
    member ExtentHeight : float
    member ExtentWidth : float
    member HorizontalOffset : float
    member LineDown : unit -> unit
    member LineLeft : unit -> unit
    member LineRight : unit -> unit
    member LineUp : unit -> unit
    member MakeVisible : System.Windows.Media.Visual * System.Windows.Rect -> System.Windows.Rect
    member MouseWheelDown : unit -> unit
    member MouseWheelLeft : unit -> unit
    member MouseWheelRight : unit -> unit
    member MouseWheelUp : unit -> unit
    member Orientation : System.Windows.Controls.Orientation with get, set
    member PageDown : unit -> unit
    member PageLeft : unit -> unit
    member PageRight : unit -> unit
    member PageUp : unit -> unit
    member ScrollOwner : System.Windows.Controls.ScrollViewer with get, set
    member SetHorizontalOffset : float -> unit
    member SetVerticalOffset : float -> unit
    member VerticalOffset : float
    member ViewportHeight : float
    member ViewportWidth : float
    static val OrientationProperty : System.Windows.DependencyProperty
  end

Full name: System.Windows.Controls.StackPanel

  type: StackPanel
  implements: Composition.DUCE.IResource
  implements: Animation.IAnimatable
  implements: IFrameworkInputElement
  implements: IInputElement
  implements: System.ComponentModel.ISupportInitialize
  implements: Markup.IHaveResources
  implements: Markup.IQueryAmbient
  implements: Markup.IAddChild
  implements: Primitives.IScrollInfo
  inherits: Panel
  inherits: FrameworkElement
  inherits: UIElement
  inherits: Visual
  inherits: DependencyObject
  inherits: Threading.DispatcherObject
val compute : ('a -> unit)
Multiple items
val e : exn

  type: exn
  implements: System.Runtime.Serialization.ISerializable
  implements: System.Runtime.InteropServices._Exception


--------------------

val e : exn

  type: exn
  implements: System.Runtime.Serialization.ISerializable
  implements: System.Runtime.InteropServices._Exception
val e : exn

  type: exn
  implements: System.Runtime.Serialization.ISerializable
  implements: System.Runtime.InteropServices._Exception
property System.Exception.Message: string
property TextBlock.Text: string
event UIElement.KeyDown: IEvent<KeyEventHandler,KeyEventArgs>
member System.IObservable.Add : callback:('T -> unit) -> unit
val e : KeyEventArgs

  type: KeyEventArgs
  inherits: KeyboardEventArgs
  inherits: InputEventArgs
  inherits: RoutedEventArgs
  inherits: System.EventArgs
property KeyEventArgs.Key: Key
type Key =
  | None = 0
  | Cancel = 1
  | Back = 2
  | Tab = 3
  | LineFeed = 4
  | Clear = 5
  | Return = 6
  | Enter = 6
  | Pause = 7
  | Capital = 8
  | CapsLock = 8
  | KanaMode = 9
  | HangulMode = 9
  | JunjaMode = 10
  | FinalMode = 11
  | HanjaMode = 12
  | KanjiMode = 12
  | Escape = 13
  | ImeConvert = 14
  | ImeNonConvert = 15
  | ImeAccept = 16
  | ImeModeChange = 17
  | Space = 18
  | Prior = 19
  | PageUp = 19
  | Next = 20
  | PageDown = 20
  | End = 21
  | Home = 22
  | Left = 23
  | Up = 24
  | Right = 25
  | Down = 26
  | Select = 27
  | Print = 28
  | Execute = 29
  | Snapshot = 30
  | PrintScreen = 30
  | Insert = 31
  | Delete = 32
  | Help = 33
  | D0 = 34
  | D1 = 35
  | D2 = 36
  | D3 = 37
  | D4 = 38
  | D5 = 39
  | D6 = 40
  | D7 = 41
  | D8 = 42
  | D9 = 43
  | A = 44
  | B = 45
  | C = 46
  | D = 47
  | E = 48
  | F = 49
  | G = 50
  | H = 51
  | I = 52
  | J = 53
  | K = 54
  | L = 55
  | M = 56
  | N = 57
  | O = 58
  | P = 59
  | Q = 60
  | R = 61
  | S = 62
  | T = 63
  | U = 64
  | V = 65
  | W = 66
  | X = 67
  | Y = 68
  | Z = 69
  | LWin = 70
  | RWin = 71
  | Apps = 72
  | Sleep = 73
  | NumPad0 = 74
  | NumPad1 = 75
  | NumPad2 = 76
  | NumPad3 = 77
  | NumPad4 = 78
  | NumPad5 = 79
  | NumPad6 = 80
  | NumPad7 = 81
  | NumPad8 = 82
  | NumPad9 = 83
  | Multiply = 84
  | Add = 85
  | Separator = 86
  | Subtract = 87
  | Decimal = 88
  | Divide = 89
  | F1 = 90
  | F2 = 91
  | F3 = 92
  | F4 = 93
  | F5 = 94
  | F6 = 95
  | F7 = 96
  | F8 = 97
  | F9 = 98
  | F10 = 99
  | F11 = 100
  | F12 = 101
  | F13 = 102
  | F14 = 103
  | F15 = 104
  | F16 = 105
  | F17 = 106
  | F18 = 107
  | F19 = 108
  | F20 = 109
  | F21 = 110
  | F22 = 111
  | F23 = 112
  | F24 = 113
  | NumLock = 114
  | Scroll = 115
  | LeftShift = 116
  | RightShift = 117
  | LeftCtrl = 118
  | RightCtrl = 119
  | LeftAlt = 120
  | RightAlt = 121
  | BrowserBack = 122
  | BrowserForward = 123
  | BrowserRefresh = 124
  | BrowserStop = 125
  | BrowserSearch = 126
  | BrowserFavorites = 127
  | BrowserHome = 128
  | VolumeMute = 129
  | VolumeDown = 130
  | VolumeUp = 131
  | MediaNextTrack = 132
  | MediaPreviousTrack = 133
  | MediaStop = 134
  | MediaPlayPause = 135
  | LaunchMail = 136
  | SelectMedia = 137
  | LaunchApplication1 = 138
  | LaunchApplication2 = 139
  | Oem1 = 140
  | OemSemicolon = 140
  | OemPlus = 141
  | OemComma = 142
  | OemMinus = 143
  | OemPeriod = 144
  | Oem2 = 145
  | OemQuestion = 145
  | Oem3 = 146
  | OemTilde = 146
  | AbntC1 = 147
  | AbntC2 = 148
  | Oem4 = 149
  | OemOpenBrackets = 149
  | Oem5 = 150
  | OemPipe = 150
  | Oem6 = 151
  | OemCloseBrackets = 151
  | Oem7 = 152
  | OemQuotes = 152
  | Oem8 = 153
  | Oem102 = 154
  | OemBackslash = 154
  | ImeProcessed = 155
  | System = 156
  | OemAttn = 157
  | DbeAlphanumeric = 157
  | OemFinish = 158
  | DbeKatakana = 158
  | OemCopy = 159
  | DbeHiragana = 159
  | OemAuto = 160
  | DbeSbcsChar = 160
  | OemEnlw = 161
  | DbeDbcsChar = 161
  | OemBackTab = 162
  | DbeRoman = 162
  | Attn = 163
  | DbeNoRoman = 163
  | CrSel = 164
  | DbeEnterWordRegisterMode = 164
  | ExSel = 165
  | DbeEnterImeConfigureMode = 165
  | EraseEof = 166
  | DbeFlushString = 166
  | Play = 167
  | DbeCodeInput = 167
  | Zoom = 168
  | DbeNoCodeInput = 168
  | NoName = 169
  | DbeDetermineString = 169
  | Pa1 = 170
  | DbeEnterDialogConversionMode = 170
  | OemClear = 171
  | DeadCharProcessed = 172

Full name: System.Windows.Input.Key

  type: Key
  inherits: System.Enum
  inherits: System.ValueType
field Key.Enter = 6
event Primitives.ButtonBase.Click: IEvent<RoutedEventHandler,RoutedEventArgs>
property ContentControl.Content: obj

More information

Link: http://fssnip.net/4Y
Posted: 2 years ago
Author: Phillip Trelford (website)
Tags: Silverlight