Language: Scala
case class Person( name:String )

Language: Scala
case class Person( val name:String )

Language: Scala
import swing._
import event._
 
 
  def top = new MainFrame {
    title = "Array Tester"
 
    object userInput extends TextField { columns = 5 }
	object userInput2 extends TextField { columns = 10}
	object output extends Label(" Hello, type what you want to say!  ")
 
	val myArray = new Array[TextField](5);
 
	myArray(0) = new TextField {columns =5}
 
    contents = new FlowPanel {
      contents += output
      contents += userInput
	  contents += userInput2
	  contents += myArray(0)
 
      border = Swing.EmptyBorder(15, 10, 10, 10)
    }
 
	//this is the part that is giving me the error. When I comment this block out, everything works.
	listenTo(myArray(0))
	reactions += {case EditDone (`myArray(0)`)=>
		println ("hello")
		val input = myArray(0).text
		output.text = input
	}
 
    listenTo(userInput)
    reactions += {
      case EditDone(`userInput`) =>
        val input = userInput.text
        output.text = input
    }    
	listenTo(userInput2)
    reactions += {
      case EditDone(`userInput2`) =>
		val input2 = userInput2.text
		myArray(0).text = input2
    }    
 
  }
 
top.visible = true

Language: Scala
val circle = CircleBuilder.create.centerX(100).centerY(115).radius(100).build

error: value centerY is not a member of ?0
possible cause: maybe a semicolon is missing before `value centerY'?
.centerY(115)

Language: Java
public class CircleBuilder<B extends javafx.scene.shape.CircleBuilder<B>>  extends javafx.scene.shape.ShapeBuilder<B> implements javafx.util.Builder<javafx.scene.shape.Circle>

Language: Java
public static javafx.scene.shape.CircleBuilder<?> create()

Language: Java
public B centerX(double v)

Language: Scala
object TestAppend {
 
  trait Appendable {
    type Self
    def ++(x: Self): Self
  }
 
  trait A extends Appendable {
    type Self <: A
    def i : Int
  }
  trait B extends A {
    type Self = B
    def s: String
  }
 
  case class AImp(i: Int) extends A {
    type Self = A
    def ++(a: A): A = AImp(i+a.i)
  }
 
  case class BImp(i: Int, s: String) extends B {
    type Self = B
    def ++(b: B) = BImp(i+b.i, s+" "+b.s)
  }
 
  val a1: A = AImp(3)
  val a2: A = AImp(2)
  val a = a1++a2
 
  val b1: B = BImp(3,"three")
  val b2: B = BImp(2,"two")
  val b = b1++b2
}

val a = a1++a2
            ^
type mismatch;  found   : TestAppend.a2.type (with underlying type TestAppend.A)  required: TestAppend.a1.Self

Language: Scala
trait Dao[A] {
  def insert(model: A): Int = {
    // generic implementation goes here
  }
 
  def find(id: Int): A = {
    // generic implementation goes here
  }
 
  def update(model: A): Int = {
    // generic implementation goes here
  }
 
  def delete(id: Int): Boolean = {
    // generic implementation goes here
  }
 
  protected def tableName: String
  protected def fields: Seq[String]
  protected def values[B](model: A): B
  protected def toModel(r: java.sql.ResultSet): A
 
  // other details like the connection setup and template strings for
  // insert, update, select, delete SQL queries 
}

Language: Scala
object ModelDao extends Dao[Model] {
  protected val tableName = "models"
 
  protected val fields = Seq("name", "created_at")
 
  // define other abstract methods too like toModel...  
 
  // Now define a type alias called MValues
  type MValues = Tuple2[String, Date]
  object MValues {
    def apply(a: String, b: Date) = (a, b)
  }
 
  protected def values[MValues](model: Model): MValues = MValues(model.name, model.createdAt)
}

  found   : (String, Date)  
  required: MValues                                                        
     MValues(                                                              
            ^

Language: Scala
pass_field.password.toString

Language: Scala
import actors.TIMEOUT
import actors.Actor._
 
receiveWithin(10) {
  case TIMEOUT => println("timeout 2")
}
println("done")

Language: Scala
import actors.TIMEOUT
import actors.Actor._
 
actor {
  receiveWithin(10) {
    case TIMEOUT => println("timeout 1")
  }
}
println("done")

Language: Scala
import actors.TIMEOUT
import actors.Actor._
 
actor {
  receiveWithin(10) {
    case TIMEOUT => println("timeout 1")
  }
}
receiveWithin(10) {
  case TIMEOUT => println("timeout 2")
}
println("done")

Language: Java
package java;
 
// interfaces
 
// type parameter identifies the return type of the query
interface Query<R>{}
 
// exec a query returning a type compatible with the query's type param
interface QueryHandler<R, Q extends Query<R>> {
    R handle(Q query);
}
 
// for a given query find a QueryHandler to exec it and then dispatch using that handler
interface QueryExecutor {
    <R, Q extends Query<R>> R execute(Q query);
}
 
/// dummy impl
 
class MyQuery implements Query<String> {}
 
class MyQueryHandler implements QueryHandler<String, MyQuery> {
 
    @Override
    public String handle(MyQuery query) {
        return "String result";
    }
}
 
 
class MyQueryExecutor implements QueryExecutor {
 
    // list of handlers
    QueryHandler qh1 = new MyQueryHandler();
 
    // find handler for query and execute it
    public <R, Q extends Query<R>> R execute(Q query) {
        if (query instanceof MyQuery) {
            return (R)qh1.handle(query);
        }
        return null;
    }
 
}
 
 
public class QueryMain {
    public static void main(String[] arg) {
        MyQuery q = new MyQuery();
        MyQueryExecutor qe = new MyQueryExecutor();
 
        String s = qe.execute(q);
 
        System.out.println(s);
    }
}

Language: Scala
package scala
 
// R indicates the type this query will return
abstract class Query[R]
 
// The handler for a given query returns a data type consistent with the template parameter of the Query
trait QueryHandler[R, Q <: Query[R]] {
  def handle(query: Q): R;
}
 
// generic executor interface
// and query will be executed against the relevant query handler and the appropriate result type returned
trait QueryExecutor {
  def execute[R, Q <: Query[R]](query: Q): R
}
 
//////////////////////
 
 
class MyQuery extends Query[String]
 
class MyQueryHandler extends QueryHandler[String, MyQuery] {
 
  @Override
  def handle(query: MyQuery): String = "String result"
}
 
 
class MyQueryExecutor extends QueryExecutor {
 
  // given a query , find the handler and execute it
  def execute[R, Q <: Query[R]](query: Q): R = {
 
    val qh1: QueryHandler[R,Q] = new MyQueryHandler().asInstanceOf[QueryHandler[R,Q]];
 
    query match {
      // code fails to comple without the cast asInstanceOf[R]
      case e: MyQuery => qh1.handle(query)
    }
  }
}
 
 
object QueryMain {
  def main(arg: Array[String]) = {
    val q = new MyQuery()
    val qe = new MyQueryExecutor()
 
    //error: inferred type arguments [Nothing,MyQuery] do not conform to method execute's type parameter bounds [R,Q <: Query[R]]
    val s: String = qe.execute(q)
 
    System.out.println(s);
  }
}

Language: Scala
protected def sendToMain(conn: SocksConn)
{ 
    try
    {
        conn.key.cancel()
        connections -= conn
        select()
        mainActor ! conn.channel
    }
}

Language: Scala
Thread [akka:event-driven:dispatcher:global-3] (Suspended (exception NoClassDefFoundError)) 
    MonitorableThread.run() line: 186

Language: Scala
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Vier Gewinnt</title>
</head>
 
<lift:surround with="default" at="content">
		<h2>Vier Gewinnt!</h2>
    <div class="lift:Feld"> </div>
    <div class="lift:OnSubmit?form=post">
    <br/>
    <input name="wert"/>
    <input type="submit" value="Submit"/>
    </div>
</lift:surround>
 
<body>
</body>
</html>

Language: Scala
package lift.lift.snippet
import net.liftweb._
import http._
import util.Helpers._
import scala.xml.NodeSeq
 
object OnSubmit {
  def render = {
    // define some variables to put our values into
    var wert = 0
 
    def process() {
      // if the age is < 13, display an error
      if (wert < 0 || wert >= 7) S.error("Wert muss zwischen 1-7 liegen")
      else {
        // otherwise give the user feedback and
        // redirect to the home page
        S.notice("Wert: "+wert)
        S.redirectTo("/")
      }
    }
    "name=wert" #> SHtml.onSubmit(s => asInt(s).foreach(wert = _)) &
    // when the form is submitted, process the variable
    "type=submit" #> SHtml.onSubmitUnit(process)
  }
}

Language: Scala
class Feld {
  def render = {
    <table border="1">
      {
        for (y <- 5 to 0 by -1) yield {
          <tr>
            {
              for (x <- 0 to 6) yield {
                <td> . </td>
              }
            }
          </tr>
        }
      }
    </table>
  }
}

Language: Scala
package viergewinnt
 
case object Naught extends Coin("O")
case object Cross extends Coin("X")
class Coin(override val toString: String)
 
trait Spieler {
  def move(spielfeld: Spielfeld, coin: Coin, io: IO) : Boolean
}
 
case class Spielername(override val toString: String) extends Spieler {
  //val scanner = new java.util.Scanner(System.in)
 
  def move(spielfeld: Spielfeld, coin: Coin, io: IO) = io.askForHumanMove(spielfeld) match {
    case Some(x) => spielfeld.move(x, coin); true
    case None => false                                                                           
  }
}
 
object VierGewinnt {
 
  def apply(io:IO) {
   def loop(spieler: Option[(Spieler, Spieler)]) {
      val (spieler1, spieler2) = spieler.getOrElse(io.askForPlayers)
      spielRunde(spieler1, spieler2, io)
    }
    loop(None)
  }
 
  def spielRunde(player1: Spieler, player2: Spieler, io:IO) {
 
    val spielfeld =  new Spielfeld()
 
    def play(player: Spieler) {
      val coin = if (player == player1) Cross else Naught 
        io.zeigeSpielfeld(spielfeld)
      if(spielfeld.winner != None) io.announceWinner(
        if (spielfeld.winner.get == Cross) player1 else player2, spielfeld.winner.get)
      else {
        io.announceMove(player, coin)
        if (player.move(spielfeld, coin, io)) play(if(player == player1) player2 else player1)
      }
    }
    play(player1)
  }
}

Language: Scala
package viergewinnt
 
class Spielfeld{
 
  val array = Array.fill(7)(Array.fill(6)(None:Option[Coin]))
 
  def move(x:Int, coin:Coin) {
    val y = array(x).indexOf(None)
    require(y >= 0) 
    array(x)(y) = Some(coin)
   }
 
  def apply(x: Int, y: Int):Option[Coin] = 
     if (0 <= x && x < 7 && 0 <= y && y < 6) array(x)(y)
     else None
 
  def winner: Option[Coin] = winner(Cross).orElse(winner(Naught))
 
  private def winner(coin:Coin):Option[Coin] = {
    val rows = (0 until 6).map(y => (0 until 7).map( x => apply(x,y)))
    val cols = (0 until 7).map(x => (0 until 6).map( y => apply(x,y)))
    val dia1 = (0 until 4).map(x => (0 until 6).map( y => apply(x+y,y))) //Diagonale von links (x=0) nach rechts (x=max 4)
    val dia2 = (3 until 7).map(x => (0 until 6).map( y => apply(x-y,y))) //Diagonale von rechts (x=7) nach links (x=max 3)	
 
    val slice = List.fill(4)(Some(coin))
    if((rows ++ cols ++ dia1 ++ dia2).exists(_.containsSlice(slice))) 
      Some(coin)
    else None
  }  
 
  override def toString = {
    val string = new StringBuilder
    for(y <- 5 to 0 by -1; x <- 0 to 6){
    	string.append(apply(x, y).getOrElse("_"))
        if (x == 6) string.append ("\n") 
        else string.append("|")
    }
    string.append("0 1 2 3 4 5 6\n").toString
  }
}

Language: Scala
def contains(elem: Any): Boolean = exists (_ == elem)

Language: Scala
package org.heapdump.cauchy
 
import scala.actors.Actor
import scala.actors.Actor._
import scala.annotation.tailrec
 
/**
 * <b> Taskmanager </b>
 * <p>Threadbased parallel processing of datastructures.</p>    
 */
object Taskmanager {
 
  /**
   * Actor message Start
   */
  private case object Start;
 
  /**
   * Actor message Stop
   */
  private case object Stop;
 
  /**
   * Abstract typed result delivered by the processing actor.
   */
  case class Result[A, B](obj: A, returndata: B, exectime: Double) 
 
  private type ResultList[A, B] = List[Result[A, B]]
 
  /**
   * The actor implementation of a processing unit (Task)
   */
  private class TaskActor[A, B](obj: A, f: (A) => B) extends Actor {
 
    def act = loop {
      react {
        case Start =>
          val t0 = System.nanoTime
          val returndata = f(obj)
          val t1: Double = (System.nanoTime - t0) / 1000000.0
 
          sender ! Result(obj, returndata, t1)
 
        case Stop => 
          exit()
      }
    }
  } 
 
  /**
   * Companion object
   */
  private object TaskActor {    
    def apply[A, B](data: A, f:(A) => B) = new TaskActor(data, f) 
  }
 
 
  /**
   * Parallel processing of a given list of data by a function.
   * 
   * @param data A list of data
   * @param f The processing function
   * @param cachesize The size of the actor-pool (max parallel actors used)
   */
  def runall[A, B](data: List[A], f:(A) => B, cachesize: Int) : ResultList[A, B] = {
 
   // @tailrec 
    def schedule(databuffer: List[A], buffer: ResultList[A, B], cache_size: Int) : ResultList[A, B] = {
 
      if (buffer.size == data.size) return buffer
 
      if (cache_size < cachesize && databuffer.size > 0) {
        val ta = new TaskActor(databuffer.head, f)
        ta.start
        ta ! Start
        return schedule(databuffer.tail, buffer, cache_size + 1)
      }
 
      receive {
        case Result(obj: A, returndata: B, t1) => 
          sender ! Stop
          return schedule(databuffer, Result(obj, returndata, t1) :: buffer, cache_size - 1)
      }  
 
    }
 
    schedule(data, List[Result[A, B]](), 0)  
  }    
 
}