econstruct, like scalaz.MonadError.emap

core/shared/src/main/scala/interface.scala

@@ -155,6 +155,29 @@ abstract class CaseClass[Typeclass[_], Type] private[magnolia] (
   final def construct[Return](makeParam: Param[Typeclass, Type] => Return): Type =
     rawConstruct(parameters map makeParam)
 
+  /**
+   * Like construct but allows each parameter to fail with an error.
+   *
+   * @see construct
+   */
+  final def constructEither[E <: AnyRef, Return](makeParam: Param[Typeclass, Type] => Either[E, Return]): Either[E, Type] = {
+    // poor man's scalaz.Traverse
+    try {
+      Right(
+        rawConstruct(
+          parameters.map { p =>
+            makeParam(p) match {
+              case Left(e) => throw EarlyExit(e)
+              case Right(a) => a
+            }
+          }
+        )
+      )
+    } catch {
+      case EarlyExit(err) => Left(err.asInstanceOf[E])
+    }
+  }
+
   /** constructs a new instance of the case class type
     *
     *  Like [[construct]] this method is implemented by Magnolia and lets you construct case class
@@ -248,3 +271,5 @@ final case class TypeName(owner: String, short: String) {
   *                     whose full name contains the given [[String]]
   */
 final class debug(typeNamePart: String = "") extends scala.annotation.StaticAnnotation
+
+private[magnolia] final case class EarlyExit[E](e: E) extends Exception with util.control.NoStackTrace

examples/shared/src/main/scala/default.scala

@@ -18,7 +18,7 @@ import magnolia._
 import scala.language.experimental.macros
 
 /** typeclass for providing a default value for a particular type */
-trait Default[T] { def default: T }
+trait Default[T] { def default: Either[String, T] }
 
 /** companion object and derivation object for [[Default]] */
 object Default {
@@ -28,24 +28,33 @@ object Default {
   /** constructs a default for each parameter, using the constructor default (if provided),
     *  otherwise using a typeclass-provided default */
   def combine[T](ctx: CaseClass[Default, T]): Default[T] = new Default[T] {
-    def default = ctx.construct { param =>
-      param.default.getOrElse(param.typeclass.default)
+    def default = ctx.constructEither { param =>
+      param.default match {
+        case Some(arg) => Right(arg)
+        case None => param.typeclass.default
+      }
     }
   }
 
   /** chooses which subtype to delegate to */
   def dispatch[T](ctx: SealedTrait[Default, T])(): Default[T] = new Default[T] {
-    def default: T = ctx.subtypes.head.typeclass.default
+    def default = ctx.subtypes.headOption match {
+      case Some(sub) => sub.typeclass.default
+      case None => Left("no subtypes")
+    }
   }
 
   /** default value for a string; the empty string */
-  implicit val string: Default[String] = new Default[String] { def default = "" }
+  implicit val string: Default[String] = new Default[String] { def default = Right("") }
 
   /** default value for ints; 0 */
-  implicit val int: Default[Int] = new Default[Int] { def default = 0 }
+  implicit val int: Default[Int] = new Default[Int] { def default = Right(0) }
+
+  /** oh, no, there is no default Boolean... whatever will we do? */
+  implicit val boolean: Default[Boolean] = new Default[Boolean] { def default = Left("truth is a lie") }
 
   /** default value for sequences; the empty sequence */
-  implicit def seq[A]: Default[Seq[A]] = new Typeclass[Seq[A]] { def default = Seq.empty }
+  implicit def seq[A]: Default[Seq[A]] = new Typeclass[Seq[A]] { def default = Right(Seq.empty) }
 
   /** generates default instances of [[Default]] for case classes and sealed traits */
   implicit def gen[T]: Default[T] = macro Magnolia.gen[T]

examples/shared/src/main/scala/semiauto.scala

@@ -0,0 +1,23 @@
+package magnolia.examples
+
+import scala.language.experimental.macros
+import magnolia._
+
+trait SemiDefault[A] {
+  def default: A
+}
+object SemiDefault {
+  type Typeclass[T] = SemiDefault[T]
+
+  def combine[T](ctx: CaseClass[SemiDefault, T]): SemiDefault[T] = new SemiDefault[T] {
+    def default = ctx.construct(p => p.default.getOrElse(p.typeclass.default))
+  }
+  def dispatch[T](ctx: SealedTrait[SemiDefault, T])(): SemiDefault[T] = new SemiDefault[T] {
+    def default = ctx.subtypes.head.typeclass.default
+  }
+  implicit val string: SemiDefault[String] = new SemiDefault[String] { def default = "" }
+  implicit val int: SemiDefault[Int] = new SemiDefault[Int] { def default = 0 }
+
+  // NOT IMPLICIT
+  def gen[T]: SemiDefault[T] = macro Magnolia.gen[T]
+}

project/build.properties

@@ -1 +1 @@
-sbt.version=1.1.1
+sbt.version=1.1.6

tests/src/main/scala/tests.scala

@@ -93,8 +93,22 @@ case class Recursive(children: Seq[Recursive])
 class GenericCsv[A: Csv]
 object ParamCsv extends GenericCsv[Param]
 
+
 class NotDerivable
 
+case class NoDefault(value: Boolean)
+
+// this should *not* be derived: both ServiceName and Option[String] should fail
+final case class LoggingConfig(
+  name: ServiceName,
+  optName: Option[String]
+)
+object LoggingConfig {
+  implicit val semi: SemiDefault[LoggingConfig] = SemiDefault.gen
+}
+
+final case class ServiceName(value: String) extends AnyVal
+
 object Tests extends TestApp {
 
   def tests(): Unit = for (_ <- 1 to 1) {
@@ -151,7 +165,7 @@ object Tests extends TestApp {
 
     test("construct a default value") {
       Default.gen[Entity].default
-    }.assert(_ == Company(""))
+    }.assert(_ == Right(Company("")))
 
     test("construction of Show instance for Leaf") {
       scalac"""
@@ -179,7 +193,7 @@ object Tests extends TestApp {
 
     test("access default constructor values") {
       implicitly[Default[Item]].default
-    }.assert(_ == Item("", 1, 0))
+    }.assert(_ == Right(Item("", 1, 0)))
 
     test("serialize case object as a sealed trait") {
       implicitly[Show[String, Color]].show(Blue)
@@ -299,7 +313,7 @@ object Tests extends TestApp {
 
         test("construct a default case class inside another class") {
           Default.gen[InnerClassWithDefault].default
-        }.assert(_ == InnerClassWithDefault())
+        }.assert(_ == Right(InnerClassWithDefault()))
 
         ()
       }
@@ -314,7 +328,7 @@ object Tests extends TestApp {
 
         test("construct a default case class inside a method") {
           Default.gen[LocalClassWithDefault].default
-        }.assert(_ == LocalClassWithDefault())
+        }.assert(_ == Right(LocalClassWithDefault()))
 
         ()
       }
@@ -330,7 +344,11 @@ object Tests extends TestApp {
 
     test("construct a default Account") {
       Default.gen[Account].default
-    }.assert(_ == Account(""))
+    }.assert(_ == Right(Account("")))
+
+    test("construct a failed NoDefault") {
+      Default.gen[NoDefault].default
+    }.assert(_ == Left("truth is a lie"))
 
     test("show a Portfolio of Companies") {
       Show.gen[Portfolio].show(Portfolio(Company("Alice Inc"), Company("Bob & Co")))
@@ -379,7 +397,7 @@ object Tests extends TestApp {
       implicit def showDefaultOption[A](
         implicit showA: Show[String, A],
         defaultA: Default[A]
-      ): Show[String, Option[A]] = (optA: Option[A]) => showA.show(optA.getOrElse(defaultA.default))
+      ): Show[String, Option[A]] = (optA: Option[A]) => showA.show(optA.getOrElse(defaultA.default.right.get))
 
       Show.gen[Path[String]].show(OffRoad(Some(Crossroad(Destination("A"), Destination("B")))))
     }.assert(_ == "OffRoad(path=Crossroad(left=Destination(value=A),right=Destination(value=B)))")