finish

Lab5/Lab5.java

@@ -10,12 +10,47 @@ import java.util.Scanner;
 class Lab5 {
   public static String getGrade(String module, String student, String assessment,
       Map<String, Map<String, Map<String, String>>> db) {
-    try {
-      return db.get(module).get(student).get(assessment).toString();
-    } catch(Exception e) {
-      return "No such entry";
-    }
+    Constant<Actually<Map<String, Map<String, Map<String, String>>>>> cDb = new Constant<>() {
+      @Override
+      public Actually<Map<String, Map<String, Map<String, String>>>> init() {
+        return Actually.ok(db);
+      }
+    };
+
+    Constant<String> cNoEntry = new Constant<>() {
+      @Override
+      public String init() {
+        return "No such entry";
+      }
+    };
+
+    Immutator<Actually<Map<String, Map<String, String>>>, Map<String, Map<String, Map<String, String>>>> getStudent = new Immutator<>() {
+
+      @Override
+      public Actually<Map<String, Map<String, String>>> invoke(Map<String, Map<String, Map<String, String>>> param) {
+        return Actually.ok(param.get(student));
+      }
+    };
+    Immutator<Actually<Map<String, String>>, Map<String, Map<String, String>>> getModule = new Immutator<>() {
+
+      @Override
+      public Actually<Map<String, String>> invoke(Map<String, Map<String, String>> param) {
+        return Actually.ok(param.get(module));
+      }
+    };
+
+    Immutator<Actually<String>, Map<String, String>> getAssessment = new Immutator<>() {
+
+      @Override
+      public Actually<String> invoke(Map<String, String> param) {
+        return Actually.ok(param.get(assessment));
+      }
+
+    };
+
+    return cDb.init().next(getStudent).next(getModule).next(getAssessment).except(cNoEntry);
   }
+
   public static void main(String[] args) {
     // Create a scanner to read from standard input.
     Scanner sc = new Scanner(System.in);
@@ -43,10 +78,10 @@ class Lab5 {
         break;
     }
   }
-  
+
   public static void test1() {
     String none = null;
-    
+
     System.out.println(Actually.err(new ArithmeticException("Err")).equals(Actually.err(new Exception("Err"))));
     System.out.println(Actually.err(new ArithmeticException("Err")).equals(Actually.err(new Exception("Error"))));
     System.out.println(Actually.err(new ArithmeticException("Err")).equals(Actually.err(new Exception(none))));
@@ -60,7 +95,7 @@ class Lab5 {
     System.out.println(Actually.ok(null).equals("Err"));
     System.out.println(Actually.ok(null).equals(null));
   }
-  
+
   public static void test2() {
     Constant<Integer> zero = new Constant<>() {
       public Integer init() {
@@ -72,13 +107,13 @@ class Lab5 {
         System.out.println(i);
       }
     };
-    
+
     try {
       Actually.<Number>ok(0).unwrap().toString();
-    } catch(Exception e) {
+    } catch (Exception e) {
       System.out.println(e.getMessage());
     }
-    
+
     Actually.<Integer>ok(9).finish(print);
     Actually.<Integer>err(new Exception("Err")).finish(print);
     System.out.println(Actually.<Number>ok(9).except(zero).toString());
@@ -86,29 +121,29 @@ class Lab5 {
     System.out.println(Actually.<Number>err(new ArithmeticException("div by 0")).unless(4).toString());
     System.out.println(Actually.<Number>ok(0).unless(4).toString());
   }
-  
+
   public static void test3() {
-    Immutator<Integer,Integer> inc = new Immutator<>() {
+    Immutator<Integer, Integer> inc = new Immutator<>() {
       public Integer invoke(Integer p) {
-        return p+1;
+        return p + 1;
       }
     };
-    Immutator<Integer,Integer> inv = new Immutator<>() {
+    Immutator<Integer, Integer> inv = new Immutator<>() {
       public Integer invoke(Integer p) {
-        return 1/p;
+        return 1 / p;
       }
     };
-    Immutator<Number,Integer> incNum = new Immutator<>() {
+    Immutator<Number, Integer> incNum = new Immutator<>() {
       public Number invoke(Integer p) {
-        return p+1;
+        return p + 1;
       }
     };
-    Immutator<Number,Integer> invNum = new Immutator<>() {
+    Immutator<Number, Integer> invNum = new Immutator<>() {
       public Number invoke(Integer p) {
-        return 1/p;
+        return 1 / p;
       }
     };
-    
+
     System.out.println(Actually.<Integer>ok(0).transform(inc).toString());
     System.out.println(Actually.<Integer>ok(0).transform(inv).toString());
     System.out.println(Actually.ok(0).transform(inc).toString());
@@ -118,46 +153,46 @@ class Lab5 {
     System.out.println(Actually.ok(0).transform(incNum).toString());
     System.out.println(Actually.ok(0).transform(invNum).toString());
   }
-  
+
   public static void test4() {
-    Transformer<Integer,Integer> inc = new Transformer<>() {
+    Transformer<Integer, Integer> inc = new Transformer<>() {
       public Integer invoke(Integer p) {
-        return p+1;
+        return p + 1;
       }
     };
-    Transformer<Integer,Integer> sqr = new Transformer<>() {
+    Transformer<Integer, Integer> sqr = new Transformer<>() {
       public Integer invoke(Integer p) {
-        return p*p;
+        return p * p;
       }
     };
-    
-    Transformer<Integer,Integer> sqrPlusOneA = sqr.before(inc);
-    Transformer<Integer,Integer> sqrPlusOneB = inc.after(sqr);
-    Transformer<Integer,Integer> plusOneSqrA = sqr.after(inc);
-    Transformer<Integer,Integer> plusOneSqrB = inc.before(sqr);
-    
+
+    Transformer<Integer, Integer> sqrPlusOneA = sqr.before(inc);
+    Transformer<Integer, Integer> sqrPlusOneB = inc.after(sqr);
+    Transformer<Integer, Integer> plusOneSqrA = sqr.after(inc);
+    Transformer<Integer, Integer> plusOneSqrB = inc.before(sqr);
+
     System.out.println(sqrPlusOneA.invoke(2).toString());
     System.out.println(sqrPlusOneA.invoke(2).toString());
     System.out.println(plusOneSqrA.invoke(2).toString());
     System.out.println(plusOneSqrB.invoke(2).toString());
   }
-  
+
   public static void test5() {
-    Immutator<Actually<Integer>,Integer> half = new Immutator<>() {
+    Immutator<Actually<Integer>, Integer> half = new Immutator<>() {
       public Actually<Integer> invoke(Integer p) {
-        if (p%2 == 0) {
-          return Actually.<Integer>ok(p/2);
+        if (p % 2 == 0) {
+          return Actually.<Integer>ok(p / 2);
         } else {
           return Actually.<Integer>err(new Exception("odd number"));
         }
       }
     };
-    Immutator<Actually<Integer>,Integer> inc = new Immutator<>() {
+    Immutator<Actually<Integer>, Integer> inc = new Immutator<>() {
       public Actually<Integer> invoke(Integer p) {
-        return Actually.<Integer>ok(p+1);
+        return Actually.<Integer>ok(p + 1);
       }
     };
-    Immutator<Actually<Integer>,Integer> make = new Immutator<>() {
+    Immutator<Actually<Integer>, Integer> make = new Immutator<>() {
       public Actually<Integer> invoke(Integer p) {
         return Actually.<Integer>ok(p);
       }
@@ -167,42 +202,35 @@ class Lab5 {
         return 0;
       }
     };
-    
+
     System.out.println(make.invoke(0).next(inc).next(inc).next(half).toString());
     System.out.println(make.invoke(0).next(inc).next(half).next(inc).toString());
     System.out.println(make.invoke(0).next(inc).next(inc).next(half).except(zero).toString());
     System.out.println(make.invoke(0).next(inc).next(half).next(inc).except(zero).toString());
   }
-  
+
   public static void test6() {
-    Map<String, Map<String, Map<String, String>>> nus =
-          Map.of(
-            "CS2030S", Map.of(
-              "Steve", Map.of(
+    Map<String, Map<String, Map<String, String>>> nus = Map.of(
+        "CS2030S", Map.of(
+            "Steve", Map.of(
                 "lab1", "A",
                 "lab2", "A-",
                 "lab3", "A+",
                 "lab4", "B",
-                "pe1", "C"
-              ),
-              "Tony", Map.of(
+                "pe1", "C"),
+            "Tony", Map.of(
                 "lab1", "C",
                 "lab2", "C",
                 "lab3", "B-",
                 "lab4", "B+",
-                "pe1", "A"
-              )
-            ),
-            "CS2040S", Map.of(
-              "Steve", Map.of(
+                "pe1", "A")),
+        "CS2040S", Map.of(
+            "Steve", Map.of(
                 "lab1", "A",
                 "lab2", "A+",
                 "lab3", "A+",
                 "lab4", "A",
-                "midterm", "A+"
-              )
-            )
-          );
+                "midterm", "A+")));
 
     System.out.println(getGrade("CS2030S", "Steve", "lab1", nus));
     System.out.println(getGrade("CS2030S", "Steve", "lab2", nus));

Lab5/cs2030s/fp/Actually.java

@@ -0,0 +1,158 @@
+package cs2030s.fp;
+
+public abstract class Actually<T> implements Immutatorable<T> {
+  public abstract T unwrap() throws Exception;
+
+  public abstract T except(Constant<? extends T> c);
+
+  public abstract void finish(Action<? super T> action);
+
+  public abstract T unless(T other);
+
+  public abstract <R> Actually<R> next(Immutator<Actually<R>, T> immutator);
+
+  public static <T> Actually<T> ok(T value) {
+    return new Success<T>(value);
+  }
+
+  public static <T> Actually<T> err(Exception e) {
+    Actually<T> failure = (Actually<T>) new Failure(e);
+    return failure;
+  }
+
+  private static class Success<T> extends Actually<T> {
+    private final T value;
+
+    private Success(T value) {
+      this.value = value;
+    }
+
+    @Override
+    public T unwrap() {
+      return this.value;
+    }
+
+    @Override
+    public T except(Constant<? extends T> c) {
+      return this.value;
+    }
+
+    @Override
+    public void finish(Action<? super T> action) {
+      action.call(this.value);
+    }
+
+    @Override
+    public T unless(T other) {
+      return this.value;
+    }
+
+    @Override
+    public <R> Actually<R> next(Immutator<Actually<R>, T> immutator) {
+      try {
+        return immutator.invoke(this.value);
+      } catch (Exception e) {
+        return Actually.err(e);
+      }
+    }
+
+    @Override
+    public <R> Immutatorable<R> transform(Immutator<? extends R, ? super T> immutator) {
+      try {
+        return Actually.ok(immutator.invoke(this.value));
+      } catch (Exception e) {
+        return Actually.err(e);
+      }
+    }
+
+    @Override
+    public String toString() {
+      return "<" + value + ">";
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (obj == this) {
+        return true;
+      }
+      if (obj instanceof Success<?>) {
+        Success<?> other = (Success<?>) obj;
+        if (this.value == other.value) {
+          return true;
+        }
+        if (this.value != null && this.value.equals(other.value)) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+  }
+
+  private static class Failure extends Actually<Object> {
+    private final Exception e;
+
+    Failure(Exception e) {
+      this.e = e;
+    }
+
+    @Override
+    public Object unwrap() throws Exception {
+      throw e;
+    }
+
+    @Override
+    public Object except(Constant<? extends Object> c) {
+      return c.init();
+    }
+
+    @Override
+    public Object unless(Object other) {
+      return other;
+    }
+
+    @Override
+    public void finish(Action action) {
+      return;
+    }
+
+    @Override
+    public <R> Immutatorable<R> transform(Immutator<? extends R, ? super Object> immutator) {
+      return Actually.err(this.e);
+    }
+
+    @Override
+    public <R> Actually<R> next(Immutator<Actually<R>, Object> immutator) {
+      return Actually.err(this.e);
+
+    }
+
+    @Override
+    public String toString() {
+      return "[" + e.getClass().getName() + "] " + e.getMessage();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      if (obj == this) {
+        return true;
+      }
+      if (obj instanceof Failure) {
+        Failure other = (Failure) obj;
+        if (this.e == other.e) {
+          return true;
+        }
+        if (this.e == null || other.e == null) {
+          return false;
+        }
+        if (this.e.getMessage() == null || other.e.getMessage() == null) {
+          return false;
+        }
+        return this.e.getMessage() == other.e.getMessage();
+      }
+      return false;
+    }
+
+  }
+
+}

Lab5/cs2030s/fp/Constant.java

@@ -0,0 +1,5 @@
+package cs2030s.fp;
+
+public interface Constant<T> {
+  T init();
+}

Lab5/cs2030s/fp/Transformer.java

@@ -0,0 +1,23 @@
+package cs2030s.fp;
+
+public abstract class Transformer<R, P> implements Immutator<R, P> {
+  public <N> Transformer<R, N> after(Transformer<P, N> g) {
+    Transformer<R, P> f = this;
+    return new Transformer<R, N>() {
+      @Override
+      public R invoke(N param) {
+        return f.invoke(g.invoke(param));
+      }
+    };
+  }
+
+  public <T> Transformer<T, P> before(Transformer<T, R> g) {
+    Transformer<R, P> f = this;
+    return new Transformer<T, P>() {
+      @Override
+      public T invoke(P param) {
+        return g.invoke(f.invoke(param));
+      }
+    };
+  }
+}