Implement a compose  method with the following signature:

            def compose[A, B, C]
            (g: B => C, f: A => B): A => C = ??? 

This method must return a function h, which is the composition of the functions f and g

Implement a fuse method with the following signature:

            def fuse[A, B] 
            (a: Option[A], b: Option[B]): Option[(A, B)] = ??? 

The resulting Option object should contain a tuple of values from the Option objects a and b, given that both a and b are non-empty. Use for-comprehensions

Implement a check method, which takes a set of values of type T and a function of type T => Boolean:

            def check[T](xs: Seq[T])(pred: T => Boolean): Boolean = ??? 

The method must return true if and only if the pred function returns true for all the values in xs without throwing an exception. Use the check method as follows:

            check(0 until 10)(40 / _ > 0) 

Modify the Pair class from this chapter so that it can be used in a pattern match.

Implement a permutations function, which, given a string, returns a sequence of strings that are lexicographic permutations of the input string:

            def permutations(x: String): Seq[String]  

Implement a combinations function that, given a sequence of elements, produces an iterator over all possible combinations of length n. A combination is a way of selecting elements from the collection so that every element is selected once, and the order of elements does not matter. For example, given a collection Seq(1, 4, 9, 16), combinations of length 2 are Seq(1, 4), Seq(1, 9), Seq(1, 16), Seq(4, 9), Seq(4, 16), and Seq(9, 16). The combinations function has the following signature:

            def combinations(n: Int, xs: Seq[Int]): Iterator[Seq[Int]] 

See the Iterator API in the standard library documentation

Implement a method that takes a regular expression, and returns a partial function from a string to lists of matches within that string:

            def matcher   (regex: String): PartialFunction[String,   
            List[String]] 

The partial function should not be defined if there are no matches within the argument strings. Otherwise, it should use the regular expression to output the list of matches.

Consider that you and three of your colleagues working in an office divided into cubicles. You cannot see each other, and you are not allowed to verbally communicate, as that might disturb other workers. Instead, you can throw pieces of paper with short messages at each other. Since you are confined in a cubicle, neither of you can tell if the message has reached its destination. At any point, you or one of your colleagues may be called to the boss's office and kept there indefinitely. Design an algorithm in which you and your colleagues can decide when to meet at the local bar. With the exception of the one among you who was called to the boss's office, all of you have to decide on the same time. What if some of the paper pieces can arbitrarily miss the target cubicle?

Imagine that, in the previous exercise, you and your colleagues also have a whiteboard in the hall next to the office. Each one of you can occasionally pass through the hall and write something on the whiteboard, but there is no guarantee that either of you will be in the hall at the same time.