function greeter(fn: (a: string) => void) {
fn('Hello, World')
}
function printToConsole(s: string) {
console.log(s)
}
greeter(printToConsole)

type GreetFn = (a: string) => void
function greeter(fn: GreetFn) {
// ...
}

type DescFn = {
description: string
(someArg: number): boolean
}
function doSomething(fn: DescFn) {
console.log(`Значением, возвращаемым ${fn.description} является ${fn(6)}`)
}

type SomeConstructor = {
new (s: string): SomeObject
}
function fn(ctor: SomeConstructor) {
return new ctor('Hello!')
}

interface CallOrConstruct {
new (s: string): Date
(n?: number): number
}

function firstElement(arr: any[]) {
return arr[0]
}

function firstElement<Type>(arr: Type[]): Type {
return arr[0]
}

// `s` имеет тип `string`
const s = firstElement(['a', 'b', 'c'])
// `n` имеет тип `number`
const n = firstElement([1, 2, 3])

function map<Input, Output>(arr: Input[], func: (arg: Input) => Output): Output[] {
return arr.map(func)
}
// Типом `n` является `string`,
// а типом `parsed` - `number[]`
const parsed = map(['1', '2', '3'], (n) => parseInt(n))

function longest<Type extends { length: number }>(a: Type, b: Type) {
if (a.length >= b.length) {
   return a
} else {
   return b
}
}
// Типом `longerArr` является `number[]`
const longerArr = longest([1, 2], [1, 2, 3])
// Типом `longerStr` является `string`
const longerStr = longest('alice', 'bob')
// Ошибка! У чисел нет свойства `length`
const notOK = longest(10, 100)
// Argument of type 'number' is not assignable to parameter of type '{ length: number }'.
// Аргумент типа 'number' не может быть присвоен параметру типа '{ length: number; }'

function minLength<Type extends { length: number }>(
obj: Type,
min: number
): Type {
if (obj.length >= min) {
   return obj
} else {
   return { length: min }
}
}
// Type '{ length: number; }' is not assignable to type 'Type'. '{ length: number; }' is assignable to the constraint of type 'Type', but 'Type' could be instantiated with a different subtype of constraint '{ length: number; }'.
// Тип '{ length: number; }' не может быть присвоен типу 'Type'. '{ length: number; }' может присваиваться ограничению типа 'Type', но 'Type' может быть инстанцирован с другим подтипом ограничения '{ length: number; }'

// `arr` получает значение `{ length: 6 }`
const arr = minLength([1, 2, 3], 6)
// и ломает приложение, поскольку массивы
// имеют метод `slice`, но не возвращаемый объект!
console.log(arr.slice(0))

function combine<Type>(arr1: Type[], arr2: Type[]): Type[] {
return arr1.concat(arr2)
}

const arr = combine([1, 2, 3], ['привет'])
// Type 'string' is not assignable to type 'number'.

const arr = combine<string | number>([1, 2, 3], ['привет'])

function firstElement1<Type>(arr: Type[]) {
return arr[0]
}
function firstElement2<Type extends any[]>(arr: Type) {
return arr[0]
}
// a: number (хорошо)
const a = fisrtElement1([1, 2, 3])
// b: any (плохо)
const b = fisrtElement2([1, 2, 3])

function filter1<Type>(arr: Type[], func: (arg: Type) => boolean): Type[] {
return arr.filter(func)
}
function filter2<Type, Func extends (arg: Type) => boolean>(
arr: Type[],
func: Func
): Type[] {
return arr.filter(func)
}

function greet<Str extends string>(s: Str) {
console.log(`Привет, ${s}!`)
}
greet('народ')

function greet(s: string) {
console.log(`Привет, ${s}!`)
}

function fn(n: number) {
console.log(n.toFixed()) // 0 аргументов
console.log(n.toFixed(3)) // 1 аргумент
}

function f(x?: number) {
// ...
}
f() // OK
f(10) // OK

function f(x = 10) {
// ...
}

declare function f(x?: number): void
// OK
f()
f(10)
f(undefined)

function myForEach(arr: any[], callback: (arg: any, index?: number) => void) {
for (let i = 0; i < arr.length; i++) {
   callback(arr[i], i)
}
}

myForEach([1, 2, 3], (a) => console.log(a))
myForEach([1, 2, 3], (a, i) => console.log(a, i))

function myForEach(arr: any[], callback: (arg: any, index?: number) => void) {
for (let i = 0; i < arr.length; i++) {
   callback(arr[i])
}
}

myForEach([1, 2, 3], (a, i) => {
console.log(i.toFixed())
// Object is possibly 'undefined'.
// Возможным значением объекта является 'undefined'
})

function makeDate(timestamp: number): Date
function makeDate(d: number, m: number, y: number): Date
function makeDate(dOrTimestamp: number, m?: number, y?: number): Date {
if (m !== undefined && y !== undefined) {
   return new Date(y, m, dOrTimestamp)
} else {
   return new Date(dOrTimestamp)
}
}
const d1 = makeDate(12345678)
const d2 = makeDate(5, 5, 5)
const d3 = makeDate(1, 3)
// No overload expects 2 arguments, but overloads do exist that expect either 1 or 3 arguments.
// Нет перегрузки, принимающей 2 аргумента, но существуют перегрузки, ожидающие получения 1 или 3 аргумента

function fn(x: string): void
function fn() {
// ...
}
// Мы ожидаем, что функция может вызываться без аргументов
fn()
// Expected 1 arguments, but got 0.
// Ожидалось получение 1 аргумента, а получено 0

function fn(x: boolean): void
// Неправильный тип аргумента
function fn(x: string): void
// This overload signature is not compatible with its implementation signature.
// Данная сигнатура перегрузки не совместима с сигнатурой ее реализации
function(x: boolean) {}

function fn(x: string): string
// Неправильный тип возвращаемого значения
function(x: number): boolean
// This overload signature is not compatible with its implementation signature.
function fn(x: string | number) {
return 'упс'
}

function len(s: string): number
function len(arr: any[]): number
function len(x: any) {
return x.length
}

len('') // OK
len([0]) // OK
len(Math.random() > 0.5 ? 'привет' : [0])
/*
No overload matches this call.
Overload 1 of 2, '(s: string): number', gave the following error.
   Argument of type 'number[] | "привет"' is not assignable to parameter of type 'string'.
     Type 'number[]' is not assignable to type 'string'.
Overload 2 of 2, '(arr: any[]): number', gave the following error.
   Argument of type 'number[] | "привет"' is not assignable to parameter of type 'any[]'.
     Type 'string' is not assignable to type 'any[]'.
*/
/*
Ни одна из перегрузок не совпадает с вызовом.
Перегрузка 1 из 2, '(s: string): number', возвращает следующую ошибку.
   Аргумент типа 'number[] | "привет"' не может быть присвоен параметру типа 'string'.
     Тип 'number[]' не может быть присвоен типу 'string'.
Перегрузка 2 из 2, '(arr: any[]): number', возвращает следующую ошибку.
   Аргумент типа 'number[] | "привет"' не может быть присвоен типу 'any[]'.
     Тип 'string' не может быть присвоен типу 'any[]'.
*/

function len(x: any[] | string) {
return x.length
}

const user = {
id: 123,
admin: false,
becomeAdmin: function() {
   this.admin = true
}
}

const db = getDB()
const admins = db.filterUsers(function() {
return this.admin
})

const db = getDB()
const admins = db.filterUsers(() => this.admin)
// The containing arrow function captures the global value of 'this'. Element implicitly has an 'any' type because type 'typeof globalThis' has no index signature.
// Стрелочная функция перехватывает глобальное значение 'this'. Неявным типом элемента является 'any', поскольку тип 'typeof globalThis' не имеет сигнатуры индекса

// Предполагаемым типом является `void`
function noop() {
return
}

function f1(a: any) {
a.b() // OK
}
function f2(a: unknown) {
a.b()
// Object is of type 'unknown'.
// Типом объекта является 'unknown'
}

function safeParse(s: string): unknown {
return JSON.parse(s)
}
const obj = safeParse(someRandomString)

function fail(msg: string): never {
throw new Error(msg)
}

function fn(x: string | number) {
if (typeof x === 'string') {
   // ...
} else if (typeof x === 'number') {
   // ...
} else {
   x // типом `x` является `never`!
}
}

function doSomething(f: Function) {
f(1, 2, 3)
}

function multiply(n: number, ...m: number[]) {
return m.map((x) => n * x)
}
// `a` получает значение [10, 20, 30, 40]
const a = multiply(10, 1, 2, 3, 4)

const arr1 = [1, 2, 3]
const arr2 = [4, 5, 6]
arr1.push(...arr2)

// Предполагаемым типом `args` является `number[]` - массив с 0 или более чисел
// а не конкретно с 2 числами
const args = [8, 5]
const angle = Math.atan2(...args)
// Expected 2 arguments, but got 0 or more.
// Ожидалось получение 2 аргументов, а получено 0 или более

// Предполагаемым типом является кортеж, состоящий из 2 элементов
const args = [8, 5] as const
// OK
const angle = Math.atan2(...args)

function sum({ a, b, c }) {
console.log(a + b + c)
}
sum({ a: 10, b: 3, c: 9 })

function sum({ a, b, c }: { a: number, b: number, c: number }) {
console.log(a + b + c)
}

type ABC = { a: number, b: number, c: number }
function sum({ a, b, c }: ABC) {
console.log(a + b + c)
}

type voidFn = () => void
const f1: voidFn = () => {
return true
}
const f2: voidFn = () => true
const f3: voidFn = function() {
return true
}

const v1 = f1()
const v2 = f2()
const v3 = f3()

const src = [1, 2, 3]
const dst = [0]
src.forEach((el) => dist.push(el))

function f2(): void {
// Ошибка
return true
}
const f3 = function(): void {
// Ошибка
return true
}