softprops

libraryDependencies += Seq(
  "net.databinder" %% "unfiltered-filter" % "0.5.1",
  "net.databinder" %% "unfiltered-jetty" % "0.5.1",
)

casualjim

trait ActorSpecification extends BaseSpecification
   with ArgumentsArgs
   with ArgumentsShortcuts
   with MustThrownMatchers
   with ShouldThrownMatchers
   with FormattingFragments
   with StandardResults
   with StandardMatchResults
   with PendingUntilFixed
   with TimeHelpers

etorreborre

  "traverse left with Stream and IO" >> {
    implicit def traverseImplicit = StreamLeftTraverse

    var result: Seq[Int] = Seq()
    val f = (i: Int) => (result = result :+ i).pure[IO]

    (1 to 3).toStream.map(f).sequence.unsafePerformIO
    result must_== Seq(3, 2, 1)
  }
  "traverse right with Stream and IO" >> {

bhudgeons

import com.mongodb.casbah.Imports._

/*
 * Simple test of the MongoDB Aggregation Framework via Casbah
 * 
 * [Note: only works on MongoDB 2.1+]
 * 
 * The "students" collection consists of student test score records that [simplified] look like this:
 * 
   {

viktorklang

// ©2012 Viktor Klang

package akka.klang

import akka.dispatch.{ DispatcherPrerequisites, ExecutorServiceFactory, ExecutorServiceConfigurator }
import com.typesafe.config.Config
import java.util.concurrent.{ ExecutorService, AbstractExecutorService, ThreadFactory, TimeUnit }
import java.util.Collections
import javax.swing.SwingUtilities

kiritsuku

import scala.util.parsing.combinator.JavaTokenParsers
import scala.util.Try

/*
 * Compiles only with 2.10
 */
object Othello extends App with InputHandler {

  private[this] var game = Game.empty

stonegao

/**
 * Notes: This code uses AsyncValue[T], a custom class that uses actors
 * to allow concurrent operations on the provided type. It can be replaced
 * by an Atomic object from the java.util.concurrent package or something 
 * that provides similar functionality.
 */

/**
 * Resets the offsets for the given group / topic pair. 

pedrofurla

  def exp[T](t: => T) =
            (scala.util.control.Exception.allCatch either t).right

  def readJson(dataField:Option[String],json:JsValue):Either[Throwable,JsValue] = {
    for (
      contents <- exp( json.asJsObject.getFields("rsp")(0) );
      stat <- exp( contents.asJsObject.getFields("stat")(0).convertTo[String] );
      jsonObject <- exp (
        dataField match {
          case Some(field) => contents.asJsObject.getFields(field)(0)

jboner

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD

erwink

// ©2012 Viktor Klang

package akka.klang

import akka.dispatch.{ DispatcherPrerequisites, ExecutorServiceFactory, ExecutorServiceConfigurator }
import com.typesafe.config.Config
import java.util.concurrent.{ ExecutorService, AbstractExecutorService, ThreadFactory, TimeUnit }
import java.util.Collections
import javax.swing.SwingUtilities