gskachkov

async function foo(value) {
  // Return async result async
  return new Promise(resolve => {
    setTimeout(() => resolve(value), 100);
  });
}

class SuperClass {
  async getValue(value) {
    var result = await foo(value);

gskachkov

async function foo() {};

typeof foo === 'function'; //true
foo[Symbol.toStringTag] === 'AsyncFunction'; //true

gskachkov

const foo = async () => console.log('foo');

const boo = async () => { 
  console.log('boo');
  const result = await 'b';
  return result;
};

gskachkov

let resolve; 

const promise = new Promise(_resolve => {
  resolve = _resolve;
});

async function foo () {
  console.log('start foo');
  // We return promise, but fullfil handler will not be executed until this promise will be resolved
  return promise;

gskachkov

//TODO: Add console.log results

async function foo () {
  console.log('foo-start');
  const result = await 'a';
  console.log('foo-end');
  return result;
}

async function boo() {

gskachkov

async function foo(args) {
  console.log('before await');
  const value = await 'b';
  console.log('after await', value);
  return value;
};

//Simplified version of async foo function 
function foo() {
   let resolve;

gskachkov

var foo = async function () { 
  try {  
    await Promise.reject('error in promise');
  } catch (e) {
    console.log('caught error:', e);
  }
};

foo().then(
  result => console.log('success-', result), 

gskachkov

const foo = async function () {
  console.log('before await');
  const value = await 'boo';
  console.log('after await');
  return value;
};

console.log('before async invocation');
foo();
console.log('after async invocation');

gskachkov

async function foo () {
  const result = await fetch("https://randomuser.me/api/?results=10", { method: "GET" }); 
  return result;
}

const boo = async function () {
  return await fetch("https://randomuser.me/api/?results=10", { method: "GET" }); 
};

foo();

gskachkov

class SuperClass {
	constructor() {
		print('SuperClass constructor')
	}
}

let ProxiedSuperClass = new Proxy(SuperClass, {});

class A extends ProxiedSuperClass {
	constructor() {