Ensemble

import scala.annotation.tailrec

sealed trait Ensemble[+A]

case object Eli extends Ensemble[Nothing]
case class Cons[+A](head: A, tail: Ensemble[A]) extends Ensemble[A]

object Ensemble {
  def add[A](a: A, list: Ensemble[A]): Ensemble[A] = Cons(a, list)
  def printEnsemble[A](a: Ensemble[A]): Unit = a match {
    case Eli => print("Nil\n")
    case Cons(head, tail) => { print(head + " "); printEnsemble(tail) }
  }

  def fallLeft[A](en: Ensemble[A])(f: (A, A) => A): A = {
    val Cons(a, b) = en
    @tailrec
    def go(en: Ensemble[A], a: A): A = en match {
      case Eli => a
      case Cons(head, tail) => go(tail, f(head, a))
    }
    go(b, a)
  }

  def foldLeft[A,B](en: Ensemble[A], b: B)(f: (A, B) => B): B = en match {
    case Eli => b
    case Cons(head, tail) => foldLeft(tail, f(head, b))(f)
  }

  def map[A,B](en: Ensemble[A])(f: (A) => B): Ensemble[B] = en match {
    case Eli => Eli
    case Cons(head, tail) => Cons(f(head), map(tail)(f))
  }

  def filter[A](en: Ensemble[A])(p: (A) => Boolean): Ensemble[A] = en match {
    case Eli => en
    case Cons(head, tail) if p(head) => Cons(head, filter(tail)(p))
    case Cons(_, tail) => filter(tail)(p)
  }

  def length[A](en: Ensemble[A]): Int = foldLeft(en, 0)((a, b) => b + 1)

}

val simpleIntList = Cons(0, Cons(1, Cons(2, Cons(3, Eli))))
val plusOneList = Ensemble.map(simpleIntList)(_ + 1)
Ensemble.printEnsemble(Ensemble.filter(plusOneList)(_ >= 2))
val l: Int = Ensemble.length(plusOneList)
println(l)