jedws

import com.atlassian.util.scala.concurrent.Atomic //https://bitbucket.org/jwesleysmith/atlassian-util-scala/src/tip/src/main/scala/com/atlassian/util/scala/concurrent/Atomic.scala

package patterns {

final class TreiberStack[A] {
  private[this] val head = Atomic[Node[A]](End)
  @annotation.tailrec
  def pop: Option[A] = head.value match {
    case l @ Link(a, prev) => if (head.compareAndSet(l, prev)) Some(a) else pop
    case _                 => None

jedws

sealed trait Heading {
  val turn = Turn(this) _
}
case object N extends Heading
case object S extends Heading
case object E extends Heading
case object W extends Heading

object Turn {
  def apply(h: Heading)(t: Turn) = t(h)

jedws

  val nonIgnoredFields = {
    @annotation.tailrec
    def loop(k: Class[_], fields: List[Array[Field]]): List[Array[Field]] = {
      if (k == null) fields
      else
        loop(k.getSuperclass, k.getDeclaredFields.filterNot(ignoreField _).reverse :: fields)
    }
    loop(klass, Nil).flatten
  }

jedws

object Sort {
  def qsort[A, CC[A] <: TraversableLike[A, CC[A]]](c: CC[A])(implicit ord : Ordering[A], bf: CanBuildFrom[CC[A], A, CC[A]]) : CC[A] = {
    if (c.isEmpty || c.tail.isEmpty) c
    else {
      val pivot = c.head
      val (low: CC[A], high: CC[A]) = c.tail.partition{ ord.lt(_, pivot) }
      qsort(low) ++ bf().+=(pivot).result ++ qsort(high)
    }
  }
}

jedws

trait Threaded[T] extends Runnable {

  @volatile private var stopping = false
  @volatile private var thread: Thread = _

  def afterPropertiesSet() {
    thread = new Thread(this)
    thread.start()
  }

jedws

/**
 * A functional Conway's game of life.
 */
package object conway {

  type Coord[A] = (Int, Int) => A
  type Calculator = Coord[Coord[Boolean] => Boolean]
  type Size = Int

  val nextCell: Boolean => Int => Boolean = 

jedws

/**
 * A functional Conway's game of life.
 */
package object conwaydef {

  type Coord[A] = (Int, Int) => A
  type Calculator = Coord[Coord[Boolean] => Boolean]
  type Size = Int

  def nextCell(old: Boolean)(mates: Int) = if (mates > 3) false else if (mates == 3) true else (old && mates == 2)

jedws

package object conway3 {

  type Gen = (Int, Int) => Boolean
  type Calculator = Gen => Gen
  type Size = Int

  val nextCell: Boolean => Int => Boolean =
    old => mates => if (mates > 3) false else if (mates == 3) true else (old && mates == 2)

  val wrapper: Size => Int => Int =

jedws

object ZipWith {
  implicit def pimpToZipWith[A, CC[A] <: Iterable[A]](cc: CC[A]) = new ZipWith(cc)

  class ZipWith[A, CC[A] <: Iterable[A]](cc: CC[A]) {
    import collection.generic.CanBuildFrom

    def zipWith[B](f: A => B)(implicit cbf: CanBuildFrom[CC[A], (A, B), CC[(A, B)]]): CC[(A, B)] = {
      val builder = cbf()
      cc foreach { a => builder += (a -> f(a)) }
      builder.result

jedws

/**
 * A simple implementation of a Banker's Queue http://www.cs.cmu.edu/~rwh/theses/okasaki.pdf 3.4.2.
 * 
 * Note that this implementation differs slightly from the one described in the original
 * paper in that the reverse operation is performed only when the out/front list is empty.
 * This is done purely to simplify this example implementation. 
 */
sealed trait BankersQueue[+A] {
  /** The head element of the queue, or an exception if empty. */
  def head: A