undefined | Better HN

story

0 points_old_dude_4y ago0 comments

> ML is probably the biggest influence

I disagree.

Java records are from Standard ML but sealed is not, it's from Scala with the improvement that subtypes of a sealed types are sealed too.

Java still not have a real syntax for ADT, Standard ML has datatype, Rust or Scala 3 have enums on steroid [1].

[1] https://dotty.epfl.ch/docs/reference/enums/adts.html

0 comments

pron4y ago

Java records and sealed types are its interpretation of product and sum types, and, true, this interpretation draws inspiration from Scala's. Deconstructing patterns are coming soon, but Java now does have real syntax for ADTs:

    sealed interface Expr {}
    record ConstantExpr(int i)       implements Expr {}
    record PlusExpr(Expr a, Expr b)  implements Expr {}
    record TimesExpr(Expr a, Expr b) implements Expr {}
    record NegExpr(Expr e)           implements Expr {}

For non-record classes, deconstructing patterns will be something like a dual to methods, and almost a first-class citizen. Among other things, they will allow patterns to support API designs that predate records and sealed types.

_old_dude_OP4y ago

Ok, it's perhaps a true Scotsman argument but saying that Java as a syntax for ADT is like saying JS (pre 2015) has classes because it can be simulated by function + prototype or that Java (pre 8) has lambdas because it can be simulated by anonymous classes.

Java misses the syntactic sugar to define ADT in one place like in Standard ML, OCaml or F#.

The closest you get is to declare records inside a sealed interface, but once you add generics in the mix, it starts to get messy.

I was not able to define a classical list with cons and nil in Java.

  sealed interface List<T> {
    record Cons<T>(T car, List<T> cdr) implements List<T> {}
    record Nil() implements List {} 
  }

The compiler give you warnings, Cons<T> or Nil are not a top level type and you can create several instances of Nil.

pron4y ago

> Java misses the syntactic sugar to define ADT in one place like in Standard ML, OCaml or F#.

I don't think so.

> I was not able to define a classical list with cons and nil in Java.

If you want to restrict Nil to a single instance, don't make it a record class:

    sealed interface List<T> {
      static <T> List<T> cons(T car, List<? extends T> cdr) { return new Cons<T>(car, cdr); }
      static <T> List<T> nil() { return (List<T>)Nil.INSTANCE; }

      record Cons<T>(T car, List<? extends T> cdr) implements List<T> {}
      enum   Nil implements List<Void> { INSTANCE }
    }

You can statically import if you mind them not being "top level":

    import static List.*;

And then write, say:

    var x = cons("a", nil());
    var y = cons(1, x);

Not as succinct as ML, but workable.

Although, in this particular case,

    record List<T>(T car, List<? extends T> cdr){}

would suffice.

_old_dude_OP4y ago

Pattern matching does not work if you use an enum

  List<String> list = cons("a", nil());
  switch(list) {
    case Cons<String>(var car, var cdr) -> ...
    case Nil -> ...
  }

Nil is typed List<Void> which is not compatible with List<String>.

You may be able to use extractors as the inverse of the static methods cons() and nil() but that adds more boilerplate.

Disjunctive enums like in Rust or Scala 3 is a simpler way to define ADT.

1 more reply

j / k navigate · click thread line to collapse

0 comments

pron4y ago

    sealed interface Expr {}
    record ConstantExpr(int i)       implements Expr {}
    record PlusExpr(Expr a, Expr b)  implements Expr {}
    record TimesExpr(Expr a, Expr b) implements Expr {}
    record NegExpr(Expr e)           implements Expr {}

_old_dude_OP4y ago

Java misses the syntactic sugar to define ADT in one place like in Standard ML, OCaml or F#.

The closest you get is to declare records inside a sealed interface, but once you add generics in the mix, it starts to get messy.

I was not able to define a classical list with cons and nil in Java.

  sealed interface List<T> {
    record Cons<T>(T car, List<T> cdr) implements List<T> {}
    record Nil() implements List {} 
  }

The compiler give you warnings, Cons<T> or Nil are not a top level type and you can create several instances of Nil.

pron4y ago

> Java misses the syntactic sugar to define ADT in one place like in Standard ML, OCaml or F#.

I don't think so.

> I was not able to define a classical list with cons and nil in Java.

If you want to restrict Nil to a single instance, don't make it a record class:

    sealed interface List<T> {
      static <T> List<T> cons(T car, List<? extends T> cdr) { return new Cons<T>(car, cdr); }
      static <T> List<T> nil() { return (List<T>)Nil.INSTANCE; }

      record Cons<T>(T car, List<? extends T> cdr) implements List<T> {}
      enum   Nil implements List<Void> { INSTANCE }
    }

You can statically import if you mind them not being "top level":

    import static List.*;

And then write, say:

    var x = cons("a", nil());
    var y = cons(1, x);

Not as succinct as ML, but workable.

Although, in this particular case,

    record List<T>(T car, List<? extends T> cdr){}

would suffice.

_old_dude_OP4y ago

Pattern matching does not work if you use an enum

  List<String> list = cons("a", nil());
  switch(list) {
    case Cons<String>(var car, var cdr) -> ...
    case Nil -> ...
  }

Nil is typed List<Void> which is not compatible with List<String>.

You may be able to use extractors as the inverse of the static methods cons() and nil() but that adds more boilerplate.

Disjunctive enums like in Rust or Scala 3 is a simpler way to define ADT.

1 more reply

j / k navigate · click thread line to collapse