Details

    • Type: CSR
    • Status: Closed
    • Priority: P3
    • Resolution: Approved
    • Fix Version/s: 12
    • Component/s: core-libs
    • Labels:
      None
    • Subcomponent:
    • Compatibility Risk:
      minimal
    • Compatibility Risk Description:
      New method added to final class.
    • Interface Kind:
      Java API
    • Scope:
      SE

      Description

      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);
          }

        Attachments

          Issue Links

            Activity

              People

              • Assignee:
                jlaskey Jim Laskey
                Reporter:
                jlaskey Jim Laskey
                Reviewed By:
                Joe Darcy, RĂ©mi Forax, Roger Riggs
              • Votes:
                0 Vote for this issue
                Watchers:
                4 Start watching this issue

                Dates

                • Created:
                  Updated:
                  Resolved: