0 people like it.

Dojo chart example for Try F# 

  1: 
  2: 
  3: 
  4: 
  5: 
  6: 
  7: 
  8: 
  9: 
 10: 
 11: 
 12: 
 13: 
 14: 
 15: 
 16: 
 17: 
 18: 
 19: 
 20: 
 21: 
 22: 
 23: 
 24: 
 25: 
 26: 
 27: 
 28: 
 29: 
 30: 
 31: 
 32: 
 33: 
 34: 
 35: 
 36: 
 37: 
 38: 
 39: 
 40: 
 41: 
 42: 
 43: 
 44: 
 45: 
 46: 
 47: 
 48: 
 49: 
 50: 
 51: 
 52: 
 53: 
 54: 
 55: 
 56: 
 57: 
 58: 
 59: 
 60: 
 61: 
 62: 
 63: 
 64: 
 65: 
 66: 
 67: 
 68: 
 69: 
 70: 
 71: 
 72: 
 73: 
 74: 
 75: 
 76: 
 77: 
 78: 
 79: 
 80: 
 81: 
 82: 
 83: 
 84: 
 85: 
 86: 
 87: 
 88: 
 89: 
 90: 
 91: 
 92: 
 93: 
 94: 
 95: 
 96: 
 97: 
 98: 
 99: 
100: 
101: 
102: 
103: 
104: 
105: 
106: 
107: 
108: 
109: 
110: 
111: 
112: 
113: 
114: 
115: 
116: 
117: 
118: 
119: 
120: 
121: 
122: 
123: 
124: 
125: 
126: 
127: 
128: 
129: 
130: 
131: 
132: 
133: 
134: 
135: 
136: 
137: 
138: 
139: 
140: 
141: 
142: 
143: 
144: 
145: 
146: 
147: 
148: 
149: 
150: 
151: 
152: 
153: 
154: 
155: 
156: 
157: 
158: 
159: 
160: 
161: 
162: 
163: 
164: 
165: 
166: 
167: 
168: 
169: 
170: 
171: 
172: 
173: 
174: 
175: 
176: 
177: 
178: 
179: 
180: 
181: 
182: 
183: 
184: 
185: 
186: 
187: 
188: 
189: 
190: 
191: 
192: 
193: 
194: 
195: 
196: 
197: 
198: 
199: 
200: 
201: 
202: 
203: 
204: 
205: 
206: 
207: 
208: 
209: 
210: 
211: 
212: 
213: 
214: 
215: 
216: 
217: 
218: 
219: 
220: 
221: 
222: 
223: 
224: 
225: 
226: 
227: 
228: 
229: 
230: 
231: 
232: 
233: 
234: 
235: 
236: 
237: 
238: 
239: 
240: 
241: 
242: 
243: 
244: 
245: 
246: 
247: 
248: 
249: 
250: 
251: 
252: 
253: 
254: 
255: 
256: 
257: 
258: 
259: 
260: 
261: 
262: 
263: 
264: 
265: 
266: 
267: 
268: 
269: 
270: 
271: 
272: 
273: 
274: 
275: 
276: 
277: 
278: 
279: 
280: 
281: 
282: 
283: 
284: 
285: 
286: 
287: 
288: 
289: 
290: 
291: 
292: 
293: 
294: 
295: 
296: 
297: 
298: 
299: 
300: 
301: 
302: 
303: 
304: 
305: 
306: 
307: 
308: 
309: 
310: 
311: 
312: 
313: 
314: 
315: 
316: 
317: 
318: 
319: 
320: 
321: 
322: 
323: 
324: 
325: 
326: 
327: 
328: 
329: 
330: 
331: 
332: 
333: 
334: 
335: 
336: 
337: 
338: 
339: 
340: 
341: 
342: 
343: 
344: 
345: 
346: 
347: 
348: 
349: 
350: 
351: 
352: 
353: 
354: 
355: 
356: 
357: 
358: 
359: 
360: 
361: 
362: 
363: 
364: 
365: 
366: 
367: 
368: 
369: 
370: 
371: 
372: 
373: 
374: 
375: 
376: 
377: 
378: 
379: 
380: 
381: 
382: 
383: 
384: 
385: 
386: 
387: 
388: 
389: 
390: 
391: 
392: 
393: 
394: 
395: 
396: 
397: 
398: 
399: 
400: 
401: 
402: 
403: 
404: 
405: 
406: 
407: 
408: 
409: 
410: 
411: 
412: 
413: 
414: 
415: 
416: 
417: 
418: 
419: 
420: 
421: 

open System

// TODO: legend is not showing
// TODO: dojo has a new way of specifying dependencies, see http://livedocs.dojotoolkit.org/dojox/charting
// TODO: can't combine line and point charts. This may be a Dojo limitation.


module Js = 
    open System.Reflection
    let internal ass = Assembly.Load "System.Windows, Version=5.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e"
    let internal ass2 = Assembly.Load "System.Windows.Browser, Version=5.0.5.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e"
    let internal htmlPageTy = ass2.GetType "System.Windows.Browser.HtmlPage"
    let internal htmlElementTy = ass2.GetType "System.Windows.Browser.HtmlElement"
    let internal htmlWindowTy = ass2.GetType "System.Windows.Browser.HtmlWindow"
    let internal htmlPageWindow = htmlPageTy.GetProperty "Window"
    let internal htmlWindowEval = htmlWindowTy.GetMethod "Eval"
    let internal contInvoke = typeof<obj->unit>.GetMethod "Invoke"
    let internal deploymentTy = ass.GetType "System.Windows.Deployment"
    let internal deploymentCurrent = deploymentTy.GetProperty "Current"
    let internal dispTy = ass.GetType "System.Windows.Threading.Dispatcher"
    let internal dispCheckAccess = dispTy.GetMethod "CheckAccess"
    let internal appDispatcher = deploymentTy.GetProperty "Dispatcher"
    let internal dispBeginInvoke = dispTy.GetMethods() |> Array.find (fun m -> m.Name = "BeginInvoke" && m.GetParameters().Length = 2)

    let uiasync (f: unit -> 'T) : Async<'T> = 
        let p = 
            Async.FromContinuations (fun (cont:obj->unit,econt,ccont) -> 
                let work () = 
                    try 
                      let res = box(f())
                      contInvoke.Invoke(cont, [| res |]) |> ignore
                    with e -> 
                      econt e
        
                let app = deploymentCurrent.GetValue(null, null)
                let disp = appDispatcher.GetValue(app, null)
                let ok = dispCheckAccess.Invoke(disp,null) 
                if ok :?> bool then 
                    work()
                else         
                    let action = new System.Action(work)            
                    dispBeginInvoke.Invoke(disp, [| box action; null |] ) |> ignore
                    )
        async { let! res = p in return (unbox res) }
    

    let uisync (f : unit -> 'T) : 'T = 
        uiasync f |> Async.RunSynchronously       

    let jsasync (script:string) : Async<obj> = 
        async { try 
                   return! uiasync (fun () -> 
                              let window = htmlPageWindow.GetValue(null, null)
                              htmlWindowEval.Invoke(window, [| script |]))
                with e -> printfn "error evaluating JS script <<<\n%s\n>>>" script; return! raise e }


    let jsDoAsync s = 
        jsasync s |> Async.Ignore 

    let jssync s = 
        jsasync s |> Async.RunSynchronously       

    let jsvoid s = 
        jssync s |> ignore

    let jsstart s = 
        jsDoAsync s |> Async.Start



    // Allow callbacks from Javascript to Silverlight through a dynamically crated Scriptable type. We don't 
    // define one statically since we don't have a static reference to System.Windows or System.Windows.Browser.
    open System
    open System.Reflection
    open System.Reflection.Emit

    let asmB = AppDomain.CurrentDomain.DefineDynamicAssembly(AssemblyName("SLCallback"),AssemblyBuilderAccess.Run)
    let modB = asmB.DefineDynamicModule("MainModule")
    let tyB = modB.DefineType("Class", TypeAttributes.Public)

    let scriptableTypeTy = ass2.GetType "System.Windows.Browser.ScriptableTypeAttribute"
    let scriptableMemberTy = ass2.GetType "System.Windows.Browser.ScriptableMemberAttribute"

    tyB.SetCustomAttribute(CustomAttributeBuilder(scriptableTypeTy.GetConstructor([| |]), [| |]))

    let fB = tyB.DefineField ("f", typeof<Action<string, obj>>, FieldAttributes.Private)
    let cB = tyB.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, [| typeof<Action<string, obj>> |])
    let cIL = cB.GetILGenerator()
    cIL.Emit(OpCodes.Ldarg_0)
    cIL.Emit(OpCodes.Call,typeof<obj>.GetConstructor([| |]))
    cIL.Emit(OpCodes.Ldarg_0)
    cIL.Emit(OpCodes.Ldarg_1)
    cIL.Emit(OpCodes.Stfld,fB)
    cIL.Emit(OpCodes.Ret)


    let mB = tyB.DefineMethod("Invoke",MethodAttributes.Public,returnType=typeof<System.Void>,parameterTypes=[| typeof<string>; typeof<obj> |])
    mB.SetCustomAttribute(CustomAttributeBuilder(scriptableMemberTy.GetConstructor([| |]), [| |]))
    let mIL = mB.GetILGenerator()
    mIL.Emit(OpCodes.Ldarg_0)
    mIL.Emit(OpCodes.Ldfld,fB)
    mIL.Emit(OpCodes.Ldarg_1)
    mIL.Emit(OpCodes.Ldarg_2)
    mIL.Emit(OpCodes.Callvirt,typeof<Action<string,obj>>.GetMethod("Invoke"))
    mIL.Emit(OpCodes.Ret)

    let ty = tyB.CreateType()

    uisync (fun () -> 
        let plugin = htmlPageTy.InvokeMember("Plugin", BindingFlags.GetProperty, null, null, [| |])
        let id = htmlElementTy.InvokeMember("Id", BindingFlags.GetProperty, null, plugin, [| |])
        if id :?> string = "" then 
            htmlElementTy.InvokeMember("SetProperty", BindingFlags.InvokeMethod, null, plugin, [| "id"; "silverlight" |]) |> ignore)

    let silverlightId = 
        uisync (fun () -> 
            let plugin = htmlPageTy.InvokeMember("Plugin", BindingFlags.GetProperty, null, null, [| |])
            htmlElementTy.InvokeMember("Id", BindingFlags.GetProperty, null, plugin, [| |]) :?> string)

    let mutable stamp = 0L
    let nextStamp() = stamp <- stamp + 1L; string stamp
    let nextCallback() = "SL" + nextStamp()

    let requests = new System.Collections.Generic.Dictionary<string,(obj -> unit)>()
    let invoke (tgt:string) (obj:obj) = 
        let f = requests.[tgt] 
        requests.Remove tgt |> ignore; 
        f obj

    let a = ty.GetConstructors().[0]
    let xobj = a.Invoke([| Action<string,obj>(invoke) |])

    uisync (fun () -> htmlPageTy.InvokeMember ("RegisterScriptableObject", BindingFlags.InvokeMethod, null, null, [| "SL"; xobj |]))

    let callback (f: 'T -> unit) = 
        let f2 (x:obj) = f (x :?> 'T)
        let stamp = nextStamp()
        requests.[stamp] <- f2
        "(function (arg) { return (document.getElementById('" + silverlightId + "')).Content.SL.Invoke('" + stamp + "',arg); })" 

    let callback0 (f: unit -> unit) = 
        let f2 (x:obj) = f ()
        let stamp = nextStamp()
        requests.[stamp] <- f2
        "(function () { document.getElementById('" + silverlightId + "').Content.SL.Invoke('" + stamp + "',''); })" 


    let convertible (x: IConvertible) = 
        match x with 
        | :? string as s -> "'" + s + "'"
        | _ -> System.Convert.ToString x
    let seq f xs = "[" + String.concat ", " (Seq.map f xs) + "]"

module Async = 
    let Once p = 
        let executed = ref false
        async { if not executed.Value then 
                    executed := true; 
                    do! p } 

module Seq = 
    let index xs = xs |> Seq.mapi (fun i x -> (i,x))       

module DojoChart = 
    module ChartTypes = 
        type ChartData = 
            | XYSeqData of seq<IConvertible * IConvertible>
            | XYSeqSeqData of seq<seq<IConvertible>>

        let conv (x:IConvertible) = x
        let YSeqSeq data = XYSeqSeqData (data |> Seq.map (Seq.map (fun y -> conv y)))
        let XYSeq data = XYSeqData (data |> Seq.map (fun (x,y) -> conv x, conv y))
 
//For any non “stacked” line plot type you can specify coordinate pairs. You need to use keys that correspond to the hAxis and vAxis parameters defined in the addPlot() call. These default to x and y.

        let (||||) a b = match a with None -> b | _ -> a
        let getSeriesXY plotName seriesName d = 
            let seriesName = defaultArg seriesName ("Series " + Js.nextStamp())
            ".addSeries('" + seriesName + "', " + (d |> Js.seq (fun (x,y) -> "{x: " + Js.convertible x + ",y: " + Js.convertible y + "}")) + ", {plotName:'" + plotName + "'})"

        let getSeriesY plotName seriesName d = 
            let seriesName = defaultArg seriesName ("Series " + Js.nextStamp() )
            ".addSeries('" + seriesName + "', " + (d |> Js.seq Js.convertible) + ", {plotName:'" + plotName + "'})"

//     {plot: "other", stroke: {color:"blue"}, fill: "lightblue"});

        let getData plotName seriesName d = 
            match d with 
            | XYSeqData xs -> [ getSeriesXY plotName seriesName xs ]
            | XYSeqSeqData xss -> xss |> Seq.map (getSeriesY plotName seriesName) |> Seq.toList

        type Theme internal (name:string) = 
            member x.Name = name

        type GenericChart internal (series : (string * string option * ChartData) list, animate:bool option, title: string option,theme: Theme option) = 
            static member internal Create(seriesKind, seriesName, seriesData) = 
                GenericChart(series=[(seriesKind,seriesName,seriesData)],animate=None,title=None,theme=Some(Theme("Wetland")))
            member internal __.With(?Title,?Animate,?SeriesName,?Theme) = 
                let series = series |> List.map (fun (kind,seriesName,data) -> (kind, (SeriesName |||| seriesName), data))
                GenericChart(series=series,animate=(Animate |||| animate),title=(Title |||| title),theme=(Theme |||| theme))

            member private __.Series = series
            member private __.Animate = animate
            member private __.Title = title
            member private __.Theme = theme
            static member internal Combine(ch1:GenericChart,ch2:GenericChart) = 
                GenericChart(series=ch1.Series @ ch2.Series,
                             animate=(ch1.Animate |||| ch2.Animate),
                             title=(ch1.Title |||| ch2.Title),
                             theme=(ch1.Theme |||| ch2.Theme))

            member ch.WithStyle(?Theme) = ch.With(?Theme=Theme)
            member internal ch.RenderAsync() = 
                let script = 
                    " dojo.empty('chartingArea'); 

                      var chart = new dojox.charting.Chart2D('chartingArea', {" + 
                          String.concat "," 
                              [ yield! Option.toList (title |> Option.map (fun s -> "title: '" + s + "'"))  ] 
                          + "});
                      chart" 
                    + 
                    String.concat "\n\t" 
                        [ yield ".addAxis('x', {fixLower: 'major', minorTicks: 'false', minorLabels: 'false', fixUpper: 'major'})"
                          yield ".addAxis('y', {vertical: true, minorTicks: 'false', minorLabels: 'false', fixLower: 'major', fixUpper: 'major', includeZero: true})" 
                          match theme with 
                          | None -> () 
                          | Some s -> yield ".setTheme(dojox.charting.themes." + s.Name + ")" 
                          for (i,(kind,seriesName,data)) in Seq.index series do 
                            let plotName = (if i = 0 then "default" else "plot" + string i)
                            let plotArgs = 
                                String.concat "," 
                                    [ yield "type: '" + kind + "' " 
                                      yield! (if animate = Some true then [ "animate: { duration: 1000, easing: dojo.fx.easing.linear}" ] else []) ]
                            yield (".addPlot('" + plotName + "', { " + plotArgs + "})" ) 
                            yield! getData plotName seriesName data ] 
                    + 
                    "\n\t.render();
                     "
                printfn "script = <<<\n%s\n>>>" script
                Js.jsDoAsync script

    open ChartTypes

    let initAsync = 
        Async.Once <| Async.FromContinuations(fun (cont,econt,_) -> 
          try 

           Js.jsstart ("

            //alert('in initAsync');
            var dojoConfig = {
                parseOnLoad: true,
                dojoBlankHtmlUrl: '/blank.html'
            };

            var oHead = document.getElementsByTagName('head')[0];
            var scriptB = document.createElement('script');
            scriptB.setAttribute('src', 'http://ajax.googleapis.com/ajax/libs/dojo/1.7/dojo/dojo.js')
            scriptB.onload = afterDojoLoad;

            oHead.appendChild(scriptB); 

            var oHead = document.getElementsByTagName('head')[0];
            try { 
              var silverlightDiv = document.getElementById('" + Js.silverlightId + "');
              silverlightDiv.style.height = '60%';

              if (document.getElementById('chartingArea') == null) {
                  var chartingArea = document.createElement('div');
                  chartingArea.id = 'chartingArea';
                  chartingArea.nodeName = 'chartingArea';
                  chartingArea.style.height = '40%';
                  silverlightDiv.parentNode.insertBefore(chartingArea,silverlightDiv.parentNode.childNodes[0]); 
              }
            }  catch (e) { alert (e.message ? e.message : e); }

            function afterDojoLoad(){
                //alert('in afterDojoLoad');
                try { 
                    dojo.require('dojox.charting.Chart2D'); 
                    dojo.require('dojox.charting.Chart3D');
                    dojo.require('dojox.charting.axis2d.Default');
                    dojo.require('dojox.charting.plot2d.Default');
                    dojo.require('dojox.charting.plot2d.Pie');
                    dojo.require('dojox.charting.plot2d.ClusteredColumns');
                    dojo.require('dojox.charting.action2d.Highlight');
                    dojo.require('dojox.charting.action2d.MoveSlice');
                    dojo.require('dojox.charting.action2d.Tooltip');
                    dojo.require('dojox.charting.widget.Legend');
                    dojo.require('dojox.charting.widget.SelectableLegend');
                    dojo.require('dojo.fx.easing');

                    dojo.require('dojox.charting.themes.Tufte');
                    dojo.require('dojox.charting.themes.Wetland');
                    dojo.require('dojox.charting.themes.MiamiNice');
                    dojo.require('dojox.charting.plot3d.Bars');

                }
                catch (e) { 
                    alert ('Failure in dojo.require: ' + (e.message ? e.message : e)); 
                }
                //alert('in afterDojoLoad, calling dojo.ready');
                dojo.ready(" + Js.callback0 cont + ");
            }")
          with e -> econt e)

    let startRender (ch:GenericChart) = 
            async { try 
                        do! initAsync
                        do! ch.RenderAsync() 
                    with e -> printfn "background error: %A" e }
                |> Async.Start

    type Chart() = 

        static member StackedArea(data, ?Title, ?Name, ?Animate) = 
            GenericChart.Create("StackedAreas", Name, YSeqSeq data).With(?Title=Title,?Animate=Animate) 

        static member StackedLines(data, ?Title, ?Name, ?Animate) = 
            GenericChart.Create("StackedLines", Name, YSeqSeq data).With(?Title=Title,?Animate=Animate) 

        static member StackedBars(data, ?Title, ?Name, ?Animate) = 
            GenericChart.Create("StackedBars", Name, YSeqSeq data).With(?Title=Title,?Animate=Animate) 

        static member StackedColumns(data, ?Title, ?Name, ?Animate) = 
            GenericChart.Create("StackedColumns", Name, YSeqSeq data).With(?Title=Title,?Animate=Animate) 

        static member Line(data:seq<#IConvertible * #IConvertible>, ?Title, ?Name, ?Animate) = 
            GenericChart.Create("Lines", Name, XYSeq data).With(?Title=Title,?Animate=Animate) 

        static member Point(data:seq<#IConvertible * #IConvertible>, ?Title, ?Name, ?Animate) = 
            GenericChart.Create("MarkersOnly", Name, XYSeq data).With(?Title=Title,?Animate=Animate) 

        static member Pie(data:seq<#IConvertible * #IConvertible>, ?Title, ?Name, ?Animate) = 
            GenericChart.Create("Pie", Name, XYSeq data).With(?Title=Title,?Animate=Animate) 

        static member Bar(data:seq<#IConvertible * #IConvertible>, ?Title, ?Name, ?Animate) = 
            GenericChart.Create("Bars", Name, XYSeq data).With(?Title=Title,?Animate=Animate) 

        static member Column(data:seq<#IConvertible * #IConvertible>, ?Title, ?Name, ?Animate) = 
            GenericChart.Create("Columns", Name, XYSeq data).With(?Title=Title,?Animate=Animate) 

        static member Combine(charts:seq<GenericChart>) = 
            Seq.reduce (fun x y -> GenericChart.Combine(x,y)) charts


do Microsoft.FSharp.Compiler.Interactive.Settings.fsi.AddPrinter (fun (ch:DojoChart.ChartTypes.GenericChart) -> DojoChart.startRender ch; "(chart)")
   
open DojoChart

let dataA =  [1.0; 2.0; 0.5; 1.5; 1.0; 2.8; 0.4] |> Seq.index
let dataB =  [2.6; 1.8; 2.0; 1.0; 1.4; 0.7; 2.0] |> Seq.index
let dataC =  [6.3; 1.8; 3.0; 0.5; 4.4; 2.7; 2.0] |> Seq.index

let stackedDataA =  [1.0; 2.0; 0.5; 1.5; 1.0; 2.8; 0.4] 
let stackedDataB =  [2.6; 1.8; 2.0; 1.0; 1.4; 0.7; 2.0] 
let stackedDataC =  [6.3; 1.8; 3.0; 0.5; 4.4; 2.7; 2.0] 


Chart.Bar( dataA, Title= "Predicted Risk") 
Chart.Column( dataA, Title= "Predicted Volatility") 
Chart.Line( dataA ) 
Chart.Pie( dataA, Title= "The True Data 2") 
Chart.Point( dataA ) 

Chart.StackedArea( [ stackedDataA; stackedDataB; stackedDataC ] ) 
Chart.StackedBars( [ stackedDataA; stackedDataB; stackedDataC ] ) 
Chart.StackedColumns( [ stackedDataA; stackedDataB; stackedDataC ] ) 
Chart.StackedLines( [ stackedDataA; stackedDataB; stackedDataC ] ) 


Chart.StackedArea( [ [ for i in 0 .. 9 -> i*i] ] ) 
Chart.Line( dataA, Name="Prices" ) 
Chart.Line( dataA, Name="Prices", Animate=true ) 
Chart.Line( dataA, Animate=true ) 
Chart.Line( dataA, Title= "The True Data 0") 


Chart.Bar( dataA, Title= "The True Data 3") 
Chart.Column( dataA, Title= "The True Data 1") 
Chart.Line( dataA ) 
Chart.Pie( dataA, Title= "The True Data 2") 
Chart.Point( dataA ) 
let rnd = new System.Random()

Chart.Point( [ for i in 0 .. 1000 do 
                   let (x,y) = (rnd.NextDouble()*2.0 - 1.0, rnd.NextDouble()*2.0 - 1.0)
                   if x*x + y*y < 1.0 then 
                       yield (x,y) ] )

Chart.Line( [ for i in 0 .. 1000 do 
                   let (x,y) = (rnd.NextDouble()*2.0 - 1.0, rnd.NextDouble()*2.0 - 1.0)
                   if x*x + y*y < 1.0 then 
                       yield (x,y) ] )

Chart.Pie( [ for i in 0 .. 1000 do 
                   let (x,y) = (rnd.NextDouble()*2.0 - 1.0, rnd.NextDouble()*2.0 - 1.0)
                   if x*x + y*y < 1.0 then 
                       yield (x,y) ] )

Chart.StackedArea( [ [ for i in 0 .. 9 -> i*i] ] ) 
Chart.Line( dataA, Name="Prices" ) 
let c = Chart.Line( dataA, Name="Prices", Animate=true ) 

Chart.Line( dataA, Animate=true ) 
Chart.Line( dataA, Title= "Predicted Prices") 


Chart.StackedArea( [ stackedDataA; stackedDataB; stackedDataC ] ) 

Chart.Combine [ Chart.Point( dataA ) ; Chart.Point( dataB ) ]


Chart.StackedArea( [ stackedDataA; stackedDataB; stackedDataC ] ) 
Chart.StackedBars( [ stackedDataA; stackedDataB; stackedDataC ] ) 
Chart.StackedColumns( [ stackedDataA; stackedDataB; stackedDataC ] ) 
Chart.StackedLines( [ stackedDataA; stackedDataB; stackedDataC ] ) 

Chart.Combine [ Chart.Line( dataA ) ; Chart.Line( dataB ) ]
namespace System
namespace System.Reflection
val internal ass : Assembly

Full name: Script.Js.ass
type Assembly =
  member CodeBase : string
  member CreateInstance : typeName:string -> obj + 2 overloads
  member EntryPoint : MethodInfo
  member Equals : o:obj -> bool
  member EscapedCodeBase : string
  member Evidence : Evidence
  member FullName : string
  member GetCustomAttributes : inherit:bool -> obj[] + 1 overload
  member GetCustomAttributesData : unit -> IList<CustomAttributeData>
  member GetExportedTypes : unit -> Type[]
  ...

Full name: System.Reflection.Assembly
Assembly.Load(rawAssembly: byte []) : Assembly
Assembly.Load(assemblyRef: AssemblyName) : Assembly
Assembly.Load(assemblyString: string) : Assembly
Assembly.Load(rawAssembly: byte [], rawSymbolStore: byte []) : Assembly
Assembly.Load(rawAssembly: byte [], rawSymbolStore: byte [], securityContextSource: Security.SecurityContextSource) : Assembly
val internal ass2 : Assembly

Full name: Script.Js.ass2
val internal htmlPageTy : Type

Full name: Script.Js.htmlPageTy
Object.GetType() : Type
Assembly.GetType(name: string) : Type
Assembly.GetType(name: string, throwOnError: bool) : Type
Assembly.GetType(name: string, throwOnError: bool, ignoreCase: bool) : Type
val internal htmlElementTy : Type

Full name: Script.Js.htmlElementTy
val internal htmlWindowTy : Type

Full name: Script.Js.htmlWindowTy
val internal htmlPageWindow : PropertyInfo

Full name: Script.Js.htmlPageWindow
Type.GetProperty(name: string) : PropertyInfo
Type.GetProperty(name: string, returnType: Type) : PropertyInfo
Type.GetProperty(name: string, types: Type []) : PropertyInfo
Type.GetProperty(name: string, bindingAttr: BindingFlags) : PropertyInfo
Type.GetProperty(name: string, returnType: Type, types: Type []) : PropertyInfo
Type.GetProperty(name: string, returnType: Type, types: Type [], modifiers: ParameterModifier []) : PropertyInfo
Type.GetProperty(name: string, bindingAttr: BindingFlags, binder: Binder, returnType: Type, types: Type [], modifiers: ParameterModifier []) : PropertyInfo
val internal htmlWindowEval : MethodInfo

Full name: Script.Js.htmlWindowEval
Type.GetMethod(name: string) : MethodInfo
Type.GetMethod(name: string, bindingAttr: BindingFlags) : MethodInfo
Type.GetMethod(name: string, types: Type []) : MethodInfo
Type.GetMethod(name: string, types: Type [], modifiers: ParameterModifier []) : MethodInfo
Type.GetMethod(name: string, bindingAttr: BindingFlags, binder: Binder, types: Type [], modifiers: ParameterModifier []) : MethodInfo
Type.GetMethod(name: string, bindingAttr: BindingFlags, binder: Binder, callConvention: CallingConventions, types: Type [], modifiers: ParameterModifier []) : MethodInfo
val internal contInvoke : MethodInfo

Full name: Script.Js.contInvoke
val typeof<'T> : Type

Full name: Microsoft.FSharp.Core.Operators.typeof
type obj = Object

Full name: Microsoft.FSharp.Core.obj
type unit = Unit

Full name: Microsoft.FSharp.Core.unit
val internal deploymentTy : Type

Full name: Script.Js.deploymentTy
val internal deploymentCurrent : PropertyInfo

Full name: Script.Js.deploymentCurrent
val internal dispTy : Type

Full name: Script.Js.dispTy
val internal dispCheckAccess : MethodInfo

Full name: Script.Js.dispCheckAccess
val internal appDispatcher : PropertyInfo

Full name: Script.Js.appDispatcher
val internal dispBeginInvoke : MethodInfo

Full name: Script.Js.dispBeginInvoke
Type.GetMethods() : MethodInfo []
Type.GetMethods(bindingAttr: BindingFlags) : MethodInfo []
type Array =
  member Clone : unit -> obj
  member CopyTo : array:Array * index:int -> unit + 1 overload
  member GetEnumerator : unit -> IEnumerator
  member GetLength : dimension:int -> int
  member GetLongLength : dimension:int -> int64
  member GetLowerBound : dimension:int -> int
  member GetUpperBound : dimension:int -> int
  member GetValue : [<ParamArray>] indices:int[] -> obj + 7 overloads
  member Initialize : unit -> unit
  member IsFixedSize : bool
  ...

Full name: System.Array
val find : predicate:('T -> bool) -> array:'T [] -> 'T

Full name: Microsoft.FSharp.Collections.Array.find
val m : MethodInfo
property MemberInfo.Name: string
MethodBase.GetParameters() : ParameterInfo []
val uiasync : f:(unit -> 'T) -> Async<'T>

Full name: Script.Js.uiasync
val f : (unit -> 'T)
Multiple items
type Async
static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
static member AwaitTask : task:Task<'T> -> Async<'T>
static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool>
static member CancelDefaultToken : unit -> unit
static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
static member Ignore : computation:Async<'T> -> Async<unit>
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:CancellationToken -> 'T
static member Sleep : millisecondsDueTime:int -> Async<unit>
static member Start : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions * ?cancellationToken:CancellationToken -> Task<'T>
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions -> Async<Task<'T>>
static member StartImmediate : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:CancellationToken -> unit
static member SwitchToContext : syncContext:SynchronizationContext -> Async<unit>
static member SwitchToNewThread : unit -> Async<unit>
static member SwitchToThreadPool : unit -> Async<unit>
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
static member CancellationToken : Async<CancellationToken>
static member DefaultCancellationToken : CancellationToken

Full name: Microsoft.FSharp.Control.Async

--------------------
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>
val p : Async<obj>
static member Async.FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
val cont : (obj -> unit)
val econt : (exn -> unit)
val ccont : (OperationCanceledException -> unit)
val work : (unit -> unit)
val res : obj
val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box
MethodBase.Invoke(obj: obj, parameters: obj []) : obj
MethodBase.Invoke(obj: obj, invokeAttr: BindingFlags, binder: Binder, parameters: obj [], culture: Globalization.CultureInfo) : obj
val ignore : value:'T -> unit

Full name: Microsoft.FSharp.Core.Operators.ignore
val e : exn
val app : obj
PropertyInfo.GetValue(obj: obj, index: obj []) : obj
PropertyInfo.GetValue(obj: obj, invokeAttr: BindingFlags, binder: Binder, index: obj [], culture: Globalization.CultureInfo) : obj
val disp : obj
val ok : obj
type bool = Boolean

Full name: Microsoft.FSharp.Core.bool
val action : Action
Multiple items
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15,'T16> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 -> unit

Full name: System.Action<_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 -> unit

Full name: System.Action<_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 -> unit

Full name: System.Action<_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 -> unit

Full name: System.Action<_,_,_,_>

--------------------
type Action<'T1,'T2,'T3> =
  delegate of 'T1 * 'T2 * 'T3 -> unit

Full name: System.Action<_,_,_>

--------------------
type Action<'T1,'T2> =
  delegate of 'T1 * 'T2 -> unit

Full name: System.Action<_,_>

--------------------
type Action =
  delegate of unit -> unit

Full name: System.Action

--------------------
type Action<'T> =
  delegate of 'T -> unit

Full name: System.Action<_>
val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async
val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox
val uisync : f:(unit -> 'T) -> 'T

Full name: Script.Js.uisync
static member Async.RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:Threading.CancellationToken -> 'T
val jsasync : script:string -> Async<obj>

Full name: Script.Js.jsasync
val script : string
Multiple items
val string : value:'T -> string

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

--------------------
type string = String

Full name: Microsoft.FSharp.Core.string
val window : obj
val printfn : format:Printf.TextWriterFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.printfn
val raise : exn:Exception -> 'T

Full name: Microsoft.FSharp.Core.Operators.raise
val jsDoAsync : s:string -> Async<unit>

Full name: Script.Js.jsDoAsync
val s : string
static member Async.Ignore : computation:Async<'T> -> Async<unit>
val jssync : s:string -> obj

Full name: Script.Js.jssync
val jsvoid : s:string -> unit

Full name: Script.Js.jsvoid
val jsstart : s:string -> unit

Full name: Script.Js.jsstart
static member Async.Start : computation:Async<unit> * ?cancellationToken:Threading.CancellationToken -> unit
namespace System.Reflection.Emit
val asmB : AssemblyBuilder

Full name: Script.Js.asmB
type AppDomain =
  inherit MarshalByRefObject
  member ActivationContext : ActivationContext
  member AppendPrivatePath : path:string -> unit
  member ApplicationIdentity : ApplicationIdentity
  member ApplicationTrust : ApplicationTrust
  member ApplyPolicy : assemblyName:string -> string
  member BaseDirectory : string
  member ClearPrivatePath : unit -> unit
  member ClearShadowCopyPath : unit -> unit
  member CreateComInstanceFrom : assemblyName:string * typeName:string -> ObjectHandle + 1 overload
  member CreateInstance : assemblyName:string * typeName:string -> ObjectHandle + 3 overloads
  ...

Full name: System.AppDomain
property AppDomain.CurrentDomain: AppDomain
AppDomain.DefineDynamicAssembly(name: AssemblyName, access: AssemblyBuilderAccess) : AssemblyBuilder
AppDomain.DefineDynamicAssembly(name: AssemblyName, access: AssemblyBuilderAccess, dir: string) : AssemblyBuilder
AppDomain.DefineDynamicAssembly(name: AssemblyName, access: AssemblyBuilderAccess, assemblyAttributes: Collections.Generic.IEnumerable<CustomAttributeBuilder>) : AssemblyBuilder
AppDomain.DefineDynamicAssembly(name: AssemblyName, access: AssemblyBuilderAccess, assemblyAttributes: Collections.Generic.IEnumerable<CustomAttributeBuilder>, securityContextSource: Security.SecurityContextSource) : AssemblyBuilder
AppDomain.DefineDynamicAssembly(name: AssemblyName, access: AssemblyBuilderAccess, dir: string, isSynchronized: bool, assemblyAttributes: Collections.Generic.IEnumerable<CustomAttributeBuilder>) : AssemblyBuilder
Multiple items
type AssemblyName =
  new : unit -> AssemblyName + 1 overload
  member Clone : unit -> obj
  member CodeBase : string with get, set
  member CultureInfo : CultureInfo with get, set
  member EscapedCodeBase : string
  member Flags : AssemblyNameFlags with get, set
  member FullName : string
  member GetObjectData : info:SerializationInfo * context:StreamingContext -> unit
  member GetPublicKey : unit -> byte[]
  member GetPublicKeyToken : unit -> byte[]
  ...

Full name: System.Reflection.AssemblyName

--------------------
AssemblyName() : unit
AssemblyName(assemblyName: string) : unit
type AssemblyBuilderAccess =
  | Run = 1
  | Save = 2
  | RunAndSave = 3
  | ReflectionOnly = 6
  | RunAndCollect = 9

Full name: System.Reflection.Emit.AssemblyBuilderAccess
field AssemblyBuilderAccess.Run = 1
val modB : ModuleBuilder

Full name: Script.Js.modB
AssemblyBuilder.DefineDynamicModule(name: string) : ModuleBuilder
AssemblyBuilder.DefineDynamicModule(name: string, fileName: string) : ModuleBuilder
AssemblyBuilder.DefineDynamicModule(name: string, emitSymbolInfo: bool) : ModuleBuilder
AssemblyBuilder.DefineDynamicModule(name: string, fileName: string, emitSymbolInfo: bool) : ModuleBuilder
val tyB : TypeBuilder

Full name: Script.Js.tyB
ModuleBuilder.DefineType(name: string) : TypeBuilder
ModuleBuilder.DefineType(name: string, attr: TypeAttributes) : TypeBuilder
ModuleBuilder.DefineType(name: string, attr: TypeAttributes, parent: Type) : TypeBuilder
ModuleBuilder.DefineType(name: string, attr: TypeAttributes, parent: Type, packsize: PackingSize) : TypeBuilder
ModuleBuilder.DefineType(name: string, attr: TypeAttributes, parent: Type, interfaces: Type []) : TypeBuilder
ModuleBuilder.DefineType(name: string, attr: TypeAttributes, parent: Type, typesize: int) : TypeBuilder
ModuleBuilder.DefineType(name: string, attr: TypeAttributes, parent: Type, packingSize: PackingSize, typesize: int) : TypeBuilder
type TypeAttributes =
  | VisibilityMask = 7
  | NotPublic = 0
  | Public = 1
  | NestedPublic = 2
  | NestedPrivate = 3
  | NestedFamily = 4
  | NestedAssembly = 5
  | NestedFamANDAssem = 6
  | NestedFamORAssem = 7
  | LayoutMask = 24
  ...

Full name: System.Reflection.TypeAttributes
field TypeAttributes.Public = 1
val scriptableTypeTy : Type

Full name: Script.Js.scriptableTypeTy
val scriptableMemberTy : Type

Full name: Script.Js.scriptableMemberTy
TypeBuilder.SetCustomAttribute(customBuilder: CustomAttributeBuilder) : unit
TypeBuilder.SetCustomAttribute(con: ConstructorInfo, binaryAttribute: byte []) : unit
Multiple items
type CustomAttributeBuilder =
  new : con:ConstructorInfo * constructorArgs:obj[] -> CustomAttributeBuilder + 3 overloads

Full name: System.Reflection.Emit.CustomAttributeBuilder

--------------------
CustomAttributeBuilder(con: ConstructorInfo, constructorArgs: obj []) : unit
CustomAttributeBuilder(con: ConstructorInfo, constructorArgs: obj [], namedProperties: PropertyInfo [], propertyValues: obj []) : unit
CustomAttributeBuilder(con: ConstructorInfo, constructorArgs: obj [], namedFields: FieldInfo [], fieldValues: obj []) : unit
CustomAttributeBuilder(con: ConstructorInfo, constructorArgs: obj [], namedProperties: PropertyInfo [], propertyValues: obj [], namedFields: FieldInfo [], fieldValues: obj []) : unit
Type.GetConstructor(types: Type []) : ConstructorInfo
Type.GetConstructor(bindingAttr: BindingFlags, binder: Binder, types: Type [], modifiers: ParameterModifier []) : ConstructorInfo
Type.GetConstructor(bindingAttr: BindingFlags, binder: Binder, callConvention: CallingConventions, types: Type [], modifiers: ParameterModifier []) : ConstructorInfo
val fB : FieldBuilder

Full name: Script.Js.fB
TypeBuilder.DefineField(fieldName: string, type: Type, attributes: FieldAttributes) : FieldBuilder
TypeBuilder.DefineField(fieldName: string, type: Type, requiredCustomModifiers: Type [], optionalCustomModifiers: Type [], attributes: FieldAttributes) : FieldBuilder
Multiple items
type Action =
  delegate of unit -> unit

Full name: System.Action

--------------------
type Action<'T> =
  delegate of 'T -> unit

Full name: System.Action<_>

--------------------
type Action<'T1,'T2> =
  delegate of 'T1 * 'T2 -> unit

Full name: System.Action<_,_>

--------------------
type Action<'T1,'T2,'T3> =
  delegate of 'T1 * 'T2 * 'T3 -> unit

Full name: System.Action<_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 -> unit

Full name: System.Action<_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 -> unit

Full name: System.Action<_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 -> unit

Full name: System.Action<_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 -> unit

Full name: System.Action<_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Action<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15,'T16> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 -> unit

Full name: System.Action<_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_>
type FieldAttributes =
  | FieldAccessMask = 7
  | PrivateScope = 0
  | Private = 1
  | FamANDAssem = 2
  | Assembly = 3
  | Family = 4
  | FamORAssem = 5
  | Public = 6
  | Static = 16
  | InitOnly = 32
  ...

Full name: System.Reflection.FieldAttributes
field FieldAttributes.Private = 1
val cB : ConstructorBuilder

Full name: Script.Js.cB
TypeBuilder.DefineConstructor(attributes: MethodAttributes, callingConvention: CallingConventions, parameterTypes: Type []) : ConstructorBuilder
TypeBuilder.DefineConstructor(attributes: MethodAttributes, callingConvention: CallingConventions, parameterTypes: Type [], requiredCustomModifiers: Type [] [], optionalCustomModifiers: Type [] []) : ConstructorBuilder
type MethodAttributes =
  | MemberAccessMask = 7
  | PrivateScope = 0
  | Private = 1
  | FamANDAssem = 2
  | Assembly = 3
  | Family = 4
  | FamORAssem = 5
  | Public = 6
  | Static = 16
  | Final = 32
  ...

Full name: System.Reflection.MethodAttributes
field MethodAttributes.Public = 6
type CallingConventions =
  | Standard = 1
  | VarArgs = 2
  | Any = 3
  | HasThis = 32
  | ExplicitThis = 64

Full name: System.Reflection.CallingConventions
field CallingConventions.Standard = 1
val cIL : ILGenerator

Full name: Script.Js.cIL
ConstructorBuilder.GetILGenerator() : ILGenerator
ConstructorBuilder.GetILGenerator(streamSize: int) : ILGenerator
ILGenerator.Emit(opcode: OpCode) : unit
   (+0 other overloads)
ILGenerator.Emit(opcode: OpCode, local: LocalBuilder) : unit
   (+0 other overloads)
ILGenerator.Emit(opcode: OpCode, str: string) : unit
   (+0 other overloads)
ILGenerator.Emit(opcode: OpCode, field: FieldInfo) : unit
   (+0 other overloads)
ILGenerator.Emit(opcode: OpCode, labels: Label []) : unit
   (+0 other overloads)
ILGenerator.Emit(opcode: OpCode, label: Label) : unit
   (+0 other overloads)
ILGenerator.Emit(opcode: OpCode, arg: float) : unit
   (+0 other overloads)
ILGenerator.Emit(opcode: OpCode, arg: float32) : unit
   (+0 other overloads)
ILGenerator.Emit(opcode: OpCode, arg: int64) : unit
   (+0 other overloads)
ILGenerator.Emit(opcode: OpCode, cls: Type) : unit
   (+0 other overloads)
type OpCodes =
  static val Nop : OpCode
  static val Break : OpCode
  static val Ldarg_0 : OpCode
  static val Ldarg_1 : OpCode
  static val Ldarg_2 : OpCode
  static val Ldarg_3 : OpCode
  static val Ldloc_0 : OpCode
  static val Ldloc_1 : OpCode
  static val Ldloc_2 : OpCode
  static val Ldloc_3 : OpCode
  ...

Full name: System.Reflection.Emit.OpCodes
field OpCodes.Ldarg_0
field OpCodes.Call
field OpCodes.Ldarg_1
field OpCodes.Stfld
field OpCodes.Ret
val mB : MethodBuilder

Full name: Script.Js.mB
TypeBuilder.DefineMethod(name: string, attributes: MethodAttributes) : MethodBuilder
TypeBuilder.DefineMethod(name: string, attributes: MethodAttributes, callingConvention: CallingConventions) : MethodBuilder
TypeBuilder.DefineMethod(name: string, attributes: MethodAttributes, returnType: Type, parameterTypes: Type []) : MethodBuilder
TypeBuilder.DefineMethod(name: string, attributes: MethodAttributes, callingConvention: CallingConventions, returnType: Type, parameterTypes: Type []) : MethodBuilder
TypeBuilder.DefineMethod(name: string, attributes: MethodAttributes, callingConvention: CallingConventions, returnType: Type, returnTypeRequiredCustomModifiers: Type [], returnTypeOptionalCustomModifiers: Type [], parameterTypes: Type [], parameterTypeRequiredCustomModifiers: Type [] [], parameterTypeOptionalCustomModifiers: Type [] []) : MethodBuilder
type Void =

Full name: System.Void
MethodBuilder.SetCustomAttribute(customBuilder: CustomAttributeBuilder) : unit
MethodBuilder.SetCustomAttribute(con: ConstructorInfo, binaryAttribute: byte []) : unit
val mIL : ILGenerator

Full name: Script.Js.mIL
MethodBuilder.GetILGenerator() : ILGenerator
MethodBuilder.GetILGenerator(size: int) : ILGenerator
field OpCodes.Ldfld
field OpCodes.Ldarg_2
field OpCodes.Callvirt
val ty : Type

Full name: Script.Js.ty
TypeBuilder.CreateType() : Type
val plugin : obj
Type.InvokeMember(name: string, invokeAttr: BindingFlags, binder: Binder, target: obj, args: obj []) : obj
Type.InvokeMember(name: string, invokeAttr: BindingFlags, binder: Binder, target: obj, args: obj [], culture: Globalization.CultureInfo) : obj
Type.InvokeMember(name: string, invokeAttr: BindingFlags, binder: Binder, target: obj, args: obj [], modifiers: ParameterModifier [], culture: Globalization.CultureInfo, namedParameters: string []) : obj
type BindingFlags =
  | Default = 0
  | IgnoreCase = 1
  | DeclaredOnly = 2
  | Instance = 4
  | Static = 8
  | Public = 16
  | NonPublic = 32
  | FlattenHierarchy = 64
  | InvokeMethod = 256
  | CreateInstance = 512
  ...

Full name: System.Reflection.BindingFlags
field BindingFlags.GetProperty = 4096
val id : obj
field BindingFlags.InvokeMethod = 256
val silverlightId : string

Full name: Script.Js.silverlightId
val mutable stamp : int64

Full name: Script.Js.stamp
val nextStamp : unit -> string

Full name: Script.Js.nextStamp
val nextCallback : unit -> string

Full name: Script.Js.nextCallback
val requests : Collections.Generic.Dictionary<string,(obj -> unit)>

Full name: Script.Js.requests
namespace System.Collections
namespace System.Collections.Generic
Multiple items
type Dictionary<'TKey,'TValue> =
  new : unit -> Dictionary<'TKey, 'TValue> + 5 overloads
  member Add : key:'TKey * value:'TValue -> unit
  member Clear : unit -> unit
  member Comparer : IEqualityComparer<'TKey>
  member ContainsKey : key:'TKey -> bool
  member ContainsValue : value:'TValue -> bool
  member Count : int
  member GetEnumerator : unit -> Enumerator<'TKey, 'TValue>
  member GetObjectData : info:SerializationInfo * context:StreamingContext -> unit
  member Item : 'TKey -> 'TValue with get, set
  ...
  nested type Enumerator
  nested type KeyCollection
  nested type ValueCollection

Full name: System.Collections.Generic.Dictionary<_,_>

--------------------
Collections.Generic.Dictionary() : unit
Collections.Generic.Dictionary(capacity: int) : unit
Collections.Generic.Dictionary(comparer: Collections.Generic.IEqualityComparer<'TKey>) : unit
Collections.Generic.Dictionary(dictionary: Collections.Generic.IDictionary<'TKey,'TValue>) : unit
Collections.Generic.Dictionary(capacity: int, comparer: Collections.Generic.IEqualityComparer<'TKey>) : unit
Collections.Generic.Dictionary(dictionary: Collections.Generic.IDictionary<'TKey,'TValue>, comparer: Collections.Generic.IEqualityComparer<'TKey>) : unit
val invoke : tgt:string -> obj:obj -> unit

Full name: Script.Js.invoke
val tgt : string
Multiple items
val obj : obj

--------------------
type obj = Object

Full name: Microsoft.FSharp.Core.obj
val f : (obj -> unit)
Collections.Generic.Dictionary.Remove(key: string) : bool
val a : ConstructorInfo

Full name: Script.Js.a
Type.GetConstructors() : ConstructorInfo []
Type.GetConstructors(bindingAttr: BindingFlags) : ConstructorInfo []
val xobj : obj

Full name: Script.Js.xobj
ConstructorInfo.Invoke(parameters: obj []) : obj
MethodBase.Invoke(obj: obj, parameters: obj []) : obj
ConstructorInfo.Invoke(invokeAttr: BindingFlags, binder: Binder, parameters: obj [], culture: Globalization.CultureInfo) : obj
MethodBase.Invoke(obj: obj, invokeAttr: BindingFlags, binder: Binder, parameters: obj [], culture: Globalization.CultureInfo) : obj
val callback : f:('T -> unit) -> string

Full name: Script.Js.callback
val f : ('T -> unit)
val f2 : (obj -> unit)
val x : obj
val stamp : string
val callback0 : f:(unit -> unit) -> string

Full name: Script.Js.callback0
val f : (unit -> unit)
val convertible : x:IConvertible -> string

Full name: Script.Js.convertible
val x : IConvertible
type IConvertible =
  member GetTypeCode : unit -> TypeCode
  member ToBoolean : provider:IFormatProvider -> bool
  member ToByte : provider:IFormatProvider -> byte
  member ToChar : provider:IFormatProvider -> char
  member ToDateTime : provider:IFormatProvider -> DateTime
  member ToDecimal : provider:IFormatProvider -> decimal
  member ToDouble : provider:IFormatProvider -> float
  member ToInt16 : provider:IFormatProvider -> int16
  member ToInt32 : provider:IFormatProvider -> int
  member ToInt64 : provider:IFormatProvider -> int64
  ...

Full name: System.IConvertible
type Convert =
  static val DBNull : obj
  static member ChangeType : value:obj * typeCode:TypeCode -> obj + 3 overloads
  static member FromBase64CharArray : inArray:char[] * offset:int * length:int -> byte[]
  static member FromBase64String : s:string -> byte[]
  static member GetTypeCode : value:obj -> TypeCode
  static member IsDBNull : value:obj -> bool
  static member ToBase64CharArray : inArray:byte[] * offsetIn:int * length:int * outArray:char[] * offsetOut:int -> int + 1 overload
  static member ToBase64String : inArray:byte[] -> string + 3 overloads
  static member ToBoolean : value:obj -> bool + 17 overloads
  static member ToByte : value:obj -> byte + 18 overloads
  ...

Full name: System.Convert
Convert.ToString(value: string) : string
   (+0 other overloads)
Convert.ToString(value: DateTime) : string
   (+0 other overloads)
Convert.ToString(value: decimal) : string
   (+0 other overloads)
Convert.ToString(value: float) : string
   (+0 other overloads)
Convert.ToString(value: float32) : string
   (+0 other overloads)
Convert.ToString(value: uint64) : string
   (+0 other overloads)
Convert.ToString(value: int64) : string
   (+0 other overloads)
Convert.ToString(value: uint32) : string
   (+0 other overloads)
Convert.ToString(value: int) : string
   (+0 other overloads)
Convert.ToString(value: uint16) : string
   (+0 other overloads)
Multiple items
val seq : f:('a -> string) -> xs:seq<'a> -> string

Full name: Script.Js.seq

--------------------
type seq<'T> = Collections.Generic.IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>
val f : ('a -> string)
val xs : seq<'a>
Multiple items
type String =
  new : value:char -> string + 7 overloads
  member Chars : int -> char
  member Clone : unit -> obj
  member CompareTo : value:obj -> int + 1 overload
  member Contains : value:string -> bool
  member CopyTo : sourceIndex:int * destination:char[] * destinationIndex:int * count:int -> unit
  member EndsWith : value:string -> bool + 2 overloads
  member Equals : obj:obj -> bool + 2 overloads
  member GetEnumerator : unit -> CharEnumerator
  member GetHashCode : unit -> int
  ...

Full name: System.String

--------------------
String(value: nativeptr<char>) : unit
String(value: nativeptr<sbyte>) : unit
String(value: char []) : unit
String(c: char, count: int) : unit
String(value: nativeptr<char>, startIndex: int, length: int) : unit
String(value: nativeptr<sbyte>, startIndex: int, length: int) : unit
String(value: char [], startIndex: int, length: int) : unit
String(value: nativeptr<sbyte>, startIndex: int, length: int, enc: Text.Encoding) : unit
val concat : sep:string -> strings:seq<string> -> string

Full name: Microsoft.FSharp.Core.String.concat
module Seq

from Microsoft.FSharp.Collections
val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.map
val Once : p:Async<unit> -> Async<unit>

Full name: Script.Async.Once
val p : Async<unit>
val executed : bool ref
Multiple items
val ref : value:'T -> 'T ref

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

--------------------
type 'T ref = Ref<'T>

Full name: Microsoft.FSharp.Core.ref<_>
val not : value:bool -> bool

Full name: Microsoft.FSharp.Core.Operators.not
property Ref.Value: bool
val index : xs:seq<'a> -> seq<int * 'a>

Full name: Script.Seq.index
val mapi : mapping:(int -> 'T -> 'U) -> source:seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.mapi
val i : int
val x : 'a
type ChartData =
  | XYSeqData of seq<IConvertible * IConvertible>
  | XYSeqSeqData of seq<seq<IConvertible>>

Full name: Script.DojoChart.ChartTypes.ChartData
union case ChartData.XYSeqData: seq<IConvertible * IConvertible> -> ChartData
Multiple items
val seq : sequence:seq<'T> -> seq<'T>

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

--------------------
type seq<'T> = Collections.Generic.IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>
union case ChartData.XYSeqSeqData: seq<seq<IConvertible>> -> ChartData
val conv : x:IConvertible -> IConvertible

Full name: Script.DojoChart.ChartTypes.conv
val YSeqSeq : data:seq<#seq<'b>> -> ChartData (requires 'b :> IConvertible)

Full name: Script.DojoChart.ChartTypes.YSeqSeq
val data : seq<#seq<'b>> (requires 'b :> IConvertible)
Multiple items
module Seq

from Script

--------------------
module Seq

from Microsoft.FSharp.Collections
val y : #IConvertible
val XYSeq : data:seq<#IConvertible * #IConvertible> -> ChartData

Full name: Script.DojoChart.ChartTypes.XYSeq
val data : seq<#IConvertible * #IConvertible>
val x : #IConvertible
val a : 'a option
val b : 'a option
union case Option.None: Option<'T>
val getSeriesXY : plotName:string -> seriesName:string option -> d:seq<#IConvertible * #IConvertible> -> string

Full name: Script.DojoChart.ChartTypes.getSeriesXY
val plotName : string
val seriesName : string option
val d : seq<#IConvertible * #IConvertible>
val seriesName : string
val defaultArg : arg:'T option -> defaultValue:'T -> 'T

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

from Script
val seq : f:('a -> string) -> xs:seq<'a> -> string

Full name: Script.Js.seq
val getSeriesY : plotName:string -> seriesName:string option -> d:seq<#IConvertible> -> string

Full name: Script.DojoChart.ChartTypes.getSeriesY
val d : seq<#IConvertible>
val getData : plotName:string -> seriesName:string option -> d:ChartData -> string list

Full name: Script.DojoChart.ChartTypes.getData
val d : ChartData
val xs : seq<IConvertible * IConvertible>
val xss : seq<seq<IConvertible>>
val toList : source:seq<'T> -> 'T list

Full name: Microsoft.FSharp.Collections.Seq.toList
Multiple items
type Theme =
  internal new : name:string -> Theme
  member Name : string

Full name: Script.DojoChart.ChartTypes.Theme

--------------------
internal new : name:string -> Theme
val name : string
val x : Theme
member Theme.Name : string

Full name: Script.DojoChart.ChartTypes.Theme.Name
Multiple items
type GenericChart =
  internal new : series:(string * string option * ChartData) list * animate:bool option * title:string option * theme:Theme option -> GenericChart
  member internal RenderAsync : unit -> Async<unit>
  member internal With : ?Title:string * ?Animate:bool * ?SeriesName:string * ?Theme:Theme -> GenericChart
  member WithStyle : ?Theme:Theme -> GenericChart
  member private Animate : bool option
  member private Series : (string * string option * ChartData) list
  member private Theme : Theme option
  member private Title : string option
  static member internal Combine : ch1:GenericChart * ch2:GenericChart -> GenericChart
  static member internal Create : seriesKind:string * seriesName:string option * seriesData:ChartData -> GenericChart

Full name: Script.DojoChart.ChartTypes.GenericChart

--------------------
internal new : series:(string * string option * ChartData) list * animate:bool option * title:string option * theme:Theme option -> GenericChart
val series : (string * string option * ChartData) list
type 'T option = Option<'T>

Full name: Microsoft.FSharp.Core.option<_>
type 'T list = List<'T>

Full name: Microsoft.FSharp.Collections.list<_>
val animate : bool option
val title : string option
val theme : Theme option
static member internal GenericChart.Create : seriesKind:string * seriesName:string option * seriesData:ChartData -> GenericChart

Full name: Script.DojoChart.ChartTypes.GenericChart.Create
val seriesKind : string
val seriesData : ChartData
union case Option.Some: Value: 'T -> Option<'T>
member internal GenericChart.With : ?Title:string * ?Animate:bool * ?SeriesName:string * ?Theme:Theme -> GenericChart

Full name: Script.DojoChart.ChartTypes.GenericChart.With
val Title : string option
val Animate : bool option
val SeriesName : string option
Multiple items
val Theme : Theme option

--------------------
type Theme =
  internal new : name:string -> Theme
  member Name : string

Full name: Script.DojoChart.ChartTypes.Theme

--------------------
internal new : name:string -> Theme
Multiple items
module List

from Microsoft.FSharp.Collections

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

Full name: Microsoft.FSharp.Collections.List<_>
val map : mapping:('T -> 'U) -> list:'T list -> 'U list

Full name: Microsoft.FSharp.Collections.List.map
val kind : string
val data : ChartData
val __ : GenericChart
member private GenericChart.Series : (string * string option * ChartData) list

Full name: Script.DojoChart.ChartTypes.GenericChart.Series
member private GenericChart.Animate : bool option

Full name: Script.DojoChart.ChartTypes.GenericChart.Animate
member private GenericChart.Title : string option

Full name: Script.DojoChart.ChartTypes.GenericChart.Title
Multiple items
member private GenericChart.Theme : Theme option

Full name: Script.DojoChart.ChartTypes.GenericChart.Theme

--------------------
type Theme =
  internal new : name:string -> Theme
  member Name : string

Full name: Script.DojoChart.ChartTypes.Theme

--------------------
internal new : name:string -> Theme
static member internal GenericChart.Combine : ch1:GenericChart * ch2:GenericChart -> GenericChart

Full name: Script.DojoChart.ChartTypes.GenericChart.Combine
val ch1 : GenericChart
val ch2 : GenericChart
property GenericChart.Series: (string * string option * ChartData) list
property GenericChart.Animate: bool option
property GenericChart.Title: string option
property GenericChart.Theme: Theme option
val ch : GenericChart
member GenericChart.WithStyle : ?Theme:Theme -> GenericChart

Full name: Script.DojoChart.ChartTypes.GenericChart.WithStyle
member internal GenericChart.With : ?Title:string * ?Animate:bool * ?SeriesName:string * ?Theme:Theme -> GenericChart
member internal GenericChart.RenderAsync : unit -> Async<unit>

Full name: Script.DojoChart.ChartTypes.GenericChart.RenderAsync
module Option

from Microsoft.FSharp.Core
val toList : option:'T option -> 'T list

Full name: Microsoft.FSharp.Core.Option.toList
val map : mapping:('T -> 'U) -> option:'T option -> 'U option

Full name: Microsoft.FSharp.Core.Option.map
val s : Theme
property Theme.Name: string
val plotArgs : string
module ChartTypes

from Script.DojoChart
val initAsync : Async<unit>

Full name: Script.DojoChart.initAsync
Multiple items
module Async

from Script

--------------------
type Async
static member AsBeginEnd : computation:('Arg -> Async<'T>) -> ('Arg * AsyncCallback * obj -> IAsyncResult) * (IAsyncResult -> 'T) * (IAsyncResult -> unit)
static member AwaitEvent : event:IEvent<'Del,'T> * ?cancelAction:(unit -> unit) -> Async<'T> (requires delegate and 'Del :> Delegate)
static member AwaitIAsyncResult : iar:IAsyncResult * ?millisecondsTimeout:int -> Async<bool>
static member AwaitTask : task:Task<'T> -> Async<'T>
static member AwaitWaitHandle : waitHandle:WaitHandle * ?millisecondsTimeout:int -> Async<bool>
static member CancelDefaultToken : unit -> unit
static member Catch : computation:Async<'T> -> Async<Choice<'T,exn>>
static member FromBeginEnd : beginAction:(AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg:'Arg1 * beginAction:('Arg1 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * beginAction:('Arg1 * 'Arg2 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromBeginEnd : arg1:'Arg1 * arg2:'Arg2 * arg3:'Arg3 * beginAction:('Arg1 * 'Arg2 * 'Arg3 * AsyncCallback * obj -> IAsyncResult) * endAction:(IAsyncResult -> 'T) * ?cancelAction:(unit -> unit) -> Async<'T>
static member FromContinuations : callback:(('T -> unit) * (exn -> unit) * (OperationCanceledException -> unit) -> unit) -> Async<'T>
static member Ignore : computation:Async<'T> -> Async<unit>
static member OnCancel : interruption:(unit -> unit) -> Async<IDisposable>
static member Parallel : computations:seq<Async<'T>> -> Async<'T []>
static member RunSynchronously : computation:Async<'T> * ?timeout:int * ?cancellationToken:CancellationToken -> 'T
static member Sleep : millisecondsDueTime:int -> Async<unit>
static member Start : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions * ?cancellationToken:CancellationToken -> Task<'T>
static member StartChild : computation:Async<'T> * ?millisecondsTimeout:int -> Async<Async<'T>>
static member StartChildAsTask : computation:Async<'T> * ?taskCreationOptions:TaskCreationOptions -> Async<Task<'T>>
static member StartImmediate : computation:Async<unit> * ?cancellationToken:CancellationToken -> unit
static member StartWithContinuations : computation:Async<'T> * continuation:('T -> unit) * exceptionContinuation:(exn -> unit) * cancellationContinuation:(OperationCanceledException -> unit) * ?cancellationToken:CancellationToken -> unit
static member SwitchToContext : syncContext:SynchronizationContext -> Async<unit>
static member SwitchToNewThread : unit -> Async<unit>
static member SwitchToThreadPool : unit -> Async<unit>
static member TryCancelled : computation:Async<'T> * compensation:(OperationCanceledException -> unit) -> Async<'T>
static member CancellationToken : Async<CancellationToken>
static member DefaultCancellationToken : CancellationToken

Full name: Microsoft.FSharp.Control.Async

--------------------
type Async<'T>

Full name: Microsoft.FSharp.Control.Async<_>
val cont : (unit -> unit)
val startRender : ch:GenericChart -> unit

Full name: Script.DojoChart.startRender
member internal GenericChart.RenderAsync : unit -> Async<unit>
Multiple items
type Chart =
  new : unit -> Chart
  static member Bar : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart
  static member Column : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart
  static member Combine : charts:seq<GenericChart> -> GenericChart
  static member Line : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart
  static member Pie : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart
  static member Point : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart
  static member StackedArea : data:seq<#seq<'r>> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart (requires 'r :> IConvertible)
  static member StackedBars : data:seq<#seq<'n>> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart (requires 'n :> IConvertible)
  static member StackedColumns : data:seq<#seq<'l>> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart (requires 'l :> IConvertible)
  ...

Full name: Script.DojoChart.Chart

--------------------
new : unit -> Chart
static member Chart.StackedArea : data:seq<#seq<'r>> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart (requires 'r :> IConvertible)

Full name: Script.DojoChart.Chart.StackedArea
val data : seq<#seq<'r>> (requires 'r :> IConvertible)
val Name : string option
static member internal GenericChart.Create : seriesKind:string * seriesName:string option * seriesData:ChartData -> GenericChart
static member Chart.StackedLines : data:seq<#seq<'p>> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart (requires 'p :> IConvertible)

Full name: Script.DojoChart.Chart.StackedLines
val data : seq<#seq<'p>> (requires 'p :> IConvertible)
static member Chart.StackedBars : data:seq<#seq<'n>> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart (requires 'n :> IConvertible)

Full name: Script.DojoChart.Chart.StackedBars
val data : seq<#seq<'n>> (requires 'n :> IConvertible)
static member Chart.StackedColumns : data:seq<#seq<'l>> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart (requires 'l :> IConvertible)

Full name: Script.DojoChart.Chart.StackedColumns
val data : seq<#seq<'l>> (requires 'l :> IConvertible)
static member Chart.Line : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart

Full name: Script.DojoChart.Chart.Line
static member Chart.Point : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart

Full name: Script.DojoChart.Chart.Point
static member Chart.Pie : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart

Full name: Script.DojoChart.Chart.Pie
static member Chart.Bar : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart

Full name: Script.DojoChart.Chart.Bar
static member Chart.Column : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> GenericChart

Full name: Script.DojoChart.Chart.Column
static member Chart.Combine : charts:seq<GenericChart> -> GenericChart

Full name: Script.DojoChart.Chart.Combine
val charts : seq<GenericChart>
val reduce : reduction:('T -> 'T -> 'T) -> source:seq<'T> -> 'T

Full name: Microsoft.FSharp.Collections.Seq.reduce
val x : GenericChart
val y : GenericChart
static member internal GenericChart.Combine : ch1:GenericChart * ch2:GenericChart -> GenericChart
namespace Microsoft
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Compiler
namespace Microsoft.FSharp.Compiler.Interactive
module Settings

from Microsoft.FSharp.Compiler.Interactive
val fsi : Compiler.Interactive.InteractiveSession

Full name: Microsoft.FSharp.Compiler.Interactive.Settings.fsi
val ch : DojoChart.ChartTypes.GenericChart
module DojoChart

from Script
Multiple items
type GenericChart =
  internal new : series:(string * string option * ChartData) list * animate:bool option * title:string option * theme:Theme option -> GenericChart
  member internal RenderAsync : unit -> Async<unit>
  member internal With : ?Title:string * ?Animate:bool * ?SeriesName:string * ?Theme:Theme -> GenericChart
  member WithStyle : ?Theme:Theme -> GenericChart
  member private Animate : bool option
  member private Series : (string * string option * ChartData) list
  member private Theme : Theme option
  member private Title : string option
  static member internal Combine : ch1:GenericChart * ch2:GenericChart -> GenericChart
  static member internal Create : seriesKind:string * seriesName:string option * seriesData:ChartData -> GenericChart

Full name: Script.DojoChart.ChartTypes.GenericChart

--------------------
internal new : series:(string * string option * DojoChart.ChartTypes.ChartData) list * animate:bool option * title:string option * theme:DojoChart.ChartTypes.Theme option -> DojoChart.ChartTypes.GenericChart
val startRender : ch:DojoChart.ChartTypes.GenericChart -> unit

Full name: Script.DojoChart.startRender
val dataA : seq<int * float>

Full name: Script.dataA
val dataB : seq<int * float>

Full name: Script.dataB
val dataC : seq<int * float>

Full name: Script.dataC
val stackedDataA : float list

Full name: Script.stackedDataA
val stackedDataB : float list

Full name: Script.stackedDataB
val stackedDataC : float list

Full name: Script.stackedDataC
static member Chart.Bar : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> ChartTypes.GenericChart
static member Chart.Column : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> ChartTypes.GenericChart
static member Chart.Line : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> ChartTypes.GenericChart
static member Chart.Pie : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> ChartTypes.GenericChart
static member Chart.Point : data:seq<#IConvertible * #IConvertible> * ?Title:string * ?Name:string * ?Animate:bool -> ChartTypes.GenericChart
static member Chart.StackedArea : data:seq<#seq<'r>> * ?Title:string * ?Name:string * ?Animate:bool -> ChartTypes.GenericChart (requires 'r :> IConvertible)
static member Chart.StackedBars : data:seq<#seq<'n>> * ?Title:string * ?Name:string * ?Animate:bool -> ChartTypes.GenericChart (requires 'n :> IConvertible)
static member Chart.StackedColumns : data:seq<#seq<'l>> * ?Title:string * ?Name:string * ?Animate:bool -> ChartTypes.GenericChart (requires 'l :> IConvertible)
static member Chart.StackedLines : data:seq<#seq<'p>> * ?Title:string * ?Name:string * ?Animate:bool -> ChartTypes.GenericChart (requires 'p :> IConvertible)
val rnd : Random

Full name: Script.rnd
Multiple items
type Random =
  new : unit -> Random + 1 overload
  member Next : unit -> int + 2 overloads
  member NextBytes : buffer:byte[] -> unit
  member NextDouble : unit -> float

Full name: System.Random

--------------------
Random() : unit
Random(Seed: int) : unit
val x : float
val y : float
Random.NextDouble() : float
val c : ChartTypes.GenericChart

Full name: Script.c
static member Chart.Combine : charts:seq<ChartTypes.GenericChart> -> ChartTypes.GenericChart
Raw view Test code New version

More information

Link:http://fssnip.net/c3
Posted:14 years ago
Author:
Tags:

This web site is created using F# and Suave web server. It is hosted on Azure and the source code is on GitHub. Contributions are welcome!

The first version of fssnip.net has been created by @tomaspetricek back in 2010. This web site is a new, open-source and contribution-friendly version.