Add Interpreter (ES5 + ES6 + CoffeeScript + TypeScript)

Author: Badacadabra

doc/GoF/Behavioral/Interpreter/Interpreter.dia

@@ -0,0 +1,17 @@
+# Synopsis
+
+I love music and I want to be able to analyze some compositions like "Moonlight Sonata" by Beethoven.
+
+# Problem
+
+Music is a beautiful but complex universe, and listening to music does not mean understanding it. To analyze compositions, music theory is an absolute necessity. Since music is a language, pretty much like English or French are, it has its own grammar. Understanding this grammar makes it possible to understand a composition. But here the question is: how do we describe a grammar with a programming language?
+
+# Solution
+
+The Interpreter pattern is exactly what we need to tell JavaScript how to interpret music grammar. Here we can have:
+
+  * A concrete context to analyze, which will be a sonata (e.g. "Moonlight Sonata")
+  * An abstract representation of music notation (abstract class or interface)
+  * Concrete (terminal and nonterminal) expressions like Note or Arpeggio
+
+The distinction between terminal and nonterminal expressions in the Interpreter pattern is a bit like the distinction between simple and composed elements in the Composite pattern. A note is a terminal expression because it is an "elementary symbol" of the grammar. However, an arpeggio is a nonterminal expression because it can be considered as a group of notes.

doc/GoF/Behavioral/Interpreter/Interpreter.png

@@ -0,0 +1,76 @@
+# ==============================
+# CONCRETE CONTEXT
+# ==============================
+
+class Sonata
+    constructor: (@name, @composer) -> 
+
+    getName: ->
+        @_name
+
+    getComposer: ->
+        @_composer
+
+# ==============================
+# ABSTRACT EXPRESSION
+# ==============================
+
+class MusicNotation
+    constructor: (name) ->
+        throw new Error "You cannot instantiate an abstract class!" if @constructor is MusicNotation
+        @_name = name
+
+    interpret: (sonata) ->
+        throw new Error "You cannot call an abstract method!"
+
+# ==============================
+# CONCRETE EXPRESSIONS
+# ==============================
+
+# Terminal expression
+class Note extends MusicNotation
+    constructor: (name) ->
+        super name
+
+    interpret: (sonata) ->
+        "#{sonata.composer} played #{@_name}\n"
+
+# Nonterminal expression
+class Arpeggio extends MusicNotation
+    constructor: (name) ->
+        super name
+        @_notes = []
+
+    addNotes: (newNotes) ->
+        @_notes.push note for note in newNotes
+            
+
+    interpret: (sonata) ->
+        res = ""
+        res += note.interpret sonata for note in @_notes
+        res += "This was a #{@_name} arpeggio from #{sonata.name}.\n"
+        res 
+
+# ==============================
+# CLIENT CODE
+# ==============================
+
+# To avoid overcomplexity, we only take into account the first measure and the right hand (G-clef)
+sonata = new Sonata "Moonlight Sonata", "Beethoven"
+
+# Notes
+gSharp = new Note "G#"
+cSharp = new Note "C#"
+e = new Note "E"
+
+# Arpeggio
+cSharpMinor = new Arpeggio "C#m"
+cSharpMinor.addNotes [gSharp, cSharp, e]
+
+# Melody
+melody = []
+
+melody.push cSharpMinor for i in [1..4] # The same musical pattern is repeated four times...
+    
+# Interpretation
+console.log arpeggio.interpret sonata for arpeggio in melody

doc/GoF/Behavioral/Interpreter/README.md

@@ -0,0 +1,102 @@
+// ==============================
+// CONCRETE CONTEXT
+// ==============================
+
+class Sonata {
+    private name: string;
+    private composer: string;
+
+    constructor(name: string, composer: string) {
+        this.name = name;
+        this.composer = composer;
+    }
+
+    public getName(): string {
+        return this.name; 
+    }
+
+    public getComposer(): string {
+        return this.composer; 
+    }
+}
+
+// ==============================
+// ABSTRACT EXPRESSION
+// ==============================
+
+abstract class MusicNotation {
+    protected name: string;
+
+    constructor(name: string) {
+        this.name = name; 
+    }
+
+    public abstract interpret(sonata: Sonata): string;
+}
+
+// ==============================
+// CONCRETE EXPRESSIONS
+// ==============================
+
+// Terminal expression
+class Note extends MusicNotation {
+    constructor(name: string) {
+        super(name);
+    }
+
+    public interpret(sonata: Sonata): string {
+        return `${sonata.getComposer()} played ${this.name}\n`;
+    }
+}
+
+// Nonterminal expression
+class Arpeggio extends MusicNotation {
+    private notes: Note[] = [];
+
+    constructor(name: string) {
+        super(name);
+    }
+
+    public addNotes(newNotes: Note[]): void {
+        for (let note of newNotes) {
+            this.notes.push(note);
+        }
+    }
+
+    public interpret(sonata: Sonata): string {
+        let res: string = "";
+        for (let note of this.notes) {
+            res += note.interpret(sonata); 
+        }
+        res += `This was a ${this.name} arpeggio from ${sonata.getName()}.\n`;
+        return res; 
+    }
+}
+
+// ==============================
+// CLIENT CODE
+// ==============================
+
+// To avoid overcomplexity, we only take into account the first measure and the right hand (G-clef)
+let sonata: Sonata = new Sonata("Moonlight Sonata", "Beethoven");
+
+// Notes
+let gSharp: Note = new Note("G#"),
+    cSharp: Note = new Note("C#"),
+    e: Note = new Note("E");
+
+// Arpeggio
+let cSharpMinor: Arpeggio = new Arpeggio("C#m");
+cSharpMinor.addNotes([gSharp, cSharp, e]);
+
+// Melody
+let melody: Arpeggio[] = [];
+
+for (let i = 0; i < 4; i++) { // The same musical pattern is repeated four times...
+    melody.push(cSharpMinor);
+}
+
+// Interpretation
+for (let arpeggio of melody) {
+    console.log(arpeggio.interpret(sonata));
+}

src/CoffeeScript/GoF/Behavioral/Interpreter/Interpreter.coffee

@@ -0,0 +1,116 @@
+'use strict';
+
+// ==============================
+// CONCRETE CONTEXT
+// ==============================
+
+var Sonata = (function () {
+    function Sonata(name, composer) {
+        this._name = name;
+        this._composer = composer;
+    }
+
+    Sonata.prototype.getName = function () {
+        return this._name; 
+    };
+
+    Sonata.prototype.getComposer = function () {
+        return this._composer; 
+    };
+
+    return Sonata;
+})();
+
+// ==============================
+// ABSTRACT EXPRESSION
+// ==============================
+
+var MusicNotation = (function() {
+    function MusicNotation(name) {
+        if (this.constructor === MusicNotation) {
+            throw new Error("You cannot instantiate an abstract class!");
+        }
+        this._name = name;
+    }
+
+    MusicNotation.prototype.interpret = function (sonata) {
+        throw new Error("You cannot call an abstract method!");
+    };
+
+    return MusicNotation;
+})();
+
+// ==============================
+// CONCRETE EXPRESSIONS
+// ==============================
+
+// Terminal expression
+var Note = (function () {
+    function Note(name) {
+        MusicNotation.call(this, name);
+    }
+    Note.prototype = Object.create(MusicNotation.prototype);
+    Note.prototype.constructor = Note;
+
+    Note.prototype.interpret = function (sonata) {
+        return sonata.getComposer() + " played " + this._name + "\n";
+    };
+
+    return Note;
+})();
+
+// Nonterminal expression
+var Arpeggio = (function () {
+    var notes = [];
+
+    function Arpeggio(name) {
+        MusicNotation.call(this, name);
+    }
+    Arpeggio.prototype = Object.create(MusicNotation.prototype);
+    Arpeggio.prototype.constructor = Arpeggio;
+
+    Arpeggio.prototype.addNotes = function (newNotes) {
+        for (var i = 0, len = newNotes.length; i < len; i++) {
+            notes.push(newNotes[i]);
+        }
+    };
+
+    Arpeggio.prototype.interpret = function (sonata) {
+        var res = "";
+        for (var i = 0, len = notes.length; i < len; i++) {
+            res += notes[i].interpret(sonata); 
+        }
+        res += "This was a " + this._name + " arpeggio from " + sonata.getName() + ".\n";
+        return res; 
+    };
+
+    return Arpeggio;
+})();
+
+// ==============================
+// CLIENT CODE
+// ==============================
+
+// To avoid overcomplexity, we only take into account the first measure and the right hand (G-clef)
+var sonata = new Sonata("Moonlight Sonata", "Beethoven");
+
+// Notes
+var gSharp = new Note("G#"),
+    cSharp = new Note("C#"),
+    e = new Note("E");
+
+// Arpeggio
+var cSharpMinor = new Arpeggio("C#m");
+cSharpMinor.addNotes([gSharp, cSharp, e]);
+
+// Melody
+var melody = [];
+
+for (var i = 0; i < 4; i++) { // The same musical pattern is repeated four times...
+    melody.push(cSharpMinor);
+}
+
+// Interpretation
+for (var j = 0, len = melody.length; j < len; j++) {
+    console.log(melody[j].interpret(sonata));
+}