Use abstract classes.

Author: back2dos

.haxerc

@@ -1,4 +1,4 @@
 {
-  "version": "4.1.3",
+  "version": "4.2.1",
   "resolveLibs": "scoped"
 }

src/coconut/diffing/Cursor.hx

@@ -1,23 +1,28 @@
 package coconut.diffing;
 
-interface Cursor<Native> {
+abstract class Cursor<Native> {
   /**
     A reference back to the applicator that created this cursor.
   **/
-  final applicator:Applicator<Native>;
+  public final applicator:Applicator<Native>;
+  public function new(applicator)
+    this.applicator = applicator;
   /**
     Inserts a native node at the current cursor position.
 
     Please note that:
 
-    1. The native element may already be a child of the parent node being iterated over
-    2. The native element may even be at the current cursor position.
+    1. The native node may already be a child of the parent node being iterated over
+    2. The native node may even be at the current cursor position.
   **/
-  function insert(native:Native):Void;
+  public abstract function insert(native:Native):Void;
   /**
-    Delete `count` elements from the current position.
+    Delete `count` nodes from the current position.
   **/
-  function delete(count:Int):Void;
-  // TODO: document
-  function current():Null<Native>;
+  public abstract function delete(count:Int):Void;
+  /**
+    Returns the current node. Only used for hydration (which is only truly relevant for coconut.vdom)
+  **/
+  public function current():Null<Native>
+    return null;
 }

src/coconut/diffing/Factory.hx

@@ -2,25 +2,29 @@ package coconut.diffing;
 
 import coconut.ui.Ref;
 
-@:using(coconut.diffing.Factory.FactoryTools)
-interface Factory<Data, Native, Target:Native> {
-  final type:TypeId;
-  function create(data:Data):Target;
-  function adopt(target:Native):Null<Target>;
-  function hydrate(target:Target, data:Data):Void;
-  function update(target:Target, next:Data, prev:Data):Void;
-}
+abstract class Factory<Data, Native, Target:Native> {
+  public final type = new TypeId();
+
+  public abstract function create(data:Data):Target;
+  public abstract function update(target:Target, next:Data, prev:Data):Void;
+
+  /**
+    Only used in hydration (by coconut.vdom). The currently encountered native node is passed to `adopt`.
+    Return `null` if the wrong type of node is encountered.
+  **/
+  public function adopt(target:Native):Null<Target> return null;
+  /**
+    The actual implementation of the hydration (only used by coconut.vdom)
+  **/
+  public function hydrate(target:Target, data:Data):Void {}
 
-class FactoryTools {
-  static public function vnode<Data, Native, Concrete:Native, RenderResult:VNode<Native>>(f:Factory<Data, Native, Concrete>, data:Data, ?key:Key, ?ref:Ref<Concrete>, ?children:Children<RenderResult>):VNode<Native>
-    return new VNative<Data, Native, Concrete>(f, data, key, ref, children);
+  public function vnode<RenderResult:VNode<Native>>(data:Data, ?key:Key, ?ref:Ref<Target>, ?children:Children<RenderResult>):VNode<Native>
+    return new VNative<Data, Native, Target>(this, data, key, ref, children);
 }
 
 private typedef Dict<T> = Null<haxe.DynamicAccess<Null<T>>>;
 
-class Properties<Value, Native:{}, Target:Native> implements Factory<Dict<Value>, Native, Target> {
-
-  public final type = new TypeId();
+class Properties<Value, Native:{}, Target:Native> extends Factory<Dict<Value>, Native, Target> {
 
   final construct:()->Target;
   final apply:(target:Target, name:String, nu:Null<Value>, old:Null<Value>)->Void;
@@ -30,11 +34,6 @@ class Properties<Value, Native:{}, Target:Native> implements Factory<Dict<Value>
     this.apply = apply;
   }
 
-  public function adopt(target)
-    return null;
-
-  public function hydrate(target, data) {}
-
   public function create(data:Dict<Value>):Target {
     var ret = construct();
     update(ret, data, null);

tests/coconut/fake/DummyApplicator.hx

@@ -1,14 +1,13 @@
 package coconut.fake;
 
-class DummyCursor implements Cursor<Dummy> {
+class DummyCursor extends Cursor<Dummy> {
 
-  public final applicator:Applicator<Dummy>;
   static var idCounter = 0;
   var index:Int;
   final target:Dummy;
 
   public function new(applicator, target, index) {
-    this.applicator = applicator;
+    super(applicator);
     this.target = target;
     this.index = index;
   }
@@ -17,7 +16,7 @@ class DummyCursor implements Cursor<Dummy> {
     target.insert(index++, native);
   }
 
-  public function current()
+  override public function current()
     return target.getChild(index);
 
   public function delete(count:Int) {

tests/coconut/fake/DummyFactory.hx

@@ -1,9 +1,8 @@
 package coconut.fake;
 
-class DummyFactory implements Factory<Attr, Dummy, Dummy> {
+class DummyFactory extends Factory<Attr, Dummy, Dummy> {
 
   public final tag:String;
-  public final type:TypeId = new TypeId();
 
   public function new(tag) {
     this.tag = tag;
@@ -15,10 +14,10 @@ class DummyFactory implements Factory<Attr, Dummy, Dummy> {
     return ret;
   }
 
-  public function adopt(dummy)
+  override public function adopt(dummy)
     return dummy;
 
-  public function hydrate(dummy:Dummy, _) {
+  override public function hydrate(dummy:Dummy, _) {
     @:privateAccess dummy.wet = true;
   }