gszeliga

import java.util.Date

abstract class Census
abstract class Translation
abstract class Passport

object VisaRequest {

  def apply(to: Someone, at: String) = new VisaRequest(to, at)

gszeliga

import java.util.Date

trait Translation
trait MissingTranslation
trait AnyTrans extends Translation with MissingTranslation

trait Certificate
trait MissingCertificate
trait AnyCert extends Certificate with MissingCertificate

gszeliga

trait Future[+A] {
  private def apply(k: A => Unit): Unit
}

type Par[+A] = ExecutorService => Future[A]

def map2[A, B, C](pa: Par[A], pb: Par[B])(f: (A, B) => C): Par[C] = {

  ex =>
	{

gszeliga

import java.util.concurrent.ExecutorService
import java.util.concurrent.Callable
import java.util.concurrent.atomic.AtomicReference
import java.util.concurrent.atomic.AtomicInteger
import scala.annotation.tailrec

final case class Actor[A](strategy: Strategy)(handler: A => Unit, onError: Throwable => Unit = throw (_)) {

  private class Node[A](var a: A = null.asInstanceOf[A]) extends AtomicReference[Node[A]]

gszeliga

import scala.util.parsing.input.Reader
import scala.util.parsing.input.CharArrayReader.EofCh
import scala.util.parsing.input.Position

case class ByteOffsetPosition(offset: Int) extends Position {
  final val line = 1 
  def column = offset + 1
  def lineContents: String = ""
} 

gszeliga

trait BencodeConstants {
  final val DEFAULT_STRING_ENCODING = "ISO-8859-15"
  final val DEFAULT_NUMBER_ENCODING = "US-ASCII"

  final val NUMBER_BEGIN: Char = 'i'
  final val NUMBER_END: Char = 'e'

  final val LIST_BEGIN = 'l'
  final val LIST_END = 'e'

gszeliga

trait BencodeParser extends Parsers with BencodeConstants {

  type Elem = Byte

  implicit def charToParser(ch: Char) = elem(ch.toByte)

  def delimitedBy[A](left: Parser[Byte], right: Parser[Byte])(p: Parser[A]): Parser[A] = left ~> p <~ right

  def single_digit = new Parser[String] {

gszeliga

def ~> [U](q: => Parser[U]): Parser[U] = { lazy val p = q // lazy argument
  (for(a <- this; b <- p) yield b).named("~>")
}

gszeliga

  def natural = rep1(single_digit) ^^ (_.mkString.toInt) named ("natural")

  def signedInt = new Parser[Int] {
    def apply(in: Input) = {
      '-'(in) match {
        case Success(_, rest) => natural(rest) map (_ * -1)
        case _ => natural(in)
      }
    }
  } named ("signed_int")

gszeliga

  def list: Parser[BList] = {
    delimitedBy(LIST_BEGIN, LIST_END) {
      rep(string | int | list | dict)
    } ^^ (BList(_)) named ("list")
  }

  def dict: Parser[BDict] = {
    delimitedBy(DICT_BEGIN, DICT_END) {
      rep(string ~ (string | int | list | dict))
    } ^^ (_.map { case key ~ value => key -> value }) ^^ (l => BDict(l.toMap)) named ("dict")