Lab 3

[the-homeless-god]

1. Take some high level task from real world and decompose it to functional paradigm based on logic with any programming language or even human language.

Ex: Play Death Note opening on guitar

fn convert Death Note to notes
fn extract tab from notes
fn map tab to finger sequence on guitar
fn play each finger step

But describe it with body of functions and used categories/types

2. Is it possible to reuse your function with different payload?

3. How do you understand the ability to scale or parallel computing in your functions?

4. Is it possible to shortify arity of functions to 1? Or 0?

5. Could you add monads like Either / Option / MayBe into your code?

[Kirill-Bokov]

function songToMindMap(song: Song): MindMap {
return {
content: song.content.map(soundToMentalSound)
};
}

function findMissing(a: any[], b: any[]): any[] {
return b.filter(x => !a.includes(x));
}

function isTheSkillSufficient(mindMap: MindMap, skillList: object[]): [boolean, object[]] {
const problems = mindMap.content.flatMap(content => findMissing(skillList, content));
return [problems.length === 0, problems];
}

function skillTraining(sufficienty: boolean, skillList: object[], problems: object[]): object[] {
if (sufficienty) {
return skillList;
}
return [...skillList, ...problems.map(problem => problem.train())];
}

function mindMapToSong(mindMap: MindMap): Song {
return { content: [...mindMap.content] };
}

function makeARecording(song: Song): Recording {
return { content: [...song.content] };
}

---

let song = Internet.downloadSong("How you remind me")
let skillList = Brain.skillList;
let mindMap = songToMindMap(song);
let [sufficienty, problems] = isTheSkillSufficient(mindMap, skillList);
skillList = skillTraining(sufficienty, skillList, problems);
let song = mindMapToSong(mindMap);
let cover = makeARecording(song);
cover.produce ✅

2. You can use my function not only for songs, but also for sheet music or learning cooking recipes for example

3. These operations cannot be done in parallel, since they are originally built for sequential execution
4. It is possible to shortify arity, but you will have to add a lot of switch functions, or come up with another way
5. I don't know, because, unfortunately, I don’t understand what a monad is right now

[EugeneWWolf]

3-147 Ермакова Ксения

fn createPokemon() -> Pokemon {
    -- Для простоты пока что возвращается один и тот же заданный покемон
    return Pokemon(name: "Вапореон", hp: 60, attack: 5, maxhp = hp)
}

fn findPokemon(tile: Tile) -> MayBe[Pokemon] {
    -- Логика поиска: если покемон найден, возвращаем его, иначе - None
    if (tile.type == "тропа") then
       return None
    
    -- На тайле с кустами вычисляем вероятность появления покемона:
    randomNumber = generateRandomNumber(0, 1)
    if randomNumber < 0.5 then
        -- Создаем покемона с заданными или случайными характеристиками
        return createPokemon()
    else
        return None
}

fn calculateDamage(attacker: Pokemon, defender: Pokemon) -> Int:
    return attacker.attack

fn battleStep(trainerPokemon: Pokemon, wildPokemon: Pokemon) -> (Pokemon, Pokemon):
    -- Первый покемон атакует второго
    damageToWildPokemon= calculateDamage(trainerPokemon, wildPokemon)
    newHpWildPokemon = wildPokemon.hp - damageToWildPokemon
    updatedWildPokemon = Pokemon(wildPokemon.name, max(0, newHpWildPokemon), wildPokemon.attack, wildPokemon.maxhp, wildPokemon.owner)

    -- Второй покемон атакует первого (если он ещё жив)
    damageToTrainerPokemon = calculateDamage(updatedWildPokemon, trainerPokemon)
    newHpTrainerPokemon = trainerPokemon.hp - damageToTrainerPokemon
    updatedTrainerPokemon = Pokemon(trainerPokemon.name, max(0, newHpTrainerPokemon), trainerPokemon.attack, trainerPokemon.maxhp, trainerPokemon.owner)

    return (updatedTrainerPokemon, updatedWildPokemon)

-- Рекурсивная функция для сражения (попытка сделать её)

fn fight(trainerPokemon: Pokemon, wildPokemon: Pokemon) -> BattleOutcome {
-- Допускается, что дикий покемон может только ослабнуть, но не умереть
if (trainerPokemon.hp > 0 AND wildPokemon.hp > 0) then
   (updatedTrainerPokemon, updatedWildPokemon) = battleStep(trainerPokemon, wildPokemon)

else if (trainerPokemon.hp <= 0) then
   return BattleOutcome.TrainerPokemonDefeated
else if (isPokemonWeakened(wildPokemon) == True)
   return BattleOutcome.WildPokemonWeakened
else
   fight(updatedTrainerPokemon, updatedWildPokemon)
    
}

-- Если у покемона хп - 0.3 от максимального, то он считается ослабленным
fn weakenPokemon(pokemon: Pokemon, battleOutcome: BattleOutcome) -> Pokemon {
    if battleOutcome == BattleOutcome.WildPokemonWeakened
           return Pokemon(name: pokemon.name, attack: pokemon.attack, hp: pokemon.maxhp * 0.3, maxhp: pokemon.maxhp, owner: None)
    else
      return pokemon
}

fn isPokemonWeakened(pokemon: Pokemon) -> boolean {
    return pokemon.hp <= (pokemon.maxHp * 0.3)
}

fn isCatchSuccessfull(pokemon: Pokemon) -> boolean {
    let catchChange = (isPokemonWeakened(pokemon)) ? 0.8 : 0.2 -- Чем больше хп, тем сложнее ловить покемона
    return generateRandomNumber(0, 1) <= catchChance ? True : False
}

fn catchPokemon(tile: Tile, trainer: Trainer) -> MayBe[Pokemon] {
    let foundPokemon: MayBe[Pokemon] = findPokemon(tile)
    if (foundPokemon не является None) then
            let battleOutcome = fight(trainer.pokemon, foundPokemon)

            if battleOutcome == BattleOutcome.TrainerPokemonDefeated then
                return None

            let weakenedPokemon = weakenPokemon(foundPokemon, battleOutcome)
            let result = isCatchSuccessfull(weakenedPokemon)
            if (result == True) then
                let catchedPokemon = Pokemon(name: pokemon.name, attack: pokemon.attack, hp: pokemon.maxhp, maxhp: pokemon.maxhp, owner: trainer)
                return catchedPokemon
     
   return None -- Если foundPokemon - это None или если не удалось поймать покемона, то возвращаем None
}

Is it possible to reuse your function with different payload?

Да, мой код работает для разных покемонов и тренеров (правда, из всего своего арсенала покемонов он должен выбрать для битвы только одного; реализация смены покемонов в бою не реализована)

How do you understand the ability to scale or parallel computing in your functions?

Мои функции могут выполняться параллельно, так как они не несут в себе сайд-эффектов. Если меняется состояние покемона, то создаётся другая, отдельная от него версия. Тем самым много тренеров одновременно могут сражаться с покемонами.

Is it possible to shortify arity of functions to 1? Or 0?

Да, это возможно с помощью каррирования. На примере функции startBattle: fn startBattle(trainer: Trainer) -> fn(Pokemon) -> BattleOutcome.

С функциями weakenPokemon и catchPokemon можно тоже сделать что-то подобное и уменьшить арность до 1. До 0 же будет проблематично, так как такой код, скорее всего, потеряет чистоту функций, у которых арность больше 0.

Could you add monads like Either / Option / MayBe into your code?

Я уже использую монаду MayBe, чтобы отправлять и получать значения, которые могут либо присутствовать, либо быть None.

[Egorius1268]

Фролов Егор 3/42

1. Cook Pelmeni

fn take_food_package (storage: Storage, package: Package){
      i  = 0
      while i <= storage.length:
            current_package = storage.package;
            if current_package.contains != package.name:
                  i++;
            else: 
		  food_package = current_package;
        break;
return food_package;
}
fn take_a_pot (pot: Kitchenware){
	pot_search = in Kitchenware search(Kitchenware.type = pot);
	if pot_search != null:
		return needed_pot;
	else: 
		return (“Нету такой кастрюли!!!”);
}
fn pour_water_in_pot (water_source: WaterSources, pot = pot_for_pelmeni): FilledPot {
	filled_pot = pot.fill(water_source);
	if filled_pot.volume > pot.volume – 75:
		filled_pot.pour_out(pot.volume – filled_pot.volume);
        return filled_pot; 
	else: return filled_pot;
}
fn boil_water (heat_source: HeatSource, pot = filled_pot) : BoilingWater{
	heat_source.add_kitchenware(pot);
        heat_source.turn_up_the_heat(100);
	If pot.water_temperature >= 98:
		return boiling_water_pot;
}
fn boil_food (spices: Spices, cooking_time: int, heat_source: HeatSource, food = food_package, pot = boiling_water_pot){
      heat_source.add(pot);
      heat_source.turn_up_the_heat(100);
      if food.packaged == True:
		food = food.open_package(food);
      pot.add_food(food, 30);
      pot.add(species);
      heat_source.wait(time);
      heat_source.reduce_heat(100);
      return boiled_food;
}
fn take_dishes (dishes: Tableware, number_of_dishes: int) {
	dishes.put_on_table(number_of_dishes);
return dishes_for_food;
}
fn serve_dishes (dishes = dishes_for_food, food = boiled_food){
	dishes.serve(food);
}

Итого, для варки пельменей:
take_food_package (refrigerator, pelmeni);
take_a_pot (pot_for_pelmeni);
pour_water_in_pot (bottle);
boil_water (stove);
boil_food (bay_leaf, 8, stove);
take_dishes(deep_plate, 1);
serve_dishes();

2. Да, эти функции можно использовать для разного набора входных данных, например при готовке мяса можно вызвать функцию take_food_package(refrigerator, meat)
   Или можно готовить на другом источнике тепла: boil_water(campfire)

3. Параллелизм у функций отсутствует, поскольку они создавались с учетом их последовательного исполнения. Касательно масштабируемости, то у большинства функций она вполне себе приемлем, например boil_water(), исполнение которой не будет ускоряться, какие бы входные данные ни были, то есть ее сложность O(1). Или pour_water_in_pot(), сложность которой тоже O(1). С другой стороны, take_food_package() будет исполняться медленнее с ростом объема входных данных, ведь ее сложность – O(n)

4. Арности 1 можно добиться, если функции с несколькими функциями разить на две функции по одному аргументу, либо вынеся один из аргументов в тело функции, но сделав его фиксированным, из-за чего потеряется гибкость. Например, fn take_food_package (storage: Storage, package: Package) можно разбить на fn choose_storage(storage: Storage), fn take_food_package (package: Package) и в теле второй функции использовать возвращенное значение первой функции
   Арности 0 тоже можно добиться, но из-за этого потеряется гибкость, поскольку все значения внутри функций будут фиксированными, соответственно и результат будет одинаковый.

5. Да, монады можно добавить в мои функции, например в take_a_pot можно использовать монаду Option, чтобы избежать ошибок, связанных с Null или использовать монаду Either в pour_water_in_pot(), используя Either.Right если объем наполненной кастрюли на 75 и больше миллилитров меньше общего объема, и Either.Left при обратном случае.

[goutosama]

Чадов 3/147

Задание: Выполнить лабораторную работу по использованию программы.

func listenToLecture(subject) {
	Brain.writeToMemory(arriveToLectureRoom(findLectureInTimetable(subject)))
	leaveLecture()
}

func leaveLecture() {
	Lectures.leave()
}

func findLectureInTimetable(subject): time, destination {
	return Timetable.search(subject)
}

func arriveToLectureRoom(time, destination): lecture {
	Lectures.showUp(time, destination)
	return Lecture.getCurrentLecture()
}

func getLabTask(subject): task {
	Moodle.getCurrentTask(subject)
}

func downloadNeededTools(task): apps, reportTemplate {
	return Moodle.getTaskPinnedFiles(task)
}

func installApps(apps) {
	for app in apps {
		PC.os.install(app)
	}
}

func doTask(task) {
	for subtasks in task {
		PC.os.save(PC.os.screenshot(PC.os.newAppForTask.do(subtask, Brain.getKnowledge(task)))) // не продумал как мы узнаем, что нам надо использовать newAppForTask
	}
}

func doReport(task, reportTemplate): file {
	var text = Brain.composeReportText(task)
	return PC.Word.saveFile(PC.Word.openFile(reportTemplate).map(
		PC.Word.editAuthorName(text),
		PC.Word.editTaskProgressDesc(text),
		insertScreenshotsToReport(text), 
		PC.Word.editSummary(text), 
	))
}

func insertScreenshotsToReport(reportTemplate) {
	for picture in PC.os.read.screenshots {
		PC.Word.pasteToFile(picture)
	}
}

func uploadReport(task, file) {
	Moodle.upload(task, file)
}

func main(subject) {
	listenToLecture()
	var task = getLabTask(subject)
	var apps, reportTemplate = downloadNeededTools(task)	
	installApps(apps)
	doTask(task)
	uploadReport(task, doReport(task, reportTemplate))
}

2. Вполне: меняйте subject и будет выполняться лабораторная другого предмета

3. Расширяемость в этих функциях достигается запуском одной функции main к разным subject, которые могут выполнять разные лабораторные одновременно. А параллельности можно достичь, запустив в двух разных потоках doTask() и doReport() - пока один поток делает задание и сохраняет в компьютер скриншоты для отчёта, другой поток редактирует шаблон отчёта и вставляет в него скриншоты

4. В моём примере все места, где функция требует два аргумента, можно заменить на какое-либо глобальное состояние или объединить в одну структуру данных, но совсем их убрать имхо не получится.

5. Да, наверное каждый аргумент в данном примере можно обернуть в Option, таким образом получится избежать ошибок, связанных с неполученными значениями, этот же код работоспособен только для самого оптимистичного варианта.

Возможно код буду дополнять

[denisbochka]

Смолов 3/147
1.Задание: Написать курсовую работу по 1С

function WriteTheoryPart(subject, requiredApps): Textfile{
    MSWord.open()
    Browser.lookForInfo(subject)
    MSWord.WriteSomething()
    for neededDiagram in subject {
        const newDiagram = MakeDiagram(neededDiagram.diagramClass, app)
        MSWord.InsertScreenshots(newDiagram)
    }
    return halfDoneTask
}

function MakeDiagram(diagramClass, app): Diagram{
    app.drawDiagram(diagramClass)
    return diagram
}

function WriteOneSPart(theoryPart, tasksToDo): Textfile{
    MSWord.open()
    OneS.open()
    for task in tasksToDo{
        MSWord.WriteSomething()
        const newTask = OneS.doTask(task)
        MSWord.InsertScreenshots(newTask)
    }
    return CompletedTask
}

function PrintTask(finishedTask){
    printer.Print(finishedTask)
}

function main{
    const theoryPart = WriteTheoryPart(sportschool, [bpwin,drawio])
    const finishedTask = WriteOneSPart(theoryPart)
    PrintTask(finishedTask)
}

2. Да, любая из этих функций будет работать с другими аргументами
3. Можно запустить функции в разных потоках, чтобы они работали параллельно. Например, пока создаётся диаграмма, можно продолжать выполнение WriteTheoryPart и писать что-то дальше.
4. В моих функцияъ можно везде сделать по 1 аргументу. В WriteTheoryPart и MakeDiagram можно просто заранее определить используемые программы так же, как мы определили использование MSWord. В WriteOneSPart tasksToDo можно задавать уже внутри функции с помощью какой-нибудь отдельной CreateTasks.
5. Можно и добавить эти монады, чтобы ловить ошибочные и пустые значения, если такие будут

[N-N0th1n9]

Цыганов Влад 3/42
draft

1. Задание: Установка или обежвреживание пачки в кс

type Weapon = 'C4' | 'DefuseKit'
type Position = { x: number; y: number; z: number }
type PlayerState = { position: Position; weapon: Weapon; health: number }
type Task = 'plant_bomb' | 'defuse_bomb'
type Error = string

type Either<L, R> = { type: 'Left'; value: L } | { type: 'Right'; value: R }

function findBombSite(): Position {
  return { x: Math.random(), y: Math.random(), z: 0 }
}

function moveToPosition(state: PlayerState, position: Position): PlayerState {
  return { ...state, position }
}

function plantBomb(state: PlayerState, bombSite: Position): Either<Error, PlayerState> {
  const distance = Math.sqrt(
    Math.pow(state.position.x - bombSite.x, 2) +
    Math.pow(state.position.y - bombSite.y, 2) +
    Math.pow(state.position.z - bombSite.z, 2)
  )

  if (distance < 0.1) {
    if (state.weapon === 'C4') {
      return { type: 'Right', value: state }
    } else {
      return { type: 'Left', value: 'Не удалось установить пачку: нет пачки в руках' }
    }
  } else {
    return { type: 'Left', value: 'Не удалось установить пачку: вы не на месте установки' }
  }
}

function defuseBomb(state: PlayerState, bombSite: Position): Either<Error, PlayerState> {
  const distance = Math.sqrt(
    Math.pow(state.position.x - bombSite.x, 2) +
    Math.pow(state.position.y - bombSite.y, 2) +
    Math.pow(state.position.z - bombSite.z, 2)
  )

  if (distance < 0.1) {
    if (state.weapon === 'DefuseKit') {
      return { type: 'Right', value: state }
    } else {
      return { type: 'Left', value: 'Не удалось обезвредить пачку: нет DefuseKit' }
    }
  } else {
    return { type: 'Left', value: 'Не удалось обезвредить пачку: вы не на месте установки' }
  }
}

function playRound(task: Task, state: PlayerState, bombSite: Position): Either<Error, PlayerState> {
  if (task === 'plant_bomb') {
    return plantBomb(state, bombSite)
  } else if (task === 'defuse_bomb') {
    return defuseBomb(state, bombSite)
  } else {
    return { type: 'Left', value: 'Неизвестная задача, стой афк' }
  }
}

function main() {
  const initialState: PlayerState = {
    position: { x: 0, y: 0, z: 0 },
    weapon: 'C4',
    health: 100,
  }

  const bombSite = findBombSite()
  const movedState = moveToPosition(initialState, bombSite)

  const result = playRound('plant_bomb', movedState, bombSite)

  if (result.type === 'Right') {
    console.log('Пачка успешно установлена!', result.value)
  } else {
    console.log('Ошибка:', result.value)
  }
}

main()

2. Да, будет работать, если передать другие входные значения.
3. Я понимаю маштабируемость, как способность кода обрабатывать увеличивающийся функционал и больший объем данных. Параллельные вычисления - независимое выполнение задач одновременно.
4. Мы можем сократить arity до 1, используя каррирование. Например для plantBomb или defuseBomb
5. Вроде можно, я попробовал.

[Victor2004]

Пыжов Виктор 3/147

let state = {
  loaded: false,
  washed: false,
  dried: false
};

function loadMachine() {
  if (!state.loaded) {
    console.log("Загружаю вещи в стиралку");
    state.loaded = true;
  }
}

function addSoap() {
  if (state.loaded) {
    console.log("Добавляю порошок");
  }
}

function startWash() {
  if (state.loaded) {
    console.log("Стирка началась");
    setTimeout(() => {
      state.washed = true;
      console.log("Стирка завершена");
    }, 2000);
  }
}

function dryClothes() {
  if (state.washed) {
    console.log("Вещи на сушке");
    state.dried = true;
  }
}

function putAway() {
  if (state.dried) {
    console.log("Убираю в шкаф");
    state = { loaded: false, washed: false, dried: false }; // Сброс
  }
}

[AlyonaUi]

Данилова Алёна 3/42

1. Сыграть в "Дурака" (Упрощённая версия)

function chooseFirstPlayer(players: Player[]): number {  // Выбираем случайного игрока, который будет ходить первым
  return Math.floor(Math.random() * players.length);
}

function takeCards(deck: Card[], count: number): Card[] {  // Берём сверху колоды указанное количество карт
  return deck.splice(0, count);
}

function сhooseTrumpCard(deck: Card[]): Suit {  // Определяем козырную масть (берём сверху карту и кладём в конец колоды)
    const trumpCard = deck.shift(); 
    deck.push(trumpCard);
    const trumpSuit = trumpCard.suit;
    return trumpSuit
}

function isHigherOrTrump(card: Card, otherCard: Card, trumpSuit: Suit): boolean { // Возвращает true, если карта игрока старше или козырная, иначе — false.
    if (card.suit === otherCard.suit) {
    return rankValue(card.rank) > rankValue(otherCard.rank); // Сравниваем ранги карт
    };
    if (card.suit === trumpSuit) return true; // Карта, которой игрок хочет отбиваться, козырная
    if (otherCard.suit === trumpSuit) return false; // Противник играет козырной картой
}

function takeToInitialValue(players: Player[], deck: Card[],  initCount: number): Player[]{  // Набираем количество карт в руку до начального значения каждому игроку из колоды
    const hands = players.map(() => takeCards(deck, initCount));
    const playersHand =  players.map((index) => players.hand = hands[index]);  
    return playersHand;
}

function selectCurrentAndNextPlayer(currentPlayerIndex: number): Player {  // Выбираем игрока который будет ходить и отбиваться
    const currentPlayer = players[currentPlayerIndex];  
    const nextPlayerIndex = (currentPlayerIndex + 1) % players.length;
    const nextPlayer = players[nextPlayerIndex];
    return currentPlayer, nextPlayer
}

function chooseCardToPlay(currentPlayer: Player): Card {  // Выбрать карту для хода
    const cardToPlay = getRandomElement(currentPlayer.hand);
    currentPlayer.hand = currentPlayer.hand.filter((card) => card !== cardToPlay);
    return cardToPlay
}

function canDefendCard(nextPlayer: Player, cardToPlay: Card, trumpSuit: Suit): boolean {  // Узнать есть ли карта, которой будем "отбиваться"
    const canDefend = nextPlayer.hand.some(card => isHigherOrTrump(card, cardToPlay, trumpSuit));
    return canDefend
}

function chooseDefendingCard(nextPlayer: Player, cardToPlay: Card, trumpSuit: Suit): Card {  // Выбрать карту для отбития
    const defendingCard = nextPlayer.hand.find(card => isHigherOrTrump(card, cardToPlay, trumpSuit));
    nextPlayer.hand = nextPlayer.hand.filter(card => card !== defendingCard);
    return defendingCard
}

function addCardToTheTable(tableCards: Card[], card: Card): Card[] {  // Добавляем карту на игровой стол
    tableCards.push(card);
}

function playCardGame(players: Player[], deck: Card[],  initCount: number, ): {  // Основная функция карточной партии
    const tableCards: Card[];
    const playersHand: Player[] = takeToInitialValue(players, deck,  initCount);
    let currentPlayer = chooseFirstPlayer(players);
    const trumpSuit = сhooseTrumpCard(deck);
    while (!currentPlayer.hand.length && !deck.length) {
        const currentPlayer, nextPlayer = selectCurrentAndNextPlayer(currentPlayerIndex);
        const cardToPlay = chooseCardToPlay(currentPlayer);
        addCardToTheTable(tableCards, cardToPlay);
        if (canDefendCard(nextPlayer, cardToPlay, trumpSuit)) {
            const defendingCard = chooseDefendingCard(nextPlayer, cardToPlay, trumpSuit);
            addCardToTheTable(tableCards, defendingCard)
            tableCards.length = 0;
       } else {
       nextPlayer.hand.push(...tableCards);
       tableCards.length = 0;
       }
       if (currentPlayer.hand.length < initCount && deck.length > 0) {
       const cardsToTakeCurrent = initCount - currentPlayer.hand.length;
       currentPlayer.hand.push(...takeCards(deck, cardsToTakeCurrent));
       }
       if (nextPlayer.hand.length < initCount && deck.length > 0) {
       const cardsToTakeNext = initCount - nextPlayer.hand.length;
       nextPlayer.hand.push(...takeCards(deck, cardsToTakeNext));
       }
       selectCurrentAndNextPlayer(nextPlayerIndex)
    }
    console.log(`${currentPlayer.name} победил!`)
}

2. Да, можно использовать для любой партии, для любого размера колоды или количества игроков.

3. Хоть по сути задача предполагает последовательное выполнение действий, некоторые функции можно выполнять параллельно, например Выбирать первого игрока и брать в руку начальное количество карт можно и одновременно. На счёт масштабируемости - вполне можно добавить новые функции, которые будут работать, например, подкидывание дополнительных карт или перевод хода на следующего игрока.

4. В принципе можно запаковать некоторые значения в объекты или использовать глобальные переменные, чтобы уменьшить количество аргументов в функциях и получить арность 1, а может и понизить до 0.

5. Да, можно добавить в код монады Either / Option / MayBe для обработки ошибок, например, если передано пустое значение или какая-либо функция возвращает пустое или некорректное значение. Например при раздаче карт или выборе козыря. Если слишком большому количеству попытаться раздать карты, то в колоде их может не хватить, обработчик ошибок поможет.

[kanclusion]

Канашин Дмитрий 3-42

1. Написать инструментал

function chooseBPM(style) {
   return BPM
}

function chooseInstrument(style) {
   return selectedInstrument
}

function chooseDrumSamples(style) {
   return drumSamples
}

function createMelody(style, instrument, choosedBPM) {
   return generatedNotes
}

function createDrums(drumSamples ,BPM) {
   return drumsTrack
}

function arrangeTrack(melody, drumTrack) {
    return arrangedMelodyAndDrums
}

function exportTrack(arrangedMelodyAndDrums, format) {
    return saveTrackToFile
}

2. Да, можно использовать другой стиль, темп или инструмент и т.д.
3. Возможно если использовать asynс, то можно использовать функции одновременно.
4. Ну сократить арность до 0, скорее всего возможно при использовании глобальных переменных. А что сделать для арности 1 я пока не знаю.
5. Вероятно можно использовать монад для обработки возможных пустых значений.

[lisl1ll]

Аксёнова Анастасия 3/42

Draft

1. Создание браслета из бисера

function prepareMaterials(): {
// Подготавливаем бисер и нить для работы
return materials
}

function chooseDesign(): {
// Выбираем дизайн браслета
return design
}

function createTracery(): {
// Создаем узор из бисера в соответствии с дизайном
return tracery
}

function stringTheBeads(): {
// Нанизываем бисер на нить согласно узору
return bracelet
}

function assembleTheBracelet(): {
// Собираем браслет и завершаем процесс
return finishedProduct
}

2. Думаю, да, ибо мы можем создавать разные изделия из бисера или можно использовать другие материалы для изготовления вещей ручной работы, если у них есть дизайн, узор и тд, что будет соответствовать функциям
3. Создание разных видов браслетов или разных изделий подразумевает масштабируемость. Параллельно мы можем подготавливать материалы и выбирать дизайн, но нанизываем нить мы согласно узору, который выбрали до, тут параллельно выполнять действия мы не можем
4. До 0 точно нет, в некоторых местах необходимо несколько аргументов, например в prepareMaterials() у нас может быть бисер, нить, лента, проволока и тп. Это можно объединить, как бисер и что-то на что его нанизывают, но как убрать полностью я не знаю
5. Если узор в createTracery возвращает ошибку, то можно использовать Either, чтобы рассматривать два сценария

[Fuflick]

3-42 Белов Степан

1 . //Listen to music

// main method (if one of attributes is null => do not do anything)
public Task ListenMusic(Device? phone, Application? app, File? track ) => PlayTrack(FindApp(FindPhone(phone), FindApp(app));

//method for find device to listen music
public Task<Device?> FindPhone(Device phone) => phone.isNear ? phone : null;

//method to find music player (if device have not been founded => device = null => app = null )
public Task<Application?> FindApp(Device phone, Application app) => phone.Contains(app) ? app : null;

//method to find specific trach (if trak not founded => listen selection of recommendations)
public Task PlayTrack(File track) => app.Contains(track) ? Enjoy() : PlayRecomendedTracks();

2. Да, можно, к примеру, использовать несколько различных устройств в методе FindPhone, или любой существующий или нет трек в методе ListenTrack

3. Насчёт параллельных вычислений я не уверен, так как методы не ассинхронны, однако можно создать различное количество экземпляров, которые будут параллеоьно выполнять одни и те же действия.
   Что насчёт расширений - пожалуйста. По сути всю эту конструкцию можно запихнуть в Абстрактный класс, сделать функции виртуальными или превратить это в интерфейс и видоизменять как только захочется

4. Думаю, в данной ситуации это возможно, однако это значит, что нужно уйти от экземпляров классов Device, Application и File к чему-то абстрактному или константно существующим экземплярам, чтобы не передавать их в качестве аргументов функции

5. Если я првильно понимаю, то в моих методах и так используются монады. Функторы могут вернуть null и выполнение функции от этого не поломается, что, как я понял и явлется подобием монад Maybe(Option) (значение может отсутствовать) и Either (обработка ошибок без исключений)

[0x0e4]

Solder solder;
Flux flux;
Tape cooperTape;
Soldering solderIron;
Alcohol alcohol;

void Tinker(Solder sold, Area area) {}
void PourIn(Object obj, Area area) {}
void Clean(Object cleaner, Area area) {}
void Insert(Object obj, Area area) {}
void Remove(Object obj) {}

// Задача: выпаять SOP-8 микросхему и впаять новую

void StartSoldering(Soldering sold) {
solderIron.Start();
while(solderIron.temp < 290) Thread.Sleep(500);
}

void TinkerSOP8ForDesoldering(Area chipPlace) {
Tinker(solder, chipPlace.GetArea(0, 3)); // пропаиваем первые 4 ноги чипа
Tinker(solder, chipPlace.GetArea(4, 7)); // пропаиваем вторые 4 ноги чипа
}

void DesolderChip(Chip oldChip, Area chipPlace) {
PourIn(flux, chipPlace);
TinkerSOP8ForDesoldering(chipPlace);
Remove(oldChip); // выпаиваем чип
Clean(cooperTape, chipPlace); // чистим место пайки от припоя с помощью медной ленты
}

void TinkerSOP8(Area chipPlace) {
for(int i = 0; i < 8; i++)
Tinker(solder, chipPlace.GetArea(i));
}

void SolderChip(Chip newChip, Area chipPlace) {
Insert(newChip, chipPlace);
PourIn(flux, chipPlace);
TinkerSOP8(chipPlace);
Clean(alcohol, chipPlace); // очищаем место пайки от флюса с помощью спирта
}

void SolderNewChip(Chip oldChip, Chip newChip, Area chipPlace) {
StartSoldering(solderIron);
DesolderChip(oldChip, chipPlace);
SolderChip(newChip, chipPlace);
}

2. В целом это возможно, даже не смотря на то, что у нас довольно узкоспециализированная функция. Мы можем, например, вместо флешки впаять ШИМ-контроллер формата SOP8. Но как это повлияет на работу устройства я предсказать не могу :)

3. Возможность параллельного вычисления в моём коде имеет место быть, но не везде. Например, можно параллельно паять все ноги чипа одновременно. Но, например, мы не можем параллельно наливать флюс и паять.

4. В целом мы можем сократить арность до 1, используя абстрактные классы, но сократить арность до 0 - это уже задача посложнее. Это мы можем лишь в том случае, если будем использовать глобальные переменные, что не есть хорошо.

5. Да, использование перечисленных монад, кроме Maybe, возможно в моём коде. Монада Either может использоваться в функциях, которые принимают в качестве аргумента Object. Так же и с Option, мы можем использовать эту монаду, поскольку в качестве Object мы можем передать и значение null. Однако, насчёт монады Maybe я не уверен.

[Mary2811]

3-42 Белова Мария

cook soup:

function buyIngridients(ingridients[]){
foreach (i in ingridients){
i.IsNeed ? buy(i) : countinue
}
}

function prepareIngridients(ingridients[]){
ingridient.IsReadyToCook ? countinue : ingridient.Prepare() // Prepare() simular to wash or clean or cut
}

function lightFire (){
Fire.IsBurn() ? Fire.Burn() : Countinue
}

function putIngrideentsInPot(ingridients[]){
var pot
foreach (i in inngridients){
i.Need ? pot.Add(i) : countinue
}
return pot
}

function wait(){
checkResult() ? return 1 : return 0
}

function checkResult (pot){
return pot.Ready
}

2. Вполне, можно использовать другой список продуктов или другой рецепт (различное время приготовления)

3. Так же как можно готовить несколько различных блюд, так можно и использовать данные методы одновременно с различными атрибутами

4. В большинстве из данных методов исопьзуется массив ingridients[], без ингридиентов в готовке никак, потому скорее нет, чем да. Больше данный код похож на машину состояний для списка продуктов. Продукты переходят из одного состояния в другое (из ещё не купленного в готовое)

5. В данных методах используется что-то на подобие монады Either в методе wait мы ожидаем готовности и время от времени проверяем, получая на выходе либо одно, либо другое

[GitSwaggCat]

3/147 Новосёлов Николай
1.

public FindRecipe(){
    foreach recipe in internet{
        if recipe == "is good"{
            return recipe;
        }
           break;
    }
}
public WriteListToCook(string recipe){
    string list[];
    list = recipe.FindProduct();
    return list;
}

public SelectNearest(string city, string category){
    int YourLocation[] = TakeYourLocation(city);
    return YourLocation.FindNearest(category);
}
public GoTo(location){
    You.GoTo(location);
}
public BuyAllProduct(string[] list){
    string storage[];
    foreach (var product in shop)
    {
        if product == list.Find(Predicate<T> product){
            storage.Add(product);
        }
        return storage;
    }
}

public Cook(recipe,storage){
    Yoy.Cook(recipe);
    return dish;
}

2. В функции где используются какие-либо аргументы, можно поменять их на другие
   Например:
   Функция SelectNearest выбирает ближайший объект по категории(магазин, спортзал и т.д)
3. Масштабировать функции можно, допустим просто запустить их с различными аргументами. Параллельность в этих функциях возможна лишь при запуске в разных потоках, т.к функции не являются асинхронными.
4. Чтобы достичь одной функции, мы можем либо запихнуть все в одну функцию и оно будет выполняться как обычный код, сократить до 0 можно, но тогда в таком случае ничего делаться не будет
5. Можно добавить функцию, которая будет проверять наличие аргументов

[kagam1i]

Балясова Елена 3/147

const getIngredients = () => ({
flour: "200g",
milk: "300ml",
eggs: 2,
sugar: "1 tbsp",
salt: "pinch",
butter: "30g",
oil: "for frying"
});

const mixBatter = ({ flour, milk, eggs, sugar, salt, butter }) =>
Batter made with ${flour} flour, ${milk} milk, ${eggs} eggs, ${sugar} sugar, ${salt} salt and ${butter} butter.;

const heatPan = () => "Pan is heated and oiled.";

const cookPancakes = (batter) =>
Pancakes cooked using: ${batter}.;

const ingredients = getIngredients();
const batter = mixBatter(ingredients);
const panReady = heatPan();
const cookedPancakes = cookPancakes(batter);

console.log(result);

2. Можно, функция принимает параметры, которые можно изменить для разных данных.

3. В моем коде все функции выполняются последовательно.

4. Да. Можно передавать один объект или массив в функцию mixBatter вместо нескольких параметров.

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