// let has block scope
let name = 'Ryan';
if (true) {
  let name = 'Michael';
  name // 'Michael'
}
name // 'Ryan'

// const has block scope too
const name = 'Ryan';
if (true) {
  const name = 'Michael';
  name // 'Michael'
}
name // 'Ryan'

const something = 'ugly stuff';
const str = 'instead of ' + something + ' like this';

const something = 'lovely stuff';
const str = `you can do ${something} like this`;

const str = `
  also
  multiline
  is totally cool
`;

// Truthy and Falsy
>> Boolean()
<< false


// boolean
>> Boolean(true)
<< true

>> Boolean(false)
<< false


// number
>> Boolean(0)
<< false

>> Boolean(1)
<< true


// string
>> Boolean('')
<< false

>> Boolean(' ')
<< true

...

const obj = {
  url: '/api/stuff',

  fetch(users) {
    users.forEach((user) => {
      // `this` is the `this` from outside this function because
      // there is no context inside an arrow function
      return getUser(`${this.url}/${user.id}`);
    })
  }
};

const numbers = [ 1, 2, 3, 4, 5 ];

// map converts an array to a new, transformed array
const doubled = numbers.map((number) => {
  return number * 2;
})
doubled // [ 2, 4, 6, 8, 10 ]

// filter, return false to remove from an array
const lessThan3 = numbers.filter((n) => {
  return n < 3;
})
lessThan3 // [ 1, 2 ]

// remember, that can be super short
const lessThan3 = numbers.filter(n => n < 3);

const obj = { x: 1, y: 2, z: { a: 3 }, c: 4, d: 5 };

// instead of:
const x = obj.x;
const y = obj.y;

console.log(`x: ${x}, y: ${y}`); // x: 1, y: 2 

// we can "destructure" the values off
const { c, d } = obj;
console.log(`c: ${c}, d: ${d}`); // c: 4,  d: 5 

// you can use this all over the place, like function parameters
const add = ({x, y}: { x: number, y: number}): number => x + y;
console.log(add({x: 3, y: 4})) // 7

// you can use nested destructuring as well
const { z: { a } } = obj;
console.log(`a: ${a}`) // a: 3

// Interfaces and Types
type TestCase = {
  description: string;
  message: string;
  assert: () => void;
};

interface TestClass {
  test(): TestCase;
}

class A implements TestClass {
  test(): TestCase {
    return {
      description: "desc",
      message: "msg",
      assert: () => {
        throw new Error("Failed.");
      },
    };
  }
}

// ...
// Union Types
// Union Exhaustiveness checking