friedbrice · June 4, 2019 17:13 · Jun 4, 2019 · Jun 4, 2019 · Jun 3, 2019 · Jun 3, 2019
diff --git a/Extend.java b/Extend.java
@@ -1,6 +1,6 @@
 import java.util.Map;
 
-// This is almost a solution to the extension problem, except for
+// This is almost a solution to the expression problem, except for
 // lines 47 and 74.
 // Instead of raising an exception, we want the program to fail to
 // compile if there are cases that we haven't considered.

diff --git a/Extend.java b/Extend.java
@@ -0,0 +1,126 @@
+import java.util.Map;
+
+// This is almost a solution to the extension problem, except for
+// lines 47 and 74.
+// Instead of raising an exception, we want the program to fail to
+// compile if there are cases that we haven't considered.
+class Extend {
+
+  // I can define a data structure by cases.
+
+  abstract class Expr {}
+
+  class Constant extends Expr {
+    Integer value;
+  }
+
+  class Variable extends Expr {
+    String name;
+  }
+
+  class Add extends Expr {
+    Expr left;
+    Expr right;
+  }
+
+  interface Op<A> {
+    A withExpr(Expr x);
+    A withConstant(Constant x);
+    A withVariable(Variable x);
+    A withAdd(Add x);
+  }
+
+  // I can add as many new operations as I want.
+
+  class Print implements Op<String> {
+
+    @Override public String withExpr(Expr x) {
+      if (x instanceof Constant) return this.withConstant((Constant) x);
+      if (x instanceof Variable) return this.withVariable((Variable) x);
+      if (x instanceof Add) return this.withAdd((Add) x);
+      throw new RuntimeException("This breaks the rules of the game.");
+    }
+
+    @Override public String withConstant(Constant x) {
+      return x.toString();
+    }
+
+    @Override public String withVariable(Variable x) {
+      return x.name;
+    }
+
+    @Override public String withAdd(Add x) {
+      return "(" + this.withExpr(x.left) + " + " + this.withExpr(x.right) + ")";
+    }
+  }
+
+  class Eval implements Op<Integer> {
+    Map<String, Expr> env;
+
+    Eval(Map<String, Expr> env) {
+      this.env = env;
+    }
+
+    @Override public Integer withExpr(Expr x) {
+      if (x instanceof Constant) return this.withConstant((Constant) x);
+      if (x instanceof Variable) return this.withVariable((Variable) x);
+      if (x instanceof Add) return this.withAdd((Add) x);
+      throw new RuntimeException("This breaks the rules of the game.");
+    }
+
+    @Override public Integer withConstant(Constant x) {
+      return x.value;
+    }
+
+    @Override public Integer withVariable(Variable x) {
+      if (env.containsKey(x.name)) return this.withExpr(env.get(x.name));
+      return new Integer(0);
+    }
+
+    @Override public Integer withAdd(Add x) {
+      return this.withExpr(x.left) + this.withExpr(x.right);
+    }
+  }
+
+  // I can add a new case of Expr
+
+  class Mult extends Expr {
+    Expr left;
+    Expr right;
+  }
+
+  interface ExtOp<A> extends Op<A> {
+    A withMult(Mult x);
+  }
+
+  // And I can update my old operations to work with the new case,
+  // without needing access to their source code.
+
+  class ExtPrint extends Print implements ExtOp<String> {
+
+    @Override public String withExpr(Expr x) {
+      if (x instanceof Mult) return withMult((Mult) x);
+      return super.withExpr(x);
+    }
+
+    @Override public String withMult(Mult x) {
+      return "(" + this.withExpr(x.left) + " * " + this.withExpr(x.right) + ")";
+    }
+  }
+
+  class ExtEval extends Eval implements ExtOp<Integer> {
+
+    ExtEval(Map<String, Expr> env) {
+      super(env);
+    }
+
+    @Override public Integer withExpr(Expr x) {
+      if (x instanceof Mult) return withMult((Mult) x);
+      return super.withExpr(x);
+    }
+
+    @Override public Integer withMult(Mult x) {
+      return this.withExpr(x.left) * this.withExpr(x.right);
+    }
+  }
+}
diff --git a/extend.js b/extend.js
@@ -0,0 +1,59 @@
+//
+// Two kinds of animals: dogs and cats
+//
+// I want greet and leave to be defined such that there are four
+// different behaviors corresponding to each combination of dog and
+// cat
+//
+class Animal {
+  receive_operation(operation) {
+    console.log("the animal is unresponsive");
+  }
+}
+
+class Operation {
+  operate() {
+    console.log("the animal is unresponsive");
+  }
+}
+
+class Turtle extends Animal {}
+
+class Dog extends Animal {
+  receive_operation(operation) {
+    // This if statement is hard to add in an extensible fashion
+    if (operation instanceof Greet) {
+      console.log("the dog wags its tail joyfully");
+    } else if (operation instanceof Leave) {
+      console.log("the dog looks very sad");
+    }
+  }
+}
+
+class Cat extends Animal {
+  receive_operation(operation) {
+    if (operation instanceof Greet) {
+      console.log("the cat stands aloof");
+    } else if (operation instanceof Leave) {
+      console.log("the cat purs happily");
+    }
+  }
+}
+
+class Greet extends Operation {}
+
+class Leave extends Operation {}
+
+function operate(animal, operation) {
+  animal.receive_operation(operation);
+}
+
+function main() {
+  for (const animal of [new Cat(), new Dog(), new Turtle()]) {
+    for (const operation of [new Greet(), new Leave()]) {
+      operate(animal, operation);
+    }
+  }
+}
+
+main();
diff --git a/extend.lisp b/extend.lisp
@@ -11,7 +11,7 @@
 (defclass operation ()
   ())
 
-(defgeneric visit (animal operation)
+(defgeneric operate (animal operation)
   #| This method ensures type safety: as long as we're given something in the domain of the function 
   (animal, operation) => effect}, we'll get a result. |#
   (:method ((animal animal) (operation operation))
@@ -33,14 +33,14 @@
 (defclass leave (operation)
   ())
 
-(defmethod visit ((animal cat) (operation greet))
+(defmethod operate ((animal cat) (operation greet))
   (format *standard-output* "the cat stands aloof~%"))
-(defmethod visit ((animal cat) (operation leave))
+(defmethod operate ((animal cat) (operation leave))
   (format *standard-output* "the cat purs happily~%"))
 
-(defmethod visit ((animal dog) (operation greet))
+(defmethod operate ((animal dog) (operation greet))
   (format *standard-output* "the dog wags its tail joyfully~%"))
-(defmethod visit ((animal dog) (operation leave))
+(defmethod operate ((animal dog) (operation leave))
   (format *standard-output* "the dog looks very sad~%"))
 
 (defun main ()
@@ -58,4 +58,4 @@ the dog wags its tail joyfully
 the dog looks very sad
 the animal is unresponsive
 the animal is unresponsive
-|#
+|#
diff --git a/extend.lisp b/extend.lisp
@@ -8,6 +8,15 @@
 (defclass animal ()
   ())
 
+(defclass operation ()
+  ())
+
+(defgeneric visit (animal operation)
+  #| This method ensures type safety: as long as we're given something in the domain of the function 
+  (animal, operation) => effect}, we'll get a result. |#
+  (:method ((animal animal) (operation operation))
+    (format *standard-output* "the animal is unresponsive~%")))
+
 (defclass turtle (animal)
   ())
 #| -------------- End Library -------------- |#
@@ -18,28 +27,29 @@
 (defclass dog (animal)
   (#| dog-specific members here |#))
 
-(defgeneric greet (thing)
-  (:method ((thing animal))
-    (format *standard-output* "the animal is unresponsive~%"))
-  (:method ((thing dog))
-    (format *standard-output* "the dog wags its tail joyfully~%"))
-  (:method ((thing cat))
-    (format *standard-output* "the cat stands aloof~%")))
-
-(defgeneric leave (thing)
-  (:method ((thing animal))
-    (format *standard-output* "the animal is unresponsive~%"))
-  (:method ((thing dog))
-    (format *standard-output* "the dog looks very sad~%"))
-  (:method ((thing cat))
-    (format *standard-output* "the cat purs happily~%")))
+(defclass greet (operation)
+  ())
+
+(defclass leave (operation)
+  ())
+
+(defmethod visit ((animal cat) (operation greet))
+  (format *standard-output* "the cat stands aloof~%"))
+(defmethod visit ((animal cat) (operation leave))
+  (format *standard-output* "the cat purs happily~%"))
+
+(defmethod visit ((animal dog) (operation greet))
+  (format *standard-output* "the dog wags its tail joyfully~%"))
+(defmethod visit ((animal dog) (operation leave))
+  (format *standard-output* "the dog looks very sad~%"))
 
 (defun main ()
   (dolist (animal (list (make-instance 'cat)
                         (make-instance 'dog)
                         (make-instance 'turtle)))
-    (dolist (action (list 'greet 'leave))
-      (funcall action animal)))) #| ===> 
+    (dolist (action (list (make-instance 'greet)
+                          (make-instance 'leave)))
+      (visit animal action)))) #| ===> 
 
 FWOAR.EXTEND> (main)
 the cat stands aloof
@@ -48,4 +58,4 @@ the dog wags its tail joyfully
 the dog looks very sad
 the animal is unresponsive
 the animal is unresponsive
-|#
+|#
diff --git a/extend.lisp b/extend.lisp
@@ -0,0 +1,51 @@
+(defpackage :fwoar.extend
+  (:use :cl )
+  (:export ))
+
+(in-package :fwoar.extend)
+
+#| ------------- Begin Library ------------- |#
+(defclass animal ()
+  ())
+
+(defclass turtle (animal)
+  ())
+#| -------------- End Library -------------- |#
+
+(defclass cat (animal)
+  (#| cat-specific members here |#))
+
+(defclass dog (animal)
+  (#| dog-specific members here |#))
+
+(defgeneric greet (thing)
+  (:method ((thing animal))
+    (format *standard-output* "the animal is unresponsive~%"))
+  (:method ((thing dog))
+    (format *standard-output* "the dog wags its tail joyfully~%"))
+  (:method ((thing cat))
+    (format *standard-output* "the cat stands aloof~%")))
+
+(defgeneric leave (thing)
+  (:method ((thing animal))
+    (format *standard-output* "the animal is unresponsive~%"))
+  (:method ((thing dog))
+    (format *standard-output* "the dog looks very sad~%"))
+  (:method ((thing cat))
+    (format *standard-output* "the cat purs happily~%")))
+
+(defun main ()
+  (dolist (animal (list (make-instance 'cat)
+                        (make-instance 'dog)
+                        (make-instance 'turtle)))
+    (dolist (action (list 'greet 'leave))
+      (funcall action animal)))) #| ===> 
+
+FWOAR.EXTEND> (main)
+the cat stands aloof
+the cat purs happily
+the dog wags its tail joyfully
+the dog looks very sad
+the animal is unresponsive
+the animal is unresponsive
+|#
No results found