--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/main/java/fj/Effect.java	Fri Mar 20 21:04:03 2015 +0900
@@ -0,0 +1,113 @@
+package fj;
+
+import fj.function.Effect0;
+import fj.function.Effect1;
+import fj.function.Effect2;
+import fj.function.Effect3;
+import fj.function.Effect4;
+import fj.function.Effect5;
+import fj.function.Effect6;
+import fj.function.Effect7;
+import fj.function.Effect8;
+
+import static fj.Unit.unit;
+
+/**
+ * Represents a side-effect.
+ *
+ * @version %build.number%
+ */
+public class Effect {
+
+	private Effect() {}
+
+    public static P1<Unit> f(Effect0 e) {
+        return P.lazy(u -> unit());
+    }
+
+    /**
+   * Returns a function for the given effect.
+   *
+   * @return The function using the given effect.
+   */
+  public static final <A> F<A, Unit> f(Effect1<A> e1) {
+    return a -> {
+        e1.f(a);
+        return unit();
+    };
+  }
+
+    public static <A, B> F2<A, B, Unit> f(Effect2<A, B> e) {
+        return (a, b) -> {
+            e.f(a, b);
+            return unit();
+        };
+    }
+
+    public static <A, B, C> F3<A, B, C, Unit> f(Effect3<A, B, C> e) {
+        return (a, b, c) -> {
+            e.f(a, b, c);
+            return unit();
+        };
+    }
+
+    public static <A, B, C, D> F4<A, B, C, D, Unit> f(Effect4<A, B, C, D> e) {
+        return (a, b, c, d) -> {
+            e.f(a, b, c, d);
+            return unit();
+        };
+    }
+
+    public static <A, B, C, D, E> F5<A, B, C, D, E, Unit> f(Effect5<A, B, C, D, E> z) {
+        return (a, b, c, d, e) -> {
+            z.f(a, b, c, d, e);
+            return unit();
+        };
+    }
+
+    public static <A, B, C, D, E, $F> F6<A, B, C, D, E, $F, Unit> f(Effect6<A, B, C, D, E, $F> z) {
+        return (a, b, c, d, e, f) -> {
+            z.f(a, b, c, d, e, f);
+            return unit();
+        };
+    }
+
+    public static <A, B, C, D, E, $F, G> F7<A, B, C, D, E, $F, G, Unit> f(Effect7<A, B, C, D, E, $F, G> z) {
+        return (a, b, c, d, e, f, g) -> {
+            z.f(a, b, c, d, e, f, g);
+            return unit();
+        };
+    }
+
+    public static <A, B, C, D, E, $F, G, H> F8<A, B, C, D, E, $F, G, H, Unit> f(Effect8<A, B, C, D, E, $F, G, H> z) {
+        return (a, b, c, d, e, f, g, h) -> {
+            z.f(a, b, c, d, e, f, g, h);
+            return unit();
+        };
+    }
+
+    /**
+   * A contra-variant functor on effect.
+   *
+   * @param f The function to map over the effect.
+   * @return An effect after a contra-variant map.
+   */
+  public final <A, B> Effect1<B> comap(Effect1<A> e1, final F<B, A> f) {
+    return new Effect1<B>() {
+      public void f(final B b) {
+        e1.f(f.f(b));
+      }
+    };
+  }
+  
+  public static <A> Effect1<A> lazy(final F<A, Unit> f) {
+    return new Effect1<A>() {
+      public void f(final A a) {
+        f.f(a);
+      }
+    };
+  }
+
+//	public static <A> void f(Effect1<A> )
+
+}