exercism | My solutions for Exercism exercises

The Keep method takes a function as a parameter. It expects it to be func (int) bool - a function taking an int and returning a bool.

When Keep is invoked in Discard, the code passes it an anonymous function with the right signature (take int, return bool). This anonymous function invokes strainer (which is a function passed into Discard) and returns its response, negated.

The idea is that strainer is a filter function: it tells you which elements to keep. So the implementation of Keep is straightforward: iterate over all elements, and keep only those for which strainer returns true.

Discard is written in a clever way using Keep, instead of also writing a loop like this:

Lists (or arrays as they're often called in other languages) in programming start from index 0. If I have a list of elements say [a, b, c ,d ,e], then index 0 would correspond to character a. Index 1 to character b and so on.

The index in a matrix (in this case) starts counting from 1. Thus, when you say: "I want the element from index 1", the computer would throw you the second element. To compensate for this, we subtract 1. That way, when you ask for the element at index 1, the computer will actually read the value at index 1-1, so 0.

You just got your wrapping and unwrapping swapped.

This is an expression:

Iterating on the receiver rx will block for new messages while senders exist. The ones you've cloned into the threads will drop out of scope when they're done, but you have the original sender tx still in scope.

You can force tx out of scope by dropping it manually:

This is due to the use of Iterator::nth. This method will call the next method on the iterator exactly n times, then stop.

It's not possible to view your link without creating an account, so I'm not sure what the problem is, but Enum.each/2 is designed to perform side effects, such as printing the values, so you don't normally care about the return value. For converting the values, you generally want Enum.map/2. For example:

Iterating until success is like .find() but if you're only interested in a true/false result you can use .any(), which does exactly what you're asking for.

Tests if any element of the iterator matches a predicate.

any() takes a closure that returns true or false. It applies this closure to each element of the iterator, and if any of them return true, then so does any(). If they all return false, it returns false.

any() is short-circuiting; in other words, it will stop processing as soon as it finds a true, given that no matter what else happens, the result will also be true.

An empty iterator returns false.

So your loop can be written like this:

I've never explicitly created the instance of the class, but it seems as if Delphi is doing it somewhere, maybe when declaring TYear?

No, Delphi is NOT automatically creating an instance of you. When you declare a variable of a class type, it is simply a pointer variable that can be made to point at a valid instance. But you must always create this instance yourself, and save the pointer in the variable: