exercism | Exercism - FP languages Exercises | Functional Programming library

Whether the method should return () or Self depends on whether you want the method to mutate the value it is called on (like +=) or leave that value alone and return a new value (like +).

Since this is a shallow type (it's a single i32 with no heap-allocated data) it makes more sense to have such a method return a new value and leave the original alone, in which case you can take &self instead of &mut self.

In fact, I'd suggest adding Copy and Clone to the derive macro for Clock and then this method can become a consuming method (taking self as a value instead of a reference):

To answer the specific question - how to use the predicate in the body - let's say that we want to do something much simpler. We want to write a function that takes a predicate pred and a value v and it just returns "OK" if the predicate holds for the given value and "Nope" if it does not.

To do this, you would write:

Your problem is that your code don't uses Async all the way up.

Your Account class has the method Open, Close, Balance and Transaction and you use a AsyncReplyChannel but you use PostAndReply to send the message. This means: You send a message to the MailboxProcessor with a channel to reply. But, at this point, the method waits Synchronously to finish.

Even with Async.Parallel and multiple threads it can mean a lot of threads lock themsels. If you change all your Methods to use PostAndAsyncReply then your problem goes away.

There are two other performance optimization that can speed up performance, but are not critical in your example.

1. Calling the Length of a list is bad. To calculate the length of a list, you must go through the whole list. You only use this in Transaction to print the length, but consider if the transaction list becomes longer. You alway must go through the whole list, whenever you add a transaction. This will be O(N) of your transaction list.

2. The same goes for calling (List.sum). You have to calculate the current Balance whenever you call Balance. Also O(N).

As you have a MailboxProcessor, you also could calculate those two values instead of completly recalculating those values again and again.Thus, they become O(1) operations.

On top, i would change the Open, Close and Transaction messages to return nothing, as in my Opinion, it doesn't make sense that they return anything. Your examples even makes me confused of what the bool return values even mean.

In the Close message you return state.Opened before you set it to false. Why?

In the Open message you return the negated state.Opened. How you use it later it just looks wrong.

If there is more meaning behind the bool please make a distinct Discriminated Union out of it, that describes the purpose of what it returns.

You used an option throughout your code, i removed it, as i don't see any purpose of it.

Anyway, here is a full example, of how i would write your code that don't have the speed problems.

Quite a few things in the time crate are feature flag gated, meaning you need to manually specify some feature to enable a certain feature. In your case the macros are missing, taking a look at time's crates.io page shows us you need to add the feature macros to enable this. You can do this by specifying your dependency like so:

You have the same behavior with this simple exemple

Something looks broken by something installed. These reg entries should be reg_expand_sz. You should not see %VARS% when viewing the path from the commandline.

There is currently no way to express this in the type system.

I assume you mean min instead of max. The typical approach would be:

A string parameter not specified doesn't contain an empty string; it contains undefined. You would want something like this:

Don't use def inside defn. If you really need some variables, you can use let, but this exercise can be completed without it: