## 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.

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()
255:         collection
256:
257: [<AutoOpen>]
258: module Resources =
259:     open System.Windows.Shapes
260:
261:     let createBorder color =
262:         Rectangle(
263:             Stretch=Stretch.Fill,
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()
302:         border
303:
304:     let (+.) (panel:#Panel) (item) =
305:         panel.Children.Add item |> ignore; panel
306:
307:     let (+@) (grid:Grid) (item,col,row) =
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)
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:         )
360:     do  this.Content <- layout
361:
362: #if INTERACTIVE
363: open Microsoft.TryFSharp
364: App.Dispatch (fun() ->
365:     App.Console.ClearCanvas()
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)
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 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>
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
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>
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 =
| 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.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
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
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
module Seq

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

Full name: Microsoft.FSharp.Collections.Seq.iter
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
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
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
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
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
inherits: UserControl
inherits: ContentControl
inherits: Control
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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
inherits: UserControl
inherits: ContentControl
inherits: Control
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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
inherits: ContentControl
inherits: Control
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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: System.IServiceProvider
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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 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: System.IServiceProvider
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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 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 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
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: ITextBoxViewHost
inherits: Primitives.TextBoxBase
inherits: Control
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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
val child : UIElement

type: UIElement
implements: Composition.DUCE.IResource
implements: Animation.IAnimatable
implements: IInputElement
inherits: Visual
inherits: DependencyObject
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
inherits: Panel
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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
inherits: Panel
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
property Panel.Children: UIElementCollection
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
inherits: Panel
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
val item : UIElement

type: UIElement
implements: Composition.DUCE.IResource
implements: Animation.IAnimatable
implements: IInputElement
inherits: Visual
inherits: DependencyObject
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
inherits: Panel
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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: ICommandSource
inherits: Primitives.ButtonBase
inherits: ContentControl
inherits: Control
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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: ICommandSource
inherits: Primitives.ButtonBase
inherits: ContentControl
inherits: Control
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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
inherits: Panel
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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
property Grid.ColumnDefinitions: ColumnDefinitionCollection
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
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: System.IServiceProvider
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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
inherits: Panel
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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
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
inherits: Panel
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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: Primitives.IScrollInfo
inherits: Panel
inherits: FrameworkElement
inherits: UIElement
inherits: Visual
inherits: DependencyObject
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
| Multiply = 84
| 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