Rewrote extractors section of tour #761

travissarles · 2017-04-07T10:54:09Z

No description provided.

travissarles · 2017-04-10T17:26:42Z

julienrf · 2017-04-11T07:56:29Z

tutorials/tour/_posts/2017-02-13-extractor-objects.md

-The `apply` method is not necessary for pattern matching.  It is only used to mimick a constructor. `val x = Twice(21)` expands to `val x = Twice.apply(21)`.
+  def unapply(customerID: String): Option[String] = {
+    val name = customerID.split("--")(0)
+    if (!name.isEmpty) Some(name) else None


You could use if (name.nonEmpty) ….

On the line above, you could also use customerID.split("--").head, or even .headOption, but split always returns at least one element, so I think that’s fine…

julienrf · 2017-04-11T08:03:17Z

tutorials/tour/_posts/2017-02-13-extractor-objects.md

+val CustomerID(name) = customer1ID
+println(name)  //  Sukyoung
+```
+The `apply` method creates a `CustomerID` string from a `name`. The `unapply` does the inverse to get the `name` back. Although `CustomerID` doesn't take any parameters, when we call `CustomerID("Sukyoung")`, this is shorthand syntax for calling `CustomerID.apply("Sukyoung")`. When we call `val CustomerID(name) = customer1ID`, this is shorthand for `val name = CustomerID.unapply(name)`.


This is not exact: val CustomerID(name) = customer1ID is a shorthand for val name = CustomerID.unapply(name).get (note the trailing .get call that is missing in your description).

Also, I think it is worth reminding that patterns can also be used in pattern matching (not just in val definitions).

Finally, the unapply method don’t have to return an Option (but that information is relevant for advanced users only, I think), and you can also define an unapplySeq method that extracts a variable number of information.

SethTisue · 2017-04-11T15:12:55Z

@SethTisue any comments?

(it's unlikely I'll have any time to review any of the tour PRs until May, I'm afraid)

S11001001

More generally:

Extractors more commonly appear as cases in a PF or match. The emphasis on val extractions doesn't reflect common use, though it is useful as well.

At the very least, it is worth noting here that, in general, extractors disable exhaustiveness checking, because a new user who has seen exhaustiveness checking in action will likely intuit that it will work for these too, even though it cannot.

Finally, speaking of matches to val, ascribing an irrefutable extractor with Some instead of Option has an interesting result:

scala> object RestString {
         def unapply(s: String): Some[String] = Some(s drop 1)
       }
defined object RestString

scala> "ooh" match {case RestString(q) => q; case _ => "nope"}
<console>:13: warning: unreachable code
       "ooh" match {case RestString(q) => q; case _ => "nope"}
                                                       ^
res1: String = oh

This rather positive effect implies that it may be worth recommending that irrefutable extractors, those explicitly designed for extraction with val instead of might-fail patterns, ought to be ascribed in this way.

S11001001 · 2017-04-17T02:55:48Z

tutorials/tour/_posts/2017-02-13-extractor-objects.md

@@ -11,32 +11,41 @@ next-page: sequence-comprehensions
 previous-page: regular-expression-patterns
 ---

-In Scala, patterns can be defined independently of case classes. To this end, a method named unapply is defined to yield a so-called extractor. An extractor can be thought of as a special method that reverses the effect of applying a particular object on some inputs. Its purpose is to 'extract' the inputs that were present before the 'apply' operation. For instance, the following code defines an extractor [object](singleton-objects.html) Twice.
-
+An extractor object is an object with an `unapply` method. Whereas the a `apply` method is like a constructor which takes arguments and creates an object, the `unapply` takes an object and tries to give back the arguments.


S11001001 · 2017-04-17T02:57:44Z

tutorials/tour/_posts/2017-02-13-extractor-objects.md


-The pattern `case Twice(n)` will cause an invocation of `Twice.unapply`, which is used to match any even number; the return value of the `unapply` signals whether the argument has matched or not, and any sub-values that can be used for further matching. Here, the sub-value is `z/2`
+  def unapply(customerID: String): Option[String] = {
+    val name = customerID.split("--").head


Can you account for CustomerID("a--b") without overly complicating the example? (e.g. split only the last one)

@S11001001 I'm not sure what you mean, can you elaborate?

Currently:

scala> val CustomerID(x) = CustomerID("a--b") x: String = a

S11001001 · 2017-04-17T02:58:21Z

tutorials/tour/_posts/2017-02-13-extractor-objects.md


-The `apply` method is not necessary for pattern matching.  It is only used to mimick a constructor. `val x = Twice(21)` expands to `val x = Twice.apply(21)`.
+val customer1ID = CustomerID("Sukyoung")  // Sukyoung-23098234908


Should be two hyphens.

S11001001 · 2017-04-17T02:59:36Z

tutorials/tour/_posts/2017-02-13-extractor-objects.md

+val CustomerID(name) = customer1ID
+println(name)  // prints Sukyoung
+```
+The `apply` method creates a `CustomerID` string from a `name`. The `unapply` does the inverse to get the `name` back. When we call `CustomerID("Sukyoung")`, this is shorthand syntax for calling `CustomerID.apply("Sukyoung")`. When we call `val CustomerID(name) = customer1ID`, this is equivalent to `val name = CustomerID.unapply(customer1ID)`. This is used in pattern matching like so:


The second equivalence does not hold, because unapply returns Option[String].

S11001001 · 2017-04-17T03:00:56Z

tutorials/tour/_posts/2017-02-13-extractor-objects.md

+In fact, if we tried to unapply an invalid `CustomerID`, we would get a `scala.MatchError`:
+```tut:fail
+val CustomerID(name2) = "--asdfasdfasdf"
+name2.isEmpty


This line will fail in tut because name2 is unbound, which probably obscures the point you're making (where only the first line's error is relevant).

The val keyword doesn't bind it? I'm seeing a MatchError when I run it in a worksheet.

@travissarles yeah I think you're right here

Here is what tut emits. Note the second error.

This is equivalent to val name = CustomerID.unapply(customer2ID).get. If there is no match, a scala.MatchError is thrown:

scala> val CustomerID(name2) = "--asdfasdfasdf" scala.MatchError: --asdfasdfasdf (of class java.lang.String) ... 198 elided scala> name2.isEmpty <console>:14: error: not found: value name2 name2.isEmpty ^

ah, I see. because tut is REPL based.

nbd either way I think, but I'd be fine with omitting the name2.isEmpty line

@S11001001 I took out the name2.isEmpty as it's not helpful

jvican · 2017-04-17T13:07:52Z

This rather positive effect implies that it may be worth recommending that irrefutable extractors, those explicitly designed for extraction with val instead of might-fail patterns, ought to be ascribed in this way.

Interesting, didn't know this trick. Thanks for sharing.

S11001001 · 2017-04-29T00:38:06Z

tutorials/tour/_posts/2017-02-13-extractor-objects.md

+```tut
+val customer2ID = CustomerID("Nico")
+val CustomerID(name) = customer2ID
+println(name)  // prints Nico


Can probably do without this println, as tut writes

scala> val customer2ID = CustomerID("Nico") customer2ID: String = Nico--8217157908548994001 scala> val CustomerID(name) = customer2ID name: String = Nico scala> println(name) // prints Nico Nico

We aren't actually using the output of tut. We're just using it to verify that code snippets compile (or don't). Actually using the output is a possible future improvement.

@SethTisue Ah, I see.

I'd like to use Scastie in the future so people can see the output and play around with the examples.

travissarles · 2017-05-08T13:55:13Z

@julienrf any other comments?

julienrf reviewed Apr 11, 2017

View reviewed changes

travissarles force-pushed the extractor-objects branch from 50343c1 to c3ea3ba Compare April 12, 2017 11:39

S11001001 reviewed Apr 17, 2017

View reviewed changes

travissarles force-pushed the extractor-objects branch 2 times, most recently from f5093a3 to 96c0032 Compare April 28, 2017 15:00

S11001001 reviewed Apr 29, 2017

View reviewed changes

Rewrote extractors section of tour

80b5e9c

travissarles force-pushed the extractor-objects branch from 96c0032 to 80b5e9c Compare May 1, 2017 15:20

julienrf approved these changes May 8, 2017

View reviewed changes

travissarles merged commit 81d6978 into scala:master May 8, 2017


		The `apply` method is not necessary for pattern matching. It is only used to mimick a constructor. `val x = Twice(21)` expands to `val x = Twice.apply(21)`.
		val customer1ID = CustomerID("Sukyoung") // Sukyoung-23098234908

Rewrote extractors section of tour #761

Rewrote extractors section of tour #761

Uh oh!

Conversation

travissarles commented Apr 7, 2017

Uh oh!

travissarles commented Apr 10, 2017

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

SethTisue commented Apr 11, 2017

Uh oh!

S11001001 left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

jvican commented Apr 17, 2017

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

travissarles commented May 8, 2017

Uh oh!

Uh oh!