retronym

object scala {
   val version = "SCALA_VERSION$"
}

val xml =         <dependencies>
            <dependency>                
                <groupId>org.scalanlp</groupId>
                <artifactId>scalala_${scala.version}</artifactId>
                <version>0.3.1</version>
            </dependency>

zentrope

// Import the magic libraries

import scala.xml._
import scala.xml.transform._

// Source xml. In Scala, xml is literal.

val xml = 
  <user>
    <email>joe@example.com</email>

umitanuki

import scala.io._
import scala.util.parsing.json._

object Sca2Main {
  def main(args: Array[String]){
		val url = "http://search.twitter.com/search.json?q=umitanuki"
		val parsed = JSON.parseRaw(Source.fromURL(url).getLines.mkString)
		parsed match{
			case Some(x:JSONObject) => println("object")
			case Some(y:JSONArray) => println("array")

joa

package go

import java.util.concurrent.{
	BlockingQueue => JBlockingQueue,
	ArrayBlockingQueue => JArrayBlockingQueue
}

object Channel {
	def empty[A]: Channel[A] = new BlockingChannel()
	def make[A]: Channel[A] = make(1)

kevinwright

//My take on: http://solog.co/47/10-scala-one-liners-to-impress-your-friends/

//1. Multiple Each Item in a List by 2
//(1 to 10) map { _ * 2 }
(1 to 10) map (2*)


//2. Sum a List of Numbers
//(1 to 1000).reduceLeft( _ + _ )
(1 to 1000).sum

milessabin

// See this mailing list thread for context:
//   https://groups.google.com/d/topic/scala-language/ImqJuGylyi8/discussion

case class Companion[-C, T](t : T)

trait Publish[C, T] { self : T =>
  implicit val companion = Companion[C, T](this)
}

trait StaticKey {

jboner

--langdef=Scala
--langmap=Scala:.scala
--regex-Scala=/^[ \t]*class[ \t]*([a-zA-Z0-9_]+)/\1/c,classes/
--regex-Scala=/^[ \t]*object[ \t]*([a-zA-Z0-9_]+)/\1/o,objects/
--regex-Scala=/^[ \t]*trait[ \t]*([a-zA-Z0-9_]+)/\1/t,traits/
--regex-Scala=/^[ \t]*case[ \t]*class[ \t]*([a-zA-Z0-9_]+)/\1/r,cclasses/
--regex-Scala=/^[ \t]*case[ \t]*object[ \t]*([a-zA-Z0-9_]+)/\1/r,cobjects/
--regex-Scala=/^[ \t]*abstract[ \t]*class[ \t]*([a-zA-Z0-9_]+)/\1/a,aclasses/
--regex-Scala=/^[ \t]*def[ \t]*([a-zA-Z0-9_=]+)[ \t]*.*[:=]/\1/m,methods/
--regex-Scala=/[ \t]*val[ \t]*([a-zA-Z0-9_]+)[ \t]*[:=]/\1/V,values/

viktorklang

/*
Copyright 2012-2021 Viktor Klang
 
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
 
       http://www.apache.org/licenses/LICENSE-2.0
 
   Unless required by applicable law or agreed to in writing, software

fcroiseaux

  /**
   * Handles the comet event stream.
   */
  def cometStream = Action {
    AsyncResult {
      implicit val timeout = Timeout(5.seconds)
      val actor=Akka.system.actorOf(Props[EventListener])
      // Actor is listening for event on the eventStream
      Akka.system.eventStream.subscribe(actor,classOf[ChangeEvent])
      // For each event, stream the data to client

stonegao

import akka.actor.Actor
import akka.actor.ActorSystem
import akka.agent.Agent
import com.typesafe.config.ConfigFactory
import akka.event.Logging
import akka.actor.Props
import kafka.utils.Utils
import java.nio.ByteBuffer