added function syntax for optional (#29)

optional/src/main/scala/henkan/optional/FunctionSyntax.scala

@@ -0,0 +1,34 @@
+package henkan.optional
+
+import cats.arrow.FunctionK
+import cats.{Functor, ApplicativeError}
+import cats.data.NonEmptyList
+import syntax.all._
+
+trait FunctionSyntax {
+  final class autoOptionalPartial[OptionalA, OptionalB] private[optional] {
+    def apply[F[_], A, B](f: A ⇒ F[B])(whenMissing: NonEmptyList[RequiredFieldMissing] ⇒ F[OptionalB])(
+      implicit
+      toOptional: ToOptional[B, OptionalB],
+      validateFromOptional: ValidateFromOptional[OptionalA, A],
+      F: Functor[F]
+    ): OptionalA ⇒ F[OptionalB] = (oa: OptionalA) ⇒ {
+      validate(oa).to[A].fold(
+        whenMissing,
+        a ⇒ F.map(f(a))(from(_).toOptional[OptionalB])
+      )
+    }
+  }
+
+  def autoOptional[OptionalA, OptionalB] = new autoOptionalPartial[OptionalA, OptionalB]
+
+  implicit class toOptionalOps[A, F[_]: Functor, B](f: A ⇒ F[B]) {
+    def toOptional[OptionalA, OptionalB](
+      whenMissing: NonEmptyList[RequiredFieldMissing] ⇒ F[OptionalB]
+    )(
+      implicit
+      toOptional: ToOptional[B, OptionalB],
+      validateFromOptional: ValidateFromOptional[OptionalA, A]
+    ) = autoOptional[OptionalA, OptionalB](f)(whenMissing)
+  }
+}

optional/src/main/scala/henkan/optional/package.scala

@@ -2,8 +2,9 @@ package henkan
 
 package object optional {
   object syntax {
-    object all extends ValidateFromOptionalSyntax with ToOptionalSyntax
+    object all extends ValidateFromOptionalSyntax with ToOptionalSyntax with FunctionSyntax
     object fromOptional extends ValidateFromOptionalSyntax
     object toOptional extends ToOptionalSyntax
+    object function extends FunctionSyntax
   }
 }

optional/src/test/scala/henkan/optional/FunctionSyntaxSpec.scala

@@ -0,0 +1,25 @@
+package henkan.optional
+
+import cats.{Applicative, ApplicativeError}
+import org.specs2.mutable.Specification
+import cats.implicits._
+import TestDomain._
+import henkan.optional.syntax.function._
+
+class FunctionSyntaxSpec extends Specification {
+  override def is = s2"""
+    FunctionSyntax
+     wraps function with Optional Types       $wrapFunction
+  """
+
+  def wrapFunction = {
+    val f: Domain ⇒ Either[String, ParentDomain] = (d: Domain) ⇒ Right(ParentDomain(1d, d))
+
+    val fm = f.toOptional[Message, ParentMessage](es ⇒ Left("Missing fields: " + es.map(_.fieldName).toList.mkString(", ")))
+
+    fm(Message(Some("a"), Some(1))) must_== Right(ParentMessage(Some(1d), Some(Message(Some("a"), Some(1)))))
+
+    fm(Message(Some("a"), None)) must_== Left("Missing fields: b")
+  }
+}
+