Added simple Scala examples

Scala/.gitignore

@@ -0,0 +1,3 @@
+.idea/
+target/
+*.iml

Scala/src/Example.scala

@@ -0,0 +1,26 @@
+import doubleLinked.{DNil, DoubleLinked}
+import singleLinked.{SNil, SingleLinked}
+
+object Example {
+  def main(args: Array[String]): Unit = {
+    val list: SingleLinked[Int] = 1 :: 2 :: 3 :: SNil
+
+    list.foreach(item => print(s"$item\t"))
+    println()
+
+    list.map(_ + 1).foreach(item => print(s"$item\t"))
+    println()
+
+    list.flatMap(item => item :: item :: singleLinked.SNil).foreach(item => print(s"$item\t"))
+    println()
+
+
+    val list2: DoubleLinked[Int] = 1 :: 2 :: 3 :: DNil
+
+    list2.foreach(item => print(s"$item\t"))
+    println()
+
+    list2.map(_ + 1).foreach(item => print(s"$item\t"))
+    println()
+  }
+}

Scala/src/doubleLinked/DoubleLinked.scala

@@ -0,0 +1,60 @@
+package doubleLinked
+
+/**
+  * In case of double linked list we have to ignore some principles of functional programming
+  * and we have to make some fields of Node class mutable
+  * In other case we will have to recreate all list after any change
+  */
+
+sealed trait DoubleLinked[+A] {
+  def ::[B >: A](x: B): DoubleLinked[B] = {
+    DoubleLinked.append(x, this)
+  }
+
+  def foreach[B >: A](f: B => Unit): Unit = {
+    DoubleLinked.foreach(this)(f)
+  }
+
+  def map[B](f: A => B): DoubleLinked[B] = {
+    DoubleLinked.map(this, DNil)(f)
+  }
+}
+
+
+case object DNil extends DoubleLinked[Nothing]
+class Node[A](var prev: DoubleLinked[A], val value: A, var next: DoubleLinked[A]) extends DoubleLinked[A]
+
+
+object DoubleLinked {
+  def empty[A]: DoubleLinked[A] = DNil
+
+  def apply[A](values: A*): DoubleLinked[A] = values.foldLeft(DoubleLinked.empty[A])((list, item) => item :: list)
+
+  def append[A](x: A, list: DoubleLinked[A]): DoubleLinked[A] = {
+    val node = new Node(DNil, x, list)
+    list match {
+      case DNil => DNil
+      case l: Node[A] =>
+        l.prev = node
+    }
+
+    node
+  }
+
+  def foreach[A](list: DoubleLinked[A])(f: A => Unit): Unit = {
+    list match {
+      case DNil =>
+      case l: Node[A] =>
+        f(l.value)
+        l.next.foreach(f)
+    }
+  }
+
+  def map[A, B](list: DoubleLinked[A], prev: DoubleLinked[B])(f: A => B): DoubleLinked[B] = {
+    list match {
+      case DNil => DNil
+      case l: Node[A] =>
+        new Node(prev, f(l.value), map(l.next, prev)(f))
+    }
+  }
+}

Scala/src/singleLinked/SingleLinked.scala

@@ -0,0 +1,63 @@
+package singleLinked
+
+
+sealed trait SingleLinked[+A] {
+  def ::[B >: A](x: B): SingleLinked[B] = {
+    SingleLinked.::(x, this)
+  }
+
+  def foreach[B >: A](f: B => Unit): Unit = {
+    SingleLinked.foreach(this)(f)
+  }
+
+  def map[B](f: A => B): SingleLinked[B] = {
+    SingleLinked.map(this)(f)
+  }
+
+  def flatMap[B](f: A => SingleLinked[B]): SingleLinked[B] = {
+    SingleLinked.flatMap(this)(f)
+  }
+}
+
+
+case object SNil extends SingleLinked[Nothing]
+case class Node[+A](value: A, next: SingleLinked[A]) extends SingleLinked[A]
+
+
+object SingleLinked {
+  def empty[A]: SingleLinked[A] = SNil
+
+  def apply[A](values: A*): SingleLinked[A] = values.foldLeft(SingleLinked.empty[A])((list, item) => item :: list)
+
+  def ::[A](x: A, list: SingleLinked[A]): SingleLinked[A] = Node(x, list)
+
+  def foreach[A](list: SingleLinked[A])(f: A => Unit): Unit = {
+    list match {
+      case SNil =>
+      case Node(x, next) =>
+        f(x)
+        next.foreach(f)
+    }
+  }
+
+  def map[A, B](list: SingleLinked[A])(f: A => B): SingleLinked[B] = {
+    list match {
+      case SNil => SNil
+      case Node(x, next) => Node(f(x), next.map(f))
+    }
+  }
+
+  def merge[A](list1: SingleLinked[A], list2: SingleLinked[A]): SingleLinked[A] = {
+    list1 match {
+      case SNil => list2
+      case Node(x, next) => Node(x, merge(next, list2))
+    }
+  }
+
+  def flatMap[A, B](list: SingleLinked[A])(f: A => SingleLinked[B]): SingleLinked[B] = {
+    list match {
+      case SNil => SNil
+      case Node(x, next) => merge(f(x), next.flatMap(f))
+    }
+  }
+}