Zero-cost newtype in Java, based on https://failex.blogspot.ch/2017/04/the-high-cost-of-anyval-subclasses.html

Label.java

import java.io.IOException;
import org.derive4j.hkt.__;

public abstract class Label<T> {
  private Label(){}
  public abstract T apply(String s);
  public abstract String unwrap(T lbl);
  public abstract <f> __<f, String> subst(__<f, T> fa);

  static Label<?> Label = new Label<String>() {
    @Override
    public String apply(String s) {
      return s;
    }

    @Override
    public String unwrap(String lbl) {
      return lbl;
    }

    @Override
    public <f> __<f, String> subst(__<f, String> fa) {
      return fa;
    }
  };

  public static void main(String[] args) throws IOException {
    program(Label).run();
  }

  // "Slight" inconvenience vs scala: you have to write your program inside method(s) parametrized by the Label(s):
  static <T> IO<Unit> program(Label<T> Label) {

    class Toto {
      private final T wrapped;
      Toto(T wrapped){this.wrapped = wrapped;}
    }

    Toto toto = new Toto(Label.apply("Hello World"));
    String unwrapped = Label.unwrap(toto.wrapped);
    return IO.effect(() -> System.out.println(unwrapped));
  }
}

Why not simply :

// poor man's newtype
interface $<A> { A __(); }

// Label is an alias for String
interface Label extends $<String> {}

void printLabel(Label label) {
  System.out.println(label.__());
}

printLabel("toto"); // doesn't compile

printLabel(() -> "toto"); // ok

Your example use a stateless lambda, but in the general case object instantiation via lambda is not cost-free. But yes it is simpler and actually practical.

related gist: https://gist.github.com/jbgi/1a3697d380f2071eb8c2fd3ad259c011