Lua Academy · Lekcja

Częściowe zastosowanie

Wstępnie uzupełni Pan/Pani argumenty funkcji.

Częściowe zastosowanie to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 3 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 Lua Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Lua Academy zawiera 4 lekcji w sumie.

Czym jest częściowa aplikacja

Częściowa aplikacja oznacza ustalenie niektórych argumentów funkcji teraz i przekazanie pozostałych później. W rezultacie otrzymujesz nową funkcję, która wymaga mniejszej liczby argumentów.

Dzięki temu można przekształcić funkcję ogólną w wyspecjalizowaną, ustalając z góry znane już wartości.

Przykład ręcznej implementacji

Załóżmy, że masz funkcję add. Możesz utworzyć addFive, pisząc domknięcie, które przechwytuje wartość 5 i czeka na drugą liczbę.

Przechwycona wartość znajduje się w zwróconej funkcji, więc każde wywołanie wymaga tylko pozostałego argumentu.

local function add(a, b)
  return a + b
end

local function addFive(b)
  return add(5, b)
end

print(addFive(10))
print(addFive(2))

Ustalanie pierwszego argumentu

Możemy uogólnić ten schemat. Pomocnicza funkcja bind1 przyjmuje funkcję i ustalony pierwszy argument, a następnie zwraca nową funkcję oczekującą drugiego argumentu.

Domknięcie przechwytuje zarówno f, jak i ustaloną wartość, a następnie przekazuje wszystkie argumenty dalej podczas wywołania.

local function bind1(f, a)
  return function(b)
    return f(a, b)
  end
end

local function mul(x, y) return x * y end
local double = bind1(mul, 2)
print(double(7))
print(double(50))

Używanie argumentów variadic

Aby ustalić dowolną liczbę początkowych argumentów, użyj składni zmiennej liczby argumentów w Lua: .... Przechwytujesz ustalone argumenty, a następnie dołączasz pozostałe podczas wywołania.

Funkcje table.pack i table.unpack pomagają przechowywać i rozpakowywać listy argumentów.

local function partial(f, ...)
  local fixed = table.pack(...)
  return function(...)
    local rest = table.pack(...)
    local args = {}
    for i = 1, fixed.n do args[i] = fixed[i] end
    for i = 1, rest.n do args[fixed.n + i] = rest[i] end
    return f(table.unpack(args, 1, fixed.n + rest.n))
  end
end

local function add3(a, b, c) return a + b + c end
local add10 = partial(add3, 10)
print(add10(2, 3))

Ustalanie kilku argumentów

Ponieważ partial akceptuje zmienną liczbę argumentów, można jednocześnie ustalić więcej niż jeden argument. Zwrócona funkcja będzie wtedy potrzebować tylko pozostałych.

W tym przypadku dwa z trzech argumentów są wstępnie wypełnione, więc pozostaje funkcja jednoargumentowa.

local function partial(f, ...)
  local fixed = table.pack(...)
  return function(...)
    local rest = table.pack(...)
    local args = {}
    for i = 1, fixed.n do args[i] = fixed[i] end
    for i = 1, rest.n do args[fixed.n + i] = rest[i] end
    return f(table.unpack(args, 1, fixed.n + rest.n))
  end
end

local function label(prefix, sep, value) return prefix .. sep .. value end
local tag = partial(label, "id", ":")
print(tag(42))

Praktyczne zastosowanie

Częściowa aplikacja doskonale sprawdza się w przypadku ogólnych funkcji narzędziowych. Konfigurację ustala się raz, a następnie wielokrotnie używa wyspecjalizowanej funkcji.

Poniżej ogólna funkcja greet staje się funkcją witającą w ustalonym języku, która potrzebuje już tylko imienia.

local function greet(lang, name)
  if lang == "tr" then return "Merhaba, " .. name end
  return "Hello, " .. name
end

local function bind1(f, a) return function(b) return f(a, b) end end
local greetTr = bind1(greet, "tr")
print(greetTr("Ada"))
print(greetTr("Lin"))

Częściowa aplikacja a curryfikacja

Curryfikacja przekształca funkcję wieloargumentową w łańcuch funkcji jednoargumentowych, z których każda zwraca następną. Częściowa aplikacja jedynie ustala niektóre argumenty, pozostawiając pozostałe w zwykłym wywołaniu.

Pojęcia te są powiązane, ale nie są tożsame: curryfikacja działa po jednym argumencie, a częściowa aplikacja ustala wybrane argumenty od razu.

local function curryAdd(a)
  return function(b)
    return function(c)
      return a + b + c
    end
  end
end

print(curryAdd(1)(2)(3))

Curryfikacja funkcji dwuargumentowej

Niewielka funkcja pomocnicza może automatycznie poddać curryfikacji dowolną funkcję dwuargumentową. Zwraca ona funkcję pierwszego argumentu, która zwraca funkcję drugiego argumentu.

W ten sposób powstają wielokrotnego użytku konstruktory jednoargumentowe, które dobrze czyta się w potokach.

local function curry2(f)
  return function(a)
    return function(b)
      return f(a, b)
    end
  end
end

local function pow(base, exp) return base ^ exp end
local cpow = curry2(pow)
print(cpow(2)(10))

To domknięcia umożliwiają działanie

Każda funkcja utworzona przez częściową aplikację lub curryfikację opiera się na domknięciach. Ustalone argumenty są przechwyconymi zmiennymi lokalnymi, które zwrócona funkcja pamięta.

Ponieważ każda zwrócona funkcja ma własny zestaw przechwyconych wartości, można bezpiecznie tworzyć wiele wyspecjalizowanych wariantów.

local function bind1(f, a) return function(b) return f(a, b) end end
local function sub(x, y) return x - y end

local from100 = bind1(sub, 100)
local from10 = bind1(sub, 10)
print(from100(40))
print(from10(3))

Kiedy warto jej użyć

Częściowej aplikacji warto użyć, aby usunąć powtarzalność, gdy wielokrotnie wywołuje się funkcję z tymi samymi początkowymi argumentami.

Pomaga ona także dostosować funkcję do interfejsu, który oczekuje mniejszej liczby argumentów, na przykład do callbacku przekazującego tylko jedną wartość.

Skonfigurowane callbacki

Częściowa aplikacja dobrze współpracuje z funkcjami map i filter. Można wstępnie wypełnić argument konfiguracyjny, aby callback otrzymywał tylko element listy.

Dzięki temu potok pozostaje przejrzysty, a jednocześnie można nadal dostosowywać jego działanie.

local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function bind1(f, a) return function(b) return f(a, b) end end
local function scale(factor, x) return factor * x end

local r = map({1,2,3,4}, bind1(scale, 10))
print(table.concat(r, ", "))

Szybkie sprawdzenie

Proszę przypomnieć sobie różnicę między tymi dwiema powiązanymi koncepcjami.

Podsumowanie

Częściowa aplikacja ustala niektóre argumenty i zwraca nową funkcję oczekującą pozostałych. Jest ona tworzona z użyciem domknięć, które przechwytują ustalone wartości.

Pomocnicza funkcja partial oparta na zmiennej liczbie argumentów uogólnia ten mechanizm, natomiast curryfikacja tworzy łańcuch funkcji jednoargumentowych. Oba podejścia ograniczają powtarzalność i dostosowują funkcje do callbacków.

Często zadawane pytania

Czy lekcja „Częściowe zastosowanie” jest bezpłatna?

Tak — pełny tekst „Częściowe zastosowanie” 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 Lua Academy, przejdź na CoddyKit PRO. Kurs Lua Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Częściowe zastosowanie”?

Wstępnie uzupełni Pan/Pani argumenty funkcji. Ćwiczysz Lua Academy 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ąć Lua Academy?

Nie wymagamy żadnego doświadczenia. Lua Academy 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 3 z 4.

Ile czasu zajmuje lekcja „Częściowe zastosowanie”?

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 Lua Academy?

Tak. Każda lekcja Lua Academy 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 Lua Academy