Should we merge RefinedTypeOps#apply and #fromIronType?

[Iltotore]

Currently, given this code:

opaque type Age = Int :| Positive
object Age extends RefinedTypeOps[Age]

We should use apply to create an Age from an Int and fromIronType to get an Age from a refined type like Int :| Positive.

If we change the RefinedTypeOps#apply method definition to:

def apply(value: A :| C): T = value

where:

• A is the "raw" type (e.g Int)
• C is the constraint (e.g Positive)
• T is the opaque type (e.g Age)

This code would compile:

val a: Age = Age(15)

val x: Int :| Positive = ???
val b: Age = Age(x)

Here are two concerns:

• Is it better to use the same method instead of apply and fromIronType? (I think so)
• Does it bring any reggression compared to current apply-fromIronType separation?

Since you made the current RefinedTypeOps implementation @antonkw, what do you think?