const test = ():never => {
  return; // エラー
}

const arr: ["A", "B"] = ["A", "B"];
const index = Math.floor(Math.random() * 2);
const value: "A" | "B" = arr[index];
switch (value) {
  case "A":
    break;
  case "B":
    break;
  default:
    const neverVal:never = value;
}

const arr: ["A", "B", "C"] = ["A", "B", "C"];
const index = Math.floor(Math.random() * 2);
const value: "A" | "B" | "C" = arr[index];
switch (value) {
  case "A":
    break;
  case "B":
    break;
  default:
    const neverVal: never = value; // ここでエラー
}

type Name = {name: string} ;
type Age = {age: number} ;
type Human = Name & Age

interface Name {name: string}
interface Age {age: number}
interface Human extends Name, Age {}

interface Human {name: string}
interface Human {age: number}
const human: Human = {
    name:"sato",
    age:20,
}

const a:A = {name:"taro"};
const b:B = {age:20};
a = b as A; // エラー(Property 'name' is missing in type 'B' but required in type 'A'.)

let str = "A"
const num = 10;
str = num as string // エラー

// 型エイリアス
type A = {
    name: string
    age: number
}
type B = {
    age: number
}

// bはaの部分集合なので両者は相互にアサーションすることができる。
let a:A = {name:"taro",age: 100};
let b:B = {age:20};

b = a as B // nameプロパティ
a = b as A // bが持たないnameプロパティを持つことになる

const A = "A"; //A型になる
let B = "B" // string型になる

const A = "A"
const C = {
  A, // string型
}

// ジェネリクスを利用しない
const returnValueFunc = (value:string | number)  =>{
    return value
}

// 下記のどちらの値もstring | numberのユニオン型です。
const personName = returnValueFunc("taro");
const personAge = returnValueFunc(10);

// ジェネリクス  <T,U><第一引数の型,第二引数の型>
const returnValueFuncG = <T>(value: T)  => {
    return value
}
// personNameJ
const personNameG = returnValueFuncG("taro");
const personAgeG = returnValueFuncG(10);

const personNameG = returnValueFuncG<string>("taro");
const personAgeG = returnValueFuncG<number>(10);

const returnValueFuncG = <T>(value: T)  => {
    return value
}

const returnValueFuncG = <T, S>(name: T, age: S)  => {}

const arrA:string[] = [];
const arrB:Array<string> = [];
const arrC = new Array<string>();

type FF =  "タコス" | "たこやき" | "焼肉" |"らーめん";
const favoriteFoods:FF[] = ["たこやき","らーめん"]

const checkRamen = <T>(values: readonly T[]) => {
    const food = "らーめん"
    values.some((values) => values === food); // ここでエラー
}
const result = checkRamen<FF>(favoriteFoods);
console.log(result)

type FF =  "タコス" | "たこやき" | "焼肉" |"らーめん";
const favoriteFoods:FF[] = ["たこやき","らーめん"]

const checkRamen = <T>(values: readonly T[]) => {
    const food = "らーめん" as T // 次はここでエラー
    values.some((values) => values === food);
}
const result = checkRamen<FF>(favoriteFoods);
console.log(result)

type FF =  "タコス" | "たこやき" | "焼肉" |"らーめん";
const favoriteFoods:FF[] = ["たこやき","らーめん"]

const checkRamen = <T extends string>(values: readonly T[]) => {
    const food = "らーめん" as T
    values.some((values) => values === food);
}
const result = checkRamen<FF>(favoriteFoods);
console.log(result)

const arr = ["taro", 20] as const ; // ["taro", 20]型

type Names = ["taro","ziro"];
type Taro = Names[0]; // taro型

type Names = ["taro","ziro"];
type UinonNames = Names[number]; // "taro" | "ziro"型

type Lastnames = "kato" | "tanaka" | "suzuki";
type Human = {
    [key in Lastnames]:{
        name: string,
        age: number,
    }
}

const human:Human = {
    kato:{
        name:"taro",
        age:100,
    },
    tanaka:{
        name:"taro",
        age:100,
    },
    suzuki:{
        name:"taro",
        age:100,
    },
}

[key名 in T]: U

type Lastnames = "kato" | "tanaka" | "suzuki";
type Info = {
    name:string,
    age:number,
}
type Human = {
    [key in Lastnames]:Info
}

const str: string = null // OK
const str: string = undefinde // OK
// 内部的には string | null | undefined と同じ型定義

const str: string = null // エラー
const str: string = undefinde // エラー
// ちゃんとstring型のみ受け入れるようになる。

// 数値列挙型
enum Color {
    Red, // 0
    Blue, // 1
    Yellow, // 2
}

let color:Color
color = Color.Red;
console.log(color); // => 0
console.log(Color.Red) // => 0
// 再代入
color = 1;
console.log(color); // => 1

const color2:Color = 2; 
console.log(color2); // => 2

// 文字列列挙型
enum Color {
    Red="RED",
    Blue="BLUR",
    Yellow="YELLOW",
}

let color:Color = Color.Yellow;
console.log(color); // => "YELLOW"
// 再代入
color = Color.Blue;
console.log(color); // => "YELLOW"

// 文字列を代入
let color2:Color = "YELLOW" // エラー

enum Color {
    Red="RED",
    Blue="BLUR",
    Yellow="YELLOW",
    Pink="PINK",
}

// エラーになる。
const checkColor = (color:Color) => {
    switch(color){
        case Color.Red:
        return "赤"
        case Color.Blue:
        return "青"
        case Color.Yellow:
        return "黄"
    }
}

enum Color {
    "Red",
    "Blue",
    "Yellow",
}

const color:Color = 100;

var Color;
(function (Color) {
    Color[Color["Red"] = 0] = "Red";
    Color[Color["Blue"] = 1] = "Blue";
    Color[Color["Yellow"] = 2] = "Yellow";
})(Color || (Color = {}));
const color = 100;

const colors = {
    red:"RED",
    blue:"BLUE",
    yellow:"Blue",
} as const

type Colors = typeof colors[keyof typeof colors];

const red: Colors = "RED"; // OK
const pink: Colors = "PINK"; // エラー

const obj = {
    name:"sato",
    age:20,
}

// obj[プロパティ名]でvalueを取り出せる
const age = obj["age"];

console.log(age) // 20

type Obj = {
    food:"ramen",
    age:20,
}

type UnionType = keyof Obj // food | age

const age:UnionType = "age"; // OK
const food:UnionType = "food"; // OK
const height:UnionType = "heith"; // エラー

// typeof colors[プロパティ名のユニオン型];
type Colors = typeof colors["red"|"blue"|"yellow"];

type tempType = keyof typeof colors;