code: public static <P, F> MethodBinder<P, F> binder(Interface<P> proxyType, Interface<F> functionalInterface) {
      Objects.requireNonNull(proxyType, "proxyType");
      Objects.requireNonNull(functionalInterface, "functionalInterface");
      Assert.ensure(functionalInterface.abstractMethods().size() == 1, "functionalInterface.abstractMethods().size() == 1");
  
      return (proxyRef, action) -> {
        Objects.requireNonNull(proxyRef, "proxyRef");
        Objects.requireNonNull(action, "action");
  
        try {
  
          Method sam = functionalInterface.abstractMethods()
              .get(0);
          BINDING.set((args) -> {
            try {
              return sam.invoke(action, args);
            } catch (IllegalAccessException e) {
              throw Exceptions.throwChecked(e);
            } catch (InvocationTargetException e) {
              throw Exceptions.throwChecked(e);
            }
          });
  
          try {
            sam.invoke(proxyRef, Methods.defaultArgs(sam));
          } catch (IllegalAccessException e) {
            Exceptions.throwChecked(e);
          } catch (InvocationTargetException e) {
            Exceptions.throwChecked(e);
          }
  
          @SuppressWarnings("unchecked")
          P proxy = (P) PROXY.get();
  
          if (proxy == null) {
            throw new IllegalArgumentException("proxy ref does not appear to be a method reference of a proxy produced by "
                + ProxyBinding.class
                + "; validate "
                + proxyRef);
          }
  
          return proxy;
        }
docs: Creates a method binder for the given types.
  {@link MethodBinder} instances returned by this method are thread safe and immutable.
  
  @param proxyType the proxy type
  @param functionalInterface a functional interface type
  @param <P> the type of the proxy
  @param <F> the type of the interface
  @return a new instance