Add tasks for all the new languages

Task/Delegates/NGS/delegates.ngs

@@ -0,0 +1,40 @@
+{
+	type Delegator
+
+	F init(d:Delegator) d.delegate = null
+
+	F default_impl(d:Delegator) 'default implementation'
+
+	F operation(d:Delegator) default_impl(d)
+
+	F operation(d:Delegator) {
+		guard defined thing
+		guard thing is Fun
+		try {
+			d.delegate.thing()
+		}
+		catch(e:ImplNotFound) {
+			# Might be unrelated exception, so check and optionally rethrow
+			e.callable !== thing throws e
+			default_impl(d)
+		}
+	}
+
+	F operation(d:Delegator) {
+		guard d.delegate is Null
+		default_impl(d)
+	}
+
+
+	a = Delegator()
+	echo(a.operation())
+
+	# There is no method thing(s:Str)
+	a.delegate = "abc"
+	echo(a.operation())
+
+	# ... now there is method thing(s:Str)
+	F thing(s:Str) 'delegate implementation'
+	echo(a.operation())
+	
+}

Task/Delegates/Oforth/delegates-1.oforth

@@ -0,0 +1,11 @@
+Object Class new: Delegate1
+
+Object Class new: Delegate2
+Delegate2 method: thing  "Delegate implementation" println ;
+
+Object Class new: Delegator(delegate)
+Delegator method: initialize  := delegate ;
+
+Delegator method: operation
+   @delegate respondTo(#thing) ifTrue: [ @delegate thing return ]
+   "Default implementation" println ;

Task/Delegates/Oforth/delegates-2.oforth

@@ -0,0 +1,8 @@
+Delegator new(null) operation
+Default implementation
+
+Delegator new(Delegate1 new) operation
+Default implementation
+
+Delegator new(Delegate2 new) operation
+Delegate implementation

Task/Delegates/Swift/delegates-1.swift

@@ -0,0 +1,33 @@
+import Foundation
+
+protocol Thingable { // prior to Swift 1.2, needs to be declared @objc
+  func thing() -> String
+}
+
+class Delegator {
+  weak var delegate: AnyObject?
+  func operation() -> String {
+    if let f = self.delegate?.thing {
+      return f()
+    } else {
+      return "default implementation"
+    }
+  }
+}
+
+class Delegate {
+  dynamic func thing() -> String { return "delegate implementation" }
+}
+
+// Without a delegate:
+let a = Delegator()
+println(a.operation())    // prints "default implementation"
+
+// With a delegate that does not implement thing:
+a.delegate = "A delegate may be any object"
+println(a.operation())    // prints "default implementation"
+
+// With a delegate that implements "thing":
+let d = Delegate()
+a.delegate = d
+println(a.operation())    // prints "delegate implementation"

Task/Delegates/Swift/delegates-2.swift

@@ -0,0 +1,27 @@
+protocol Thingable : class {
+  func thing() -> String
+}
+
+class Delegator {
+  weak var delegate: Thingable?
+  func operation() -> String {
+    if let d = self.delegate {
+      return d.thing()
+    } else {
+      return "default implementation"
+    }
+  }
+}
+
+class Delegate : Thingable {
+  func thing() -> String { return "delegate implementation" }
+}
+
+// Without a delegate:
+let a = Delegator()
+println(a.operation())    // prints "default implementation"
+
+// With a delegate:
+let d = Delegate()
+a.delegate = d
+println(a.operation())    // prints "delegate implementation"