Tagged Union Syntax

[wongjiahau]

Things do discussed:

1. How to define a tagged union?
2. How to construct an expression with type of tagged union?

[zypeh]

type Shape
  = Circle (radius: Float)
  | Rectangle (height: Float, width: Float)
  | None

area: (shape: Shape) -> (result: Float) := {
  (shape = Circle(radius)) -> 
    radius.square.multiple(by:= pi),

  (shape = Rectangle(height, width)) ->
    height.multiple(by:= width),

  (shape = None) ->
    0
}

1. Are we gonna make the ADT cases (alternatives) an individual constructor or a field of a type?

ps. I think we need to think the type system first. #17

[wongjiahau]

If we make ADT cases an individual constructor, the BAD thing is that it might be confusing for some cases, because user might not know which type does the constructor belongs to, but the GOOD thing is the code is shorter.

Example:

type Shape
  = Circle (radius: Float)
  | Rectangle (height: Float, width: Float)
  | None

area: (shape: Shape) -> Float := {
  (shape = Circle(radius)) -> 
    radius.square.multiple(by:= pi),

  (shape = Rectangle(height, width)) ->
    height.multiple(by:= width),

  (shape = None) ->
    0
}

===
If we make ADT cases a field of a type, the GOOD things are:

1. the parent type of each cases can be understood easily,
2. it's better for autocomplete to work, because user can just type the type name, then the list of possible cases will fall down for them to choose.
3. It's more consistent with our syntax, because we can view Shape.Circle(radius:=3) as a function application where the function is Circle and the arguments is Shape and (radius:=3).
4. We can prevent name clashing, for example if we have two types with some common cases:

type TrafficColor :=
  | Red
  | Green

type RainbowColor :=
  | Red
  | Green
  | Blue

TrafficColor.Red

RainbowColor.Red

If we use ADT cases as individual constructor, we need to prevent this type of clashing by using prefixes:

type TrafficColor :=
  | TrafficRed
  | TrafficGreen

type RainbowColor ：=
  | RainbowRed
  | RainbowGreen
  | RainbowBlue

The BAD thing is of course the resulting code will be noisier.

Example:

type Shape
  = Circle (radius: Float)
  | Rectangle (height: Float, width: Float)
  | None

area: (shape: Shape) -> Float := {
  (shape = Shape.Circle(radius)) -> 
    radius.square.multiple(by:= pi),

  (shape = Shape.Rectangle(height, width)) ->
    height.multiple(by:= width),

  (shape = Shape.None) ->
    0
}

[zypeh]

Q: Do we support pattern matching over the anonymous tagged union.

so here's how Rust does it:

let x: None | Some(i32) = Some(100)

the compiler creates an invisible enum, it's just like pattern matching against normal enums. (1)

Q: How do rec-Nat and recursion works?
We will try to understand this by reading the book "The Little Typer".

Q: Can we make the pattern matching case into the polymorphic record, so that we can compose cases.
(2), I think the pattern matching rule will be huge. 😢

References

1. Polymorphic variants
2. First-class case