Time for an 2014 update…

Task/Parametric-polymorphism/Dart/parametric-polymorphism.dart

@@ -0,0 +1,42 @@
+class TreeNode<T> {
+
+  T value;
+  TreeNode<T> left;
+  TreeNode<T> right;
+
+  TreeNode(this.value);
+
+  TreeNode map(T f(T t)) {
+    var node = new TreeNode(f(value));
+    if(left != null) {
+      node.left = left.map(f);
+    }
+    if(right != null) {
+      node.right = right.map(f);
+    }
+    return node;
+  }
+
+  void forEach(void f(T t)) {
+    f(value);
+    if(left != null) {
+      left.forEach(f);
+    }
+    if(right != null) {
+      right.forEach(f);
+    }
+  }
+}
+
+void main() {
+  TreeNode root = new TreeNode(1);
+  root.left = new TreeNode(2);
+  root.right = new TreeNode(3);
+  root.left.right = new TreeNode(4);
+
+  print('first tree');
+  root.forEach(print);
+  var newRoot = root.map((t) => t * 222);
+  print('second tree');
+  newRoot.forEach(print);
+}

Task/Parametric-polymorphism/Icon/parametric-polymorphism.icon

@@ -0,0 +1,10 @@
+procedure main()
+    bTree := [1, [2, [4, [7]], [5]], [3, [6, [8], [9]]]]
+    mapTree(bTree, write)
+    bTree := [1, ["two", ["four", [7]], [5]], [3, ["six", ["eight"], [9]]]]
+    mapTree(bTree, write)
+end
+
+procedure mapTree(tree, f)
+    every f(\tree[1]) | mapTree(!tree[2:0], f)
+end

Task/Parametric-polymorphism/Perl-6/parametric-polymorphism.pl6

@@ -1,12 +1,12 @@
 role BinaryTree[::T] {
-    has T $!value;
+    has T $.value;
     has BinaryTree[T] $.left;
     has BinaryTree[T] $.right;
 
     method replace-all(T $value) {
         $!value = $value;
-        $.left.?replace-all($value);
-        $.right.?replace-all($value);
+        $!left.replace-all($value) if $!left.defined;
+        $!right.replace-all($value) if $!right.defined;
     }
 }
 

Task/Parametric-polymorphism/REXX/parametric-polymorphism.rexx

@@ -0,0 +1,35 @@
+/*REXX program demonstrates a method of parametric polymorphism in REXX.*/
+call newRoot  1.00, 3                  /*new root and indicate 3 stems. */
+                                       /* [↓] no need to label the stems*/
+call addStem  1.10                     /*new stem and its initial value.*/
+call addStem  1.11                     /* "    "   "   "     "      "   */
+call addStem  1.12                     /* "    "   "   "     "      "   */
+call addStem  1.20                     /* "    "   "   "     "      "   */
+call addStem  1.21                     /* "    "   "   "     "      "   */
+call addStem  1.22                     /* "    "   "   "     "      "   */
+call sayNodes                          /*display nicely formatted values*/
+call modRoot  50                       /*MOD will add 50 to all stems.  */
+call sayNodes                          /*display nicely formatted values*/
+exit                                   /*stick a fork in it, we're done.*/
+/*──────────────────────────────────MODROOT─────────────────────────────*/
+modRoot:       do j=1  for nodes       /*traipse through all the nodes. */
+                  do k=1  for stems;     _=root.j.k;     ?=datatype(_,'N')
+                  if ?  then root.j.k=_+arg(1)   /*can stem be added to?*/
+                  end   /*k*/          /* [↑]  only add if it's numeric.*/
+               end      /*j*/
+return
+/*──────────────────────────────────NEWROOT─────────────────────────────*/
+newRoot: stems=arg(2);  nodes=-1;      /*set NODES to a kind of "null". */
+call addStem copies('─',9);              call addStem arg(1)
+return
+/*──────────────────────────────────SAYNODES────────────────────────────*/
+sayNodes: say;     do j=0  to nodes;      _=      /*each node gets shown*/
+                      do k=1  for stems;  _=_ right(root.j.k,9); end /*k*/
+                   say substr(_,2)                /*ignore the 1st blank*/
+                   end      /*j*/
+
+say left('', stems*9+stems) || '('nodes" nodes)"  /*also show # of nodes*/
+return
+/*──────────────────────────────────ADDSTEM─────────────────────────────*/
+addStem: nodes=nodes+1;  do j=1 for stems;  root.nodes.j=arg(1); end /*j*/
+return

Task/Parametric-polymorphism/Visual-Prolog/parametric-polymorphism.pro

@@ -0,0 +1,19 @@
+domains
+   tree{Type} = branch(tree{Type} Left, tree{Type} Right); leaf(Type Value).
+
+class predicates
+   treewalk : (tree{X},function{X,Y}) -> tree{Y} procedure (i,i).
+
+clauses
+   treewalk(branch(Left,Right),Func) = branch(NewLeft,NewRight) :-
+        NewLeft = treewalk(Left,Func), NewRight = treewalk(Right,Func).
+
+   treewalk(leaf(Value),Func) = leaf(X) :-
+        X = Func(Value).
+
+   run():-
+       init(),
+       X = branch(leaf(2), branch(leaf(3),leaf(4))),
+       Y = treewalk(X,addone),
+       write(Y),
+       succeed().