jrudolph

/*
 * This is the Towers of Hanoi example from the prolog tutorial [1]
 * converted into Scala, using implicits to unfold the algorithm at
 * compile-time. 
 * 
 * [1] http://www.csupomona.edu/~jrfisher/www/prolog_tutorial/2_3.html
 */

object TowersOfHanoi {
  import scala.reflect.Manifest

retronym

class A
class A2 extends A
class B

trait M[X]

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

mkhl

#!/bin/bash

# Bail out if anything goes wrong
set -e

# Make sure Homebrew and DocBook are present
which -s brew
docbook="$(brew --prefix docbook)"
test -d "$docbook"

mccv

import java.lang.reflect.Method

class Sendable(a: AnyRef) {
  val methods = a.getClass.getDeclaredMethods
  def wrapByte(b: Byte) = new java.lang.Byte(b)
  def wrapShort(s: Short) = new java.lang.Short(s)
  def wrapInt(i: Int) = new java.lang.Integer(i)
  def wrapLong(l: Long) = new java.lang.Long(l)
  def wrapFloat(f: Float) = new java.lang.Float(f)

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._

jorgeortiz85

type ¬[A] = A => Nothing
type ∨[T, U] = ¬[¬[T] with ¬[U]]
type ¬¬[A] = ¬[¬[A]]
type |∨|[T, U] = { type λ[X] = ¬¬[X] <:< (T ∨ U) }

class FoldUnion[T](t: T) {
  def boxClass(x: java.lang.Class[_]): java.lang.Class[_] = x.toString match {
    case "byte" => manifest[java.lang.Byte].erasure
    case "char" => manifest[java.lang.Character].erasure
    case "short" => manifest[java.lang.Short].erasure

mariofusco

class MnemonicsCoder(words: List[String]) {

  private val mnemonics = Map('2' -> "ABC", '3' -> "DEF", '4' -> "GHI", '5' -> "JKL",
                              '6' -> "MNO", '7' -> "PQRS", '8' -> "TUV", '9' -> "WXYZ")

  /** Invert the mnemonics map to give a map from chars 'A' ... 'Z' to '2' ... '9' */
  private val charCode: Map[Char, Char] =
    for ((digit, str) <- mnemonics; letter <- str) yield (letter -> digit)

  /** Maps a word to the digit string it can represent */

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

retronym

// see https://github.com/gseitz/Lensed

object Lensed {

  import scalaz._
  import Scalaz._

  case class Address(street: String)

  case class Person(name: String, address: Address)

gseitz

import sbt._
import Keys._


// source of the actual shell modification take from Daniel C. Sobral's gist:
// https://gist.github.com/996474

// prompt looks like:
// $PROJECTNAME:$GITBRANCH>
object ShellPrompt extends Plugin {