Benutzer:Diaspomod/lambda

Eine anonyme Funktion (Funktionsliteral, Lambdafunktion oder Lambdaausdruck) ist eine Funktionsdefinition, die nicht an einen Bezeichner gebunden ist. Eine anonyme Funktion, die Zugriff auf ihren Erstellungskontext erhält, wird Closure genannt. Anonyme Funktionen werden häufig als Argumente an Funktionen höherer Ordnung übergeben oder zum Erstellen des Ergebnisses einer Funktion höherer Ordnung verwendet, die eine Funktion zurückgeben muss. Wenn eine Funktion nur an einer Stelle verwendet wird und einen begrenzten Umfang hat, kann eine anonyme Funktion syntaktisch einfacher sein als die Verwendung einer benannten Funktion. Anonyme Funktionen sind in funktionalen Programmiersprachen und anderen Sprachen mit First-Class-Funktionen allgegenwärtig, wo sie für den Funktionstyp dieselbe Rolle erfüllen wie Literale für andere Datentypen.

Anonyme Funktionen wurden ursprünglich von Alonzo Church mit seiner Erfindung des Lambda-Kalküls im Jahr 1936 geprägt, in dem alle Funktionen anonym sind. Anonyme Funktionen sind seit Lisp im Jahr 1958 ein Merkmal von Programmiersprachen, und eine wachsende Anzahl moderner Programmiersprachen unterstützt anonyme Funktionen.

Benannte Funktionen

Im Gegensatz zu einer anonymen Funktion erhält eine benannte Funktionen bei ihrer Deklaration einen eindeutigen Bezeichner, unter dem sie anschließend angesprochen wird. Der Name der Funktion wird vom Compiler oder vom Laufzeitsystem dazu verwendet, mit Hilfe der Symboltabelle oder eines dynamischen Verfahrens die Funktionsdefinition zu identifizieren und dort hinterlegten Code auszuführen.

Beispiel in JavaScript

function identifier() {
    console.log("Hello, world!");
}

identifier();

Beispiel in C

#include <stdio.h>

void identifier() {
    puts("Hello, world!");
}

int main() {
    identifier();
}

Beispiele

${\textstyle predicate(value)={\begin{cases}true&{\text{ if }}x\equiv 0{\pmod {2}}\\false&{\text{ if }}x\equiv 1{\pmod {2}}.\end{cases}}}$

Ansicht der Verarbeitungsschritte beim Anwenden der Filterfunktion auf eine Liste

Common Lisp

(lambda (x) (* x 2))

Um diese Funktion, die einen Wert verdoppelt, im selben Zug zu verwenden, kann die Funktion direkt mit einem Argument angewendet werden:

((lambda (x) (* x 2)) 5)

Worauf 10 zurückgegeben wird.

(defun myFilter (predicate container)
    (cond ((null container) nil)
        ((if (funcall predicate (car container))
            (cons (car container) (myFilter predicate (cdr container)))
            (myFilter predicate (cdr container))))))

(print (myFilter (lambda (value) (/= (mod value 2) 1))' (0 1 2 3 4 5 6 7 8 9)))

C++

Lambdaausdrücke bieten semantisch ähnliche Möglichkeiten wie das verwandte Konzept der Funktionszeiger. In C++ können anonyme Funktionen folgendermaßen definiert werden:

[capture]<template>(parameter) -> type { body }

• capture: Übertrag der angegebenen Symbole in den Gültigkeitsbereich des Lambda-Ausdrucks
• template: Liste der Templateparameter
• parameter: Liste der Übergabeparameter
• type: Rückgabetyp
• body: Funktionsrumpf

#include <functional>
#include <iostream>
#include <vector>

using namespace std;

vector<int> myFilter(function<bool(int)> predicate, const vector<int> &container) {
    auto sieve = vector<int>();
    sieve.reserve(container.size());

    for (int element: container)
        if (predicate(element))
            sieve.push_back(element);

    return sieve;
}

int main() {
    vector<int> container = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    auto sieve = myFilter([](int value) { return value % 2 != 1; }, container);
        
    for (int element: sieve)
        cout << element << " ";

    return 0;
}

C#

using System;
using System.Collections.Generic;

delegate bool Function(int value);

class Program {
    static List<int> myFilter(Function predicate, List<int> container) {
        var sieve = new List<int>();
        sieve.Capacity = container.Count;

        foreach (var element in container)
            if (predicate(element))
                sieve.Add(element);

        return sieve;
    }

    public static void Main(string[] args) {
        var container = new List<int>() {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
        var sieve = myFilter(value => value % 2 != 1, container);

        foreach (int element in sieve)
            Console.Write(element + " ");
    }
}

Haskell

myFilter predicate container = [element | element <- container, predicate element]

main = print $ myFilter (\value -> mod value 2 /= 1) [0..9]

Java

In Java mussten für diesen Zweck früher anonyme innere Klassen verwendet werden. Ab Version 8 stehen sogenannte Lambda-Ausdrücke zur Verfügung.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.function.IntPredicate;
import java.util.List;

class Main {
    static List<Integer> myFilter(IntPredicate predicate, List<Integer> container) {
        var sieve = new ArrayList<Integer>();

        for (Integer element: container)
            if (predicate.test(element))
                sieve.add(element);

        return sieve;
    }

    public static void main(String[] args) {
        var container = Arrays.asList(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
        var sieve = myFilter(value -> value % 2 != 1, container);

        for (var element: sieve)
            System.out.print(element + " ");
    }
}

JavaScript

function myFilter(predicate, container) {
    let sieve = [];

    for (let element of container)
        if (predicate(element))
            sieve.push(element);

    return sieve;
}

let container = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
console.log(myFilter(value => value % 2 != 1, container));

Python

def myFilter(predicate, container):
    sieve = []

    for element in container:
        if predicate(element):
            sieve.append(element)

    return sieve

container = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(myFilter(lambda value: value % 2 != 1, container))