Cleanup examples and avoid confusing use of fat arrows

Author: eriwen

MIGRATION_GUIDE.md

@@ -16,13 +16,13 @@ All you have to do to get stacktrace.js v0.x behavior is call `.toString()` on a
 v0.x:
 ```js
 printStackTrace();
-=> Array[String]
+//===> Array[String]
 ```
 
 v1.x:
 ```js
 StackTrace.get().then(callback).catch(errback);
-=> Promise(Array[StackFrame], Error)
+//===> Promise(Array[StackFrame], Error)
 ```
 
 `StackTrace.get()` returns a [Promise](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise)
@@ -34,14 +34,14 @@ v0.x:
 ```js
 var error = new Error('Boom');
 printStackTrace({e: error});
-=> Array[String]
+//===> Array[String]
 ```
 
 v1.x:
 ```js
 var error = new Error('Boom');
 StackTrace.fromError(error).then(callback).catch(errback);
-=> Promise(Array[StackFrame], Error)
+//===> Promise(Array[StackFrame], Error)
 ```
 
 If this is all you need, you don't even need the full stacktrace.js library! Just use [error-stack-parser](https://github.com/stacktracejs/error-stack-parser)!
@@ -55,23 +55,23 @@ Instrumenting now takes `Function` references instead of `String`s.
 
 v0.x:
 ```js
-function interestingFn() {...}; 
+function interestingFn() {/* ... */}
 
 var p = new printStackTrace.implementation();
 p.instrumentFunction(this, 'interestingFn', logStackTrace);
-=> Function (instrumented)
+//===> Function (instrumented)
 
 p.deinstrumentFunction(this, 'interestingFn');
-=> Function (original)
+//===> Function (original)
 ```
 
 v1.x:
 ```js
-function interestingFn() {...};
+function interestingFn() {/* ... */}
 
 StackTrace.instrument(interestingFn, callback, errback);
-=> Function (instrumented)
+//===> Function (instrumented)
 
 StackTrace.deinstrument(interestingFn);
-=> Function (original)
+//===> Function (original)
 ```

README.md

@@ -24,9 +24,9 @@ var callback = function(stackframes) {
 
 var errback = function(err) { console.log(err.message); };
 
-StackTrace.get().then(callback).catch(errback)
-=> Promise(Array[StackFrame], Error)
-=> callback([StackFrame('func1', [], 'file.js', 203, 9), StackFrame('func2', [], 'http://localhost:3000/file.min.js', 1, 3284)])
+StackTrace.get().then(callback).catch(errback);
+//===> Promise(Array[StackFrame], Error)
+//===> callback([StackFrame('func1', [], 'file.js', 203, 9), StackFrame('func2', [], 'http://localhost:3000/file.min.js', 1, 3284)])
 ```
 
 #### window.onerror integration
@@ -42,29 +42,29 @@ window.onerror = function(msg, file, line, col, error) {
 ```js
 var error = new Error('BOOM!');
 
-StackTrace.fromError(error).then(callback).catch(errback)
-=> Promise(Array[StackFrame], Error)
+StackTrace.fromError(error).then(callback).catch(errback);
+//===> Promise(Array[StackFrame], Error)
 ```
 
 #### Generate a stacktrace from walking arguments.callee
 This might capture arguments information, but isn't supported in ES5 strict-mode
 ```js
-StackTrace.generateArtificially().then(callback).catch(errback)
-=> Promise(Array[StackFrame], Error)
+StackTrace.generateArtificially().then(callback).catch(errback);
+//===> Promise(Array[StackFrame], Error)
 ```
 
 #### Trace every time a given function is invoked
 ```js
 // callback is called with an Array[StackFrame] every time wrapped function is called
-var myFunc = function(arg) { return 'Hello ' + arg; }
-var myWrappedFunc = StackTrace.instrument(myFunc, callback, errback)
-=> Instrumented Function
+var myFunc = function(arg) { return 'Hello ' + arg; };
+var myWrappedFunc = StackTrace.instrument(myFunc, callback, errback);
+//===> Instrumented Function
 myWrappedFunc('world');
-=> 'Hello world'
+//===> 'Hello world'
 
 // Use this if you overwrote you original function
-myFunc = StackTrace.deinstrument(myFunc)
-=> De-instrumented Function
+myFunc = StackTrace.deinstrument(myFunc);
+//===> De-instrumented Function
 ```
 
 ## Get stacktrace.js