Implicit conversion for libraries dependent on refined (seperating `auto` to trait and object)

Problem: Libraries which depend on refined types currently force the user to call import eu.timepit.refined.auto._ to allow standard type variables (literals) to be implicitly converted into their refined types.

Example:

  import eu.timepit.refined.api.Refined
  import eu.timepit.refined.api.Validate
  case class ZeroOrOne()
  implicit val zeroOrOneValidate: Validate.Plain[Int, ZeroOrOne] =
    Validate.fromPredicate(p => p == 0 || p == 1, p => s"($p is in not binary)", ZeroOrOne())

  def libFunc(x : Int Refined ZeroOrOne) : Int = x.get

libFunc(1) fails without the import

Solution (as discussed in gitter): Split refined’s auto into trait and object (see code). I recommend that the trait’s name will be more significant than auto.

This will allow the user to extend a companion object to the refined type from that trait, thus allowing the implicit conversion. So the example above changes into:

  import eu.timepit.refined.api.Refined
  import eu.timepit.refined.api.Validate
  case class ZeroOrOne()
  object ZeroOrOne extends eu.timepit.refined.api.auto //Or other name if chosen
  implicit val zeroOrOneValidate: Validate.Plain[Int, ZeroOrOne] =
    Validate.fromPredicate(p => p == 0 || p == 1, p => s"($p is in not binary)", ZeroOrOne())

  def libFunc(x : Int Refined ZeroOrOne) : Int = x.get

[fthomas]

Ok, applying this diff

--- a/modules/core/shared/src/main/scala-2.12/eu/timepit/refined/api/Refined.scala
+++ b/modules/core/shared/src/main/scala-2.12/eu/timepit/refined/api/Refined.scala
@@ -15,7 +15,7 @@ final class Refined[T, P] private (val value: T) extends AnyVal with Serializabl
     value.toString
 }
 
-object Refined {
+object Refined extends AutomaticConversions[Refined] {

--- a/modules/core/shared/src/main/scala/eu/timepit/refined/auto.scala
+++ b/modules/core/shared/src/main/scala/eu/timepit/refined/auto.scala
@@ -80,3 +80,12 @@ object auto {
       v: Validate[T, P]
   ): T @@ P = macro RefineMacro.impl[@@, T, P]
 }
+
+trait AutomaticConversions[F[_, _]] {
+
+  implicit def autoRefine[T, P](t: T)(implicit rt: RefType[F], v: Validate[T, P]): F[T, P] =
+    macro RefineMacro.impl[F, T, P]
+
+  implicit def autoUnwrap[T](tp: F[T, _])(implicit rt: RefType[F]): T =
+    rt.unwrap(tp)
+}

allows this usage with only one import that introduces the type alias type PosInt = Int Refined Positive:

Welcome to Scala 2.12.1 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_102).
Type in expressions for evaluation. Or try :help.

scala> import eu.timepit.refined.types.all.PosInt
import eu.timepit.refined.types.all.PosInt

scala> 23: PosInt
res0: eu.timepit.refined.types.all.PosInt = 23

scala> -23: PosInt
<console>:16: error: Predicate failed: (-23 > 0).
       -23: PosInt
        ^

scala> res0: Int
res2: Int = 23

So for Refined types we can basically get rid off the extra auto._ import at the expense that users can’t opt out of the implicit conversions T => Refined[T, P] and Refined[T, P] => T. I need to think about the pros and cons of this approach to decide if we want to do this.

[soronpo]

Thanks @fthomas. Nice update! You may now close this issue. I’m using singleton-ops which better fits my use-case.