* (you can omit the comparator if it is the natural order).
   */
  public <F extends @Nullable Object> Ordering<F> onResultOf(Function<F, ? extends T> function) {
    return new ByFunctionOrdering<>(function, this);
  }

  <T2 extends T> Ordering<Entry<T2, ?>> onKeys() {
    return onResultOf(Entry::getKey);
  }

  /**

func panic(v any)

// The recover built-in function allows a program to manage behavior of a
// panicking goroutine. Executing a call to recover inside a deferred
// function (but not any function called by it) stops the panicking sequence
// by restoring normal execution and retrieves the error value passed to the
// call of panic. If recover is called outside the deferred function it will

$(document).ready(function(){
  openPage("home.html");
  setEventHandlers();
});

function setEventHandlers(){
  $('#info').click(function(){ openPage("info.html") } );
  $('#home').click(function(){ openPage("home.html") } );
}

function openPage(page){
  $('#content').load(page);
  location.hash = page;
}

function addFooter(msg){
  $('#footer').html($('#footer').html() + "<p>FOOTER: " + msg + "</p>");

 * @return {boolean} Whether the given string is null or is the empty string.
 * @public
 */
Platform.stringIsNullOrEmpty = function(str) {
  return !str;
};


/**
 * @param {?string} str
 * @return {string} Original str, if it is non-null. Otherwise empty string.
 */
Platform.nullToEmpty = function(str) {
  return str || "";
};


/**
 * @param {?string} str

    // order of 't'.
    @Override
    public int compareTo(Composite<T> that) {
      return Integer.compare(rank, that.rank);
    }

    static <T extends @Nullable Object> Function<Composite<T>, T> getValueFunction() {
      return new Function<Composite<T>, T>() {
        @Override
        public T apply(Composite<T> from) {
          return from.value;
        }
      };
    }
  }

    // order of 't'.
    @Override
    public int compareTo(Composite<T> that) {
      return Integer.compare(rank, that.rank);
    }

    static <T extends @Nullable Object> Function<Composite<T>, T> getValueFunction() {
      return new Function<Composite<T>, T>() {
        @Override
        public T apply(Composite<T> from) {
          return from.value;
        }
      };
    }
  }

import java.util.Spliterator;
import java.util.Spliterators;
import java.util.Spliterators.AbstractSpliterator;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;
import java.util.function.IntConsumer;
import java.util.function.LongConsumer;
import java.util.stream.BaseStream;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;

        execute ->> code: return the result
    end

    rect rgba(0, 255, 255, .1)
        code ->> function: say_hi(name="Camila")
        function ->> code: return stored result
    end

    rect rgba(0, 255, 0, .1)
        code ->> function: say_hi(name="Rick")
        function ->> execute: execute function code
        execute ->> code: return the result
    end

participant code as Code
participant function as say_hi()
participant execute as Execute function

    rect rgba(0, 255, 0, .1)
        code ->> function: say_hi(name="Camila")
        function ->> execute: execute function code
        execute ->> code: return the result
    end

    rect rgba(0, 255, 255, .1)
        code ->> function: say_hi(name="Camila")
        function ->> code: return stored result
    end

  public void testAbsent() {
    assertEquals(
        "Map.merge(absent, value, function) should return value",
        v3(),
        getMap()
            .merge(
                k3(),
                v3(),
                (oldV, newV) -> {
                  throw new AssertionFailedError(
                      "Should not call merge function if key was absent");
                }));
    expectAdded(e3());
  }