Currying (vor allem in der Linguistik auchSchönfinkeln) ist die Umwandlung einerFunktion mit mehreren Argumenten in eine Sequenz von Funktionen mit jeweils einem Argument. Obwohl das Verfahren 1924 vonMoses Schönfinkel^[1] erfunden und vonGottlob Frege^[2] um 1900 vorausgedacht wurde, wird es oft nachHaskell Brooks Curry benannt, der das Verfahren 1958 umfangreich theoretisch ausgearbeitet hat.^[3]

Es sei eine Funktion gegeben, dien Argumente erfordert. Wird diese aufein Argument angewendet, so konsumiert sie nur genau dieses und liefert als Funktionswert eine weitere Funktion, die noch${\displaystyle n-1}$ Argumente verlangt. Die zurückgegebene Funktion wird anschließend auf alle weiteren Argumente angewendet.

In Typen ausgedrückt, handelt es sich um die Umrechnung einer Funktion${\displaystyle f:A_1\times \dots \times A_n\to B}$ zu einer modifizierten Funktion${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}:A_1\to (A_2\to (\dots (A_n\to B)\dots ))}$.^[4]

Eine alternative Schreibweise ist${\displaystyle \mathrm{curry}(f)=f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}}$, wobei${\displaystyle \mathrm{curry}}$ als einOperator verstanden wird, der${\displaystyle n}$-stellige Abbildungen (für${\displaystyle n>1}$) modifiziert zu einer einstelligen Abbildung, deren Bildwerte einstellige Abbildungen sind usw., wobei der Reihe nach alle Argumente der ursprünglichen Abbildung durchlaufen werden; formal:

${\displaystyle \mathrm{curry}:(A_1\times \dots \times A_n\to B)\to (A_1\to (A_2\to (\dots (A_n\to B)\dots )))}$.

Das Konzept des Currying ist verwandt mit, aber (für${\displaystyle n>2}$) verschieden von dem derpartiellen Anwendung wie etwa:

${\displaystyle f(a_1,a_2,\dots a_{n-1},\cdot ):A_n\to B,a_n\mapsto f(a_1,a_2,\dots a_n)}$,

${\displaystyle f(a_1,\underset{(n-1)\text{-mal}}{\underbrace{\cdot ,\dots ,\cdot }})):A_2\times \dots \times A_n\to B,(a_2,\dots ,a_n)\mapsto f(a_1,a_2,\dots a_n)}$.

Im einstelligen Fall (${\displaystyle n=1}$) hat Currying keine Auswirkung:

${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}=f}$,

im zweistelligen Fall (${\displaystyle n=2}$) besteht der Zusammenhang

${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}:A_1\to (A_2\to B),a_1\mapsto f(a_1,\cdot )}$, d. h. für alle${\displaystyle a_1\in A_1}$:

${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}(a_1)=f(a_1,\cdot )}$,

im dreistelligen Fall (${\displaystyle n=3}$) gilt für${\displaystyle a_1\in A_1}$:

${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}(a_1):A_2\to (A_3\to B),a_2\mapsto f(a_1,a_2,\cdot )}$, und mit zusätzlich${\displaystyle a_2\in A_2}$:

${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}(a_1)(a_2):A_3\to B,a_3\mapsto f(a_1,a_2,\cdot )}$, d. h.${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}(a_1)(a_2)=f(a_1,a_2,\cdot )}$,

allgemein:

${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}(a_1)(a_2)\dots (a_n)=f(a_1,a_2,\dots ,a_n)}$,

${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}(a_1)(a_2)\dots (a_{n-1})=f(a_1,a_2,\dots ,a_{n-1},\cdot )}$.^[5]

Es kommt häufig vor, dass eine mehrstellige Abbildung nicht für alle Wertekombinationen aus den Trägermengen${\displaystyle A_1,\dots ,A_n}$ definiert ist, also nur auf einer Teilmenge des kartesischen Produkts${\displaystyle R=D_f\subseteq A_1\times \cdots \times A_n}$, d. h. auf (dem Graphen einer)Relation.^[6] Man kann diese Situation behandeln, indem man entweder grundsätzlichpartielle Abbildungen zulässt und die obigen Definitionen formal übernimmt, oder man dagegen am Konzept totaler Abbildungen festhält; in letzterem Falle werden die Definitionsbereiche der beteiligten Abbildungen von der Wahl bereits festgelegter Parameter abhängig, wie das Beispiel zweistelliger Abbildungen zeigt:

${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}(a_1)=f(a_1,\cdot )}$;

der Definitionsbereich dieser Abbildung ist von${\displaystyle a_1}$ abhängig:

${\displaystyle \{a_2\in A_2|\mathrm{\exists }{a}_1\in A_1:(a_1,a_2)\in D_f\}=R^{\leftarrow }(\{a\})}$,

also dieUrbildfaser von${\displaystyle a_1}$ bezüglich des als Relation aufgefassten Definitionsbereichs${\displaystyle R=D_f}$.^[7]

Da für n=1 gilt${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}=f}$, kann für${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}}$ dasselbe Symbol verwendet werden wie für${\displaystyle f}$. Man nennt diesÜberladung (siehe auchSignatur (Modelltheorie) §Anmerkungen).^[8]

Ein Beispiel inLambda-Notation soll das Verfahren verdeutlichen, wobei die Funktion konkret folgendermaßen definiert sei:

${\displaystyle \lambda xyz.xyz}$

Die Funktion verlangt also 3 Argumente und gibt diese zurück. Die Definition ist äquivalent zu:

${\displaystyle \lambda x.\lambda y.\lambda z.xyz}$

Bei der Anwendung der Funktion auf die Argumente a, b und c geschieht Folgendes:

${\displaystyle \left(\lambda x.\lambda y.\lambda z.xyz\right)abc\mathsf{-}\mathsf{D}\mathsf{i}\mathsf{e}\mathsf{A}\mathsf{n}\mathsf{w}\mathsf{e}\mathsf{n}\mathsf{d}\mathsf{u}\mathsf{n}\mathsf{g}}$

${\displaystyle \left(\lambda y.\lambda z.ayz\right)bc}$

${\displaystyle \left(\lambda z.abz\right)c}$

${\displaystyle abc\mathsf{-}\mathsf{R}\mathsf{e}\mathsf{s}\mathsf{u}\mathsf{l}\mathsf{t}\mathsf{a}\mathsf{t}}$

Nach erstmaliger Anwendung der Funktion aufa,b und c wirdx im Funktionskörper durch das erste Argument a ersetzt. Das Resultat ist eine Funktion, die noch die Argumentey undz verlangt. Diese wird sofort aufb und c angewendet.

Angenommen, wir haben eine zweistellige Multiplikationsfunktion${\displaystyle \mathrm{mult}}$, die zwei natürliche Zahlen multipliziert, d. h. einem Paarnatürlicher Zahlen ihr Produkt zuordnet:

${\displaystyle \mathrm{mult}:\{\begin{array}{l}\mathbb{N}\times \mathbb{N}\to \mathbb{N}\\ (m,n)\mapsto m\ast n\end{array}}$ mit${\displaystyle \mathrm{mult}(m,n)=m\ast n}$ ^[9]

Per Definition wird diese Funktion auf zwei natürliche Zahlen angewendet und eine natürliche Zahl wird zurückgegeben, beispielsweise${\displaystyle \mathrm{mult}(2,3)=6}$.

Wird nun zunächst das erste Argument besetzt (etwa mit${\displaystyle 2}$), das zweite noch freigelassen, entsteht eine einstellige ‚höhere Funktion‘, die selbst ein (weiteres) Argument aufnimmt und das Produkt mit diesem festen Parameter (der Nummer${\displaystyle 2}$) zurückgibt:

${\displaystyle \mathrm{mult}(2,\cdot ):}$ ${\displaystyle \{\begin{array}{l}\mathbb{N}\to \mathbb{N}\\ n\mapsto 2\ast n\end{array}}$,

und für ein beliebiges festes erstes Argument${\displaystyle m\in \mathbb{N}}$:

${\displaystyle \mathrm{mult}(m,\cdot ):}$ ${\displaystyle \{\begin{array}{l}\mathbb{N}\to \mathbb{N}\\ n\mapsto m\ast n\end{array}}$ .

Currying bedeutet nun bei einer n-stelligen Funktion, diesen Vorgang so lange durchzuführen, bis nur eine noch einstellige höhere Funktion übrigbleibt. Für n = 2 ist daher:

${\displaystyle {\mathrm{mult}}_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}:\{\begin{array}{l}\mathbb{N}\to (\mathbb{N}\to \mathbb{N})\\ m\mapsto \mathrm{mult}(m,\cdot )\end{array}}$ ^[10]

Da die Bezeichnung${\displaystyle \mathrm{mult}}$ als einstellige Funktion noch unbesetzt ist, kann diese überladen werden,^[11] d. h., im einstelligen Fall wird${\displaystyle \mathrm{mult}}$ als${\displaystyle {\mathrm{mult}}_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}}$ verstanden:

${\displaystyle \mathrm{mult}(m)(n)={\mathrm{mult}}_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}(m)(n)=\mathrm{mult}(m,n)=m\ast n}$.

Man kann sich die Situation für eine Funktion mit zwei Argumenten${\displaystyle z=f(x,y)}$wie folgt vorstellen: das Fixieren einer Argumentvariable entspricht einerEinschränkung der zweidimensionalen Definitionsmengeauf eine eindimensionale Teilmenge, z. B.${\displaystyle y=1}$, die resultierende Funktion entspricht derSchnittkurve des Graphenvon${\displaystyle f(x,y)}$ mit der Ebene aller Punkte${\displaystyle (x,1,z)}$.Alle Punkte${\displaystyle (x,y,z)}$ des Graphen können somit auch durch eine zweistufige Auswahl erreicht werden:zunächst durch die Festlegung der Schnittebene${\displaystyle y=1}$ und dann durch die Auswertung derSchnittkurve${\displaystyle s(x)=f(x,y){|}_{y=1}}$ an der Stelle${\displaystyle x}$.

Currying wird überwiegend in Programmiersprachen und Kalkülen verwendet, in denen Funktionen nur ein einzelnes Argument erhalten dürfen. Dazu gehören beispielsweiseML,Unlambda und derLambda-Kalkül sowie das nach Curry benannteHaskell.Viele dieser Sprachen bieten dem Programmierer allerdings syntaktische Möglichkeiten, dies zu verschleiern. Ein Beispiel hierfür ist die Äquivalenz der Funktionsdefinition im oben gezeigtenBeispiel.

Das nachfolgende Beispiel zeigt Currying inJavaScript. Zunächst wird eine Funktionuncurried_add definiert, die als Ergebnis die Summe der beiden Argumente hat. Andererseits wird eine Funktioncurried_add definiert, die eine alsClosure definierte Funktion zurückgibt, welche partiell angewendet werden kann.

functionuncurried_add(x,y){returnx+y;}functioncurried_add(x){returnfunction(y){returnx+y;};}console.log(uncurried_add(3,5));// 8console.log(curried_add(3)(5));// 8constadd_three=curried_add(3);console.log(add_three(5));// 8console.log(add_three(12));// 15

Durch Currying wird die Funktion partiell angewendet, wobei die Funktionsargumente nacheinander übergeben werden und zwischenzeitlich in einer neuen Funktion gehalten werden, die beliebig weiterverwendet werden kann.

Die Funktionen können in JavaScript mit der Lambda-Notation auch kürzer definiert werden:

constuncurried_add=(x,y)=>x+y;constcurried_add=x=>y=>x+y;

Geläufig ist in JavaScript auch das Currying durchapply, eine Methode des Prototyps von Funktionen, der ein Kontextobjekt und eine Teilmenge der Parameter übergeben werden. Das Kontextobjekt kann dabei null oder undefined sein und wird dann implizit durch das globale Objekt ersetzt:^[12]

functionuncurried_add(x,y){returnx+y;}constcurried_add=uncurried_add.bind(null,3);console.log(curried_add(5));// 8

importjava.util.function.*;classMain{staticIntBinaryOperatoruncurriedAdd=(x,y)->x+y;staticIntFunction<IntUnaryOperator>curriedAdd=x->y->x+y;publicstaticvoidmain(String[]args){System.out.println(uncurriedAdd.applyAsInt(3,5));// 8System.out.println(curriedAdd.apply(3).applyAsInt(5));// 8varaddThree=curriedAdd.apply(3);System.out.println(addThree.applyAsInt(5));// 8System.out.println(addThree.applyAsInt(12));// 15}}

valuncurried_add={x:Int,y:Int->x+y}valcurried_add={x:Int->{y:Int->x+y}}println(uncurried_add(3,5))// 8println(curried_add(3)(5))// 8valadd_three=curried_add(3)println(add_three(5))// 8println(add_three(12))// 15

C++ führte denLambda-Kalkül mit anonymen Funktionen in die Sprache ein. Mit dem Schlüsselwortauto wird durchTypinferenz derDatentyp implizit abgeleitet, ohne den Datentypen explizit deklarieren zu müssen. Dadurch ergibt sich eine kürzere Schreibweise für die Currifizierung:

#include<iostream>usingnamespacestd;intuncurried_add(intx,inty){returnx+y;}autocurried_add(intx){return[x](inty){returnx+y;};}intmain(){cout<<uncurried_add(3,5)<<endl;// 8cout<<curried_add(3)(5)<<endl;// 8autoadd_three=curried_add(3);cout<<add_three(5)<<endl;// 8cout<<add_three(12)<<endl;// 15return0;}

Man beachte, dass die Erwähnung des Typsint im Argument des Lambda-Ausdrucks auch durchauto ersetzt werden kann, wodurch die Implementierung verallgemeinert wird. Die Parameter der benannten Funktioncurried_add kann jedoch nur durchTemplates für verschiedene Datentypen verallgemeinert werden.

Da es in der ProgrammierspracheC keine anonymen Funktionen gibt, wird eine benannte Funktionadd separat definiert, die voncurried_add zurückgegeben wird. Der Wert vonx wird in der globalen Variablenz gespeichert, da die Funktionadd nicht auf dieContinuation der Funktioncurried_add zugreifen kann.

#include<stdio.h>intuncurried_add(intx,inty){returnx+y;}intz;intadd(inty){returny+z;}typedefintfunction(int);function*curried_add(intx){z=x;returnadd;}intmain(){printf("%d\n",uncurried_add(3,5));// 8printf("%d\n",curried_add(3)(5));// 8function*add_three=curried_add(3);printf("%d\n",add_three(5));// 8printf("%d\n",add_three(12));// 15return0;}

usingSystem;classProgram{delegateintMethod(intx,inty);delegateFunc<int,int>Curry(intx);staticMethoduncurried_add=(x,y)=>x+y;staticCurrycurried_add=x=>y=>x+y;publicstaticvoidMain(){Console.WriteLine(uncurried_add(3,5));// 8Console.WriteLine(curried_add(3)(5));// 8varadd_three=curried_add(3);Console.WriteLine(add_three(5));// 8Console.WriteLine(add_three(12));// 15}}

letuncurried_add(x,y)=x+yletcurried_addxy=x+yprintfn"%i"(uncurried_add(3,5))// 8printfn"%i"((curried_add3)5)// 8printfn"%i"(curried_add35)// 8letadd_three=curried_add3printfn"%i"(add_three5)// 8printfn"%i"(add_three12)// 15

packagemainimport"fmt"varuncurried_add=func(a,bint)int{returna+b}varcurried_add=func(aint)func(aint)int{returnfunc(bint)int{returna+b}}funcmain(){fmt.Println(uncurried_add(2,3))fmt.Println(curried_add(2)(3))addThree:=curried_add(3)fmt.Println(addThree(5))// 8fmt.Println(addThree(12))// 15}

In der ProgrammierspracheHaskell kann eine Funktion nur genau einen Parameter haben. Wenn man eine Funktion mit mehreren Argumenten aufrufen möchte, müssen die Argumente zuerst in einem neuen Objekt zusammengesetzt werden, sodass die Funktion nur ein Argument erhält. Dafür können die Parameter in runden Klammern mit Kommata getrennt aufgelistet werden, um einTupel zu definieren.

uncurried_add(x,y)=x+y

Eine Alternative dazu ist das Currying. In der expliziten Schreibweise definiert man für jeden Wert im Tupel jeweils eine Funktion mit nur einem Argument. Solange noch nicht alle Argumente übergeben wurden, wird eine Funktion zurückgegeben, die ein Teilergebnis liefert.

curried_addx=\y->x+y

Da die Schreibweise mit mehrerenLambda-Funktionen umständlich sein kann, gibt es einesyntaktisch gezuckerte Notation, die semantisch äquivalent ist. Schreibt man die Argumente ohne runde Klammern hintereinander, erhält man automatisch eine currifizierte Funktion.

curried_addxy=x+y

Die currifizierte Funktion kann sowohl explizit als auch implizit partiell angewendet werden.

main=doprint(uncurried_add(3,5))-- 8print((curried_add3)5)-- 8print(curried_add35)-- 8letadd_three=curried_add3print(add_three5)-- 8print(add_three12)-- 15

Zudem gibt es in Haskell die Möglichkeit eine Funktion im Nachhinein zwischen currifizierter und nicht currifizierter Definition umzuwandeln. Dafür werden die Funktionencurry unduncurry verwendet.

main=doletuncurried=uncurrycurried_addprint(uncurried(3,5))-- 8letcurried=curryuncurried_addprint((curried3)5)-- 8print(curried35)-- 8letadd_three=curried3print(add_three5)-- 8print(add_three12)-- 15

defuncurried_add(x,y):returnx+ydefcurried_add(x):returnlambday:x+yprint(uncurried_add(3,5))# 8print(curried_add(3)(5))# 8add_three=curried_add(3)print(add_three(5))# 8print(add_three(12))# 15

subuncurried_add($x,$y) {$x +$y }subcurried_add($x) {sub ($y) {$x +$y };}sayuncurried_add(3,5);# 8saycurried_add(3)(5);# 8my&add_three =&curried_add(3);say&add_three(5);# 8say&add_three(12);# 15

Es gibt in der ProgrammierspracheRaku die Möglichkeit, ein Funktionsobjekt erst beim Funktionsaufruf zu currifizieren.

my&uncurried_add =sub ($x,$y) {$x +$y };say&uncurried_add(3,5);# 8say&uncurried_add.assuming(3)(5);# 8my&add_three =&uncurried_add.assuming(3);say&add_three(5);# 8say&add_three(12);# 15

defuncurried_add(x,y)returnx+yenddefcurried_add(x)returnlambda{|y|x+y}endputsuncurried_add(3,5)# 8putscurried_add(3).call(5)# 8add_three=curried_add(3)putsadd_three.call(5)# 8putsadd_three.call(12)# 15

Es gibt in der ProgrammierspracheRuby die Möglichkeit, ein Funktionsobjekt erst beim Funktionsaufruf zu currifizieren.

uncurried_add=lambda{|x,y|x+y}putsuncurried_add.call(3,5)# 8putsuncurried_add.curry[3][5]# 8add_three=uncurried_add.curry[3]putsadd_three.call(5)# 8putsadd_three.call(12)# 15

(defineuncurried-add(lambda(xy)(+xy)))(definecurried-add(lambda(x)(lambda(y)(+xy))))(display(uncurried-add35))(newline); 8(display((curried-add3)5))(newline); 8(defineadd-three(curried-add3))(display(add-three5))(newline); 8(display(add-three12))(newline); 15

InTcl ist es nicht notwendig, irgendwelche speziellen Konstrukte als curried- oder uncurried-Variante vorzubereiten.

Ein Kommando-Aufruf ist in Tcl nur eine Liste von Worten, in der das Kommando-Wort an erster Position steht. Mit dem Operator{*} kann man ein Argument, das seinerseits eine Liste ist, inplace durch deren Elemente ersetzen. Damit kann eine beim Aufruf an vorderster Position stehende Liste neben dem zu rufenden Kommando zusätzlich beliebig viele Argumente in sich tragen.

Currying ist demzufolge identisch mit dem Anhängen eines weiteren Wortes an diese Liste, und jeder mit{*} beginnende Aufruf ist ein Lambda-Call (Benannt nach den in anderen Sprachen oft „Lambda-Ausdruck“ genannten anonymen Funktionen, die sich gut auf diese Weise einbinden lassen).

Zum Addieren ist hier das Standard-Kommandotcl::mathop::+ verwendet, das zur Implementierung der hier nicht benutzten Tcl-Expression-Syntax existiert. Dieses Kommando addiert beliebig viele Argumente.

Da man solche Experimente sinnvollerweise in der Tcl-Konsole anstellt, sind hier keine expliziten print-Anweisungen nötig.

tcl::mathop::+35;# 8    direkter Aufrufsetftcl::mathop::+;#      simple "Lambda"-Liste, nur das Kommando{*}$f35;# 8    Aufruf über "Lambda" in Variable flappendf3;#      "Currying" durch Hinzufügensetf{tcl::mathop::+3};#      "Curried" alternativ direkt formuliert{*}$f5;# 8    Aufruf über "Curried Lambda"lappendf12;#      mehr Parameter hinzufügen{*}$f45;# 15 = (3+1+2) + (4+5) ... ganz natürlich

programcurried;{$APPTYPE CONSOLE}{$R *.res}usesSystem.SysUtils;functionuncurried_add(a,b:Integer):Integer;beginResult:=a+b;end;functioncurried_add(a:Integer):TFunc<Integer,Integer>;beginResult:=function(b:Integer):IntegerbeginResult:=a+b;end;end;beginWriteln(uncurried_add(3,5));// 8Writeln(curried_add(3)(5));// 8varaddThree:=curried_add(3);Writeln(addThree(5));// 8Writeln(addThree(12));//15end.

1. ↑Moses Schönfinkel:Über die Bausteine der mathematischen Logik. In:Mathematische Annalen 92 (1924). S. 305–316,Digitalisat.
2. ↑Gottlob Frege:Grundgesetze der Arithmetik. Hermann Pohle, Jena 1893 (Band I) 1903 (Band II)korpora.org (Memento vom 28. Oktober 2022 imInternet Archive).
3. ↑Haskell Brooks Curry, Robert Feys,Roger Hindley, Jonathan P. Seldin:Combinatory Logic. North Holland, 2 Bände, 1958, 1972.
4. ↑Dabei bezeichnet${\displaystyle (X\to Y)}$ oder${\displaystyle [X\to Y]}$ die Menge der Abbildungen von${\displaystyle X}$ nach${\displaystyle Y}$.
5. ↑Imnullstelligen Fall (n=0) würde das Currying einer Abbildung${\displaystyle f}$ ohne Parameter und mit einem Wert${\displaystyle b\in B}$ eine einstellige Abbildung mit konstantem Wert${\displaystyle b}$ zuordnen, also etwa

   ${\displaystyle f_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}:B\to B,x\mapsto b}$.

6. ↑Ein Beispiel ist${\displaystyle f(a_1,a_2):=a_1/(a_1-a_2)}$ mit${\displaystyle a_1,a_2\in \mathbb{R}\setminus {\mathrm{\Delta }}_{\mathbb{R}}}$ (wobei${\displaystyle {\mathrm{\Delta }}_{\mathbb{R}}}$ dieDiagonale${\displaystyle \{(a_1,a_2)\in {\mathbb{R}}^2|a_1=a_2\}}$ bezeichnet).
7. ↑Im obigen Beispiel ist dies${\displaystyle \mathbb{R}\setminus \{a_1\}}$.
8. ↑Voraussetzung ist, dass das Symbol${\displaystyle f}$ nicht schon anderweitig mit Stelligkeit 1 überladen ist (siehe Beispiel unten, dies zwingt zwischen${\displaystyle \mathrm{mult}}$ und${\displaystyle \mathrm{prod}}$ zu unterscheiden).
9. ↑Zur Unterscheidung vom Platzhalter${\displaystyle \cdot }$ wird hier${\displaystyle \ast }$ als Multiplikationszeichen verwendet.
10. ↑Dieser Funktion könnte man auch einen eigenen Namen vergeben:

    ${\displaystyle \mathrm{doppelt}:={\mathrm{mult}}_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}(2)=\mathrm{mult}(2,\cdot ):\mathbb{N}\to \mathbb{N}}$

    mit${\displaystyle \mathrm{doppelt}(n)=2\ast n}$.
11. ↑Man unterscheide zwischen${\displaystyle \mathrm{mult}}$ und der überladenen Funktion${\displaystyle \mathrm{prod}}$ mit${\displaystyle \mathrm{prod}(k_1,\dots ,k_r)=\prod _{i=1}^r{k}_i}$ zur Stelligkeit${\displaystyle r}$ und Faktoren${\displaystyle k_i\in \mathbb{N}}$. Zwar ist zweistellig${\displaystyle \mathrm{mult}(m,n)=\mathrm{prod}(m,n)=m\ast n}$, aber einstellig ist${\displaystyle \mathrm{prod}(m)=m}$, während${\displaystyle \mathrm{mult}(m)={\mathrm{mult}}_{\mathrm{c}\mathrm{u}\mathrm{r}\mathrm{r}\mathrm{i}\mathrm{e}\mathrm{d}}(m)=\mathrm{mult}(m,\cdot )}$ eine einstellige Funktion ist.
12. ↑Kyle Simpson:this & Object Prototypes. In:You Don't Know JS. 1. Auflage.Band 3. O’Reilly, 2014,ISBN 978-1-4919-0415-2,S. 26–28. 

• Programmierung
• Theoretische Informatik