monw3c
diff --git a/‎06_object.md‎
Lines changed: 79 additions & 45 deletions b/‎06_object.md‎
Lines changed: 79 additions & 45 deletions
diff --git a/‎07_robot.md‎
Lines changed: 37 additions & 31 deletions b/‎07_robot.md‎
Lines changed: 37 additions & 31 deletions
diff --git a/‎11_async.md‎
Lines changed: 6 additions & 7 deletions b/‎11_async.md‎
Lines changed: 6 additions & 7 deletions
diff --git a/‎20_node.md‎
Lines changed: 1 addition & 1 deletion b/‎20_node.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎21_skillsharing.md‎
Lines changed: 8 additions & 8 deletions b/‎21_skillsharing.md‎
Lines changed: 8 additions & 8 deletions
diff --git a/‎code/solutions/06_2_groups.js‎
Lines changed: 36 additions & 0 deletions b/‎code/solutions/06_2_groups.js‎
Lines changed: 36 additions & 0 deletions
@@ -1063,76 +1063,110 @@ JavaScript.
 
 hint}}
 
-### List class
+### Groups
 
-{{index "list (exercise)", interface, iterator, "static method", "List class"}}
+{{index "groups (exercise)", "Set class", "Group class", "set (data structure)"}}
 
-Rewrite the list data structure from the exercises in [Chapter
-?](data#list) as a ((class)). Give `List` objects their old
-`value` and `rest` properties, but also a `toArray` method and a
-`length` getter that returns the length of the list. Make `fromArray`
-a static method on the `List` constructor.
+{{id groups}}
 
-In order for lists to work as a class with methods, we can no longer
-represent the empty list as `null`, but have to create a special
-instance of our class that acts as the empty list placeholder, and
-compare with that instance, instead of `null`, when checking if we've
-reached the end of a list. Store this instance in `List.empty` (a
-static property).
+The standard JavaScript environment provides another data structure
+called `Set`. Like an instance of `Map`, a set holds a collection of
+values. Unlike `Map`, it does not associate other values with those—it
+just tracks which values are part of the set. A value can only be part
+of a set once—adding it again doesn't have any effect.
+
+{{index "add method", "delete method", "has method"}}
+
+Write a class called `Group` (since `Set` is already taken). Like
+`Set`, it has `add`, `delete`, and `has` methods. Its constructor
+creates an empty group, `add` adds a value to the group (but only if
+it isn't already a member), `delete` removes its argument from the
+group (it if was a member), and `has` returns a Boolean value
+indicating whether its argument is a member of the group.
+
+{{index "=== operator", "indexOf method"}}
+
+Use the `===` operator, or something equivalent such as `indexOf`, to
+determine whether two values are the same.
+
+{{index "static method"}}
+
+Give the class a static `from` method that takes an iteratable object
+as argument and creates a group that contains all the values produced
+by iterating over it.
 
 {{if interactive
 
 ```{test: no}
-class List {
+class Group {
   // Your code here.
 }
 
-console.log(List.fromArray([10, 20]));
-// → {value: 10, rest: {value: 20, rest: null}}
-console.log(List.fromArray([10, 20, 30]).toArray());
-// → [10, 20, 30]
-console.log(new List(2, List.empty).length);
-// → 1
+let group = Group.from([10, 20]);
+console.log(group.has(10));
+// → true
+console.log(group.has(30));
+// → false
+group.add(10);
+group.delete(10);
+console.log(group.has(10));
+// → false
 ```
 
 if}}
 
 {{hint
 
-{{index "list (exercise)"}}
+{{index "groups (exercise)", "Group class", "indexOf method", "includes method"}}
+
+The easiest way to do this is to store an ((array)) of group members
+in an instance property. The `includes` or `indexOf` methods can be
+used to check whether a given value is in the array.
+
+{{index "push method"}}
 
-Your class' constructor should take a value and a rest list as
-parameters, and store those in the instance.
+Your class' ((constructor)) can set the member collection to an empty
+array. When `add` is called, it must check whether the given value is
+in the array, and add it, for example with `push`, otherwise.
 
-The static `fromArray` method can be written inside the class
-declaration. The `empty` property, because it is not a function, must
-be added to the prototype afterwards—but that would have been
-necessary anyway, because we couldn't create an instance of `List`
-before we've finished defining the class.
+{{index "filter method"}}
 
-The value of the empty list object is not important—when using lists
-correctly, it should not be read. The `toArray` and `length` methods
-do the right thing automatically, even on this object, if you make the
-end conditions of their loops check for `== List.empty`.
+Deleting an element from an array, in `delete`, is slightly awkward,
+but you can use `filter` to create a new array without the value.
+Don't forget to overwrite the property holding the members with the
+newly filtered version of the array.
+
+{{index "for/of loop", "iterable interface"}}
+
+The `from` method can use a `for`/`of` loop to get the values out of
+the iterable object, and call `add` to put them into a newly created
+group.
 
 hint}}
 
-### List iteration
+### Iterable groups
 
-{{index "list (exercise)", interface, "iterator interface"}}
+{{index "groups (exercise)", interface, "iterator interface", "Group class"}}
 
-{{id list_iterator}}
+{{id group_iterator}}
 
-Make the `List` class from the previous exercise iterable. Refer back
+Make the `Group` class from the previous exercise iterable. Refer back
 to the section about the iterator interface earlier in the chapter if
 you aren't clear on the exact form of the interface anymore.
 
+If you used an array to represent the group's members, don't just
+return the iterator created by calling the `Symbol.iterator` method on
+the array. That would work, but defeats the purpose of this exercise.
+
+It is okay if your iterator behaves strangely when the group is
+modified during iteration.
+
 {{if interactive
 
 ```{test: no}
 // Your code here (and the code from the previous exercise)
 
-for (let value of List.fromArray(["a", "b", "c"])) {
+for (let value of Group.from(["a", "b", "c"])) {
   console.log(value);
 }
 // → a
@@ -1144,16 +1178,16 @@ if}}
 
 {{hint
 
-{{index "list (exercise)"}}
+{{index "groups (exercise)", "Group class", "next method"}}
 
-It is probably worthwhile to define a new class `ListIterator`.
-Iterator instances should have a property that tracks the current rest
-of the list. If that's the empty list, the `next` method can say it is
-done. If not, it should return the current element and move the
-current rest forward.
+It is probably worthwhile to define a new class `GroupIterator`.
+Iterator instances should have a property that tracks the current
+position in the group. Every time `next` is called, it checks whether
+it is done, and if not, moves past the current value and returns it.
 
-The list class itself gets a method named by `Symbol.iterator` which,
-when called, returns a new instance of the list iterator class.
+The `Group` class itself gets a method named by `Symbol.iterator`
+which, when called, returns a new instance of the iterator class for
+that group.
 
 hint}}
 
 
@@ -621,50 +621,50 @@ pick up a package, instead of delivering a package.
 
 hint}}
 
-### Persistent map
+### Persistent group
 
-{{index "persistent map (exercise)", "persistent data structure", "Map class", "map (data structure)", "PMap class"}}
+{{index "persistent group (exercise)", "persistent data structure", "Set class", "set (data structure)", "Group class", "PGroup class"}}
 
 Most data structures provided in a standard JavaScript environment
 aren't very well suited for persistent use. Arrays have `slice` and
 `concat` methods, which allow us to easily create new arrays without
-damaging the old one. But `Map`, for example, has no methods for
-creating a new map with an item added or removed.
+damaging the old one. But `Set`, for example, has no methods for
+creating a new set with an item added or removed.
 
-Write a new class `PMap`, which stores a mapping from keys to other
-values, and, like `Map`, has a `get` method to retrieve a value and a
-`has` method to check if a value is present.
+Write a new class `PGroup`, similar to the `Group` class from [Chapter
+?](object#groups), which stores a set of values. Like `Group`, it has
+`add`, `delete`, and `has` methods.
 
-Its `set` method, however, should return a _new_ `PMap` instance with
-the given key added, and leave the old one unchanged. Similarly,
-`delete` creates a new instance without a key.
+Its `add` method, however, should return a _new_ `PGroup` instance
+with the given member added, and leave the old one unchanged.
+Similarly, `delete` creates a new instance without a member.
 
 The class should work for keys of any type, not just strings. It does
 _not_ have to be efficient when used with large amounts of keys.
 
 The ((constructor)) shouldn't be part of the class' ((interface))
 (though you'll definitely want to use it internally). Instead, there
-is an empty instance, `PMap.empty`, that can be used as a starting
+is an empty instance, `PGroup.empty`, that can be used as a starting
 value.
 
 {{index singleton}}
 
-Why do you only need one `PMap.empty` value, rather than having a
+Why do you only need one `PGroup.empty` value, rather than having a
 function that creates a new, empty map every time?
 
 {{if interactive
 
 ```{test: no}
-class PMap {
+class PGroup {
   // Your code here
 }
 
-let a = PMap.empty.set("a", 1);
-let ab = a.set("b", 2);
+let a = PGroup.empty.add("a");
+let ab = a.add("b");
 let b = ab.delete("a");
 
-console.log(b.get("b"));
-// → 2
+console.log(b.has("b"));
+// → true
 console.log(a.has("b"));
 // → false
 console.log(b.has("a"));
@@ -675,23 +675,29 @@ if}}
 
 {{hint
 
-{{index "persistent map (exercise)", "Map class", array}}
+{{index "persistent map (exercise)", "Set class", array, "PGroup class"}}
 
-Since this needs to work with keys that aren't strings, you can't use
-object properties to store the mapping. You could use a `Map` instance
-inside your `PMap` instance, or an array that stores a set of pairs.
+The most convenient way to represent the set of member values remains
+is still an array, since those are easy to copy.
 
-I recommend using an array, since those are easy to copy. For each key
-added to the map, the array would hold a `{key, value}` object or a
-two-element array. When looking something up, you search the array for
-the pair that contains the proper key.
+{{index "concat method", "filter method"}}
 
-The class' ((constructor)) would then take such an array as argument,
-and store it as the instance's (only) direct property. This array is
-never updated. The `set` and `delete` methods create copies of it,
-with the appropriate elements added and removed.
+When a value is added to the group, you can create a new group with a
+copy of the original array that has the value added (for example using
+`concat`). When a value is deleted, you filter it from the array.
 
-When writing `set`, make sure that you also remove old versions of the
-key, in case a key that already exists is being set.
+The class' ((constructor)) would take such an array as argument, and
+store it as the instance's (only) property. This array is never
+updated.
+
+{{index "static method"}}
+
+To add a property to a constructor that is not a method, you have to
+add it to the constructor after the class definition, as a regular
+property.
+
+You only need on `empty` instance because all empty groups are the
+same and instances of the class don't change. You can create many
+different groups from that single empty group without affecting it.
 
 hint}}
@@ -997,16 +997,15 @@ the function returns (the one in the example never does), the iterator
 is done.
 
 Writing iterators is often much easier when you use generator
-functions. The iterator for a list object (from the exercise in
-[Chapter ?](object#list_iterator)) can be written with this generator:
+functions. The iterator for a group object (from the exercise in
+[Chapter ?](object#group_iterator)) can be written with this generator:
 
-{{index "List class"}}
+{{index "Group class"}}
 
 ```
-List.prototype[Symbol.iterator] = function*() {
-  for (let node = this; node != List.empty;
-       node = node.rest) {
-    yield node.value;
+Group.prototype[Symbol.iterator] = function*() {
+  for (let i = 0; i < this.members.length; i++) {
+    yield this.members[i];
   }
 };
 ```
 
@@ -903,7 +903,7 @@ the `isDirectory` method tells us.
 
 {{index "readdir function"}}
 
-We use `readdir` to read the list of files in a ((directory)) and
+We use `readdir` to read the array of files in a ((directory)) and
 return it to the client. For normal files, we create a readable stream
 with `createReadStream` return that as the body, along with the
 content type that the `mime` package gives us based on the file's
 
@@ -49,9 +49,9 @@ and a _((client))_ part, written for the ((browser)). The server
 stores the system's data and provides it to the client. It also serves
 the files that implement the client-side system.
 
-The server keeps a list of ((talk))s proposed for the next meeting,
+The server keeps the list of ((talk))s proposed for the next meeting,
 and the client shows this list. Each talk has a presenter name, a
-title, a summary, and a list of ((comment))s associated with it. The
+title, a summary, and an array of ((comment))s associated with it. The
 client allows users to propose new talks (adding them to the list),
 delete talks, and comment on existing talks. Whenever the user makes
 such a change, the client makes an ((HTTP)) ((request)) to tell the
@@ -548,18 +548,18 @@ be either a simple request for all talks or a long-polling request.
 
 {{index "talkResponse method", "ETag header"}}
 
-There will be multiple places in which we have to send a list of talks
-to the client, so we first define a helper method that builds up such
-a list and includes an `ETag` header in the response.
+There will be multiple places in which we have to send an array of
+talks to the client, so we first define a helper method that builds up
+such an array and includes an `ETag` header in the response.
 
 ```{includeCode: ">code/skillsharing/skillsharing_server.js"}
 SkillShareServer.prototype.talkResponse = function(talks) {
-  let list = [];
+  let talks = [];
   for (let title of Object.keys(this.talks)) {
-    list.push(this.talks[title]);
+    talks.push(this.talks[title]);
   }
   return {
-    body: JSON.stringify(list),
+    body: JSON.stringify(talks),
     headers: {"Content-Type": "application/json",
               "ETag": `"${this.version}"`}
   };
 
@@ -0,0 +1,36 @@
+class Group {
+  constructor() {
+    this.members = [];
+  }
+
+  add(value) {
+    if (!this.members.includes(value)) {
+      this.members.push(value);
+    }
+  }
+
+  delete(value) {
+    this.members = this.members.filter(v => v !== value);
+  }
+
+  has(value) {
+    return this.members.includes(value);
+  }
+
+  static from(collection) {
+    let group = new Group;
+    for (let value of collection) {
+      group.add(value);
+    }
+    return group;
+  }
+}
+
+let group = Group.from([10, 20]);
+console.log(group.has(10));
+// → true
+console.log(group.has(30));
+// → false
+group.add(10);
+group.delete(10);
+console.log(group.has(10));