Give implicit conversion on Option function lower priority

Author: Atry

deploy.sbt.disabled renamed to deploy.sbt

@@ -1,5 +1,32 @@
 package com.thoughtworks
 
+private[thoughtworks] sealed trait LowPrirorityExtractor {
+
+  sealed trait SeqExtractor[-A, +B] {
+    def unapplySeq(a: A): Option[Seq[B]]
+  }
+
+  implicit final class OptionFunctionToSeqExtractor[-A, +B] private[LowPrirorityExtractor](underlying: A => Option[Seq[B]]) {
+    def extractSeq = new SeqExtractor[A, B] {
+      def unapplySeq(a: A) = underlying(a)
+    }
+  }
+
+  implicit final class OptionFunctionToExtractor[-A, +B] private[LowPrirorityExtractor](underlying: A => Option[B]) {
+    def extract = new Extractor[A, B] {
+      def unapply(a: A) = underlying(a)
+    }
+  }
+
+}
+
+/**
+  * A pattern that can be used in `match` / `case` expressions.
+  */
+sealed trait Extractor[-A, +B] {
+  def unapply(a: A): Option[B]
+}
+
 /**
   * Utilities to convert between `A => Option[B]`, `PartialFunction[A, B]` and [[Extractor]].
   *
@@ -37,47 +64,24 @@ package com.thoughtworks
     }}}
   *
   */
-object Extractor {
-
-  sealed trait SeqExtractor[-A, +B] {
-    def unapplySeq(a: A): Option[Seq[B]]
-  }
+object Extractor extends LowPrirorityExtractor {
 
   implicit final class PartialFunctionToSeqExtractor[-A, +B] private[Extractor](underlying: PartialFunction[A, Seq[B]]) {
     def extractSeq = new SeqExtractor[A, B] {
       def unapplySeq(a: A) = underlying.lift(a)
     }
   }
 
-  implicit final class OptionFunctionToSeqExtractor[-A, +B] private[Extractor](underlying: A => Option[Seq[B]]) {
-    def extractSeq = new SeqExtractor[A, B] {
-      def unapplySeq(a: A) = underlying(a)
-    }
-  }
-
   implicit final class PartialFunctionToExtractor[-A, +B] private[Extractor](underlying: PartialFunction[A, B]) {
     def extract = new Extractor[A, B] {
       def unapply(a: A) = underlying.lift(a)
     }
   }
 
-  implicit final class OptionFunctionToExtractor[-A, +B] private[Extractor](underlying: A => Option[B]) {
-    def extract = new Extractor[A, B] {
-      def unapply(a: A) = underlying(a)
-    }
-  }
-
   implicit final class OptionFunctionToPartialFunction[-A, +B] private[Extractor](underlying: A => Option[B]) {
     def unlift: PartialFunction[A, B] = {
       case underlying.extract(b) => b
     }
   }
 
-}
-
-/**
-  * A pattern that can be used in `match` / `case` expressions.
-  */
-sealed trait Extractor[-A, +B] {
-  def unapply(a: A): Option[B]
-}
+}

shared/src/main/scala/com/thoughtworks/Extractor.scala

@@ -31,6 +31,18 @@ class ExtractorSpec extends FreeSpec with Matchers {
     }
   }
 
+  "PartialOptionFunction toExtractor" in {
+
+    val pf: PartialFunction[Int, Option[String]] = {
+      case 1 => Some("match")
+    }
+
+    1 match {
+      case pf.extract(m) => m should be(Some("match"))
+    }
+
+  }
+
   "example" in {
     val pf: PartialFunction[Int, String] = {
       case 1 => "matched by PartialFunction"