24 |
32 |
56 |
25 |
29 |
31 | @Properties["project-name"]
30 |32 |
33 |
55 |
34 | @RenderBody()
35 |
36 |
37 | 
38 |
53 |
54 |
38 |
53 | 
57 |
58 |
59 |
--------------------------------------------------------------------------------
/src/Freckle/Helpers.fs:
--------------------------------------------------------------------------------
1 | ///A helper module used for the library, use at your own discrestion
2 | module FSharp.Helpers
3 |
4 | let inline undefined<'a> : 'a = failwith "undefined"
5 |
6 | let inline swap (a,b) = (b,a)
7 |
8 | let inline flip f a b = f b a
9 |
10 | let inline const' k = fun _ -> k
11 |
12 |
13 | let safeUnbox (o : obj) =
14 | match o with
15 | | :? 'a as a -> Some a
16 | | _ -> None
17 |
18 | let tuple fst snd = (fst, snd)
19 |
20 |
21 | type SortedType(t) =
22 | member x.Type : System.Type = t
23 | override x.Equals(yobj) =
24 | match yobj with
25 | | :? SortedType as y -> (x.Type = y.Type)
26 | | _ -> false
27 | override x.GetHashCode() = hash x.Type
28 | interface System.IComparable with
29 | member x.CompareTo yobj =
30 | match yobj with
31 | | :? SortedType as y -> compare (hash x.Type) (hash y.Type)
32 | | _ -> invalidArg "yobj" "cannot compare values of different types"
33 | module AutoResetEvent =
34 | open System.Threading
35 |
36 | let wait (a : AutoResetEvent) = a.WaitOne() |> ignore
37 |
38 | let release (a : AutoResetEvent) = a.Set() |> ignore
39 |
40 | module Async =
41 | open System.Threading
42 | open System.Threading.Tasks
43 |
44 | let (>>=) ma f = async.Bind(ma, f)
45 | let ( *>>) ma mb = async.Bind(ma, (fun _ -> mb))
46 |
47 | let startFreeChild a =
48 | a
49 | |> Async.StartChild
50 | |> Async.Ignore
51 |
52 | let doNothing = async.Zero()
53 |
54 | type Signal<'a> = Continue of 'a
55 | | Completed of 'a
56 |
57 | let recursion (f : 's -> Async
20 |
21 |
29 |
30 | *)
31 |
32 | (**
33 |
34 | Quick Introduction
35 | -----------------------
36 |
37 | ### Namespace and referecing
38 |
39 | *)
40 | open Freckle
41 |
42 | (**
43 | ### Setting up a sampler and running
44 | Create a sampler that prints the timespan it samples over
45 | *)
46 |
47 | let sampler count =
48 | sample {
49 | let! currentSpan = Sample.period
50 | let startedAt = (Time.toDateTime currentSpan.Beginning)
51 | let endedAt = (Time.toDateTime currentSpan.Finish)
52 | printfn "%d: Sampling %A -> %A" count startedAt endedAt
53 | return count + 1
54 | } |> SampleAsync.ofSample
55 |
56 | Sample.sampleForever Clock.systemUtc sampler 0
57 | |> Async.RunSynchronously
58 |
59 |
60 | (**
61 | ### Guaranteed Fixed interval updates
62 | Create a sampler that counts every second from 0 and is resistentent to computer lagspike
63 | *)
64 |
65 | let countSecondsSampler count =
66 | sample {
67 | let! pulses = Feed.pulse 1
68 | return! Feed.foldPast (fun c _ -> c + 1) count pulses
69 | } |> SampleAsync.ofSample
70 |
71 | Sample.sampleForever Clock.systemUtc countSecondsSampler 0
72 | |> Async.RunSynchronously
73 |
74 | (**
75 | ### Best attempt Fixed interval updates
76 | Creates a sampler that does something every second, but doesn't care if a step is skipped due to a lagspike
77 | *)
78 | let render =
79 | async {
80 | return printfn "Pretend like this is graphic rendering"
81 | }
82 |
83 | let renderingSampler () =
84 | sample {
85 | let! pulses = Feed.pulseUpto 1 //Notice it's pulseUpto
86 | return! Feed.transition (fun _ _ -> render) () pulses
87 | }
88 |
89 | Sample.sampleForever Clock.systemUtc renderingSampler ()
90 | |> Async.RunSynchronously
91 |
92 |
93 | (**
94 | ### Listening to events
95 | Listen to external events and print their content to the console
96 |
97 | *)
98 |
99 | async {
100 | let syncClock = Clock.synchronized Clock.systemUtc
101 | let! mb = Mailbox.createWithExpiration (Expire.After (Time.ofSeconds 30)) syncClock
102 |
103 | let renderingSampler mb () =
104 | sampleAsync {
105 | let! events = Mailbox.read mb |> SampleAsync.ofAsync
106 | do! Mailbox.clear |> SampleAsync.ofAsync
107 | return! Feed.foldPast (fun _ msg -> printfn "revieved %s" msg) () events
108 | |> SampleAsync.ofSample
109 | }
110 |
111 | do! Sample.sampleForever syncClock (renderingSampler mb) ()
112 | }
113 | |> Async.RunSynchronously
114 |
115 | (**
116 |
117 | Further Reading
118 | ---------------
119 |
120 | * [Tutorial](tutorial.html) contains a further explanation of this sample library.
121 |
122 | * [API Reference](reference/index.html) contains automatically generated documentation for all types, modules
123 | and functions in the library. This includes additional brief samples on using most of the
124 | functions.
125 |
126 | Contributing and copyright
127 | --------------------------
128 |
129 | The project is hosted on [GitHub][gh] where you can [report issues][issues], fork
130 | the project and submit pull requests. If you're adding a new public API, please also
131 | consider adding [samples][content] that can be turned into a documentation. You might
132 | also want to read the [library design notes][readme] to understand how it works.
133 |
134 | The library is available under Public Domain license, which allows modification and
135 | redistribution for both commercial and non-commercial purposes. For more information see the
136 | [License file][license] in the GitHub repository.
137 |
138 | [content]: https://github.com/fsprojects/Freckle/tree/master/docs/content
139 | [gh]: https://github.com/fsprojects/Freckle
140 | [issues]: https://github.com/fsprojects/Freckle/issues
141 | [readme]: https://github.com/fsprojects/Freckle/blob/master/README.md
142 | [license]: https://github.com/fsprojects/Freckle/blob/master/LICENSE.txt
143 | *)
144 |
--------------------------------------------------------------------------------
/examples/AirlockStatemachine/FrpAirlockExample.fs:
--------------------------------------------------------------------------------
1 | module FrpAirlockExample
2 | open FSharp
3 | open System
4 | open FSharp.Helpers
5 | open Freckle
6 |
7 |
8 | type Door = InnerDoor
9 | | OuterDoor
10 |
11 | type DoorStatus = Opened
12 | | Closed
13 |
14 | type AirLockEvent = PressButton
15 | | DoublePressButton
16 | | DoorOpened of Door
17 | | DoorClosed of Door
18 | | Pressurized
19 | | Depressurized
20 |
21 | type AirLockState =
22 | | Pressurizing
23 | | Depressurizing
24 | | IsPressurized
25 | | IsDepressurized
26 |
27 | type Airlock =
28 | { Open : Door -> Async
22 |
27 |
28 |
23 | The Freckle library can be installed from NuGet:
24 |
26 | PM> Install-Package Freckle25 |