Scala for Backend Engineering & Functional Programming · Lekcja

Curryfikacja

Aplikacja częściowa

Curryfikacja to bezpłatna lekcja Scala for Backend Engineering & Functional Programming na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Scala for Backend Engineering & Functional Programming, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Czym jest currying

Currying przekształca funkcję przyjmującą wiele argumentów w łańcuch funkcji, z których każda przyjmuje jeden argument. W Scali zapisuje się to za pomocą wielu list parametrów.

object Main {
  def add(a: Int)(b: Int): Int = a + b
  def main(args: Array[String]): Unit = {
    println(add(3)(4))
  }
}

Wiele list parametrów

Metoda poddana curryingowi ma kilka list parametrów: def f(a: Int)(b: Int). Wywołuje się ją, przekazując kolejno każdą listę: f(1)(2).

object Main {
  def combine(prefix: String)(value: Int): String = s"$prefix$value"
  def main(args: Array[String]): Unit = {
    println(combine("id-")(42))
  }
}

Częściowa aplikacja

Można zastosować tylko niektóre listy argumentów i otrzymać funkcję oczekującą na pozostałe. Nazywa się to częściową aplikacją.

object Main {
  def add(a: Int)(b: Int): Int = a + b
  def main(args: Array[String]): Unit = {
    val addFive = add(5) _
    println(addFive(10))
    println(addFive(20))
  }
}

Specjalizowanie funkcji ogólnej

Częściowa aplikacja pozwala tworzyć wyspecjalizowane funkcje na podstawie funkcji ogólnej, ograniczając powtarzanie kodu.

object Main {
  def power(exp: Int)(base: Int): Int = math.pow(base, exp).toInt
  def main(args: Array[String]): Unit = {
    val square = power(2) _
    val cube = power(3) _
    println(square(5))
    println(cube(2))
  }
}

Currying zwykłej funkcji

Zwykły obiekt funkcyjny ma metodę .curried, która przekształca go do postaci poddanej curryingowi.

object Main {
  def main(args: Array[String]): Unit = {
    val add = (a: Int, b: Int) => a + b
    val curriedAdd = add.curried
    println(curriedAdd(3)(4))
  }
}

Powrót z curryingu

Pomocnicza funkcja Function.uncurried odwraca ten proces, przekształcając funkcję poddaną curryingowi z powrotem w funkcję z jedną listą parametrów.

object Main {
  def main(args: Array[String]): Unit = {
    val curried: Int => Int => Int = a => b => a + b
    val normal = Function.uncurried(curried)
    println(normal(3, 4))
  }
}

Dlaczego currying jest przydatny

Currying umożliwia ponowne wykorzystanie kodu: pierwsze argumenty można ustalić raz, a następnie wielokrotnie wywoływać wynik z różnymi pozostałymi argumentami. Pomaga też kompilatorowi wnioskować o typach w kolejnych listach.

object Main {
  def discount(rate: Double)(price: Double): Double = price * (1 - rate)
  def main(args: Array[String]): Unit = {
    val blackFriday = discount(0.3) _
    println(blackFriday(100))
    println(blackFriday(250))
  }
}

Wnioskowanie o typach w ostatniej liście

Praktyczną zaletą wielu list parametrów jest to, że kompilator może wywnioskować typy parametrów lambdy na podstawie wcześniejszych list, dzięki czemu można je pominąć.

object Main {
  def fold[A](xs: List[A])(init: A)(op: (A, A) => A): A =
    xs.foldLeft(init)(op)
  def main(args: Array[String]): Unit = {
    val total = fold(List(1, 2, 3))(0)((a, b) => a + b)
    println(total)
  }
}

Currying z trzema listami

Można mieć dowolną liczbę list parametrów. Każde wywołanie dostarcza jedną listę i zwraca funkcję dla następnej.

object Main {
  def make(a: Int)(b: Int)(c: Int): Int = a + b + c
  def main(args: Array[String]): Unit = {
    println(make(1)(2)(3))
    val step = make(10) _
    println(step(20)(30))
  }
}

Budowanie konfigurowalnych walidatorów

Typowe zastosowanie w praktyce: poddać regułę walidacji curryingowi, ustalić próg, a następnie używać otrzymanego predykatu w całym zbiorze danych.

object Main {
  def atLeast(min: Int)(value: Int): Boolean = value >= min
  def main(args: Array[String]): Unit = {
    val adult = atLeast(18) _
    println(List(15, 21, 18, 12).map(adult))
  }
}

Currying a częściowa aplikacja

Currying to strukturalne przekształcenie w funkcje jednoargumentowe. Częściowa aplikacja to czynność polegająca na przekazaniu części argumentów teraz, a pozostałych później. Funkcje poddane curryingowi ułatwiają częściową aplikację.

object Main {
  def greet(greeting: String)(name: String): String = s"$greeting, $name!"
  def main(args: Array[String]): Unit = {
    val sayHi = greet("Hi") _
    println(sayHi("Ann"))
    println(sayHi("Bob"))
  }
}

Szybkie sprawdzenie

Jak zdefiniować metodę poddaną curryingowi w Scali?

Podsumowanie

Opanował(a) Pan/Pani currying i częściową aplikację:

Metody poddane curryingowi używają wielu list parametrów: f(a)(b)
Częściowo stosuj argumenty za pomocą f(x) _, aby otrzymać nową funkcję
.curried i Function.uncurried konwertują między tymi postaciami
Ułatwia to ponowne wykorzystanie, specjalizowanie i wnioskowanie o typach

Często zadawane pytania

Czy lekcja „Curryfikacja” jest bezpłatna?

Tak — pełny tekst „Curryfikacja” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Scala for Backend Engineering & Functional Programming, przejdź na CoddyKit PRO. Kurs Scala for Backend Engineering & Functional Programming zawiera 4 lekcji w sumie.

Co nauczysz się w „Curryfikacja”?

Aplikacja częściowa Ćwiczysz Scala for Backend Engineering & Functional Programming z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Scala for Backend Engineering & Functional Programming?

Nie wymagamy żadnego doświadczenia. Scala for Backend Engineering & Functional Programming w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Curryfikacja”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Scala for Backend Engineering & Functional Programming?

Tak. Każda lekcja Scala for Backend Engineering & Functional Programming zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Scala for Backend Engineering & Functional Programming