Lab 3: Functor definition

[the-homeless-god]

[the-homeless-god]

type Human = {
    name: string
    age: number
}
type NameContainer = Pick<Human, 'name'>
type CreateHumanFunctor = (amount: number) => Human[]
type CreateHumansFunctor = (amount: number) => Human[]
type ChainHumanFunctor<Input = Human | Human[], Output = NameContainer | NameContainer[]> = (human: Input) => Output
type ChainHumanFunctorSingle = ChainHumanFunctor<Human, NameContainer>
type ChainHumanFunctorMultiple = ChainHumanFunctor<Human[], NameContainer[]>
type ApplicativeFunctor<SourceCategory, SubsourceCategory> = (obj: SourceCategory) => SubsourceCategory
type ApplicableSingleFunctors = ApplicativeFunctor<Human, NameContainer> | ChainHumanFunctor<Human, NameContainer> | CreateHumanFunctor
type ApplicableMultipleFunctors = ApplicativeFunctor<Human[], NameContainer[]> | ChainHumanFunctor<Human[], NameContainer[]>
type SequenceFunctor = (ApplicableSingleFunctors | ApplicableMultipleFunctors)[]
type CreateRoboHumanFunctor = <OutputCategory> (sequenceFunctor: SequenceFunctor) => {
    get: () => OutputCategory
}

const createHuman: CreateHumanFunctor = (amount: number) => {
    return [{
        name: Math.random().toString(),
        age: Math.random()
    }]
}

const createHumans: CreateHumansFunctor = (amount) => {
    return Array.from(new Array(amount)).map(() => {
        const [human] = createHuman(amount)
        return human
    })
}

const humans: Human[] = createHumans(10);


const chainHuman: ChainHumanFunctorSingle = ({ name }) => {
    return {
        name
    }
}

const chainHumans: ChainHumanFunctorMultiple = (humans) => humans.map(chainHuman)

const humanNames = humans.map(chainHuman)


const withLog = (name: string, data: any): void => {
    console.log(name, data)
}

// closure – замыкание
const createRoboHuman: CreateRoboHumanFunctor = (sequenceFunctor) => {
    const human = sequenceFunctor.reduce((accumulator, functor) => {
        const functorResult = functor(accumulator)
        // нарушается ссылочная прозрачность
        withLog(functor.name, functorResult)
        return functorResult
    }, {} as any)

    return {
        get: () => ({ ...human }),
    }
}
console.clear()

const functorCollections = [createHumans, chainHumans, chainHumans, chainHumans, chainHumans, createHumans]

const { get: getMyRoboObject } = createRoboHuman(functorCollections)

[IWantSomeFish]

Виноградов Антон 3/147

Получение строки из базы данных по id

import * as readline from 'readline'
import redis from './redis'
import toJson from './parsers/toJson'

function map(value, fn) {
    if (value == null) return null
    return fn(value)
}

function alternative(value, fallback) {
    if (value != null) return value
    return fallback()
}

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

rl.question('Enter id to search: ', (id: number) => {
    const result = alternative(
        await redis.get(id),
        () => db.get(id)
    )
    console.log(map(result, toJson))
    rl.close();
});

В данном варианте применяется тип функторов alternative. Он расширяет аппликативный функтор тем, что добавляет иные исходы вычисления результата функции. Так, если значения в redis с таким id нет, альтернативный вариант будет обратиться к базе. И так далее.

[MarkVRKS]

Вераксо Марк 3/147

Конвейер по производству ботинок

type Boot = {
    readonly brand: string
    readonly size: number
    readonly status: 'raw' | 'cutUpped' | 'ready'
}

const cutUpper = (boot: Boot): Boot => ({
    ...boot,
    status: 'cutUpped'
})

const glueOutsole = (boot: Boot): Boot => ({
    ...boot,
    status: 'ready'
})

const bootBatch: Boot[] = [
    {brand: 'Adidas', size: 43, status: 'raw'},
    {brand: 'Nike', size: 41, status: 'raw'}
]

const cutUpperBatch = bootBatch.map(cutUpper)
console.log('Результат отрезания верхней части:', cutUpperBatch)
const glueOutsoleBatch = cutUpperBatch.map(glueOutsole)
console.log('Результат приклеивания подошвы:', glueOutsoleBatch)


//можно скомпоновать всё в композицию, в один станок
//const extraBatch = (boot: Boot) => glueOutsole(cutUpper(boot))
//const finalBatch = bootBatch.map(extraBatch)
//console.log('Результат экстра станка:', finalBatch)

Применил массив как функтор, после чего поднял морфизмы до уровня работы со всей партией на конвейере
Плюс расписал композицию функторов без потери логики (=надеюсь что без потери=)

для большего осмысления, я решил все визуализировать (ну немножко), чтобы вкатиться и понять всю суть функторов

[Recrusion]

Григорьев А. К. 3/42

Асинхронная отправка писем

package main

import (
	"errors"
	"fmt"
	"time"
)

func mapVal(v interface{}, err error, fn func(interface{}) interface{}) interface{} {
	if err != nil {
		return nil
	}
	return fn(v)
}

func alt(v interface{}, err error, fallback func() (interface{}, error)) (interface{}, error) {
	if err == nil {
		return v, nil
	}
	return fallback()
}

func sendQueue(to string) (interface{}, error) {
	if time.Now().Unix()%2 == 0 {
		return nil, errors.New("очередь полна")
	}
	return "письмо для " + to + " ушло через очередь", nil
}

func sendSMTP(to string) (interface{}, error) {
	return "письмо для " + to + " ушло через резервный SMTP", nil
}

func main() {
	var email string = "email"

	go func() {
		v, err := sendQueue(email)
		res, err2 := alt(v, err, func() (interface{}, error) {
			fmt.Println("-> основной канал недоступен, переключаюсь")
			return sendSMTP(email)
		})
		output := mapVal(res, err2, func(v interface{}) interface{} {
			return "Успешно - " + v.(string)
		})
		if output != nil {
			fmt.Println(output)
		} else {
			fmt.Println("Ошибка отправки")
		}
	}()
}

В своём примере я реализовал функтор Alternative для асинхронной отправки писем. Функция alt проверяет результат функции sendQueue, если она вернула ошибку, вызывается резервная функция sendSMTP. Функция mapVal применяет преобразование только к успешному результату, игнорируя ошибки. Запуск в горутине обеспечивает неблокирующее выполнение: основной поток продолжает работу, не дожидаясь завершения отправки.

[Purp1ee]

Войтович Дмитрий 3/147

Приготовление пиццы

type Pizza = {
    readonly flavor: string
    readonly size: number
    readonly stage: 'raw' | 'topped' | 'baked'
}

const addToppings = (pizza: Pizza): Pizza => ({
    ...pizza,
    stage: 'topped'
})

const bakePizza = (pizza: Pizza): Pizza => ({
    ...pizza,
    stage: 'baked'
})

const pizzaBatch: Pizza[] = [
    { flavor: 'Pepperoni', size: 40, stage: 'raw' },
    { flavor: 'Margarita', size: 35, stage: 'raw' }
]

// Все пиццы на столе получают начинку
const toppedBatch = pizzaBatch.map(addToppings)
console.log('После добавления начинки:', toppedBatch)

// Все пиццы отправляются в печь
const readyBatch = toppedBatch.map(bakePizza)
console.log('Результат из печи:', readyBatch)

Я применил массив как функтор, морфизмы addToppings и bakePizza работают с одной пиццей, а с помощью map можно будет работать со всей партией, получается каждая пицца обрабатывается независимо

[RenatZhappuev]

Жаппуев Ренат 3-42

Заказы интернет-магазина

from dataclasses import dataclass

@dataclass
class Order:
    order_id: str
    total: float
    status: str


# морфизм apply_discount
def apply_discount(order: Order) -> Order:
    return Order(order.order_id, order.total * 0.9, order.status)


# морфизм confirm_order
def confirm_order(order: Order) -> Order:
    return Order(order.order_id, order.total, "confirmed")


def print_batches(batch: [Order]) -> None:
    for i in batch:
        print(f"{i.order_id}: {i.total}₽, {i.status}")
    print()


# создаём партию заказов
orders_batch = [
    Order("1", 10000, "draft"),
    Order("2", 5000, "draft"),
    Order("3", 3000, "draft")
]
print_batches(orders_batch)

# применяем скидку ко всем
discounted = list(map(apply_discount, orders_batch))
print_batches(discounted)

# подтверждаем все заказы
confirmed = list(map(confirm_order, discounted))
print_batches(confirmed)

В этом примере я использовал массив как функтор. Функция apply_discount применяет скидку к 1 заказу, а функция confirm_order меняет статус заказа. Для применения функций к элементам массива использую map

[molodecp]

Полозков Максим 3/42

Внедрение автоматического деплоя после успешной сборки

const Just = (value) => ({ tag: 'just', value });
const Nothing = () => ({ tag: 'nothing' });

const map = (maybe, fn) => {
    if (maybe.tag === 'nothing') return Nothing();
    return Just(fn(maybe.value));
};

const push = (code) => code;

const build = (code) => {
    if (code === 'good') {
        return Just({ artifact: 'app.jar', version: 123 });
    }
    return Nothing();
};

const deploy = (artifact) => {
    return `Deployed: ${artifact.artifact} v${artifact.version}`;
};

const autoDeploy = (code) => map(build(code), deploy);

const goodResult = autoDeploy('good');
const badResult = autoDeploy('bad');

console.log(goodResult);
console.log(badResult);

функтор Maybe позволяет применить деплой только к успешному результату сборки, игнорируя случай провала. Функция map автоматически проверяет наличие значения и выполняет деплой только когда сборка завершилась успехом

[AlenaY2312]

Яковлева Алёна 3/42
Применение функтора к категории "Процесс приготовления кофе"

from dataclasses import dataclass
from typing import List

@dataclass
class CoffeeOrder:
    order_id: str
    drink: str          
    status: str         
    ground_coffee: float = 0.0  

# Морфизм 1: Помол кофе
def grind_coffee(order: CoffeeOrder) -> CoffeeOrder:
    if order.status == "draft":
        return CoffeeOrder(order.order_id, order.drink, "ground", 18.0)
    return order

# Морфизм 2: Варка
def brew_coffee(order: CoffeeOrder) -> CoffeeOrder:
    if order.status == "ground":
        return CoffeeOrder(order.order_id, order.drink, "brewed", order.ground_coffee)
    return order

# Морфизм 3: Подача + обновление статуса
def serve_coffee(order: CoffeeOrder) -> CoffeeOrder:
    if order.status == "brewed":
        return CoffeeOrder(order.order_id, order.drink, "served", order.ground_coffee)
    return order
# Партия заказов
orders_batch: List[CoffeeOrder] = [
    CoffeeOrder("001", "эспрессо", "draft"),
    CoffeeOrder("002", "капучино", "draft"),
    CoffeeOrder("003", "эспрессо", "draft")
]

print("Исходная партия:")
for o in orders_batch:
    print(o)

# Применяем морфизмы через map (функтор List)
grounded = list(map(grind_coffee, orders_batch))
brewed = list(map(brew_coffee, grounded))
served = list(map(serve_coffee, brewed))

print("\nПосле помола:")
for o in grounded: print(o)

print("\nПосле варки:")
for o in brewed: print(o)

print("\nПосле подачи:")
for o in served: print(o)

В моем примере я использовала массив как функтор. Функция grind_coffe переводит заказ в стадию помола, brew_coffe - в стадию варки, а serve_coffe - в стадию подачи. Для применения морфизмов ко всем элементам партии заказов я использую map.

[Sofia3003]

Чурсина Софья, 3/42

Бэкенд авторизации и функтор Alternative

def just(x):
    return (True, x)

def nothing():
    return (False, None)

def fmap(maybe, fn):
    if maybe[0]:
        return just(fn(maybe[1]))
    return nothing()

def alt(a, b):
    if a[0]:
        return a
    return b()

def auth_from_token(token):
    return nothing()

def auth_from_db(login, password):
    return nothing()

def login(login, password, token=None):
    if token:
        result = alt(auth_from_token(token), lambda: auth_from_db(login, password))
    else:
        result = auth_from_db(login, password)
    
    return fmap(result, lambda user: user)

функтор alternative пробует первый вариант получения значения, если не получается — берёт второй. В коде сначала пытаемся авторизоваться по токену, а если токена нет или он неверный — проверяем логин и пароль в базе данных. Функция fmap применяет преобразование к результату, если он есть.

[K11tykat]

Парамонов Илья 3/147

Публикация поста в нескольких соцсетях

type Post = {
    readonly content: string
    readonly status: 'draft' | 'published'
}

function alternative<T>(value: T | null, fallback: () => T | null): T | null {
    if (value != null) return value; 
    return fallback();               
}

const markAsPublished = (post: Post): Post => ({
    ...post,
    status: 'published'
});

const postToTelegram = (content: string): Post | null => {
    console.log("Публикация в Telegram...");
    return null; 
};

const postToVK = (content: string): Post | null => {
    console.log("Telegram недоступен. Публикация в VK...");
    return { content, status: 'draft' };
};

const rawContent = "Мой новый пост";

const result = alternative(
    postToTelegram(rawContent),
    () => postToVK(rawContent)
);

const finalPost = result ? markAsPublished(result) : null;
console.log('Итоговый статус публикации:', finalPost);

В своем примере я применил функтор Alternative для выбора рабочего канала публикации, то есть если отправка в Telegram возвращает пустое значение, то мы автоматически пробуем запасной вариант с VK

[holenyt]

Коротков Михаил 3/42

type Either<L, R> = { tag: 'left'; value: L } | { tag: 'right'; value: R }
const left = <L, R = never>(value: L): Either<L, R> => ({ tag: 'left', value })
const right = <R, L = never>(value: R): Either<L, R> => ({ tag: 'right', value })

const bimap = <L, R, L2, R2>(
    either: Either<L, R>,
    f: (l: L) => L2,
    g: (r: R) => R2
): Either<L2, R2> => {
    if (either.tag === 'left') {
        return left(f(either.value))
    } else {
        return right(g(either.value))
    }
}

type Form = { email: string; password: string; age: number }
type ApiError = { code: 400; errors: string[] }

const validate = (email: string, password: string, age: number): Either<string[], Form> => {
    const errors: string[] = []
    if (!email.includes('@')) errors.push('Некорректный email')
    if (password.length < 6) errors.push('Пароль слишком короткий')
    if (age < 18) errors.push('Возраст менее 18')
    if (errors.length > 0) return left(errors)
    return right({ email, password, age })
}

const toApiError = (errors: string[]): ApiError => ({ code: 400, errors })
const log = (form: Form): string => `Почта: ${form.email}, пароль: ***, возраст: ${form.age}`

const forms: Form[] = [
    { email: 'test@mail.mail', password: '123456', age: 20 },
    { email: 'test', password: '123', age: 15 },
    { email: 'q@w.e', password: 'qwerty123', age: 25 },
    { email: 'blabla', password: 'qwe', age: 67 },
]

const results: Either<ApiError, string>[] = forms.map(({ email, password, age }) =>
    bimap(
        validate(email, password, age),
        toApiError,
        log
    )
)

results.forEach(r => console.log(r))

с помощью BiFunctor я преобразовываю обе стороны: левую (ошибки) и правую (успешные данные). Функция validate возвращает Either<string[], Form> либо массив ошибок валидации, либо корректно заполненную форму. Операция bimap одной функцией toApiError преобразует левую сторону (список ошибок в объект ApiError), а другой функцией log правую сторону (валидная форма в строку для логирования как пример)

[mariyayakim]

Функтор для покупки билетов в кино.
Сначала пробуешь оплатить картой, если не прошло — пробуешь наличными. В терминале после блокировки заказа нужно оплатить. Оплата может быть разными способами.
Функтор позволяет перебирать способы, пока один не сработает.

def just(x):
    return (True, x)          

def nothing():
    return (False, None)      

def fmap(maybe, fn):
      if maybe[0]:
              return just(fn(maybe[1]))
      return nothing()

def alt(a, b):
      if a[0]:
          return a
     return b()                

def pay_by_card(amount):
      if amount <= 1000:
           return just("Оплачено картой")
     return nothing()           

def pay_by_cash(amount):
      if amount <= 500:
           return just("Оплачено наличными")
     return nothing()           

def pay_by_bonuses(amount):
      if amount <= 200:
           return just("Оплачено бонусами")
     return nothing()


def pay(amount):

      result = alt(pay_by_card(amount), lambda: alt(pay_by_cash(amount), lambda: pay_by_bonuses(amount)))
      return fmap(result, lambda msg: f"Успех! {msg}. Печатаем билеты...")

[Fuziks]

Коровин Артём 3/147

Доставка сообщений с подтверждениями

type Message = { id: number; text: string; senderId: string }
 
type WithStatus<S extends string> = Message & { status: S }
type DeliveredMessage = WithStatus<'delivered'>
type ReadMessage = WithStatus<'read'>
 
type Option<T> = T | null
 
function map<A, B>(value: Option<A>, fn: (a: A) => B): Option<B> {
    if (value == null) return null
    return fn(value)
}
 
const toDelivered = (m: Message): DeliveredMessage => ({ ...m, status: 'delivered' })
const toRead = (m: DeliveredMessage): ReadMessage => ({ ...m, status: 'read' })
 
const fromSocket: Option<Message> = { id: 1, text: 'hello', senderId: 'user_2' }
 
const delivered = map(fromSocket, toDelivered)
const result = map(delivered, toRead)
 
console.log(result)

const missingMessage: Option<Message> = null
 
const missingResult = map(map(missingMessage, toDelivered), toRead)
 
console.log(missingResult)

Использую Option как функтор. map применяет функцию к значению внутри option, если оно есть.
Если значения нет (null), ничего не происходит - option моделирует вычисление с возможным отсутствием результата.

[temawan2gecko]

Чалунин Артём 3/42

Обработка задач в системе CI/CD

type Task = {
    readonly id: number
    readonly title: string
    readonly status: 'new' | 'testing' | 'done'
}

const sendToTesting = (task: Task): Task => ({
    ...task,
    status: 'testing'
})

const completeTask = (task: Task): Task => ({
    ...task,
    status: 'done'
})

const taskQueue: Task[] = [
    { id: 1, title: 'Fix login bug', status: 'new' },
    { id: 2, title: 'Update landing page', status: 'new' }
]

const testingQueue = taskQueue.map(sendToTesting)
console.log('Задачи отправлены на тестирование:', testingQueue)

const completedQueue = testingQueue.map(completeTask)
console.log('Задачи после завершения:', completedQueue)

// Композиция функций в один процесс
// const fullPipeline = (task: Task) => completeTask(sendToTesting(task))
// const finalTasks = taskQueue.map(fullPipeline)
// console.log('Результат полного CI/CD pipeline:', finalTasks)

В данной работе массив используется как функтор. С помощью метода map функции обработки задач были подняты до уровня работы со всей очередью задач.

Функция sendToTesting переводит задачу в этап тестирования, а completeTask завершает её выполнение. После этого обе функции можно объединить через композицию, создав единый pipeline обработки.

Таким образом демонстрируется применение функторов и композиции функций на примере процесса CI/CD в разработке программного обеспечения.

[pvzprrrr]

Наумова Алёна 3/42

Обработка заказов в магазине косметики

const applyDiscount = (product) => ({
    ...product,
    price: product.price * 0.9
})

const markAsPacked = (product) => ({
    ...product,
    status: 'packed'
})

const orders = [
    { name: 'Помада', price: 1200, status: 'new' },
    { name: 'Тушь', price: 900, status: 'new' }
]

// Ко всем товарам применяется скидка
const discountedOrders = orders.map(applyDiscount)
console.log('После применения скидки:', discountedOrders)

// Все товары отправляются на упаковку
const packedOrders = discountedOrders.map(markAsPacked)
console.log('После упаковки:', packedOrders)

В своём примере я использовала массив как функтор.

Морфизмы applyDiscount и markAsPacked работают с одним товаром, а с помощью map можно применять преобразования сразу ко всему списку заказов.

Сначала для всех товаров применяется скидка, а затем каждый товар получает статус упаковки.

Таким образом, каждый элемент массива обрабатывается независимо, а структура контейнера при этом не изменяется.