Chapter 18: Patterns #469

steveklabnik · 2017-02-23T20:53:19Z

Fixes #468 (I ended up using the last example, we should give credit)

Fixes #298 by discussing destructuring, ref, and more complex patterns.

sophiajt · 2017-02-23T21:16:19Z

src/ch18-00-patterns.md

-    println!("The value of y is: {}", y);
-}
+Here, we have a tuple that we're matching against a pattern. Rust will compare
+the value `(1, 2, 3)` to the pattern `(x, y, z)`, and see that it's valid. In


Just realised you do this in the concurrency chapter when creating a channel. We may want to mention this chapter there, depending on how that chapter shakes out.

sophiajt · 2017-02-23T21:16:47Z

src/ch18-00-patterns.md

-the most commonly used ones in this section. Any of these abilities work in any
-place where a pattern is used.
+One of Rust's more subtle features is the simple *pattern*. Patterns let us
+pick apart complex strucutres and do all kinds of fun things with them. In this


strucutres => structures

sophiajt · 2017-02-23T21:22:51Z

src/ch18-00-patterns.md

-And run it with `cargo run`:
+Where we nest tons of things inside of each other. 
+
+## Refutability


Can we move this section lower? It feels like I want more hands-on with working with patterns before we get into the peculiarities of them.

sophiajt · 2017-02-23T21:23:40Z

src/ch18-00-patterns.md

+familliar with the word when you see it, and realize that you need to change
+either the pattern, or the construct you're using the pattern with.
+
+## Where can I use patterns?


Also if let

sophiajt · 2017-02-23T21:24:19Z

src/ch18-00-patterns.md

-In simple cases like this, two `let`s may be clearer, but in others, creating
-multiple variables at once is nice. As we become more proficient in Rust, we’ll
-figure out which style is better, but it’s mostly a judgment call.
+These patterns are refuatble. However...


refuatble => refutable

sophiajt · 2017-02-23T21:26:00Z

src/ch18-00-patterns.md

-In simple cases like this, two `let`s may be clearer, but in others, creating
-multiple variables at once is nice. As we become more proficient in Rust, we’ll
-figure out which style is better, but it’s mostly a judgment call.
+These patterns are refuatble. However...


I'm wondering if we could say let and match must cover all cases that the value can be. We can introduce the terms for this later, as I think they're less interesting than the concept of patterns matching values

sophiajt · 2017-02-23T21:29:17Z

src/ch18-00-patterns.md

-## Literals & _
+Here's a list of all of the different types of patterns.
+
+### Literals & _

 You can match against literals directly, and `_` acts as an any case:


this is rendering for me as �any�

your comment is rendering for me as �any�

I think i found all of these?

sophiajt · 2017-02-23T21:30:23Z

src/ch18-00-patterns.md

-## Literals & _
+Here's a list of all of the different types of patterns.
+
+### Literals & _


We may want to say "the underscore (_) pattern"

sophiajt · 2017-02-23T21:33:02Z

src/ch18-00-patterns.md

@@ -178,7 +280,7 @@ match name {
 println!("name is: {:?}", name);
 ```

-## Destructuring
+### Destructuring


Destructuring mentions structs and enums, but only shows structs.

Since you're quite often going to use pattern matching against enums, we probably want to cover them again here.

sophiajt · 2017-02-23T21:34:30Z

src/ch18-00-patterns.md

+```
+
+In this case, we want to compare `id` against the range `3...7`, but we also
+want to save the actual value of `id`.


Do we want a summary?

sophiajt · 2017-02-23T21:35:19Z

This one feels like a reference rather than the narrative style of the rest of the book. Perhaps that's mostly okay, but I think we should at least chat about whether or not we want the narrative style here as well.

carols10cents · 2017-02-27T20:57:02Z

@steveklabnik @jonathandturner I rearranged this a bunch, better or worse?

I like this chapter as a reference; trying to think of an example or use case that could weave through this whole chapter seems hard and like we'd end up with a gargantuan match with a million arms 🐙

@steveklabnik some of the TODOs in here are places that I think we could use some more text, could you take care of those please, or let me know if you'd rather I do it?

steveklabnik · 2017-04-01T15:23:52Z

TODO: if let example that isn't too repetitive with ch06-03

The problem here is that almost all uses of if let are those ones; I
grepped the compiler and 99% of them are either "do something on Some/None" or
"do something on one variant of an enum." I did have an interesting example in
the chapter 20, but then this would be duplicate of that...

steveklabnik · 2017-04-01T15:32:48Z

TODO: but not floating point literals right?

Sure, that works too.

TODO: would you consider references with & as a sort of literal? or is that
more like destructuring?

Only if the value itself is a literal, that is, &5 is a literal match, &n is a destructuring.

steveklabnik · 2017-04-01T15:45:41Z

I've pushed up some TODO fixes; @carols10cents if you get the chance, feel free to wrap this up; if not, I'll try to take another look soon.

Fixes #468

carols10cents · 2017-04-07T16:26:58Z

TODO: but not floating point literals right?

Sure, that works too.

I'm so confused right now. In my research for this chapter, I found this tracking issue (still open but partially complete) and this merged RFC which seem to imply that attempting to use floating point literals in match arms should produce a warning and in the future will be a hard error.

However, this code does not give me any warnings and seems to work happily.

It's only if I put the floating point in a constant that I can trigger the error mentioned.

Why are floating point literals allowed but not floating point constants? From the discussion on the RFC and linked threads, it's floating point numbers only implementing PartialEq and not Eq that's the problem, so shouldn't these both be disallowed?

Did I find a bug or am I misunderstanding something...?

Fixes #554.

Fixes #280.

carols10cents · 2017-04-07T23:25:35Z

OK, I'm ignoring whether or not you're supposed to be allowed to match floating point literals, and I think this is ready for review.

@steveklabnik @jonathandturner @ScottAbbey @matthewjasper ? ❤️ Anyone else? ❤️

matthewjasper · 2017-04-08T13:15:42Z

second-edition/src/ch18-02-refutability.md

+fail to match for some possible value are said to be *refutable*. `let`
+statements, function parameters, and `for` loops are restricted to only accept
+irrefutable patterns, since there's nothing correct the program could do if the
+pattern fails to match. `match`, `if let`, and `while let` expressions are


Not match. As this section says later: 'the last arm that might match any remaining values with an irrefutable pattern'.

matthewjasper · 2017-04-08T13:29:46Z

second-edition/src/ch18-03-pattern-syntax.md

+`Some(y)` introduces a new variable name `y` that will match any value inside a
+`Some` value. Because we're in a new scope inside the `match` expression, this
+is a new variable, not the `y` we declared at the beginning that has the value
+10. The new `y` binding will match any value inside a `Some`, which is what we


Sigh... 'value' needs to be moved down to this line.

aaaiiiieeee

matthewjasper · 2017-04-08T13:34:23Z

second-edition/src/ch18-03-pattern-syntax.md

+
+### Multiple patterns
+
+You can match multiple patterns with `|`, which means *or*:


This is for match only. Perhaps that could be clearer.

matthewjasper · 2017-04-08T13:36:17Z

second-edition/src/ch18-03-pattern-syntax.md

+
+### Matching Ranges of Values with `...`
+
+You can match a range of values with `...`:


(inclusive)

matthewjasper · 2017-04-08T13:37:56Z

second-edition/src/ch18-03-pattern-syntax.md

+
+    match p {
+        Point { x, y: 0 } => println!("On the x axis at {}", x),
+        Point { x: 0, y} => println!("On the y axis at {}", y),


space between y and }?

matthewjasper · 2017-04-08T13:38:26Z

second-edition/src/ch18-03-pattern-syntax.md

+# }
+#
+let points = vec![
+    Point { x: 0, y: 0},


Space before } (and following two lines)?

matthewjasper · 2017-04-08T13:44:57Z

second-edition/src/ch18-03-pattern-syntax.md

+let _s = s;
+
+println!("{}", s);
+```


Would this and the next example be more helpful if they showed this in a match/if let, like 18-16.

matthewjasper · 2017-04-08T13:45:12Z

second-edition/src/ch18-03-pattern-syntax.md

+
+This works just fine. Because we never bind `s` to anything, it's not moved.
+
+### Ignoring Remaining Parts of a Value with `..`


Should have 4 '#'?

matthewjasper · 2017-04-08T13:45:52Z

second-edition/src/ch18-03-pattern-syntax.md

+`robot_name` is moved within the `match` when `name` binds to that value.
+
+Using `&` in a pattern matches an existing reference in the value, as we saw in
+the previous section on destructuring. If you want to create a reference


'a previous section'?

I used "the" to refer to the specific section; I'm changing this to have the section heading to be clearer which section we're referring to 👍

matthewjasper · 2017-04-08T13:57:56Z

second-edition/src/ch18-03-pattern-syntax.md

+<span class="caption">Listing 18-21: Ignoring all fields of a `Point` except
+for `x` by using `..`</span>
+
+Using `..` is shorter to type than having to list out `_y` and `_z`. The `..`


y: _ and z: _

lol idk why I thought i could combine the shorthand struct syntax and underscores....

steveklabnik

💯 some very small typo things

steveklabnik · 2017-04-10T14:37:21Z

second-edition/src/ch18-01-all-the-places-for-patterns.md

+
+The first call to `enumerate` produces the tuple `(0, 1)`. When this value is
+matched to the pattern `(index, value)`, `index` will be 0 and `value` will
+equal 1.


s/equal/be/, that is, changing the verb in the middle of the sentence feels weird to me (so we could also change 'be' to 'equal' on the line above and i'd be fine either way

steveklabnik · 2017-04-10T14:37:56Z

second-edition/src/ch18-01-all-the-places-for-patterns.md

+let x = 5;
+```
+
+We've done this hundreds of times throughout this book. You may not have


don't we know it

steveklabnik · 2017-04-10T14:38:27Z

second-edition/src/ch18-01-all-the-places-for-patterns.md

+
+With `let`, we compare the expression against the pattern, and assign any names
+we find. So for example, in our `let x = 5;` case, `x` is a pattern that says
+"bind what matches here to the variable `x`. And since the name `x` is the


need a " after the .

steveklabnik · 2017-04-10T14:39:53Z

second-edition/src/ch18-02-refutability.md

+## Refutability: Whether a Pattern Might Fail to Match
+
+Patterns come in two forms: refutable and irrefutable. Patterns which cannot
+fail to match for any possible value are *irrefutable*, and patterns which can


"are said to be" so this matches up with the latter part of the sentence

steveklabnik · 2017-04-10T14:45:23Z

second-edition/src/ch18-03-pattern-syntax.md

+        println!("Found some other id: {}", id)
+    },
+}
+```


👍 😍 zomg i have not found an example this good in years of trying, every @ example I've seen has been to complex

rambip · 2023-07-11T09:57:09Z

I'm surprised there is no explanation about the ref syntax: it seems it is a quite isefull part of pattern matching !

Even other books use it, see here

Am I missing something here ?

It deserves an entire page IMO

If someone adds an explanation in chapter 18, it would be usefull to add a link from "deref" or pointers more broadly to this explanation

sophiajt reviewed Feb 23, 2017

View reviewed changes

steveklabnik and others added 11 commits April 7, 2017 10:10

Chapter 18: Patterns

209287c

Fixes #468

Carol edits

fc9a314

spelling

51abccf

Fix code examples

e8864b2

Let's try refutability this way

4b4cd22

More rearranging, notes with TODOs

adbd028

Resolve comments, leave more TODOs

03323ab

Clarify range is ONLY good for char & numeric

b453fa2

add another note

e97a642

more words

2f56ea9

fix some TODOs

cebc14e

carols10cents force-pushed the ch18-patterns branch from c8f4aae to cebc14e Compare April 7, 2017 14:11

Fix typo

4639ff2

carols10cents added 7 commits April 7, 2017 15:59

Rearranging and editing

68eda18

Add an example of matching on a struct field value

2f77940

Fixes #554.

Clarify in the intro a bit better what a pattern is

f2bb785

Fixes #280.

Wrapping lines

b0abb64

Add a summary

6ae5499

Fix listing numbers

b921380

Break sections into multiple files

3d47ebd

Fix spelling

3e59e17

matthewjasper reviewed Apr 8, 2017

View reviewed changes

Fixing things matthewjasper pointed out

5d794b4

steveklabnik commented Apr 10, 2017

View reviewed changes

carols10cents mentioned this pull request Apr 10, 2017

Drafts to get into beta #614

Closed

16 tasks

Fix steve nits

4ca9e51

carols10cents approved these changes Apr 10, 2017

View reviewed changes

carols10cents merged commit 73c1a0d into master Apr 10, 2017

carols10cents deleted the ch18-patterns branch April 10, 2017 15:34


		### Multiple patterns

		You can match multiple patterns with `\|`, which means or:


		### Matching Ranges of Values with `...`

		You can match a range of values with `...`:


		This works just fine. Because we never bind `s` to anything, it's not moved.

		### Ignoring Remaining Parts of a Value with `..`

Chapter 18: Patterns #469

Chapter 18: Patterns #469

Conversation

steveklabnik commented Feb 23, 2017 • edited by carols10cents Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

sophiajt commented Feb 23, 2017

carols10cents commented Feb 27, 2017

steveklabnik commented Apr 1, 2017

steveklabnik commented Apr 1, 2017

steveklabnik commented Apr 1, 2017

carols10cents commented Apr 7, 2017

carols10cents commented Apr 7, 2017

matthewjasper Apr 8, 2017 • edited Loading

Choose a reason for hiding this comment

matthewjasper Apr 8, 2017 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

steveklabnik left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

rambip commented Jul 11, 2023

steveklabnik commented Feb 23, 2017 •

edited by carols10cents

Loading

matthewjasper Apr 8, 2017 •

edited

Loading

matthewjasper Apr 8, 2017 •

edited

Loading