Lua Academy · Lektion

Partielle Anwendung

Füllen Sie Funktionsargumente vorab aus.

Partielle Anwendung ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist partielle Anwendung

Partielle Anwendung bedeutet, einige Argumente einer Funktion jetzt festzulegen und die übrigen später zu übergeben. Sie erhalten eine neue Funktion, die weniger Argumente benötigt.

So können Sie eine allgemeine Funktion in eine spezialisierte umwandeln, indem Sie bereits bekannte Werte festlegen.

Ein manuelles Beispiel

Angenommen, Sie haben eine Funktion add. Sie können addFive erstellen, indem Sie eine Closure schreiben, die 5 erfasst und auf die zweite Zahl wartet.

Der erfasste Wert lebt in der zurückgegebenen Funktion weiter, sodass jeder Aufruf nur noch das verbleibende Argument benötigt.

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

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

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

Das erste Argument festlegen

Wir können dieses Muster verallgemeinern. Eine Hilfsfunktion bind1 nimmt eine Funktion und ein festgelegtes erstes Argument entgegen und gibt eine neue Funktion zurück, die das zweite Argument erwartet.

Die Closure erfasst sowohl f als auch den festgelegten Wert und leitet beim Aufruf anschließend alle Werte weiter.

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))

Varargs verwenden

Um eine beliebige Anzahl führender Argumente festzulegen, verwenden Sie die Vararg-Syntax von Lua: .... Sie erfassen die festgelegten Argumente und hängen die späteren beim Aufruf an.

Die Funktionen table.pack und table.unpack helfen dabei, Argumentlisten zu speichern und zu entpacken.

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))

Mehrere Argumente festlegen

Da partial ein variadisches Argument akzeptiert, können Sie mehrere Argumente gleichzeitig festlegen. Die zurückgegebene Funktion benötigt dann nur noch die übrigen Argumente.

Hier werden zwei von drei Argumenten vorab festgelegt, sodass eine Funktion mit einem einzigen Argument übrig bleibt.

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))

Eine praktische Anwendung

Partielle Anwendung spielt ihre Stärke bei allgemeinen Hilfsfunktionen aus. Legen Sie die Konfiguration einmal fest und verwenden Sie die spezialisierte Funktion anschließend beliebig oft.

Unten wird aus einem generischen greet eine Begrüßungsfunktion für eine feste Sprache, die nur noch einen Namen benötigt.

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"))

Partielle Anwendung und Currying

Currying wandelt eine Funktion mit mehreren Argumenten in eine Kette von Funktionen mit jeweils einem Argument um, wobei jede Funktion die nächste zurückgibt. Bei der partiellen Anwendung werden lediglich einige Argumente festgelegt, während die übrigen in einem normalen Aufruf übergeben werden.

Die beiden Konzepte sind verwandt, aber nicht identisch: Currying arbeitet Argument für Argument, bei der partiellen Anwendung werden einige Argumente sofort festgelegt.

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

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

Currying einer Funktion mit zwei Argumenten

Eine kleine Hilfsfunktion kann jede Funktion mit zwei Argumenten automatisch per Currying umwandeln. Sie gibt eine Funktion für das erste Argument zurück, die wiederum eine Funktion für das zweite Argument zurückgibt.

So entstehen wiederverwendbare Konstruktoren mit jeweils einem Argument, die sich in Pipelines gut lesen lassen.

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))

Closures machen es möglich

Jede partiell angewendete und jede per Currying umgewandelte Funktion basiert auf Closures. Die festgelegten Argumente sind erfasste lokale Variablen, an die sich die zurückgegebene Funktion erinnert.

Da jede zurückgegebene Funktion ihre eigenen erfassten Werte besitzt, können Sie sicher viele spezialisierte Varianten erstellen.

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))

Wann Sie es einsetzen sollten

Verwenden Sie die partielle Anwendung, um Wiederholungen zu vermeiden, wenn Sie eine Funktion immer wieder mit denselben führenden Argumenten aufrufen.

Sie hilft außerdem dabei, eine Funktion an eine Schnittstelle anzupassen, die weniger Argumente erwartet, etwa an einen Callback, der nur einen Wert übergibt.

Konfigurierte Callbacks

Partielle Anwendung passt gut zu map und filter. Sie können ein Konfigurationsargument vorab festlegen, sodass der Callback nur noch das Listenelement erhält.

Dadurch bleibt Ihre Pipeline übersichtlich, während Sie das Verhalten weiterhin anpassen können.

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, ", "))

Kurze Überprüfung

Rufen Sie sich den Unterschied zwischen zwei verwandten Konzepten ins Gedächtnis.

Zusammenfassung

Bei der partiellen Anwendung werden einige Argumente festgelegt und eine neue Funktion zurückgegeben, die die übrigen Argumente erwartet. Möglich wird das durch Closures, die sich die festgelegten Werte merken.

Eine auf variadischen Argumenten basierende Hilfsfunktion partial verallgemeinert dieses Verfahren, während Currying Funktionen mit jeweils einem Argument aneinanderreiht. Beide Konzepte verringern Wiederholungen und passen Funktionen an Callbacks an.

Häufig gestellte Fragen

Ist die Lektion „Partielle Anwendung“ kostenlos?

Ja — der vollständige Text von „Partielle Anwendung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Partielle Anwendung“?

Füllen Sie Funktionsargumente vorab aus. Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Partielle Anwendung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Lua Academy