Create 2018-08-20-converters-among-optional-functions-partialfunctions-and-extractor-objects.md

Author: Atry

_sips/sips/2018-08-20-converters-among-optional-functions-partialfunctions-and-extractor-objects.md

@@ -0,0 +1,86 @@
+---
+layout: sips
+discourse: true
+title: SIP-NN - Converters among optional Functions, PartialFunctions and extractor objects
+---
+
+**By: Yang Bo**
+
+
+## History
+
+| Date          | Version       |
+|---------------|---------------|
+| Aug 20th 2018 | Initial Draft |
+
+## Motivation
+
+There are three types in Scala to represent a function that accept some of the parameters:
+
+1. optional functions: `A => Option[B]`
+2. extracter objects: `{ def unapply(a: A): Option[B] }` and `{ def unapplySeq(a: A): Option[Seq[B]] }`
+3. partial fucntions: `PartialFunction[A, B]`
+
+Optional functions and partial functions can be converted to each other via `PartialFunction.lift` and `Function.unlift`. However, there is no simple approach to convert a partial function to an extractor object. As a result, partial functions are not composable. You cannot create a partial function then use it as a pattern in another partial function.
+
+This proposal provide an `extract` method to convert all these representation to extractor objects.
+
+## Motivating Examples
+
+{% highlight scala %}
+// Define a PartialFunction
+val pf: PartialFunction[Int, String] = {
+  case 1 => "matched by PartialFunction"
+}
+
+// Define an optional function
+val f: Int => Option[String] = { i =>
+  if (i == 2) {
+    Some("matched by optional function")
+  } else {
+    None
+  }
+}
+
+// Convert an optional function to a PartialFunction
+val pf2: PartialFunction[Int, String] = Function.unlift(f)
+
+util.Random.nextInt(4) match {
+  case pf.extract(m) => // Convert a PartialFunction to a pattern
+    println(m)
+  case f.extract(m) => // Convert an optional function to a pattern
+    println(m)
+  case pf2.extract(m) => // Convert a PartialFunction to a pattern
+    throw new AssertionError("This case should never occur because it has the same condition as `f.extract`.")
+  case _ =>
+    println("Not matched")
+}
+{% endhighlight %}
+
+Alternatively, `extract.seq` can be used to create an object with a `unapplySeq` method, which extracts each element of a sequence data.
+
+{% highlight scala %}
+val csvRow: String => Option[Seq[String]] = { line =>
+  Some(line.split(','))
+}
+
+"foo,bar,baz" match {
+  case csvRow.extract.seq(cell0, cell1, cell2) =>
+    println(s"cell1=$cell1") // Output: cell1=bar
+}
+{% endhighlight %}
+
+## Implementation
+
+The `extract` method has been implemented in a library: [Extractor.scala](https://github.com/ThoughtWorksInc/Extractor.scala), which has been used in Binding.scala in order to [extract patterns of XML literals](https://github.com/ThoughtWorksInc/Binding.scala/blob/10.0.x/XmlExtractor/src/main/scala/com/thoughtworks/binding/XmlExtractor.scala#L63).
+
+## Drawbacks
+
+Why should we *not* do this. Be honest, these questions will come out during the
+process anyway so it's better to get them out up front.
+
+## References
+
+1. [Existing Implementation (Extractor.scala)][1]
+
+[1]: https://github.com/ThoughtWorksInc/Extractor.scala "Extractor.scala"