Trying to keep types unwrapped when using refined

Question

I am trying to use refined to create smart constructors based on primitives and avoid wrapping since same types might be used in large collections. Am I doing this right? Seems to work but a bit boilerplaty

    type ONE_Pred = = MatchesRegex[W....
    type ONE = String @@ ONE_Pred
    type TWO_Pred = OneOf[...
    type TWO = String @@ TWO_PRED 

and then

 case class C(one:ONE, two:TWO)
 object C {
  def apply(one:String, two:String):Either[String, C] = 
  (
   refineT[ONE_Pred](one),
   refineT[TWO_Pred](two)
  ).mapN(C.apply)
}

Answer 1

Refined has a mechanism for creating a companion-like objects that have some utilites already defined:

type ONE = String @@ MatchesRegex["\\d+"]
object ONE extends RefinedTypeOps[ONE, String]

Note that:

1. You don't need a predicate type to be mentioned separately
2. It works for both shapeless tags and refined own newtypes. The flavor you get is based on the structure of type ONE.

You get:

• ONE("literal") as alternative to refineMT/refineMV
• ONE.from(string) as alternative to refineT/refineV
• ONE.unapply so you can do string match { case ONE(taggedValue) => ... }
• ONE.unsafeFrom for when your only option is to throw an exception.

With these "companions", it's possible to write much simpler code with no need to mention any predicate types:

object C {
  def apply(one: String, two: String): Either[String, C] =
    (ONE.from(one), TWO.from(two)).mapN(C.apply)
}

(example in scastie, using 2.13 with native literal types)