(λ) Функционально Ориентированное Программирование (ФОП)

// Какие функции являются чистыми, а какие нет

const fn1 = (a: string): string => {
	return a + ", hi!"
}

const fn2 = (a: { name: string }) => {
	a.name += ", hi!"
	return a
}

const fn3 = (a: { name: string }) => {
	fn2(a)

	return a.name + ", hi!"
}

const fn4 = (a: { name: string }) => {
	return {
		name: a.name + ", hi!"
	}
}

const fn5 = (a: { name: string }) => {
	const newName = fn4(a)

	newName.name += " Bye!"

	reutrn newName
}

let counter = 0
const fn6 = () => {
	counter += 1
	return `Updated ${counter} times`
}


const fn7 = () => {
	let counter = 0
	return () => {
		counter += 1
		return `Updated ${counter} times`
	}
}

const fn8 = (a: number): number => {
	console.log(Math.random())
	return a * 2
}

const fn9 = (
	db: {update: (byId: string, email: string) => void},
	id: string,
	newEmail: srtring
) => {
	return db.update(id, newEmail)
}

const fn10 = (db: {getById: (id: string) => User}, id: string) => {
	return db.getById(id)
}

// Чистая
const fn1 = (a: string): string => {
	return a + ", hi!"
}

// Нечистая, потому что меняет внешнее состояние (аргумент)
const fn2 = (a: { name: string }): { name: string } => {
	a.name += ", h1!"
	return a
}

// Нечистая, потому что использует другую нечистую (fn2)
const fn3 = (a: { name: string }) => {
	fn2(a)

	return a.name + ", hi!"
}

// Чистая, потому что ничего не изменяет
const fn4 = (a: { name: string }) => {
	return {
		name: a.name + ", hi!"
	}
}

// Нечистая, потому что изменяет возврат внутренней чистой функции (fn4)
const fn5 = (a: { name: string }) => {
	const newName = fn4(a)

	newName.name += " Bye!"

	reutrn newName
}

// Нечистая, потому что меняет внешнее состояние (внешнюю переменную)
let counter = 0
const fn6 = () => {
	counter += 1
	return `Updated ${counter} times`
}

// Эту можно назвать чистой
const fn7 = () => {
	let counter = 0
	// А вот это нечистая функция, потому что меняет внешнее состояние (внешнюю переменную)
	return () => {
		counter += 1
		return `Updated ${counter} times`
	}
}

// Нечистая, потому что делает сразу 2 side-effect:
// 1. console.log – это изменение внешнего состояния (stdout.write)
// 2. Math.random() – это сайд-эффект, потому что он обращается к ОС, чтобы взять сид для рандома
const fn8 = (a: number): number => {
	console.log(Math.random())
	return a * 2
}

// Нечистая, потому-что делает 2 side-effect:
// 1. Обращается к внешней системе (db)
// 2. Меняет состояние (db.update)
const fn9 = (
	db: {update: (byId: string, email: string) => void},
	id: string,
	newEmail: srtring
) => {
	return db.update(id, newEmail)
}

// Нечистая, потому-что делает side-effect: обращается к внешней системе (db)
const fn10 = (db: {getById: (id: string) => User}, id: string) => {
	return db.getById(id)
}

1. Что если нам нужно обращаться к внешним системам (db)?

2. Что если нам все-таки надо что-то поменять?

// Типы
type User = {
	id: string
	email: string
	// pasword: string – это поле лежит в БД, но мы не хотим его доставать в программу
}

type DB = {
	updateById: (id: string, user: User) => void
	getById: (id: string) => User
}

// Нечистая функция работы с бд
const updateUser = (
	db: db,
	user: User,
) => {
	return db.updateById(user.id, user)
}

// Нечистая функция работы с бд
const getUserById = (db: DB, id: string) => {
	const res = db.getById(id)

	return {
		id: res.id,
		email: res.email
	}
}

// Чистая функция бизнес-логики
const assignNewUserEmail = (user: User, newEmail: string) => {
	if (!newEmail.includes("@") {
		throw new Error(`Email is invalid`)
	}

	if (user.email === newEmail) {
		throw new Error(`New email must be different`)
	}

	return {
		...user,
		email: newEmail,
	}
}

// А теперь собираем их вместе
const updateUserEmailController = (db: DB, userId: string, newEmail: string) => {
	const user = getUserById(db, userId)
	
	const updatedUser = assignNewUserEmail(user, newEmail)

	updateUser(db, updatedUser)
}

type User = {
	firstName: string;
	secondName: string;
	fio: string | undefined;
}

const addFIO = (user: User): User => {
	return {
		...user, // Копируем все свойства
		fio: user.firstName + user.secondName // добавляем новое поле
	}
}

const someFn = (someArray: string[]) => {
	const array = []

	for (let i = 0; i < someArray.length; i++) {
		// Мы можем изменять array, потому что он был создан в этой же функции
		array.push(someArray[i] + ", hi!")
	}

	return array
}

const predictabilityExaple = async (db: DB) => {
	const user = await db.getUser()
	const userSubscriptions = await db.getUserSubscriptions(user.id)
	const userWallet = await db.getUserWallet(user.id)
	
	await changeUserSubscriptionPlan(user, userSubscriptions, userWallet)
}

const predictabilityExaple = async (db: DB) => {
	const user = await db.getUser()
	const userSubscriptions = await db.getUserSubscriptions(user.id)
	const userWallet = await db.getUserWallet(user.id)
	
	const [updatedUserSubscriptions, updatedUserWallet] = await changeUserSubscriptionPlan(user, userSubscriptions, userWallet)
}

type User = {
	id: string
	username: string
	team: {
		id: string
		name: string
		members: User[]
	}
}

const shallowComparisonExample = async (db: DB) => {
	const user: User = await db.getUser()
	const updatedUser = await someFunctionThatUpdateSomethingInUser(user)
	if (user !== updatedUser) {
		// Не важно что изменилось и насколько глубоко в user, если
		// хоть какое-то изменение произошло, ссылки у user и updatedUser
		// будут разные
	}
}

type User = {
	id: string
	username: string
	team: {
		id: string
		name: string
		members: User[]
	}
}


// Ооочень утрированная функция проверки на изменения
const compare = (recordA: Record<any, any>, recordB: Record<any, any>) => {
	// Итерируем по свойствам Record
	for (const property in userB) {
	  if (recordA[property] !== recordB[property]) {
			console.log(`Property ${property} changed from ${recordA[property]} to ${recordB[property]}`)
			// Утрированная проверка, что поле тоже является 
			if (typeof userB[property] === 'object') {
				compare(recordA[property], recordB[property])
			}
		}
	}
}

const shallowComparisonExample = async (db: DB) => {
	const user: User = await db.getUser()
	const updatedUser = someFunctionThatUpdateSomethingInUser(user)
	if (user !== updatedUser) {
		compare(user, updatedUser)
	}
}

const UserDataService = (db: DB) => {
	let users = {}
	return {
		getUserById: (id: string): User => {
			const user = await db.getUser({id: id})
			users = {
				...users,
				[user.id]: user,
			}
		},
		saveUser: (updatedUser: User): Promise<User> => {
			// Функция getChangedProperiesAndValues возвращает мне объект только с измененными
			// полями и их значениями. Она отрабатывает очень быстро, потому что я знаю, что мой код
			// иммутабельный, а значит, если user хоть како-то изменился, достаточно сделать простую проверку
			const delta = getChangedProperiesAndValues(updatedUser, users[updatedUser.id])
			if (delta) {
				await db.saveUser(delta)
			}
			return updatedUser
		}
	}
}

const uowExample = async (db: DB, userId: string) => {
	const userDS = UserDataService(db)
	const user: User = await userDS.getUserById(userId)
	const updatedUser = someFunctionThatUpdateSomethingInUser(user)
	await userDS.saveUser(updatedUser)
}

const raceConditionCounter = async () => {
	let counter = {
		value: 1
	}
	
	await Promise.all([
		async () => counter.value = counter.value - 1,
		async () => counter.value = counter.value * 4,
		async () => {
			if (counter.value === 0) throw new Error() 
			counter.value = counter.value / 2
		},
	])
	
	console.log(counter.value)
}

const raceConditionCounter = async () => {
	let counter = {
		value: 1
	}
	
	const [decrementedCounter, mulipliedCounter, dividedCounter] = await Promise.all([
		async () => { value: counter.value - 1 },
		async () => { value: counter.value * 4 },
		async () => {
			if (counter.value === 0) throw new Error() 
			return { value: counter.value / 2 },
		},
	])
	
	console.log(counter.value, decrementedCounter.value, mulipliedCounter.value, dividedCounter.value) // 1, 0, 4, 0.5
}

const user = getUser()
const userUpdatedEmail = updateUserEmail(user)
const userUpdatedEmailAndAge = updateUserAge(userUpdatedEmail)
const userUpdatedEmailAgeAddedRewards = addRewards(userUpdatedEmailAndAge)
const userToSave = updateUserAge(userUpdatedEmailAgeAddedRewards)
saveUser(userToSave)

// Скоро такой оператор появиться в JS,
// но он есть в функциальных языках типа Elixir
const user = getUser(userId)
						 |-> updateUserEmail
						 |-> updateUserAge
						 |-> addRewards
						 |-> updateUserAge
						 |-> saveUser		

// Альтернативой может быть композиция
const user = saveUser(
	updateUserAge(
		addRewards(
			updateUserAge(
				updateUserEmail(
					getUser(userId)
				)
			)
		)
	)
)

// Или использование сторонних библиотек, НО сразу скажу,
// на TS например, такие функции очень тяжело типизировать
// если они используют generic
const user = pipe(
	getUser,
	updateUserEmail,
	updateUserAge,
	addRewards,
	updateUserAge,
	saveUser,
)(userId)