Language: Scala
def largestChain(end: Long): List[Long] = {
    var maxChainSize: Long = 0
    var maxChain: List[Long] = Nil
    (1l until end).foreach {n =>
      val chain = calcChain(n)
      val chainSize = chain.size
      if(chainSize > maxChainSize && chain.head == 1) {
	maxChainSize = chainSize
	maxChain = chain
      }
    }
    maxChain
  }
 
  def calcChain(n: Long): List[Long] = {
    def _calcChain(chain: List[Long]): List[Long] = {
      val head = chain.head
      if(head == 1) return chain
      else if(head%2 == 0) return _calcChain(head/2 :: chain)
      else return _calcChain(head*3+1 :: chain)
    }
    _calcChain(n :: Nil)
  }

Language: Java
Object process(Object request, String... parameter);

Language: Scala
def process(request: AnyRef, parameter: String*) : AnyRef = {
  ... //do something
}

class SimpleCoRFilterProcessor needs to be abstract, since method process in trait FilterProcessor of 
 type (x$1: Any,x$2: <repeated...>[java.lang.String])java.lang.Object is not defined

Language: Scala
val v = new Vector(1, 1, 1)
val s = 5.0
 
val res1 = v * s // no problem
val res2 = s * v // problem

Language: Scala
def aMethod_= (a:Double) { new Vector( ... ) } // no problem
def *_= (a:Double) { new Vector ( .... ) } // Scala say: '=' expected but '_' found

Language: Scala
class A {  def f = ...  }  // change this
class A {  val f = ...  }  // to this

Language: Scala
class A {
  var cachedF = null
  def f = {
    if (cachedF == null){
      cachedF = ...
    }
    cachedF
  }
}

Language: Scala
class A {
  var cachedF = _
  var fIsCached = false
  def f = {
    if (!fIsCached){
      fIsCached = true
      cachedF = ...
    }
    cachedF
  }
}

Language: Scala
import collection.mutable.ArrayBuffer
import io.Source
 
object Problem11 {
	def main(args: Array[String]) {
		val ab = dataToArr()
 
		val calcHorizontal = {
			var greatest = 0
			for (i <- 0 until ab.length; j <- 0 until ab(i).length - 3) {
				val prod = ab(i)(j) * ab(i)(j + 1) * ab(i)(j + 2) * ab(i)(j + 3)
				if (prod > greatest) greatest = prod	  		
			}
			greatest
		}
 
		val calcVertical = {
			var greatest = 0
			for (i <- 0 until ab.length - 3; j <- 0 until ab(i).length) {
				val prod = ab(i)(j) * ab(i + 1)(j) * ab(i + 2)(j) * ab(i + 3)(j)
				if (prod > greatest) greatest = prod
			}
			greatest
		}
 
		val calcDiagForward = {
			var greatest = 0
			for (i <- 0 until ab.length - 3; j <- 0 until ab(i).length - 3) {
				val prod = ab(i)(j) * ab(i + 1)(j + 1) * ab(i + 2)(j + 2) * ab(i + 3)(j + 3)
				if (prod > greatest) greatest = prod
			}
			greatest
		}
 
		val calcDiagBackward = {
			var greatest = 0
			for (i <- 3 until ab.length; j <- 0 until ab(i).length - 3) {
				val prod = ab(i)(j) * ab(i - 1)(j + 1) * ab(i - 2)(j + 2) * ab(i - 3)(j + 3)
				if (prod > greatest) greatest = prod	  		
			}
			greatest
		}
 
		val greatest = List[Int](calcHorizontal, calcVertical, calcDiagForward, calcDiagBackward)
		printf("max:%d\n", greatest.max)
	}
 
	def dataToArr(): ArrayBuffer[ArrayBuffer[Int]] = {
		val arr = Source.fromFile("p11.txt").mkString.split("\n")
		val r = ArrayBuffer[ArrayBuffer[Int]]()
 
		for (i <- 0 until arr.length) {
			val row = arr(i).split(' ')
			val lb = ArrayBuffer[Int]()
			for (j <- 0 until row.length) lb += row(j).toInt
			r += lb
		}
		r
	}
}

Language: Scala
class A(val hash: Int){
  override def hashCode = hash
 
  override def equals(other: Any): Boolean = other match{
    case that: A => hash == that.hash
    case _ => false
  }
}
 
trait Id{
  val id: Int
 
  override def hashCode =
    super.hashCode * 41 + id
 
  override def equals(other: Any) = other match {
    case that: Id => (this.id == that.id) && super.equals(that)
    case _ => false
  }
}
 
// instead of normal construction for class A <val x = new A(10)> I can use:
val a = new A(10) with Id {val id = 1}
val b = new A(10) with Id {val id = 2}

Language: Scala
class A {
  var s:Array[Array[String]]
 // init. s
  def apply(i:Int)(j:Int) = s(i)(j)
 
  def update ???
}
 
val a = new A
 
a(0)(0) = "hello"
 
Console.println(a(0)(0)

Language: Scala
val petMap = ImmutableMultiMap(Alice->Cat, Bob->Dog, Alice->Hamster)

Language: Scala
import collection.{mutable,immutable}
 
class ImmutableMultiMap[K,V] extends immutable.HashMap[K,immutable.Set[V]]
 
object ImmutableMultiMap {
  def apply[K,V](pairs: Tuple2[K,V]*): ImmutableMultiMap[K,V] = {
    var m = new mutable.HashMap[K,mutable.Set[V]] with mutable.MultiMap[K,V]
    for ((k,v) <- pairs) m.addBinding(k,v)
    // How do I return the ImmutableMultiMap[K,V] corresponding to m here?
  }
}

Language: Scala
import java.awt.Color;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.ChartPanel;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.AxisLocation;
import org.jfree.chart.axis.NumberAxis;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.plot.XYPlot;
import org.jfree.chart.renderer.StandardXYItemRenderer;
import org.jfree.chart.title.TextTitle;
import org.jfree.data.XYDataset;
import org.jfree.data.time.Minute;
import org.jfree.data.time.RegularTimePeriod;
import org.jfree.data.time.TimeSeries;
import org.jfree.data.time.TimeSeriesCollection;
import org.jfree.ui.ApplicationFrame;
import org.jfree.ui.RefineryUtilities;
import org.jfree.ui.Spacer;
 
/**
 * An example of....
 *
 * @author David Gilbert
 */
class MultipleAxisDemo1 extends ApplicationFrame {
 
    /**
     * A demonstration application showing how to create a time series chart with muliple axes.
     *
     * @param title  the frame title.
     */
    this(title: String) {
 
        super(title);
        JFreeChart chart = createChart();
        ChartPanel chartPanel = new ChartPanel(chart);
        chartPanel.setPreferredSize(new java.awt.Dimension(600, 270));
        chartPanel.setHorizontalZoom(true);
        chartPanel.setVerticalZoom(true);
        setContentPane(chartPanel);
 
    }
 
    /**
     * Creates the demo chart.
     * 
     * @return The chart.
     */
    private createChart(): JFreeChart = {
 
        val dataset1: XYDataset = createDataset("Series 1", 100.0, new Minute(), 200);
 
        val chart: JFreeChart = ChartFactory.createTimeSeriesChart(
            "Multiple Axis Demo 1", 
            "Time of Day", 
            "Primary Range Axis",
            dataset1, 
            true, 
            true, 
            false
        );
 
        chart.setBackgroundPaint(Color.white);
        chart.addSubtitle(new TextTitle("Four datasets and four range axes."));  
        XYPlot plot = chart.getXYPlot();
        plot.setOrientation(PlotOrientation.VERTICAL);
        plot.setBackgroundPaint(Color.lightGray);
        plot.setDomainGridlinePaint(Color.white);
        plot.setRangeGridlinePaint(Color.white);
 
        plot.setAxisOffset(new Spacer(Spacer.ABSOLUTE, 5.0, 5.0, 5.0, 5.0));
 
        val renderer = (StandardXYItemRenderer) plot.getRenderer();
        renderer.setPaint(Color.black);
 
        // AXIS 2
        val axis2 = new NumberAxis("Range Axis 2");
        axis2.setAutoRangeIncludesZero(false);
        axis2.setLabelPaint(Color.red);
        axis2.setTickLabelPaint(Color.red);
        plot.setSecondaryRangeAxis(0, axis2);
        plot.setSecondaryRangeAxisLocation(0, AxisLocation.BOTTOM_OR_LEFT);
 
        val dataset2: XYDataset = createDataset("Series 2", 1000.0, new Minute(), 170);
        plot.setSecondaryDataset(0, dataset2);
        plot.mapSecondaryDatasetToRangeAxis(0, new Integer(0));
        plot.setSecondaryRenderer(0, new StandardXYItemRenderer());
        plot.getSecondaryRenderer(0).setSeriesPaint(0, Color.red);
 
        // AXIS 3
        val axis3 = new NumberAxis("Range Axis 3");
        axis3.setLabelPaint(Color.blue);
        axis3.setTickLabelPaint(Color.blue);
        plot.setSecondaryRangeAxis(1, axis3);
 
        val dataset3: XYDataset = createDataset("Series 3", 10000.0, new Minute(), 170);
        plot.setSecondaryDataset(1, dataset3);
        plot.mapSecondaryDatasetToRangeAxis(1, new Integer(1));
 
        plot.setSecondaryRenderer(1, new StandardXYItemRenderer());
        plot.getSecondaryRenderer(1).setSeriesPaint(0, Color.blue);
 
        // AXIS 4        
        val axis4 = new NumberAxis("Range Axis 4");
        axis4.setLabelPaint(Color.green);
        axis4.setTickLabelPaint(Color.green);
        plot.setSecondaryRangeAxis(2, axis4);
 
        dataset4: XYDataset = createDataset("Series 4", 25.0, new Minute(), 200);
        plot.setSecondaryDataset(2, dataset4);
        plot.mapSecondaryDatasetToRangeAxis(2, new Integer(2));
 
        plot.setSecondaryRenderer(2, new StandardXYItemRenderer());
        plot.getSecondaryRenderer(2).setSeriesPaint(0, Color.green);        
 
        return chart;
    }
 
    // ****************************************************************************
    // * JFREECHART DEVELOPER GUIDE                                               *
    // * The JFreeChart Developer Guide, written by David Gilbert, is available   *
    // * to purchase from Object Refinery Limited:                                *
    // *                                                                          *
    // * http://www.object-refinery.com/jfreechart/guide.html                     *
    // *                                                                          *
    // * Sales are used to provide funding for the JFreeChart project - please    * 
    // * support us so that we can continue developing free software.             *
    // ****************************************************************************
 
    /**
     * Creates a sample dataset.
     * 
     * @param name  the dataset name.
     * @param base  the starting value.
     * @param start  the starting period.
     * @param count  the number of values to generate.
     *
     * @return The dataset.
     */
    private createDataset(String name, double base, RegularTimePeriod start, int count): XYDataset {
 
        series: TimeSeries = new TimeSeries(name, start.getClass());
        var period = start;
        var value: Double = base;
        for (int i = 0; i < count; i++) {
            series.add(period, value);    
            period = period.next();
            value = value * (1 + (Math.random() - 0.495) / 10.0);
        }
 
        val dataset = new TimeSeriesCollection();
        dataset.addSeries(series);
 
        return dataset;
 
    }
}
 
 
object MultipleAxisDemoMain {
 
  def main(args: Array[String]): Unit = { 
        val demo = new MultipleAxisDemo1("Multiple Axis Demo 1");
        demo.pack();
        RefineryUtilities.centerFrameOnScreen(demo);
        demo.setVisible(true);
  }
 
}

Language: Scala
$ fsc -cp /jars/jfreechart/jfreechart-1.0.13/lib:. MultipleAxisDemo1.scala
MultipleAxisDemo1.scala:41: error: '.' expected but '(' found.
        super(title);
             ^
MultipleAxisDemo1.scala:41: error: identifier expected but ';' found.
        super(title);
                    ^
MultipleAxisDemo1.scala:56: error: expected start of definition
    private createChart(): JFreeChart = {
            ^
MultipleAxisDemo1.scala:147: error: expected start of definition
    private createDataset(String name, double base, RegularTimePeriod start, int count): XYDataset {
            ^
four errors found

Language: Scala
abstract class AbstractPersistentObjectConverter  extends Converter {
	type A <: PersistentObject[Serializable]
        ... //something else
 }

Language: Scala
class PersistentObjectConverter(val persistentObjects: Seq[A]) extends AbstractPersistentObjectConverter {	
 
	val poMap: Map[Serializable, A]
	def refresh() {		
		persistentObjects.foreach((a: A) => poMap + (a.getPersistentId.toString, a))
	}
        ... //something else

• NASA's Jet Propulsion Laboratory (JPL) has been using Scala to explore the use of DSLs in shuttle and other space mission launch control applications.
• The Guardian uses Scala for their "Open Platform" API.
• Novell uses Scala for Pulse, a cloud-based, real-time collaboration platform.
• NHS (National Health Service, UK) launched two Websites powered by Scala. The first is the NHS Foundation Trust Network and the second is NHS Institute for Innovation and Improvement.
• LinkedIn has been using Scala to write Norbert, a framework that makes it fast and easy to write asynchronous, cluster aware, message based client/server applications.
• Thatcham Motor Insurance Repair Research Centre uses Scala for their research work and their website.
• Foursquare, a cross between a friend-finder, a social city-guide and a game has decided to move all services to Scala.
• XMPie, a business unit of Xerox Corporation, has been using Scala to develop software solutions for variable-data publishing.
• Twitter uses Scala for the back-end.
• Siemens uses Scala for their Lift based Enterprise Social Messaging Experiment (ESME).
• Électricité de France Trading has ported a substancial part of their 300,000 lines of Java code for energy derivatives trading and pricing to Scala.
• Reaktor, a Finnish software company, started introducing Scala into new development projects and now recommend the technology to their customers.
• Nature, the scientific publishing group, has been using Scala for building various restful APIs.
• Triental, a Swedish wealth management company, uses Scala.
• Sygneca has used Scala in a number of projects, including several for the UK government.
• SAIC (government contracting in the USA) is using Scala on a project to provide a RESTful and XML-RPC API.
• WattzOn, a social energy auditing site, is entirely coded in Scala.

error: missing parameter type for expanded function ((x$1) => x$1.number)
    option.ifExists(println(_.number))

Language: Scala
class OptionWrapper[T](option: Option[T]) {
  def ifExists(action: T => Unit) {
    if (option.isDefined) action(option.get)
  }
}
 
class Block(val number: Int)
 
object Foo {
  def main(args: Array[String]) {
    val option = new OptionWrapper(Some(new Block(666)))
    option.ifExists(println(_.number))
  }
}

Language: Scala
class SumSet extends scala.collection.immutable.HashSet[Double] {
  def average:Double = this.sum / size
}

Language: Scala
val set = SumSet(4.0,6.0)     // does not compile

Language: Scala
val executer = new scala.actors.scheduler.ResizableThreadPoolScheduler
val c:Array[Doulbe] = ...
 
// c as a parameter
def parallel_1(abc:Int, c:Array[Double]) = {
  // ....
  c(i) = a_no_zero_value
}
 
// c as a class variable
def parallel_1(abc:Int) = {
  // ....
  c(i) = a_no_zero_value
}
 
def run() = {
  // 1
  for(i <- 0 until c.size)
    executer.execute(parallel_1(i, c))
 
  // 2
  for(i <- 0 until c.size)
    executer.execute(parallel_2(i))
 
  // 3
  for(i <- 0 until c.size)
    parallel_1(i, c)
 
  // 4
  for(i <- 0 until c.size)
    parallel_2(i)
}