opaque types

[jleahred]

A very cool language, very nice job

Wouldn't it be interesting to have opaque types?

Let me give you an example.

Imagine we want a type of integers but not zero

It could be represented as...

pub type IntNot0 {
  priv IntNot0(i: Int)   //  priv to hide it from other modules
}

pub fn int_not_zero(i: Int) -> Option(IntNot0) {
  case i {
     0 -> None
    _ -> IntNot0(i)
  }
}

pub fn to_int(inz : IntNot0) -> Int {
   let IntNot0(i) = inz
   i
}

In this way, we could define a type that is an integer except for zero, and it is during the creation of the type where the verification must be performed to ensure correctness

Because the "content" is private, there is only one way to create values of this types, with a "creation" function that will verify (in this case) that value never is zero

Now we could have a function with signature...

fn div(a : Int, b : IntNot0) {
   a / int_not_zero.to_int(b)   // we know is not zero, not needed code to check
}

We don't need to check in all uses that is not zero, checking is done on value creation one time (one place and as soon as possible)

Very cooool language
Congrats!!!

[lpil]

We do have opaque types!

pub opaque type IntNot0 {
  IntNot0(i: Int)
}

The tour currently is missing a page on them, sorry about that.

[jgarte]

@jleahred Does this answer your question?

[jleahred]

completly