Shulou(Shulou.com)06/02 Report--

Today, Xiaobian will share with you the relevant knowledge points on how to realize F#and FRP. The content is detailed and the logic is clear. I believe most people still know too much about this knowledge, so share this article for your reference. I hope you will gain something after reading this article. Let's find out together.

This is a more elegant event-based approach, suitable for things like interactive animation and automation. Even if it's not common, I think it's appropriate as a "try" or "practice."

I learned about events as objects and FRPs through F#, and Microsoft's Matthew Podwysocki has been blogging a lot about F#events. F#directly embodies the concept of "events as objects", which converts events in the. NET class library into IEvent objects, which can then be programmed. The IEvent object is the standard F#type for "event," and its most critical member is the Add method, which, if represented in C#, is:

public interface IEvent { void Add(Action callback); }

Of course, F#'s incident is not that simple, but we only need to pay attention to it for now (for more detailed information, you can follow Matthew's article or Anders Cui's Chinese version). The Add method adds a callback function to the event, which is naturally called when the event is triggered. The parameter passed in, you can think of as the EventArgs object of the event in C#(that is, the second parameter). With IEvent objects, there are various ways to respond to an event in F#. For example:

#light open System open System.Windows.Forms let form = new Form(Visible = true, TopMost = true, Text = form.MouseDown |> Event.map (fun args -> (args.X, args.Y)) |> Event.filter (fun (x, y) -> x > 100 && y > 100) |> Event.listen (fun (x, y) -> printfn "(%d, %d)" x y)

The Event.map method takes an IEvent object, a higher-order function to convert event parameters, and returns a new event object. Users can listen for this new event. When the original event is triggered, its event parameters are converted into new objects by higher-order functions, and new events are started from them. F#can be used|> symbol to change the order in which parameters are passed so that code can be written more smoothly. For example, the following two lines of F#code are equivalent:

Console.WriteLine "Hello World" "Hello World" |> Console.WriteLine

Event.filter filters events. Only when the original event is triggered and its event parameters meet a certain condition will a new event object be triggered. Event.listen is a simple call to the Add method of the IEvent object, which is just an auxiliary function.

F#'s Event module has other methods, such as:

let form = new Form(Visible = true, TopMost = true, Text = "Event Sample") form.MouseDown |> Event.choose (fun args -> if args.X > 100 && args.Y > 100 then Some(args.X, args.Y) else None) |> Event.listen (fun (x, y) -> printfn "(%d, %d)" x y)

The Event.choose method combines Event.filter and Event.map, i.e. filtering is possible while converting. Args is fired as an argument to the next event only if the high-level function returns Some(args) instead of None. Also:

let form = new Form(Visible = true, TopMost = true, Text = "Event Sample") form.MouseDown |> Event.merge form.MouseMove |> Event.filter (fun args -> args.Button = MouseButtons.Left) |> Event.map (fun args -> (args.X, args.Y)) |> Event.listen (fun (x, y) -> printfn "(%d, %d)" x y)

The Event.merge method merges two events (with the same parameters). When any of these events are triggered, a new event object is triggered. In addition:

let form = new Form(Visible = true, TopMost = true, Text = "Event Sample") let (overEvent, underEvent) = form.MouseMove |> Event.merge form.MouseDown |> Event.filter (fun args -> args.Button = MouseButtons.Left) |> Event.map (fun args -> (args.X, args.Y)) |> Event.partition (fun (x, y) -> x > 100 && y > 100) overEvent |> Event.listen (fun (x, y) -> printfn "Over (%d, %d)" x y) underEvent |> Event.listen (fun (x, y) -> printfn "Under (%d, %d)" x y)

The Event.partition method splits the original event into two, and determines which new event to trigger based on the return value of the higher-order function when the original event is triggered.

These are all things Matthew has already covered in his blog. However, I think there are two other methods worth mentioning under the Event module, namely Event.pairwise and Event.scan. Please see the following code:

let (trigger : (int -> unit), event) = Event.create() event |> Event.pairwise |> Event.listen (fun (x, y) -> printfn "%d + %d = %d" x y (x + y)) [1.. 10] |> Seq.iter trigger //trigger is called using 1 through 10

The Event.create method creates an event object and returns the event and its trigger. Event.pairwise returns an IEvent object based on the IEvent object--(T, T) is a tuple, but if this language feature is not present in C#, we can use IEvent instead. When we use the trigger method *** times to trigger an event, the new event object does not fire. It is not until the second and subsequent event triggers that the parameters of the previous event are "merged" with the current event parameters to trigger a new event. Therefore, the code above outputs the following:

1 + 2 = 3 2 + 3 = 5 3 + 4 = 7 4 + 5 = 9 5 + 6 = 11 6 + 7 = 13 7 + 8 = 15 8 + 9 = 17 9 + 10 = 19

The Event.scan method can be used as follows:

let (trigger : (int -> unit), event) = Event.create() event |> Event.scan (fun acc i -> acc + i) 0 |> Event.listen (printfn "%d") [1.. 10] |> Seq.iter trigger

The Event.scan method maintains an accumulator (acc), which is initialized to 0 in the code above. Each time an event is triggered, it calculates the event parameters into the current accumulator to get a new value through a higher-order function, and triggers a new event based on the new value. So the code above prints the following (excluding comments):

1 // +1 3 // +2 6 // +3 10 // ... 15 21 28 36 45 55

Naturally, the new objects obtained by Event.pairwise and Event.scan methods have side effects and need to be considered thread-safe. F#libraries do not guarantee thread safety when events are triggered, so events need to be controlled when they are used or triggered.

OK, so this is fun programming. Can you design and implement a class library that provides a similar feature for C#? You need to perform the following 7 functions:

◆map

◆filter

◆choose

◆merge

◆partition

◆pairware

◆scan

Some of you may be wondering, why not just use C#to invoke F#'s libraries? The reason is "inappropriate." F#'s class library design follows F#'s language features, and as mentioned earlier, F#itself makes some changes to. NET events. Furthermore, implementing a suitable API for C#is a good practice. For example, this is again a good scenario for extending method features. In my opinion, *** API should be used like this:

someEvent .Map(args => new { args.X, args.Y }) .Filter(args => args.X + args.Y > 100) .Scan(0, (acc, args) => acc + args.X, args.Y) .Add(args => Console.WriteLine(args)); That's all for "F#and FRP how to achieve". Thanks for reading! I believe everyone has a great harvest after reading this article. Xiaobian will update different knowledge for everyone every day. If you want to learn more knowledge, please pay attention to the industry information channel.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.