djspiewak

Collections Redesign Proposal

I'm going to start off by motivating what I'm doing here. And I want to be clear that I'm not "dissing" the existing collections implementation or anything as unproductively negative as that. It was a really good experiment, it was a huge step forward given what we knew back in 2.8, but now it's time to learn from that experiment and do better. This proposal uses what I believe are the lessons we can learn about what worked, what didn't work, and what is and isn't important about collections in Scala.

This is going to start out sounding really negative and pervasively dismissive, but bear with me! There's a point to all my ranting. I want to be really clear about my motivations for the proposal being the way that it is.

Problems

Generic Interfaces

paulbdavis

# colors
client.focused              #688060 #688060 #303030 #ffcfaf
client.focused_inactive     #3f3f3f #3F3F3F #7f9f7f #3f3f3f
client.unfocused            #3f3f3f #3F3F3F #DCDCCC #3f3f3f
client.urgent               #dca3a3 #dca3a3 #DCDCCC #3f3f3f


# Start i3bar to display a workspace bar (plus the system information i3status
# finds out, if available)
bar {

akshaal

/** Akshaal, 2012. http://akshaal.info */

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

/**
 * Macros for traversing over annotated elements.
 *
 * See http://www.akshaal.info/2012/08/scala-210-annotated-fields-macro.html for more information.

jboner

Latency Comparison Numbers (~2012)
----------------------------------
L1 cache reference                           0.5 ns
Branch mispredict                            5   ns
L2 cache reference                           7   ns                      14x L1 cache
Mutex lock/unlock                           25   ns
Main memory reference                      100   ns                      20x L2 cache, 200x L1 cache
Compress 1K bytes with Zippy             3,000   ns        3 us
Send 1K bytes over 1 Gbps network       10,000   ns       10 us
Read 4K randomly from SSD*             150,000   ns      150 us          ~1GB/sec SSD

pchiusano

/** GADTs in Scala and their limitations */

/** Background: what is an algebraic data type (ADT) ? 
  * ADT: (possibly) recursive datatype with sums and products
  * In scala - a trait with case classes (case class is product, subtyping is sum) 
  */

/** Motivation: untyped embedded DSL doesn't prevent nonsensical expressions */
sealed trait Expr { 
  def apply(other: Expr) = Ap(this, other)

gertjana

package net.addictivesoftware.scala.akkaactors

import akka.actor.{Actor, PoisonPill}
import Actor._
import akka.routing.{Routing, CyclicIterator}
import Routing._

import collection.mutable.{HashMap, Map}
import java.util.concurrent.CountDownLatch

leepike

--
-- Play a song and flash LEDs on alternate notes.
-- Lee Pike <lee pike @ gmail . com> (remove spaces)
-- See http://leepike.wordpress.com/?p=427
-- BSD3 License
-- 
-- Note timing issues: http://www.arduino.cc/en/Tutorial/PlayMelody
--

module CopilotSing where

petermarks

-- | This program benchmarks different versions of the counting function for
-- the Rope Intranet problem for Google Code Jam 
-- http://code.google.com/codejam/contest/dashboard?c=619102#.
--
-- To compile:
-- >>> ghc -O2 --make bench.hs
--
-- To run (Windows):
-- >>> Bench

Crossing.hs

import Data.List

main = interact $ unlines . map showSolution . zip [1..] . map solve . parseProblems

parseProblems = parse . map (map read . words) . tail . lines
  where parse [] = []
        parse ([n]:xs) = map (\ [x,y] -> (x,y)) (take n xs) : parse (drop n xs)

showSolution (n, s) = "Case #" ++ show n ++ ": " ++ show s