Add tasks for all the new languages

Task/Doubly-linked-list-Definition/Nim/doubly-linked-list-definition.nim

@@ -0,0 +1,68 @@
+type
+  List[T] = object
+    head, tail: Node[T]
+
+  Node[T] = ref TNode[T]
+
+  TNode[T] = object
+    next, prev: Node[T]
+    data: T
+
+proc initList[T](): List[T] = discard
+
+proc newNode[T](data: T): Node[T] =
+  new(result)
+  result.data = data
+
+proc prepend[T](l: var List[T], n: Node[T]) =
+  n.next = l.head
+  if l.head != nil: l.head.prev = n
+  l.head = n
+  if l.tail == nil: l.tail = n
+
+proc append[T](l: var List[T], n: Node[T]) =
+  n.next = nil
+  n.prev = l.tail
+  if l.tail != nil:
+    l.tail.next = n
+  l.tail = n
+  if l.head == nil:
+    l.head = n
+
+proc insertAfter[T](l: var List[T], r, n: Node[T]) =
+  n.prev = r
+  n.next = r.next
+  n.next.prev = n
+  r.next = n
+  if r == l.tail: l.tail = n
+
+proc remove[T](l: var List[T], n: Node[T]) =
+  if n == l.tail: l.tail = n.prev
+  if n == l.head: l.head = n.next
+  if n.next != nil: n.next.prev = n.prev
+  if n.prev != nil: n.prev.next = n.next
+
+proc `$`[T](l: var List[T]): string =
+  result = ""
+  var n = l.head
+  while n != nil:
+    if result.len > 0: result.add(" -> ")
+    result.add($n.data)
+    n = n.next
+
+var l = initList[int]()
+var n = newNode(12)
+var m = newNode(13)
+var i = newNode(14)
+var j = newNode(15)
+l.append(n)
+l.prepend(m)
+l.insertAfter(m, i)
+l.prepend(j)
+l.remove(m)
+echo l
+
+var l2 = initList[string]()
+l2.prepend newNode("hello")
+l2.append newNode("world")
+echo l2

Task/Doubly-linked-list-Definition/Oforth/doubly-linked-list-definition.oforth

@@ -0,0 +1,50 @@
+Object Class new: DNode(value, mutable prev, mutable next)
+
+DNode method: initialize  := next := prev := value ;
+DNode method: value  @value ;
+DNode method: prev  @prev ;
+DNode method: next  @next ;
+DNode method: setPrev := prev ;
+DNode method: setNext  := next ;
+DNode method: <<  @value << ;
+
+DNode method: insertAfter(node)
+   node setPrev(self)
+   node setNext(@next)
+   @next ifNotNull: [ @next setPrev(node) ]
+   node := next ;
+
+// Double linked list definition
+Collection Class new: DList(mutable head, mutable tail)
+DList method: head  @head ;
+DList method: tail  @tail ;
+
+DList method: insertFront(v)
+| p |
+   @head ->p
+   DNode new(v, null, p) := head
+   p ifNotNull: [ p setPrev(@head) ]
+   @tail ifNull: [ @head := tail ] ;
+
+DList method: insertBack(v)
+| n |
+   @tail ->n
+   DNode new(v, n, null) := tail
+   n ifNotNull: [ n setNext(@tail) ]
+   @head ifNull: [ @tail := head ] ;
+
+DList method: forEachNext
+   dup ifNull: [ drop @head ifNull: [ false ] else: [ @head @head true] return ]
+   next dup ifNull: [ drop false ] else: [ dup true ] ;
+
+DList method: forEachPrev
+   dup ifNull: [ drop @tail ifNull: [ false ] else: [ @tail @tail true] return ]
+   prev dup ifNull: [ drop false ] else: [ dup true ] ;
+
+: test      // ( -- aDList )
+| dl dn |
+   DList new ->dl
+   dl insertFront("A")
+   dl insertBack("B")
+   dl head insertAfter(DNode new("C", null , null))
+   dl ;