Abstraction for Web Client Server

 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: 

// server

    let testFile<'entity> 
        (testFn: string -> 'entity) (filename: string) 
        : Result<'entity, string> =
        try
            testFn filename
            |> Ok
        with
        | exc ->
            Error exc.Message
    
    let showFn 
        (getValidData: string ->  'a[]) 
        (showLine: 'a -> 'entity)
        (filename: string) 
        : 'entity[] =
        getValidData filename
        |> Array.map showLine

// client

    let showExtractAbstract<'extract, 'test> 
        (globalTest: 'extract[] -> 'test)
        (showHeader: 'test -> Doc)
        (showEntity: 'test -> 'extract -> Doc)
        (extract: Result<'extract[], string>)
        : Doc = 
        match extract with
        | Ok lines 
            when (lines |> Array.length) = 0  -> 
            Doc.Empty
        | Ok lines -> 
            let anyNotice =
                globalTest lines
            table [] [
                thead [] [
                    showHeader anyNotice
                ]
                tbody [] [
                    lines
                    |> Array.map 
                        (showEntity anyNotice)
                    |> Doc.Concat
                ]
            ]
        | Error error ->
            p [] [text <| "Error: " + error]

    let reactiveButton 
        (reactiveFn: unit -> Async<'entity>) (showVar: 'entity -> Doc) 
        (initial: 'entity) (label:string) (descr:string) 
        : Doc =
        let reactVar = Var.Create initial
        div [] [
            p [] [
                Doc.Button 
                    label [attr.``class``"btn btn-info"] (fun () ->
                        async {
                            let! test = reactiveFn()
                            reactVar.Set test
                        } |> Async.StartImmediate)
                text <| " " + descr + " "]
            Doc.BindView 
                showVar
                reactVar.View
        ]

val testFile : testFn:(string -> 'entity) -> filename:string -> obj

Full name: Script.testFile

val testFn : (string -> 'entity)

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

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

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

Full name: Microsoft.FSharp.Core.string

val filename : string

val exc : exn

property System.Exception.Message: string

val showFn : getValidData:(string -> 'a []) -> showLine:('a -> 'entity) -> filename:string -> 'entity []

Full name: Script.showFn

val getValidData : (string -> 'a [])

val showLine : ('a -> 'entity)

module Array

from Microsoft.FSharp.Collections

val map : mapping:('T -> 'U) -> array:'T [] -> 'U []

Full name: Microsoft.FSharp.Collections.Array.map

val showExtractAbstract : globalTest:('extract [] -> 'test) -> showHeader:('test -> obj) -> showEntity:('test -> 'extract -> obj) -> extract:obj -> obj

Full name: Script.showExtractAbstract

val globalTest : ('extract [] -> 'test)

val showHeader : ('test -> obj)

val showEntity : ('test -> 'extract -> obj)

val extract : obj

val length : array:'T [] -> int

Full name: Microsoft.FSharp.Collections.Array.length

val reactiveButton : reactiveFn:(unit -> Async<'entity>) -> showVar:('entity -> 'a) -> initial:'entity -> label:string -> descr:string -> 'b

Full name: Script.reactiveButton

val reactiveFn : (unit -> Async<'entity>)

type unit = Unit

Full name: Microsoft.FSharp.Core.unit

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 -> Async<unit>
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 showVar : ('entity -> 'a)

val initial : 'entity

val label : string

val descr : string

val reactVar : obj

val async : AsyncBuilder

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.async

Multiple items
module Set

from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> =
  interface IComparable
  interface IEnumerable
  interface IEnumerable<'T>
  interface ICollection<'T>
  new : elements:seq<'T> -> Set<'T>
  member Add : value:'T -> Set<'T>
  member Contains : value:'T -> bool
  override Equals : obj -> bool
  member IsProperSubsetOf : otherSet:Set<'T> -> bool
  member IsProperSupersetOf : otherSet:Set<'T> -> bool
  ...

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

--------------------
new : elements:seq<'T> -> Set<'T>

static member Async.StartImmediate : computation:Async<unit> * ?cancellationToken:System.Threading.CancellationToken -> unit