Make RefinedTypeOps blackbox

[Iltotore]

Following #250

RefinedTypeOps leaks its implementation in apply method, forcing users to have io.github.iltotore.iron.autoRefine in their scope.

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

This is because apply requires a A :| C and relies on autoRefine to refine the non-iron values at compile-time.

A potential solution would be to separate apply(A :| C) into two methods (like it used to in earlier versions):

• apply(A) checking the passed value at compile-time or aborts (like autoRefine but embedded in the method)
• fromIronType(A :| C), equivalent to current apply

This way, it is possible to make compile-time checked newtype instances without requiring Iron in the scope so libraries can use Iron in their datatypes without exposing it.

While harder to achieve, finding a solution with only an apply method might be doable by checking if the passed value's type is an Iron type:

inline def apply[A1 <: A](inline value: A1): T =
  inline if macros.isIronType[A1] then value.asInstanceOf
  else
    macros.assertCondition(...)
    value.asInstanceOf

This approach has the pro of being source-retrocompatible but it has two cons:

• It might have some corner cases due to macros/inlines
• apply's signature is less trivial

Since it is pretty straightforward to rewrite the code to fit the new definition of apply or even make a Scalafix rewriting rule, I'm in favor of the first approach which is simpler and less prone to some metaprogramming corner cases.