Add tasks for all the new languages

Task/Pattern-matching/EchoLisp/pattern-matching-1.echolisp

@@ -0,0 +1,27 @@
+;; code adapted from Racket and Common Lisp
+;; Illustrates matching on structures
+(require 'match)
+(require 'struct)
+
+
+(define (N-tostring n) (format "%s %d"  (N-color n) (N-value n)))
+(struct N (color left value right) #:tostring N-tostring)
+
+(define (balance t)
+  (match t
+    [(N '⚫️ (N '🔴 (N '🔴 a x b) y c) z d) (N '🔴 (N '⚫️ a x b) y (N '⚫️ c z d))]
+    [(N '⚫️ (N '🔴 a x (N '🔴 b y c)) z d) (N '🔴 (N '⚫️ a x b) y (N '⚫️ c z d))]
+    [(N '⚫️ a x (N '🔴 (N '🔴 b y c) z d)) (N '🔴 (N '⚫️ a x b) y (N '⚫️ c z d))]
+    [(N '⚫️ a x (N '🔴 b y (N '🔴 c z d))) (N '🔴 (N '⚫️ a x b) y (N '⚫️ c z d))]
+    [else t]))
+
+    (define (ins value: x  tree: t)
+    (match t
+      ['empty (N '🔴 'empty x 'empty)]
+      [(N c l v r) (cond [(< x v) (balance (N c (ins x l) v r))]
+                         [(> x v) (balance (N c l v (ins x r)))]
+                         [else t])]))
+
+	(define (insert value: x tree: s)
+  		(match (ins x s) [(N _ l v r) (N '⚫️ l v r)]))
+  	

Task/Pattern-matching/EchoLisp/pattern-matching-2.echolisp

@@ -0,0 +1,8 @@
+(define (t-show n (depth 0))
+	(when (!eq? 'empty n)
+		(t-show (N-left n) (+ 12 depth))
+		(writeln (string-pad-left (format "%s" n ) depth))
+		(t-show (N-right n) (+ 12 depth))))
+
+(define T (for/fold [t 'empty] ([i 32]) (insert (random 100) t)))
+(t-show T)

Task/Pattern-matching/Swift/pattern-matching.swift

@@ -0,0 +1,37 @@
+enum Color { case R, B }
+enum Tree<A> {
+  case E
+  indirect case T(Color, Tree<A>, A, Tree<A>)
+}
+
+func balance<A>(input: (Color, Tree<A>, A, Tree<A>)) -> Tree<A> {
+  switch input {
+  case let (.B, .T(.R, .T(.R,a,x,b), y, c), z, d): return .T(.R, .T(.B,a,x,b), y, .T(.B,c,z,d))
+  case let (.B, .T(.R, a, x, .T(.R,b,y,c)), z, d): return .T(.R, .T(.B,a,x,b), y, .T(.B,c,z,d))
+  case let (.B, a, x, .T(.R, .T(.R,b,y,c), z, d)): return .T(.R, .T(.B,a,x,b), y, .T(.B,c,z,d))
+  case let (.B, a, x, .T(.R, b, y, .T(.R,c,z,d))): return .T(.R, .T(.B,a,x,b), y, .T(.B,c,z,d))
+  case let (col, a, x, b)                        : return .T(col, a, x, b)
+  }
+}
+
+func insert<A : Comparable>(x: A, s: Tree<A>) -> Tree<A> {
+  func ins(s: Tree<A>) -> Tree<A> {
+    switch s {
+    case     .E           : return .T(.R,.E,x,.E)
+    case let .T(col,a,y,b):
+      if x < y {
+        return balance((col, ins(a), y, b))
+      } else if x > y {
+        return balance((col, a, y, ins(b)))
+      } else {
+        return s
+      }
+    }
+  }
+  switch ins(s) {
+  case let .T(_,a,y,b): return .T(.B,a,y,b)
+  case     .E:
+    assert(false)
+    return .E
+  }
+}