let a: unknown = 30
let b = a === 123
let c = a + 10
if (typeof a === 'number') {
let d = a + 10 // number }

let a = true // boolean
var b = false // boolean
const c = true // true
let d: boolean = true // boolean
let e: true = true // true
let f: true = false // エラー TS2322: 型 'false' を型 'true' に // 割り当てることはできません。

// [名前, 名字, 生まれ年]のタプル
let b: [string, string, number] = ['malcolm', 'gladwell', 1963]

// 鉄道運賃の配列。方向によって異なる場合があります
let trainFares: [number, number?][] = [
[3.75], [8.25, 7.70], [10.50]
]
// これは次のものと同等です
let moreTrainFares: ([number] | [number, number])[] = [
// ... ]

function greet(name: string) {
  return 'hello' + name
}
// 名前付き関数


let greet2 = function(name: string) {
  return 'hello' + name
}
// 関数式

let greet3 = (name: string) => {
  return 'hello' + name
}
// アロー関数式

let greet4 = (name: string) => 'hello' + name
// アロー関数式省略

let greet5 = new Function('name', 'return "hello " + name')
// 関数コンストラクタ (使っちゃ駄目)

let numbers = {
  *[Symbol.iterator]() {
    for (let n = 1; n <= 10; n++) {
      yield n;
    }
  },
};

type Log = (message: string, userId?: string) => void
let log: Log = (
  message,
  userId = 'Not signed in'
) => {
  let time = new Date().toISOString()
   console.log(time, message, userId) }

function map<T, U>(array: T[], f: (item: T) => U): U[]

type A = number
type B = A | string

interface A {
  good(x: number): string
  bad(x: number): string
}

interface B extends A {
  good(x: string | number): string
  bad(x: string): string
}
// Aは型エイリアスなので、型インターフェイスに拡張はできない

type ClassConstructor<T> = new (...args: number[] | string[]) => T;
function withEZDebug<C extends ClassConstructor<{ getDebugValue(): object }>>(Class: C) {
  return class extends Class {
    debug() {
      let Name = this.constructor.name
      let value = this.getDebugValue()
      return Name + '(' + JSON.stringify(value) + ')'
    }
  }
}

class HardToDebugUser {
  constructor(
    private id: number,
    private firstName: string,
    private lastName: string
  ) {}
  getDebugValue() {
    return {
      id: this.id,
      name: this.firstName + ' ' + this.lastName
    }
  }
}

let User = withEZDebug(HardToDebugUser)
let user = new User(3, 'Emma', 'Gluzman')
console.log(user.debug());

type Weekday = 'Mon' | 'Tue'| 'Wed' | 'Thu' | 'Fri'
type Day = Weekday | 'Sat' | 'Sun'

function getNextDay(w: Weekday): Day { switch (w) {
 case 'Mon': return 'Tue' }
}

type APIResponse = {
    user: {
      userId: string
      friendList: {
        count: number
        friends: {
          firstName: string
          lastName: string
        }[]
      }
   }
}

type ResponseKeys = keyof APIResponse // 'user'
type UserKeys = keyof APIResponse['user'] // 'userId' | 'friendList'
type FriendListKeys = keyof APIResponse['user']['friendList'] // 'count' | 'friends'

function get<
  O extends object,
  K extends keyof O
>(
  o: O,
  k: K
): O[K] {
 return o[k]
}

interface Person {
  name: string;
  age: number;
}

type members = "one" | "two" | "three" | "four";

const member:Record<members, Person> = {
  one: { name: "taro", age: 12 },
  two: { name: "hanako", age: 15 },
  three: { name: "saburo", age: 18 },
  four: { name: "siro", age: 17 },
};

// const member:{
//   one:Person,
//   two:Person,
//   three:Person,
//   four:Person,
// } = {
//   one: { name:'taro',age:12 },
//   two: { name:'hanako',age:15 },
//   three: { name:'saburo',age:18 },
//   four: { name:'siro',age:17 },
// }

// ↑ 本来だったら、 type membersの 数値をこう書く。冗長

type WeightUnit = 'kg' | 'g'

export type Fish = {
    weightUnit: WeightUnit
    weightValue: number
}

export let Fish = {
    from(weightValue: number, weightUnit: WeightUnit): Fish {
        return {
            weightUnit,
            weightValue
        }
    }
}

import { Fish } from './Fish'

// こっちのFishは型
let fish: Fish = {
    weightUnit: 'kg',
    weightValue: 100,
}

// こっちのFishは値
let otherFish = Fish.from(200, 'g')

function tuple<T extends unknown[]>(
  ...ts: T
): T {
  return ts
}

tuple(["aaa"])

console.log(tuple(["aaa"], [true],[1]))

function isString(a: unknown): a is string {
  return typeof a === "string";
}
//  function isString(a: unknown): boolean だと駄目

function parseInput(input: string | number) {
  let formattedInput: string
  if (isString(input)) {
    formattedInput = input.toUpperCase();
  }
}

type IsString<T> = T extends string ? true : false

type A = IsString<string> // true
type B = IsString<number> // false

type ToArray2<T> = T extends unknown ? T[] : T[]
type A = ToArray2<number> // number[]
type B = ToArray2<number | string> // number[] | string[]

type Without<T, U> = T extends U ? never : T;

type C = Without<
boolean | number | string, boolean
> // number | string
// Tには含まれているがUには含まれていない型を計算する

Exclude<T, U> // Tに含まれているが Uには含まれていない型を計算します。
Extract<T, U> // Tに含まれている型のうち、Uに割り当てることのできるものを計算します。
NonNullable<T> // nullと undefinedを除外した Tのバージョンを計算します。
ReturnType<F> // 関数の戻り値の型を計算します
InstanceType<C> // クラスコンストラクターのインスタンス型を計算します。