Game 3: Guess That Type

ts
const values = [3, "14", [21]]
 
for (let a in values) {
        
let a: string
}
for (let b of values) {
        
let b: string | number | number[]
}Try

ts
class Person {
  constructor(public name: string) {}
}
class Library {
  librarians: Person[] = []
}
 
const localLibrary = Library
           
const localLibrary: typeof Library
const otherLibrary = new Library()
           
const otherLibrary: LibraryTry

ts
class AsyncManager {
  constructor(arg: 0 | 4 | string) {
    if (arg > 0 || arg <= 0) {
Operator '>' cannot be applied to types 'string | number' and 'number'.
Operator '<=' cannot be applied to types 'string | number' and 'number'.2365
2365Operator '>' cannot be applied to types 'string | number' and 'number'.
Operator '<=' cannot be applied to types 'string | number' and 'number'.
      new Promise((resolve, reject) => {
        arg
        
(parameter) arg: string | 0 | 4
      })
    }
  }
}Try

ts
enum CoinResult {
  heads,
  tails,
}
function flipCoin(): CoinResult {
  return Math.random() > 0.5
    ? CoinResult.heads
    : CoinResult.tails
}
 
function main() {
  const flipResult = flipCoin()
  if (flipResult === CoinResult.heads) {
    console.log("heads")
  } else if (flipResult === CoinResult.tails) {
    console.log("tails")
  } else {
    flipResult
        
const flipResult: never
  }
}Try

ts
function getValue(): [number] | Promise<number> {
  if (Math.random() > 0.5) return [42]
  else return Promise.resolve(42)
}
 
async function main() {
  const resolved = await getValue()
           
const resolved: number | [number]
}Try

ts
let x: number | any = 41
const y = x
     
const y: anyTry

ts
const values = [4, 1, null, 21, 45, 32]
 
const filtered = values.filter((val) => val !== null)
         
const filtered: (number | null)[]Try

ts
class Person {
  static species = "Homo Sapien"
  constructor(public name: string) {}
}
 
const p = new Person("mike")
let x: keyof typeof Person
   
let x: "prototype" | "species"
let y: keyof typeof p
   
let y: "name"Try

ts
enum Language {
  JavaScript,
  TypeScript = "TS",
}
 
let lang1: Language = Language.JavaScript
     
let lang1: Language
let lang2: Language = Language.TypeScript
     
let lang2: Language
 
Math.round(lang1)
Math.round(lang2)
Argument of type 'Language' is not assignable to parameter of type 'number'.2345Argument of type 'Language' is not assignable to parameter of type 'number'.Try

ts
async function tryFetch(url: RequestInfo) {
  try {
    const val = await (await fetch(url)).json()
    return val
  } catch (err) {
    console.error(err)
    return undefined
  }
}
 
async function main() {
  const val = await tryFetch("https://example.com")
        
const val: any
}Try

ts
class Book {
  title: string = ""
  author: string = ""
}
const keys = Object.keys(new Book())
       
const keys: string[]Try