Summary
-------

Provide a String instance method to allow function application of custom
transformations applied to an instance of String.

Problem
-------

Functional programming landed in Java with the introduction of lambdas
in JDK 8. The main advantage of this style of programming is the clarity
it brings to otherwise complex code.  

At the time, the focus was on the internal iteration of collection
object types. Other base objects, such as String, don't have the same
advantage because it's **not possible to extend base objects with new
methods**. The main recourse is to provide static methods that take the
base object as argments. Since static methods can't be chained they
distort readabilty of the resulting code.

```

Example:

    static String naiveDropFirstWord(String string) {
        return List.of(string.split("\\W+"))
                   .stream()
                   .skip(1)
                   .collect(Collectors.joining(" "));
    }

    static String naiveTitleCase(String string) {
        return List.of(string.split("\\W+"))
                   .stream()
                   .transform(s -> s.substring(0, 1).toUpperCase() +
                             s.substring(1).toLowerCase())
                   .collect(Collectors.joining(" "));
    }

    String title = "darn poor title for a book";
    
    String capped = naiveTitleCase(naiveDropFirstWord(title)).concat(".");

Result:

    Poor Title For A Book.
    
```

In this example, the reader is forced to interpret portions of the expression
from the inside out.

Solution
--------

Introduce a new String instance method `transform` that applies a Function
against the string.

```

Example:

    static String naiveDropFirstWord(String string) {
        ...
    }
    
    static String naiveTitleCase(String string) {
        ...
    }
    
    String title = "darn poor title for a book";
    
    String capped = title.transform(Example::naiveDropFirstWord);
                         .transform(Example::naiveTitleCase)
                         .concat(".");

Result:

    Poor Title For A Book.

```

In this example, the steps can be discerned more clearly.

Specification
-------------

```
    /**
     * This method allows the application of a function to {@code this}
     * string. The function should expect a single String argument
     * and produce an {@code R} result.
     *
     * @param f    functional interface to a apply
     *
     * @param <R>  class of the result
     *
     * @return     the result of applying the function to this string
     *
     * @see java.util.function.Function
     *
     * @since 12
     */
    public <R> R transform(Function<? super String, ? extends R> f) {
        return f.apply(this);
    }
```