Add examples to computed-props and for-of READMEs [skip ci] (#5096)

packages/babel-plugin-transform-es2015-computed-properties/README.md

@@ -2,6 +2,49 @@
 
 > Compile ES2015 computed properties to ES5
 
+## Example
+
+**In**
+
+```js
+var obj = {
+  ["x" + foo]: "heh",
+  ["y" + bar]: "noo",
+  foo: "foo",
+  bar: "bar"
+};
+```
+
+**Out**
+
+```js
+var _obj;
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+var obj = (
+  _obj = {},
+  _defineProperty(_obj, "x" + foo, "heh"),
+  _defineProperty(_obj, "y" + bar, "noo"),
+  _defineProperty(_obj, "foo", "foo"),
+  _defineProperty(_obj, "bar", "bar"),
+  _obj
+);
+```
+
 ## Installation
 
 ```sh
@@ -46,6 +89,38 @@ require("babel-core").transform("code", {
 
 ## Options
 
-* `loose` - Just like method assignment in classes, in loose mode, computed property names
+### `loose`
+
+`boolean`, defaults to `false`
+
+Just like method assignment in classes, in loose mode, computed property names
 use simple assignments instead of being defined. This is unlikely to be an issue
 in production code.
+
+#### Example
+
+***In***
+
+```js
+var obj = {
+  ["x" + foo]: "heh",
+  ["y" + bar]: "noo",
+  foo: "foo",
+  bar: "bar"
+};
+```
+
+***Out***
+
+```js
+var _obj;
+
+var obj = (
+  _obj = {},
+  _obj["x" + foo] = "heh",
+  _obj["y" + bar] = "noo",
+  _obj.foo = "foo",
+  _obj.bar = "bar",
+  _obj
+);
+```

packages/babel-plugin-transform-es2015-for-of/README.md

@@ -2,6 +2,41 @@
 
 > Compile ES2015 for...of to ES5
 
+## Example
+
+**In**
+
+```js
+for (var i of foo) {}
+```
+
+**Out**
+
+```js
+var _iteratorNormalCompletion = true;
+var _didIteratorError = false;
+var _iteratorError = undefined;
+
+try {
+  for (var _iterator = foo[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+    var i = _step.value;
+  }
+} catch (err) {
+  _didIteratorError = true;
+  _iteratorError = err;
+} finally {
+  try {
+    if (!_iteratorNormalCompletion && _iterator.return) {
+      _iterator.return();
+    }
+  } finally {
+    if (_didIteratorError) {
+      throw _iteratorError;
+    }
+  }
+}
+```
+
 ## Installation
 
 ```sh
@@ -44,52 +79,48 @@ require("babel-core").transform("code", {
 });
 ```
 
-## Options `loose`
+## Options
 
-#### Abrupt completions
+### `loose`
 
-In loose mode an iterators `return` method will not be called on abrupt completions caused by thrown errors.
+`boolean`, defaults to `false`
 
-Please see [google/traceur-compiler#1773](https://github.com/google/traceur-compiler/issues/1773) and
-[babel/babel#838](https://github.com/babel/babel/issues/838) for more information.
+In loose mode, arrays are put in a fast path, thus heavily increasing performance.
+All other iterables will continue to work fine.
 
-#### Arrays
+#### Example
 
-Under loose mode the `forOf` transformer will output more verbose iteration code.
+**In**
 
-For example the following:
-
-```javascript
+```js
 for (var i of foo) {}
 ```
 
-is normally output as:
+**Out**
 
-```javascript
-for (var _iterator = foo[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) {
-  var i = _step.value;
-}
-```
-
-Under loose mode however it's output as:
-
-```javascript
+```js
 for (var _iterator = foo, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
-  var i;
+  var _ref;
+
   if (_isArray) {
     if (_i >= _iterator.length) break;
-    i = _iterator[_i++];
+    _ref = _iterator[_i++];
   } else {
     _i = _iterator.next();
     if (_i.done) break;
-    i = _i.value;
+    _ref = _i.value;
   }
+
+  var i = _ref;
 }
 ```
 
-The result is that arrays are put in a fast path, heavily increasing performance.
-All other iterables will continue to work fine but array iteration will be
-significantly faster.
+#### Abrupt completions
+
+In loose mode an iterator's `return` method will not be called on abrupt completions caused by thrown errors.
+
+Please see [google/traceur-compiler#1773](https://github.com/google/traceur-compiler/issues/1773) and
+[babel/babel#838](https://github.com/babel/babel/issues/838) for more information.
 
 ### Optimization