Docs: Use parens in arrow functions, and overall reduce arrows funcs

Cut back the use of arrow functins somewhat, especially in migration
guides from older versions, and in generic examples that aren't about
scope.

When we use them, consistency use parentheses around the arguments.

Remove the `hooks => ` and `assert => ` idiom from examples which
have not taken off in practice, and don't jive well with most
practical style guides. It may seem minimal, but it makes the code
not realistic and not directly portable. It also makes it harder to
adopt, e.g. to add an argument such as the case when using
`QUnit.test.each()`.

Author: Krinkle

docs/api/QUnit/module.md

@@ -249,7 +249,7 @@ QUnit.module.skip('Robot', (hooks) => {
     android = new Robot();
   });
 
-  QUnit.test('hello', (assert) => {
+  QUnit.test('hello', function (assert) {
     assert.strictEqual(android.hello(), 'Hello, my name is AN-2178!');
   });
 });
@@ -274,7 +274,7 @@ QUnit.module.only('Robot', (hooks) => {
     android = new Robot();
   });
 
-  QUnit.test('hello', (assert) => {
+  QUnit.test('hello', function (assert) {
     assert.strictEqual(android.hello(), 'Hello, my name is AN-2178!');
   });
 });
@@ -289,7 +289,7 @@ QUnit.module.todo('Robot', (hooks) => {
     android = new Robot();
   });
 
-  QUnit.test('hello', (assert) => {
+  QUnit.test('hello', function (assert) {
     assert.strictEqual(android.hello(), 'Hello');
     // TODO
     // Actual: Goodbye

docs/api/QUnit/test.md

@@ -54,7 +54,7 @@ function square (x) {
   return x * x;
 }
 
-QUnit.test('square()', (assert) => {
+QUnit.test('square()', function (assert) {
   assert.equal(square(2), 4);
   assert.equal(square(3), 9);
 });
@@ -67,7 +67,7 @@ Following the example above, `QUnit.test` also supports JS [async functions][] s
 [async functions]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function
 
 ```js
-QUnit.test('Test with async-await', async (assert) => {
+QUnit.test('Test with async-await', async function (assert) {
   const a = await fetchSquare(2);
   const b = await fetchSquare(3);
 

docs/api/QUnit/test.only.md

@@ -45,23 +45,23 @@ When debugging a larger area of code, you may want to expand your filter to run
 How to use `QUnit.test.only` to filter which tests are run.
 
 ```js
-QUnit.module('robot', hooks => {
+QUnit.module('robot', (hooks) => {
   let robot;
   hooks.beforeEach(() => {
     robot = new Robot();
   });
 
-  QUnit.test('say()', assert => {
+  QUnit.test('say()', (assert) => {
     assert.true(robot.say('Hello'));
   });
 
   // Run only this test
   // For example, you are working on changing this method.
-  QUnit.test.only('laser()', assert => {
+  QUnit.test.only('laser()', (assert) => {
     assert.true(robot.laser());
   });
 
-  QUnit.test('take()', assert => {
+  QUnit.test('take()', (assert) => {
     assert.true(robot.take(5));
   });
 });

docs/api/QUnit/test.skip.md

@@ -43,18 +43,18 @@ As a codebase becomes bigger, you may sometimes want to temporarily disable an e
 How to use `skip` as a placeholder for future tests, or to temporarily skip a broken test.
 
 ```js
-QUnit.module('robot', hooks => {
+QUnit.module('robot', (hooks) => {
   let robot;
   hooks.beforeEach(() => {
     robot = new Robot();
   });
 
-  QUnit.test('say', assert => {
+  QUnit.test('say', (assert) => {
     assert.strictEqual(robot.say(), 'Exterminate!');
   });
 
   // Robot does not yet have a laser() method yet, skip this test for now
-  QUnit.test.skip('laser', assert => {
+  QUnit.test.skip('laser', (assert) => {
     assert.true(robot.laser());
   });
 

docs/api/QUnit/test.todo.md

@@ -43,14 +43,14 @@ You can also use [`QUnit.module.todo()`](./module.md) to manage the "todo" state
 How to use `QUnit.test.todo` to denote code that is still under development.
 
 ```js
-QUnit.module('Robot', hooks => {
+QUnit.module('Robot', (hooks) => {
   let robot;
   hooks.beforeEach(() => {
     robot = new Robot();
   });
 
   // Robot is not yet finished
-  QUnit.test.todo('fireLazer', assert => {
+  QUnit.test.todo('fireLazer', (assert) => {
     const result = robot.fireLazer();
     assert.equal(result, "I'm firing my lazer!");
   });

docs/api/assert/async.md

@@ -40,10 +40,10 @@ function fetchDouble (num, callback) {
   callback(double);
 }
 
-QUnit.test('async example', assert => {
+QUnit.test('async example', function (assert) {
   const done = assert.async();
 
-  fetchDouble(21, res => {
+  fetchDouble(21, (res) => {
     assert.strictEqual(res, 42, 'Result');
     done();
   });
@@ -54,15 +54,15 @@ QUnit.test('async example', assert => {
 Call `assert.async()` multiple times to wait for multiple async operations. Each `done` callback must be called exactly once for the test to pass.
 
 ```js
-QUnit.test('two async calls', assert => {
+QUnit.test('two async calls', function (assert) {
   const done1 = assert.async();
   const done2 = assert.async();
 
-  fetchDouble(3, res => {
+  fetchDouble(3, (res) => {
     assert.strictEqual(res, 6, 'double of 3');
     done1();
   });
-  fetchDouble(9, res => {
+  fetchDouble(9, (res) => {
     assert.strictEqual(res, 18, 'double of 9');
     done2();
   });
@@ -82,7 +82,7 @@ function uploadBatch (batch, notify, complete) {
   complete(null);
 }
 
-QUnit.test('multiple calls example', assert => {
+QUnit.test('multiple calls example', function (assert) {
   assert.timeout(1000);
 
   const notify = assert.async(3);

docs/api/assert/closeTo.md

@@ -31,7 +31,7 @@ To learn how floating-point numbers work internally, refer to [Double-precision
 ## Examples
 
 ```js
-QUnit.test('good example', assert => {
+QUnit.test('good example', function (assert) {
   const x = 0.1 + 0.2; // 0.30000000000000004
 
   // passing: must be between 0.299 and 0.301
@@ -42,7 +42,7 @@ QUnit.test('good example', assert => {
   assert.closeTo(y, 20.10, 0.05);
 });
 
-QUnit.test('bad example', assert => {
+QUnit.test('bad example', function (assert) {
   const x = 20.7;
   // failing: must be between 20.0 and 20.2 inclusive
   assert.closeTo(x, 20.1, 0.1);

docs/api/assert/deepEqual.md

@@ -36,10 +36,10 @@ To assert strict equality on own properties only, refer to [`assert.propEqual()`
 
 ```js
 function makeComplexObject (name, extra, country) {
-  var children = new Set();
+  const children = new Set();
   children.add('Alice');
   children.add(extra);
-  var countryToCapital = { UK: 'London' };
+  const countryToCapital = { UK: 'London' };
   return {
     name: name,
     children: children,
@@ -51,7 +51,7 @@ function makeComplexObject (name, extra, country) {
 }
 
 QUnit.test('object example', function (assert) {
-  var result = makeComplexObject('Marty', 'Bob', 'UK');
+  const result = makeComplexObject('Marty', 'Bob', 'UK');
 
   // Succeeds!
   // While each object is distinct by strict equality (identity),
@@ -91,7 +91,7 @@ class BaseCoord {
 class PrimaryDimensionCoord extends BaseCoord {}
 class UpsideDownCoord extends BaseCoord {}
 
-QUnit.test('class example', assert => {
+QUnit.test('class example', function (assert) {
   eleven.goto('Enschede');
   eleven.enterGate();
   const loc = eleven.getLocation();
@@ -105,7 +105,7 @@ QUnit.test('class example', assert => {
 ```
 
 ```js
-QUnit.test('failing example', assert => {
+QUnit.test('failing example', function (assert) {
   const result = {
     a: 'Albert',
     b: 'Berta',

docs/api/assert/false.md

@@ -27,7 +27,7 @@ This method is similar to the `assertFalse()` method found in xUnit-style framew
 ## Examples
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   // success
   assert.false(false, 'boolean false');
 

docs/api/assert/notDeepEqual.md

@@ -31,7 +31,7 @@ This is the inverse of [`assert.deepEqual()`](./deepEqual.md).
 Compare the value of two objects.
 
 ```js
-QUnit.test('example', assert => {
+QUnit.test('example', function (assert) {
   const result = { foo: 'yep' };
 
   // succeeds, objects are similar but have a different foo value.