retronym

class A
class A2 extends A
class B

trait M[X]

//
// Upper Type Bound
//
def upperTypeBound[AA <: A](x: AA): A = x

nuxlli

Sublime Text 2 - Useful Shortcuts

Tested in Mac OS X: super == command

Open/Goto

---

• super+t: go to file
• super+ctrl+p: go to project
• super+r: go to methods

xeno-by

Answers http://stackoverflow.com/questions/10373318/mixing-in-a-trait-dynamically.

Compile as follows:
scalac Common_1.scala Macros_2.scala
scalac Common_1.scala Test_3.scala -cp <path to the result of the previous compilation>

Tested in 2.10.0-M3, will most likely not compile by the time 2.10.0 final is released, because we're actively rehashing the API. 
However the principles will remain the same in the final release, so the concept itself is okay.
upd. Code updated for 2.10.0-M7.
upd. Code updated for 2.10.0-RC1.

jvranish

{-# LANGUAGE Rank2Types
           , RebindableSyntax
           , ImplicitParams
           , NoMonomorphismRestriction #-}

import Data.Maybe
import Data.Function
import Data.String
import Prelude (undefined, error, String, (++))

gist:4450690

import scala.reflect.macros.Context
import language.experimental.macros

case class EnclosingApplication(tree: scala.reflect.runtime.universe.Tree)

object Macros {
  def impl(c: Context): c.Expr[EnclosingApplication] = {
    import c.universe._
    import treeBuild._

xeno-by

import language.experimental.macros
import language.implicitConversions
import scala.reflect.macros.Context
import scala.reflect.runtime.universe.Tree

class ReflectiveClosure[A, B](val tree: Tree, fn: Function1[A, B]) extends Function1[A, B] {
  def apply(x: A) = fn(x)
}

object ReflectiveClosure {

pthariensflame

The Indexed State Monad in Haskell, Scala, and C#

Have you ever had to write code that made a complex series of succesive modifications to a single piece of mutable state? (Almost certainly yes.)

Did you ever wish you could make the compiler tell you if a particular operation on the state was illegal at a given point in the modifications? (If you're a fan of static typing, probably yes.)

If that's the case, the indexed state monad can help!

Motivation

jhickner

import Control.Proxy
import Control.Proxy.TCP

main :: IO ()
main = serve (Host "0.0.0.0") "8000" $ \(socket,_) ->
         runProxy $ socketReadS 4096 socket >-> socketWriteD socket

jamesward

Modern Web Apps with Play Framework

Create an app:

play new foo
cd foo

Add dependencies to project/Build.scala:

mzero

#!/bin/sh

inPreprocessorMode () {
    hasE=0
    hasU=0
    hasT=0
    for arg in "$@"
    do
        if [ 'x-E' = "x$arg" ];             then hasE=1; fi
        if [ 'x-undef' = "x$arg" ];         then hasU=1; fi