code: public static <A, E> Correspondence<A, E> transforming(
        Function<A, ? extends E> actualTransform, String description) {
      return new Transforming<>(actualTransform, identity(), description);
    }
docs: Constructs a {@link Correspondence} that compares elements by transforming the actual elements
  using the given function and testing for equality with the expected elements. If the
  transformed actual element (i.e. the output of the given function) is null, it will correspond
  to a null expected element.
  
  <p>The correspondence does not support formatting of diffs (see {@link #formatDiff}). You can
  add that behaviour by calling {@link Correspondence#formattingDiffsUsing}.
  
  <p>Note that, if you the data you are asserting about contains null actual values, your
  function may be invoked with a null argument. If this causes it to throw a {@link
  NullPointerException}, then your test will fail. (See {@link Correspondence#compare} for more
  detail on how exceptions are handled.) In particular, this applies if your function is an
  instance method reference on the actual value (as in the example below). If you want a null
  actual element to correspond to a null expected element, you must ensure that your function
  transforms a null input to a null output.
  
  <p>Example:
  
  <pre>{@code
  static final Correspondence<MyRecord, Integer> HAS_ID =
  Correspondence.transforming(MyRecord::getId, "has an ID of");
  }</pre>
  
  This can be used as follows:
  
  <pre>{@code
  assertThat(myRecords).comparingElementsUsing(HAS_ID).containsExactly(123, 456, 789);
  }</pre>
  
  @param actualTransform a {@link Function} taking an actual value and returning a new value
  which will be compared with an expected value to determine whether they correspond
  @param description should fill the gap in a failure message of the form {@code "not true that
  <some actual element> is an element that <description> <some expected element>"}, e.g.
  {@code "has an ID of"}