Language: Scala
case class Person( name:String )

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

Language: Scala
//extra val
val myArray0 = myArray(0)
reactions += {case EditDone (myArray0) => 
...
 
//guard clause
reactions += {case EditDone (foo) if foo == myArray(0) => 
...

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
package demo
 
//////////////////////
// interfaces and abstracts
//////////////////////
 
 
// R indicates the type this query will return
abstract class Query {
  type R
}
 
// The handler for a given query returns a data type consistent with the template parameter of the Query
trait QueryHandler[Q <: Query] {
  def handle(query: Q): 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[Q <: Query](query: Q): Q#R
}
 
trait ConfigurableQueryExecutor extends QueryExecutor {
 
  def execute[Q <: Query](query: Q): Q#R = {
 
    val qh = lookupHandler(query)
 
    qh.handle(query).asInstanceOf[Q#R]
  }
 
  protected def lookupHandler[Q <: Query](value: Q): QueryHandler[Query]
}
 
//////////////////////
// make them concrete
//////////////////////
 
 
// value object
class MyQuery extends Query {
  type R = String
}
 
// value object
class YourQuery(val arg: Int) extends Query {
  type R = Int
}
 
// handler with constructor DI
class MyQueryHandler(someDependency: String) extends QueryHandler[MyQuery] {
 
  @Override
  override def handle(query: MyQuery): String = "String result" + someDependency
}
 
// handler with constructor DI
class YourQueryHandler(someOtherDependency: Int) extends QueryHandler[YourQuery] {
 
  @Override
  override def handle(query: YourQuery): Int = query.arg * someOtherDependency
}
 
// fully concrete runner
object ConfiguredQueryRunner extends ConfigurableQueryExecutor {
  // DI params used below
  private val someDependency = "HELLO"
  private val someOtherDependency = 2
 
  // instantiate handlers with constructor DI
  private val h1 = new MyQueryHandler(someDependency)
  private val h2 = new YourQueryHandler(someOtherDependency)
 
  // define mapping function
  @Override
  override def lookupHandler[Q <: Query](value: Q): QueryHandler[Query] = {
    val handler = value match {
      case q: MyQuery => h1
      case q: YourQuery => h2
    }
 
    handler.asInstanceOf[QueryHandler[Query]]
  }
}
 
 
// usage
object QueryMain {
 
  def main(arg: Array[String]) = {
 
    // run queries
    val q = new MyQuery()
    val q1 = new YourQuery(123)
 
    val s: String = ConfiguredQueryRunner.execute(q)
    val s1: Int = ConfiguredQueryRunner.execute(q1)
 
    System.out.println(s);
    System.out.println(s1);
  }
 
}

Language: Scala
object MakeCircle {
   def apply(centerX:Double = 0, centerY: Double = 0, ...) {
       val circle = CircleBuilder.create
       circle.centerX(centerX)
       circle.centerY(centerY)
       ...
       circle
   }
}
 
Circle circle = MakeCircle(centerY = 100, centerX = 115)

Language: Scala
val circle = CircleBuilder.create
circle centerX 115
circle centerY 100

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
xs map { x => (x: @unchecked) match {
  case SomeCase(x) => //...
  case OtherCase(x) => //... 
}}