retronym

class A
class A2 extends A
class B

trait M[X]

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

debasishg

// for comprehension
scala> for {
     |   l <- List(2,5,10)
     |   m <- List(8,10,11)
     | } yield l * m
res17: List[Int] = List(16, 20, 22, 40, 50, 55, 80, 100, 110)

// map a pure function into applicatives
scala> List(8,10,11) <*> (List(2,5,10) map (((_: Int) * (_: Int)).curried))
res18: List[Int] = List(16, 20, 22, 40, 50, 55, 80, 100, 110)

viktorklang

//Usage: 
//override def pomPostProcess(node: Node): Node = mcPom(moduleConfigurations)(super.pomPostProcess(node))

trait McPom { self: DefaultProject =>
  import scala.xml._

  def mcPom(mcs: Set[ModuleConfiguration])(node: Node): Node = {
    //make sure we have a trailing slash so we deduplicate URLs properly
    def cleanUrl(url: String) = url match {
      case null => ""

oxbowlakes

/**
 * Part Zero : 10:15 Saturday Night
 *
 * (In which we will see how to let the type system help you handle failure)...
 *
 * First let's define a domain. (All the following requires scala 2.9.x and scalaz 6.0)
 */

import scalaz._
import Scalaz._

dcsobral

// Based on Fantom's word count example here: http://blog.joda.org/2011/11/guide-to-evaluating-fantom.html
// I'm commenting the lines that need changing, and leaving a few of them uncommented, 
// as they are the same

// class WordCount {
   object WordCount {
//  Void main(Str[] args) {
    def main(args: Array[String]) {

      if (args.size != 1) {

fedesilva

#!/bin/bash -e
#
# Since unicorn creates a new pid on restart/reload, it needs a little extra love to 
# manage with runit. Instead of managing unicorn directly, we simply trap signal calls
# to the service and redirect them to unicorn directly.
#
# To make this work properly with RVM, you should create a wrapper for the app's gemset unicorn.
#

function is_unicorn_alive {

gclaramunt

case class ListZipper[T](rev:List[T], fwd:List[T]){
    override def toString = rev.reverse.toString ++" " ++ fwd.toString  
    
    def read:T= fwd.head
    def add(c:T)=ListZipper(rev,c::fwd)
    def update(c:T)=ListZipper(rev,c::fwd.tail)
    def remove()=ListZipper(rev,fwd.tail)  

    def back=ListZipper(rev.tail,rev.head::fwd)
    def forward=ListZipper(fwd.head::rev,fwd.tail)

jonifreeman

Miles Sabin implemented a nice selection sort example in Scala's type system. See:

http://www.chuusai.com/2012/01/27/type-level-sorting-in-shapeless/

To get a better understanding how that works I ported the algorithm to Prolog.

selectleast([H|T], TM, [H|TRem]):-
    selectleast(T, TM, TRem), TM < H.

selectleast([H|T], H, T).

fedesilva

import sbt._
import Keys._
/**
 *   How in the world do I make bye depend on hello?
 *   And how do I depend on a task like test?
 *   I have not been able to make this work
     goodbyeTask <<= goodbyeTask.dependsOn(helloTask) as in https://github.com/harrah/xsbt/wiki/Tasks
     no matter where I stick it!
     Halp!
 */

gclaramunt

trait FlightStatus
trait Flying extends FlightStatus
trait Landed extends FlightStatus

case class Plane[Status <: FlightStatus]()

def land(p:Plane[Flying])=Plane[Landed]()
def takeOff(p:Plane[Landed])= Plane[Flying]()

val plane = new Plane[Landed]()