Accessing underlying value of opaque-based iron type

[antonkw]

As far as I see, many people consider opaque types as something they can use in the same way as newtypes.
That connotation of domain values maintenance implies having access to underlying value.

Access to underlying values is another step to let Iron be a legitimate replacement of the newtype+refined stack.

opaque type Temperature = Double :| Positive
object Temperature extends RefinedTypeOps[Temperature] 

Usage

val temperature = Temperature(100)
val sum: Double = temperature.raw + 100

sum is Double; depending on the context, it could be packed back to Temperature. But that is up to the user.

Pull request with the idea: #120

[Iltotore]

Scala 3 's opaque types already allow you to do it :

//The parentheses may not be mandatory
opaque type Temperature <: (Double :| Positive) = Double :| Positive
object Temperature extends RefinedTypeOps[Temperature]

val a: Temperature = Temperature(10)
val b: Double :| Positive = a //Works
val c: Double = a //Also works
val d: Double = a + 100 //110

Does it fulfill the expressed need ?

[antonkw]

Thank you for response!

Two points there

1. <: (Double :| Positive)-like additions are quite cumbersome
2. additional "widening" makes it very unsafe and let opaque types behave like usual ones:

opaque type Moisture <: (Int :| Positive)  = Int :| Positive
object Moisture extends RefinedTypeOps[Moisture]

opaque type Moisture2 <: (Int :| Positive)  = Int :| Positive
object Moisture2 extends RefinedTypeOps[Moisture2]

and then

val mst: Moisture = Moisture(200)
val mst2: Moisture2 = Moisture2(200)
val sum: Int = mst2 + mst

Am I missing something?
Explicit conscious accessing still makes sense to me.

[Iltotore]

I get your point. I will take a look at your PR during the week.