nuclearace

abstract class Cloneable[T <: Cloneable[T]] {
  def clone(original: T): T
}

class TestChild(name: String) extends Cloneable[TestChild] {
  def clone(original: TestChild) = {
    new TestChild(original.name)
  }
}

nuclearace

abstract class AbsIterator {
	type T
	def hasNext: Boolean
	def next: T
}

trait RichIterator extends AbsIterator {
	def foreach(f: T => Unit) { while (hasNext) f(next) }
}

nuclearace

trait Logger {
  def log(msg: String)(implicit logType: String) = {
    println(s"${logType}: ${msg}")
  }
}

object DefaultLogger extends Logger

class SomeClass {
  implicit val logType = "SomeClass"

nuclearace

trait BobLike {
  val name = "Bob"
}

trait PersonLike {
    var money: Double
    
    def isWealthy = money > 10000000
}

nuclearace

extension Array {
    mutating func appendReturn(item: Array.Element)-> Array.Element {
        self.append(item)
        return item
    }
}

nuclearace

import Foundation

enum Coin: Int, CustomStringConvertible {
    case Tails, Heads
    
    var description: String {
        if self == .Tails {
            return "T"
        } else {
            return "H"

nuclearace

object Main extends App {
  implicit val queue: dispatch.queue = "goodbyeQueue"
  
  def sayHello = () => {println("hello")}
  def sayGoodbye = () => {println("goodbye")}

  dispatch.async(sayHello)("helloQueue")
  dispatch async sayGoodbye
}

nuclearace

enum Testing: String {
    case Thing = "thing"
    case Bob = {.Bob + "hello"}
}

nuclearace

class Test {
    struct Inside {
        
    }
}

let a = [Test.Inside]()

nuclearace

struct Bob {
    let lastName: String
    
    static var creth: Bob {
        return Bob(lastName: "Creth")
    }
    
    static func bobNamedFlumper() -> Bob {
        return Bob(lastName: "Flumper")
    }