Mischen

Im objektorientierte Programmiersprachen, a mischen (oder Mischen)^[1][2][3][4] ist ein Klasse Das enthält Methoden zur Verwendung durch andere Klassen, ohne die übergeordnete Klasse dieser anderen Klassen sein zu müssen. Wie diese anderen Klassen Zugriff auf die Methoden des Mixins erhalten, hängt von der Sprache ab. Mixins werden manchmal als "eingeschlossen" und nicht "erbelt" beschrieben.

Mixins ermutigen Code -Wiederverwendung und kann verwendet werden, um die Vererbungsdeutigkeit zu vermeiden, die mehrere Vererbung verursachen kann^[5] (das "Diamantproblem") oder um mangelnde Unterstützung für mehrere Erbschaften in einer Sprache zu arbeiten. Ein Mixin kann auch als als angesehen werden Schnittstelle mit implementiert Methoden. Dieses Muster ist ein Beispiel für die Durchsetzung der Durchsetzung der Abhängigkeitsinversionsprinzip.

Geschichte

Mixins erschien zuerst in SymbolikObjektorientiert Flavors System (entwickelt von Howard Cannon), das ein Ansatz zur Objektorientierung war, das in verwendet wurde Lisp Machine Lisp. Der Name wurde von inspiriert von Steves Eisdiele in Somerville, Massachusetts:^[1] Der Eigentümer der Eisdiele bot einen einfachen Geschmack aus Eiscreme (Vanille, Schokolade usw.) und mischte eine Kombination aus zusätzlichen Gegenständen (Nüsse, Kekse, Fudge usw.) und nannte den Artikel A ""Mischen", Seine eigene Markenzeit zu dieser Zeit.^[2]

Definition

Mixins sind ein Sprachkonzept, das es einem Programmierer ermöglicht, einen Code in a zu injizieren Klasse. Mixin -Programmierung ist ein Stil von Software-Entwicklung, in denen Einheiten der Funktionalität in einer Klasse erstellt und dann mit anderen Klassen gemischt werden.^[6]

Eine Mixin -Klasse fungiert als übergeordnete Klasse, die die gewünschte Funktionalität enthält. EIN Unterklasse kann dann diese Funktionalität erben oder einfach wiederverwenden, aber nicht als Spezialisierungsmittel. Normalerweise exportiert der Mixin die gewünschte Funktionalität in a KinderklasseOhne eine starre Erstellung "ist eine" eine Beziehung "ist eine" Beziehung. Hier liegt der wichtige Unterschied zwischen den Konzepten von Mixins und NachlassDa die Kinderklasse immer noch alle Merkmale der Elternklasse erben kann, aber die Semantik über das Kind "eine Art" eine Art von Eltern ist, muss nicht unbedingt angewendet werden.

Vorteile

1. Es bietet einen Mechanismus für Mehrfacherbe Indem einer Klasse die gemeinsame Funktionalität aus mehreren Klassen verwendet, jedoch ohne die komplexe Semantik der multiplen Vererbung.^[7]
2. Code -Wiederverwendbarkeit: Mixins sind nützlich, wenn ein Programmierer die Funktionalität zwischen verschiedenen Klassen teilen möchte. Anstatt den gleichen Code immer wieder zu wiederholen, kann die gemeinsame Funktionalität einfach in ein Mixin gruppiert und dann in jede Klasse einbezogen werden, die ihn benötigt.^[8]
3. Mixins ermöglichen die Vererbung und Verwendung nur der gewünschten Funktionen der übergeordneten Klasse, nicht unbedingt alle Funktionen der übergeordneten Klasse.^[9]

Implementierungen

Im Simula, Klassen werden in einem Block definiert, in dem Attribute, Methoden und Klasseninitialisierung zusammen definiert sind. Somit sind alle Methoden, die in einer Klasse aufgerufen werden können, zusammen definiert, und die Definition der Klasse ist vollständig.

Im FlavorsEin Mixin ist eine Klasse, aus der eine andere Klasse Slot -Definitionen und -Methoden erben kann. Der Mixin hat normalerweise keine direkten Instanzen. Da ein Geschmack von mehr als einem anderen Geschmack erben kann, kann er von einem oder mehreren Mixins erben. Beachten Sie, dass die ursprünglichen Aromen keine generischen Funktionen verwendeten.

In neuen Geschmacksrichtungen (ein Nachfolger von Aromen) und Schloss, Methoden sind in "organisiert"generische Funktionen"Diese generischen Funktionen sind Funktionen, die in mehreren Fällen (Methoden) durch Klassenversand- und Methodenkombinationen definiert sind.

CLOS und Aromen ermöglichen Mixin -Methoden, um vorhandenen Methoden ein Verhalten hinzuzufügen: :Vor und :nach Daemons, Whoppers und Wrapper in Aromen. Clos hinzugefügt :um Methoden und die Fähigkeit, Schattenmethoden aufzurufen CALL-NEXT-METHOD. So kann beispielsweise ein Stream-Lock-Mixin das Sperren vorhandenen Methoden einer Stream-Klasse hinzufügen. In den Aromen würde man einen Wrapper oder einen Whopper schreiben und in Clos würde man eine verwenden :um Methode. Sowohl Clos als auch Aromen ermöglichen die berechnete Wiederverwendung durch Methodenkombinationen. :Vor, :nach und :um Methoden sind ein Merkmal der Standardmethodekombination. Andere Methodenkombinationen werden bereitgestellt.

Ein Beispiel ist das + Methodenkombination, wobei die resultierenden Werte jeder der anwendbaren Methoden einer generischen Funktion arithmetisch hinzugefügt werden, um den Rückgabewert zu berechnen. Dies wird beispielsweise mit dem Rand-Mixin für grafische Objekte verwendet. Ein grafisches Objekt kann eine generische Breite haben. Das Rand-Mixin würde einen Rand um ein Objekt hinzufügen und über eine Methode verfügt, die seine Breite berechnet. Eine neue Klasse Grenze (Das ist sowohl ein grafisches Objekt als auch das verwendet die Grenze Mixin) würde seine Breite berechnen, indem alle Methoden anwendbarer Breite aufgerufen werden - via die + Methodenkombination. Alle Rückgabewerte werden hinzugefügt und erstellen die kombinierte Breite des Objekts.

In einem oopsla 90 Papier,^[10] Gilad Bracha und William Cook interpretieren verschiedene Vererbungsmechanismen, die in SmallTalk, Beta und CLOs zu finden sind, als besondere Formen eines Mixin -Vererbung.

Programmiersprachen, die Mixins verwenden

Anders als Geschmack und Clos (ein Teil von Common Lisp) Einige Sprachen, die Mixins verwenden, sind:

• Ada (Durch Erweiterung eines vorhandenen markierten Datensatzes mit willkürlichen Operationen in einem Generika)
• C# (Da C# 8.0 mittels von Standardmethoden von Schnittstellen)^[11]
• Kobra
• Coldfusion (Klassenbasierte Verwendung und Objekt basierend durch Zuweisen von Methoden von einem Objekt zur Laufzeit an ein anderes.)
• Locken (mit Curl Rte)
• D (genannt "Vorlagenmischungen"; D enthält auch a "Mixin" Anweisung, die Zeichenfolgen als Code kompiliert.)
• Pfeil
• Faktor^[12]
• Groovig
• Java (seit Java 8 mittels von Standardmethoden von Schnittstellen)
• JavaScript -Delegation - Funktionen als Rollen (Merkmale und Mixins)
• Kotlin
• Weniger
• Ocaml^[13]
• Perl (durch Rollen in der Elchverlängerung des Perl 5 -Objektsystems)
• Php's "Züge"
• Magik
• Matlab^[14]
• Python
• Schläger (Mixins -Dokumentation)
• Raku
• Rost
• Rubin
• Scala^[15]
• Xotcl/Tcloo (Objektsysteme integriert zu Tcl)^[16]
• Sass (eine Stylesheet -Sprache)
• Smalltalk
• Vala
• Schnell
• Systemverilog
• Typoskript (Mixins -Dokumentation)

Einige Sprachen unterstützen Mixins nicht auf Sprachebene, können sie jedoch leicht durch Kopieren von Methoden von einem Objekt zum anderen zur Laufzeit nachahmen, wodurch die Methoden des Mixins "geliehen" werden. Dies ist auch möglich mit statisch typisiert Sprachen, aber es erfordert das Erstellen eines neuen Objekts mit dem erweiterten Satz von Methoden.

Andere Sprachen, die Mixins nicht unterstützen, können sie über andere Sprachkonstrukte auf runde Weise unterstützen. Zum Beispiel, Visual Basic .net und C# unterstützen die Hinzufügung von Erweiterungsmethoden an Schnittstellen, was bedeutet, dass jede Klasse, die eine Schnittstelle mit definierten Erweiterungsmethoden implementiert, die Erweiterungsmethoden als Pseudo-Mitglieder verfügbar ist.

Beispiele

In gemeinsamer Lisp

Common Lisp Bietet Mixins In Clos (Common Lisp -Objektsystem) ähnlich wie Aromen.

Objektbreite ist eine generische Funktion mit einem Argument, das das verwendet + Methodenkombination. Diese Kombination stellt fest, dass alle anwendbaren Methoden für eine generische Funktion aufgerufen und die Ergebnisse hinzugefügt werden.

(Defgenerisch Objektbreite (Objekt)  (: Methodenkombination +)) 

Taste ist eine Klasse mit einem Slot für den Schaltflächentext.

(Defklasse Taste ()  ((Text : initform "Klick mich"))) 

Es gibt eine Methode für Objekte der Klassenschaltfläche, die die Breite basierend auf der Länge des Schaltflächentextes berechnet. + ist das Methode -Qualifikationsmerkmal für die Methodenkombination desselben Namens.

(Defmethod Objektbreite + ((Objekt Taste))  (* 10 (Länge (Slot-Wert Objekt 'Text)))) 

A Grenzmixin Klasse. Die Benennung ist nur eine Konvention. Es gibt keine Superklassen und keine Slots.

(Defklasse Grenzmixin () ()) 

Es gibt eine Methode, die die Breite des Randes berechnet. Hier ist es nur 4.

(Defmethod Objektbreite + ((Objekt Grenzmixin))  4) 

Grenze ist eine Klasse, die von beiden erbt Grenzmixin und Taste.

(Defklasse Grenze (Grenzmixin Taste) ()) 

Wir können jetzt die Breite eines Knopfes berechnen. Berufung Objektbreite Berechnet 80. Das Ergebnis ist das Ergebnis der einzelnen anwendbaren Methode: der Methode Objektbreite für die Klasse Taste.

? (Objektbreite (maßgeschneidert 'Taste)) 80 

Wir können auch die Breite von a berechnen Grenze. Berufung Objektbreite Berechnet 84. Das Ergebnis ist die Summe der Ergebnisse der beiden anwendbaren Methoden: die Methode Objektbreite für die Klasse Taste und die Methode Objektbreite für die Klasse Grenzmixin.

? (Objektbreite (maßgeschneidert 'Grender Button)) 84 

In Python

Im PythonEin Beispiel für das Mixin -Konzept findet sich in der Socketserver Modul,^[17] das hat beide a UDPSERVER Klasse und a Tcpserver Klasse. Sie fungieren als Server für UDP und TCP Sockel -Server. Zusätzlich gibt es zwei Mixinklassen: Forkingmixin und ThreadingMixin. Normalerweise werden alle neuen Verbindungen im selben Prozess behandelt. Durch Erweiterung Tcpserver mit dem ThreadingMixin folgendermaßen:

Klasse ThreadingtCpServer(ThreadingMixin, Tcpserver):  passieren 

das ThreadingMixin Die Klasse fügt dem TCP -Server Funktionalität hinzu, so dass jede neue Verbindung eine neue erstellt Faden. Verwenden der gleichen Methode a Threadingudpserver kann erstellt werden, ohne den Code in duplizieren zu müssen ThreadingMixin. Alternativ verwenden Sie die Forkingmixin würde dazu führen, dass der Prozess ist gegabelt Für jede neue Verbindung. Die Funktionalität, einen neuen Thread zu erstellen oder einen Prozess zu geben, ist eindeutig als eigenständige Klasse nicht besonders nützlich.

In diesem Verwendungsbeispiel bieten die Mixins eine alternative zugrunde liegende Funktionalität, ohne die Funktionalität als Socket -Server zu beeinflussen.

In Ruby

Der größte Teil der Ruby -Welt basiert auf Mixins über Module. Das Konzept von Mixins wird in Ruby durch das Schlüsselwort implementiert enthalten an die wir den Namen des Moduls als übergeben Parameter.

Beispiel:

Klasse Student  enthalten Vergleichbar # Der Klassenstudent erbt das vergleichbare Modul mit dem Schlüsselwort 'Include'  Attr_Accessor :Name, :Punktzahl  def initialisieren(Name, Punktzahl)  @Name = Name  @Punktzahl = Punktzahl  Ende  # Einschließlich des vergleichbaren Moduls erfordert die Implementierungsklasse, um den Vergleichsbetreiber zu definieren  # Hier ist der Vergleichsbetreiber. Wir vergleichen 2 Studenteninstanzen anhand ihrer Punktzahlen.  def <=>(Sonstiges)  @Punktzahl <=> Sonstiges.Punktzahl  Ende  # Hier ist das gute Bit - ich bekomme kostenlos Zugriff auf <, <=,>,> = und andere Methoden der vergleichbaren Schnittstelle. Ende S1 = Student.Neu("Peter", 100) S2 = Student.Neu("Jason", 90) S1 > S2 #Stimmt S1 <= S2 #FALSCH 

In JavaScript

Das Objekt-literal und erweitern Sich nähern

Es ist technisch gesehen möglich, einem Objekt ein Verhalten hinzuzufügen, indem Funktionen an Schlüssel im Objekt gebunden werden. Dieser Mangel an Trennung zwischen Zustand und Verhalten hat jedoch Nachteile:

1. Es vermischt die Eigenschaften der Modelldomäne mit der der Implementierungsdomäne.
2. Kein Teilen von gemeinsamem Verhalten. MetaObjects lösen dieses Problem, indem die domänenspezifischen Eigenschaften von Objekten von ihren verhaltenspezifischen Eigenschaften getrennt werden.^[18]

Eine Erweiterungsfunktion wird verwendet, um das Verhalten in:^[19]

"Strikt verwenden"; Const Halbling = Funktion (fname, lname) {  Dies.Vorname = fname;  Dies.Nachname = lname; }; Const mischen = {  vollständiger Name() {  Rückkehr Dies.Vorname + '' ' + Dies.Nachname;  },  umbenennen(Erste, letzte) {  Dies.Vorname = Erste;  Dies.Nachname = letzte;  Rückkehr Dies;  } }; // eine Verlängerungsfunktion Const erweitern = (obj, mischen) => {  Objekt.Schlüssel(mischen).für jeden(Schlüssel => obj[Schlüssel] = mischen[Schlüssel]);  Rückkehr obj; }; Const Sam = Neu Halbling('Sam', 'Lowery' '); Const Frodo = Neu Halbling("Freeda", "Baggs"); // die anderen Methoden mischen erweitern(Halbling.Prototyp, mischen); Konsole.Protokoll(Sam.vollständiger Name());  // Sam Loawry Konsole.Protokoll(Frodo.vollständiger Name());  // Freeda Baggs Sam.umbenennen("Samwise", "Gamgee"); Frodo.umbenennen("Frodo", "Baggins"); Konsole.Protokoll(Sam.vollständiger Name());  // Samwise Gamgee Konsole.Protokoll(Frodo.vollständiger Name());  // Frodo Beutlin 

Mischen Sie mit Object.assisign ()

"Strikt verwenden"; // Erstellen eines Objekts Const OBJ1 = {  Name: "Marcus Aurelius",  Stadt: 'Rom',  geboren: '121-04-26' }; // Mixin 1 Const mix1 = {  tostring() {  Rückkehr `$ {Dies.Name} wurde geboren in $ {Dies.Stadt} in $ {Dies.geboren}`;  },  das Alter() {  Const Jahr = Neu Datum().Getreide();  Const geboren = Neu Datum(Dies.geboren).Getreide();  Rückkehr Jahr - geboren;  } }; // Mixin 2 Const mix2 = {  tostring() {  Rückkehr `$ {Dies.Name} - $ {Dies.Stadt} - $ {Dies.geboren}`;  } }; // Hinzufügen der Methoden von Mixins zum Objekt mit Object.assisign () hinzufügen Objekt.zuordnen(OBJ1, mix1, mix2); Konsole.Protokoll(OBJ1.tostring());  // Marcus Aurelius - Rom - 121-04-26 Konsole.Protokoll(`Sein Alter ist $ {OBJ1.das Alter()} Ab heute);  // sein Alter ist bis heute 1897 

Die reine Funktion und Delegationsbasis Flug-Mixin-Ansatz

Obwohl der erste beschriebene Ansatz größtenteils weit verbreitet ist, ist der nächste näher an dem, was JavaScripts Sprachkern grundlegend bietet - - Delegation.

Zwei Funktionsobjekt -basierte Muster aus wirken bereits den Trick, ohne dass die Implementierung eines Dritten von Dritter erforderlich ist erweitern.

"Strikt verwenden"; // Implementierung Const Aufzählbare Firstlast = (Funktion () { // Funktionsbasiertes Modulmuster.  Const Erste = Funktion () {  Rückkehr Dies[0];  },  letzte = Funktion () {  Rückkehr Dies[Dies.Länge - 1];  };  Rückkehr Funktion () {  // Funktionsbasierte Flug-Mixin-Mechanik ...  Dies.Erste  = Erste;  // ... in Bezug auf ...  Dies.letzte  = letzte;  // ... gemeinsamer Code.  }; } ()); // Anwendung - Explizite Delegation: // Anwenden [zuerst] und [letztes] aufzählbares Verhalten auf [Array] von [Prototyp] anwenden. Aufzählbare Firstlast.Anruf(Array.Prototyp); // Jetzt kannst du es tun: Const a = [1, 2, 3]; a.Erste(); // 1 a.letzte();  // 3 

In anderen Sprachen

In dem Locken Web-In-In-In-Incontent-Sprache, multiple Vererbung wird als Klassen ohne Instanzen verwendet, die Methoden implementieren können. Gemeinsame Mixine sind alle dünn Controluis Erben von SkinnableControlui, Delegierobjekte der Benutzeroberfläche, die Dropdown -Menüs von Standardbasedropdownui und so explizit benannten Mixin -Klassen als Mixin -Klassen erfordern Fontgraphicmixin, Fontvisualmixin und Numericaxismixin-of Klasse. Version 7.0 Der Zugang zur Bibliothek hinzugefügt, sodass Mixins nicht im selben Paket sein oder öffentlich abstrakt sein müssen. Curl-Konstrukteure sind Fabriken, die die Verwendung mehrerer Ineritanz ohne explizite Deklaration entweder Schnittstellen oder Mixins ermöglichen.

Schnittstellen und Merkmale

Java 8 führt eine neue Funktion in Form von Standardmethoden für Schnittstellen ein.^[20] Grundsätzlich ermöglicht es eine Methode, in einer Schnittstelle mit Anwendung im Szenario zu definieren, wenn eine neue Methode nach dem Programmieraufbau der Schnittstellenklasse zu einer Schnittstelle hinzugefügt werden soll. Um der Schnittstelle eine neue Funktion hinzuzufügen, bedeutet dies, die Methode in jeder Klasse zu implementieren, die die Schnittstelle verwendet. Standardmethoden helfen in diesem Fall, wenn sie jederzeit an eine Schnittstelle eingeführt werden können und eine implementierte Struktur haben, die dann von den zugehörigen Klassen verwendet wird. Daher fügt Standardmethoden die Möglichkeit hinzu, das Konzept auf eine Art Mixin anzuwenden.

Schnittstellen kombiniert mit Aspekt-orientiertes Programmieren Kann auch vollwertige Mixins in Sprachen produzieren, die solche Funktionen wie C# oder Java unterstützen. Zusätzlich durch die Verwendung des Markierungsschnittstellenmuster, generische Programmierungund Erweiterungsmethoden, C# 3.0 hat die Fähigkeit, Mixins nachzuahmen. Mit C# 3.0 kam die Einführung von Erweiterungsmethoden und sie können nicht nur auf Klassen, sondern auch an Schnittstellen angewendet werden. Erweiterungsmethoden bieten zusätzliche Funktionen für eine vorhandene Klasse, ohne die Klasse zu ändern. Es wird dann möglich, eine statische Helferklasse für bestimmte Funktionen zu erstellen, die die Erweiterungsmethoden definiert. Da die Klassen die Schnittstelle implementieren (auch wenn die tatsächliche Schnittstelle keine Methoden oder Eigenschaften enthält), wird auch alle Erweiterungsmethoden aufgegriffen.^[3][4][21] C# 8.0 fügt die Funktion von Standard -Schnittstellenmethoden hinzu.^[22]

ECMaskript (In den meisten Fällen, die als JavaScript implementiert sind) muss die Objektzusammensetzung nicht nach schrittweisen Kopierfeldern von einem Objekt zum anderen nachahmen. Es nativ^[23] Unterstützung Merkmal und mischen^[24][25] basierte Objektzusammensetzung über Funktionsobjekte, die zusätzliches Verhalten implementieren und dann über delegiert werden Anruf oder anwenden an Objekte, die solche neuen Funktionen benötigen.

In Scala

Scala verfügt über ein reiches Typsystem und Eigenschaften sind Teil davon, was dazu beiträgt, das Mixin -Verhalten zu implementieren. Wie ihr Name zeigt, werden Merkmale normalerweise verwendet, um ein eindeutiges Merkmal oder Aspekt darzustellen, der normalerweise orthogonal für die Verantwortung eines konkreten Typs oder zumindest eines bestimmten Beispiels ist.^[26] Zum Beispiel wird die Fähigkeit zum Singen als ein solches orthogonales Merkmal modelliert: Es könnte auf Vögel, Personen usw. angewendet werden.

Merkmal Sänger{  def singen { println(" Singen … ") }  // Weitere Methoden } Klasse Vogel erweitert Sänger 

Hier hat Bird alle Methoden des Merkmals in seine eigene Definition gemischt, als hätte die Klasse Bird Methode Sing () selbst definiert.

Wie erweitert wird auch verwendet, um von einer Superklasse im Falle eines Merkmals zu erben erweitert wird verwendet, wenn keine Superklasse geerbt wird und nur für Mixin im ersten Merkmal. Alle folgenden Merkmale werden in der Verwendung von Keywords gemischt mit.

Klasse Person Klasse Schauspieler erweitert Person mit Sänger Klasse Schauspieler erweitert Sänger mit Künstler 

Scala ermöglicht das Mischen eines Merkmals (Schaffung eines anonymer Typ) beim Erstellen einer neuen Instanz einer Klasse. Bei einer Personklasseninstanz können nicht alle Instanzen singen. Diese Funktion wird dann verwendet: dann:

Klasse Person{  def erzählen {  println (" Menschlich ") }  // Weitere Methoden } val Gesangsperson = Neu Person mit Sänger Gesangsperson.singen 

Im Rost

Rost nutzt Mixins durchfang Züge. Merkmale wie in Scala ermöglichen es Benutzern, Verhaltensweisen für einen definierten Typ zu implementieren. Sie werden auch für verwendet Generika und Dynamischer Versand, die es ermöglichen, dass Typen mit denselben Merkmalen zur Laufzeit austauschbar oder dynamisch verwendet werden.^[27]

// Ermöglicht Typen, "zu sprechen" Merkmal Sprechen { 	fn sprechen(); 	// Rust ermöglicht es Implementierern, Standardimplementierungen für Funktionen zu definieren, die in Merkmalen definiert sind 	fn Großartig() { 		println!("Hi!") 	} } Struktur Roboter; impl Sprechen zum Roboter { 	fn sprechen() { 		println!("Beep Beep Boop Boop"); 	} } Struktur Hund; impl Sprechen zum Hund { 	fn sprechen() { 		println!("Wau-Wau"); 	} 	// Hier überschreiben wir die Definition von Speak :: Großartig auf Hund 	fn Großartig() { 		println!("Roboter sagt überzeugt!") 	} } 

In Swift

Mixin kann in SWIFT mithilfe einer Sprachfunktion, die als Standardimplementierung in der Protokollerweiterung bezeichnet wird, erreicht werden.

Protokoll Errordisplayable {   Func Error(Botschaft:Saite) }  Verlängerung Errordisplayable {   Func Error(Botschaft:Saite) {   // Tun Sie, was es braucht, um einen Fehler anzuzeigen   // ...   drucken(Botschaft)   } }  Struktur Netzwerk Manager : Errordisplayable {   Func onError() {   Error("Bitte überprüfe deine Internetverbindung.")   } } 

Siehe auch

• Zusammenfassung Typ
• Dekorateurmuster
• Richtlinienbasierter Design
• Merkmal, eine ähnliche Struktur, die keine lineare Zusammensetzung erfordert

Verweise

Externe Links

• Mischen im Portland Muster Repository
• Mischungen in Aktionen
• Das gemeinsame Lisp -Objektsystem: eine Übersicht durch Richard P. Gabriel Und Linda Demichiel bietet eine gute Einführung in die Motivation zur Definition von Klassen mittels generischer Funktionen.