bbq2100

def throwableToLeft[T](block: => T): Either[Throwable, T] = {
  try {
    Right(block)
  }
  catch {
    case ex: Throwable => Left(ex)
  }
}

val r = throwableToLeft {

bbq2100

val languages: Seq[String] = Seq("Scala", "Haskell", "OCaml", "ML")
languages(1)

val default: PartialFunction[Int, String] = {
  case _=> "Is it a FP language???"
}

val languageWithDefault = languages orElse default
languageWithDefault(15)

bbq2100

import java.util
import java.util.{Collection => JCollection, ArrayList}

class JavaToTraversable[E] (javaCollection: JCollection[E]) extends Traversable[E] {
  override def foreach[U](f: (E) => U): Unit = {
    val iterator = javaCollection.iterator()
    while(iterator.hasNext) {
      f(iterator.next())
    }
  }

bbq2100

def mapPatternMatching[A, B](xs: List[A], f: A => B): List[B] = {
  xs match {
    case List() => scala.Nil
    case head :: tail => f(head) :: mapPatternMatching(tail, f)
  }
}

//map(List(1, 2, 3), (x: Int) => x + 1)

def mapForComprehension[A, B](xs: List[A], f: A => B) = {

bbq2100

def position[A](list: List[A], element: A) = {
  val index: Int = list indexOf (element)
  if (index == -1) Nil
  else Just(index)
}

sealed abstract class Maybe[+A] {
  def isEmpty: Boolean

  def get: A

bbq2100

static class RestServlet extends HttpServlet {

		public void addConfiguration(String key, String value) {
			response.put(key, value);
		}
		
		private Map<String, String> response = new HashMap<String, String>();
		
		public RestServlet() {
			response.put("/autos",  Arrays.asList("BMW", "Mercedes").toString());

bbq2100

//-----------------------------------------------------------------------
    /**
     * Parses the given pattern and appends the rules to the given
     * DateTimeFormatterBuilder.
     *
     * @param pattern  pattern specification
     * @throws IllegalArgumentException if the pattern is invalid
     * @see #forPattern
     */
    private static void parsePatternTo(DateTimeFormatterBuilder builder, String pattern) {