patriknw

package example

import java.util.concurrent.ConcurrentHashMap
import java.util.concurrent.ConcurrentLinkedQueue
import com.typesafe.config.Config
import com.typesafe.config.ConfigFactory
import akka.actor.Actor
import akka.actor.ActorContext
import akka.actor.ActorRef
import akka.actor.ActorSystem

travisbrown

/**
 * Digging through arbitrarily nested case classes, tuples, and lists
 * by Travis Brown
 *
 * In response to this question by Channing Walton on the Shapeless dev list:
 *
 *     https://groups.google.com/d/msg/shapeless-dev/hn7_U21tupI/Zm9h3uNb51gJ
 *
 * Tested with Scala 2.9.2 and Shapeless 1.2.3. Should work on 1.2.2 with minor edits.
 */

travisbrown

import shapeless._

trait Flatten[I, O <: HList] {
  def apply(i: I): O
}

trait FlattenLow {
  implicit def otherFlatten[I] = new Flatten[I, I :: HNil] {
    def apply(i: I) = i :: HNil
  }

etorreborre

import shapeless._

// if there's only one element, return it
trait ToTuple2 extends Poly1 {
  implicit def h2[T] = at[T :: HNil] { case t :: HNil => t }
}
// if there are at least 2 elements, tuple them
trait ToTuple1 extends ToTuple2 {
  implicit def h1[T1, T2, L <: HList, T <: T1 :: T2 :: L](implicit tupler: Tupler[T1 :: T2 :: L]) = at[T1 :: T2 :: L] { 
    case l @ (t1 :: t2 :: rest)  => l.tupled

jkodumal

// Based on shapeless 1.2.2
import shapeless._, HList._

trait RecIso[T, R] {
  def iso(t: T) : R
}

trait RecId[T] extends RecIso[T, T] {
  def iso(t: T) : T = t
}

viktorklang

import scala.concurrent._
import scala.collection.mutable.Builder
import scala.collection.generic.CanBuildFrom
import language.higherKinds

/**
 * Linearize asynchrnously applies a given function in-order to a sequence of values, producing a Future with the result of the function applications.
 * Execution of subsequent entries will be aborted if an exception is thrown in the application of the function.
 */
def linearize[T, U, C[T] <: Traversable[T]](s: C[T])(f: T => U)(implicit cbf: CanBuildFrom[C[T], U, C[U]], e: ExecutionContext): Future[C[U]] = {

sadache

Bits'bout Play2 Architecture

Play2 Simple HTTP API

Essential blueprint of Play2 architecture is pretty simple and it should be easy to explain in a fairly short blog post. The framework can be understood progressively at different levels; each time having better exposure to some aspects of its design.

The core of Play2 is really small, surrounded by a fair amount of useful APIs, services and structure to make Web Programming tasks easier.

Basically, Play2 is an API that abstractly have the folllowing type

YoEight

object Alacarte {
  trait Functor[F[_]]{
    def map[A, B](fa: F[A])(f: A => B): F[B]
  }
  
  trait Eval[F[_]] {
    def F: Functor[F]
	
    def evalAlgebra(fa: F[Int]): Int 
  }

guillaumebort

web: target/start -Dhttp.port=${PORT} -Dconfig.resource=prod.conf ${JAVA_OPTS}

viktorklang

trait Enum { //DIY enum type
  import java.util.concurrent.atomic.AtomicReference //Concurrency paranoia

  type EnumVal <: Value //This is a type that needs to be found in the implementing class

  private val _values = new AtomicReference(Vector[EnumVal]()) //Stores our enum values

  //Adds an EnumVal to our storage, uses CCAS to make sure it's thread safe, returns the ordinal
  private final def addEnumVal(newVal: EnumVal): Int = { import _values.{get, compareAndSet => CAS}
    val oldVec = get