promise.then

p.then(onFulfilled[, onRejected]

p.then(function(value) {
  // fulfillment
}, function(reason) {
  // rejection
}

// using a resolved promise, the 'then' block will be triggered instantly, but its handlers will be triggered asynchronously as demonstrated by the console.logs
var resolvedProm = Promise.resolve(33

var thenProm = resolvedProm.then(function(value){
    console.log("this gets called after the end of the main stack. the value received and returned is: " + value
    return value;
}
// instantly logging the value of thenProm
console.log(thenProm

// using setTimeout we can postpone the execution of a function to the moment the stack is empty
setTimeout(function(){
    console.log(thenProm
}


// logs, in order:
// Promise {[[PromiseStatus]]: "pending", [[PromiseValue]]: undefined}
// "this gets called after the end of the main stack. the value received and returned is: 33"
// Promise {[[PromiseStatus]]: "resolved", [[PromiseValue]]: 33}

var p1 = new Promise( (resolve, reject) => {
  resolve('Success!'
  // or
  // reject ("Error!"
} 

p1.then( value => {
  console.log(value // Success!
}, reason => {
  console.log(reason // Error!
} 

Promise.resolve('foo')
  // 1. Receive "foo", concatenate "bar" to it, and resolve that to the next then
  .then(function(string) {
    return new Promise(function(resolve, reject) {
      setTimeout(function() {
        string += 'bar';
        resolve(string
      }, 1
    }
  })
  // 2. receive "foobar", register a callback function to work on that string
  // and print it to the console, but not before returning the unworked on
  // string to the next then
  .then(function(string) {
    setTimeout(function() {
      string += 'baz';
      console.log(string
    }, 1)
    return string;
  })
  // 3. print helpful messages about how the code in this section will be run
  // before the string is actually processed by the mocked asynchronous code in the
  // previous then block.  
  .then(function(string) {
    console.log("Last Then:  oops... didn't bother to instantiate and return " +
                "a promise in the prior then so the sequence may be a bit " +
                "surprising"

    // Note that `string` will not have the 'baz' bit of it at this point. This 
    // is because we mocked that to happen asynchronously with a setTimeout function
    console.log(string
  }

var p2 = new Promise(function(resolve, reject) {
  resolve(1
}

p2.then(function(value) {
  console.log(value // 1
  return value + 1;
}).then(function(value) {
  console.log(value + '- This synchronous usage is virtually pointless' // 2- This synchronous usage is virtually pointless
}

p2.then(function(value) {
  console.log(value // 1
}

Promise.resolve()
  .then( () => {
    // Makes .then() return a rejected promise
    throw 'Oh no!';
  })
  .then( () => { 
    console.log( 'Not called.' 
  }, reason => {
    console.error( 'onRejected function called: ', reason 
  }

Promise.reject()
  .then( () => 99, () => 42 ) // onRejected returns 42 which is wrapped in a resolving Promise
  .then( solution => console.log( 'Resolved with ' + solution )  // Resolved with 42

Promise.resolve()
  .then( () => {
    // Makes .then() return a rejected promise
    throw 'Oh no!';
  })
  .catch( reason => {
    console.error( 'onRejected function called: ', reason 
  })
  .then( () => {
    console.log( "I am always called even if the prior then's promise rejects" 
  }

function fetch_current_data() {
  // The fetch() API returns a Promise.  This function
  // exposes a similar API, except the fulfillment
  // value of this function's Promise has had more
  // work done on it.
  return fetch('current-data.json').then((response) => {
    if (response.headers.get('content-type') != 'application/json') {
      throw new TypeError(
    }
    var j = response.json(
    // maybe do something with j
    return j; // fulfillment value given to user of
              // fetch_current_data().then()
  }
}

function resolveLater(resolve, reject) {
  setTimeout(function () {
    resolve(10
  }, 1000
}
function rejectLater(resolve, reject) {
  setTimeout(function () {
    reject(20
  }, 1000
}

var p1 = Promise.resolve('foo'
var p2 = p1.then(function() {
  // Return promise here, that will be resolved to 10 after 1 second
  return new Promise(resolveLater
}
p2.then(function(v) {
  console.log('resolved', v  // "resolved", 10
}, function(e) {
  // not called
  console.log('rejected', e
}

var p3 = p1.then(function() {
  // Return promise here, that will be rejected with 20 after 1 second
  return new Promise(rejectLater
}
p3.then(function(v) {
  // not called
  console.log('resolved', v
}, function(e) {
  console.log('rejected', e // "rejected", 20
}