VD>>>И чем по твоему unit отличается от void? Что то я не пойму.

object LoopSpeed2 extends Application {
  def meter( name: String, action: => unit ) {
    val start = java.util.Calendar.getInstance.getTimeInMillis
    action
    val finish = java.util.Calendar.getInstance.getTimeInMillis

    Console.println( name + ": " + (finish - start) )
  }

  class Repeater( command: => unit ) {
    def until( condition: => boolean ): unit = {
      do command while( !condition )
    }
  }

  def repeatLoop( action: => unit ) = new Repeater( action )

  val LIMIT = 100000000

  meter( "Simple do-while",
    { var i = 0; do { i = i + 1 } while( i < LIMIT ); } )
  meter( "Repeat until",
    { var i = 0; repeatLoop { i = i + 1 } until( i >= LIMIT ); } )
}

// vim:ts=2:sts=2:sw=2:expandtab

using (выражение)
{
    другие выражения
}

object UnitDemo1 extends Application
{
  val codeBlock: unit = { Console.println( "Hello from CodeBlock!" ) }

  codeBlock
}

// vim:ts=2:sts=2:sw=2:expandtab

VD>using (выражение)
VD>{
VD>    другие выражения
VD>}
VD>

object MutliArgs1 extends Application
{
  def demo(x: int)( block: => unit) : unit = {
    for( val i <- Iterator.range( 0, x ) )
      block
  }

  demo( 3 ) { Console.println( "Hello, world!" ) }
}

// vim:ts=2:sts=2:sw=2:expandtab

object MutliArgs2 extends Application
{
  def repeatLoop( action: => unit )( condition: => boolean ): unit = {
    action
    if( condition ) repeatLoop( action )( condition )
  }

  var i = 0;
  repeatLoop {
    Console.println( "i=" + i )
    i = i + 1
  }( i < 4 )
}

// vim:ts=2:sts=2:sw=2:expandtab

object MutliArgs3 extends Application
{
  def repeatLoop( action: => unit )( condition: => boolean ): unit = {
    action
    if( condition ) repeatLoop( action )( condition )
  }

  var i = 0;
  repeatLoop {
    Console.println( "i=" + i )
    i = i + 1
  } { i < 4 }
}

// vim:ts=2:sts=2:sw=2:expandtab

E>object UnitDemo1 extends Application
E>{
E>  val codeBlock: unit = { Console.println( "Hello from CodeBlock!" ) }

E>  codeBlock
E>}

E>

Executing a definition such as def x = e will not evaluate the expression e. Instead
e is evaluated whenever x is used. Alternatively, Scala offers a value definition
val x = e, which does evaluate the right-hand-side e as part of the evaluation
of the definition. If x is then used subsequently, it is immediately replaced by the
pre-computed value of e, so that the expression need not be evaluated again.

scala> val bar = { Console.println("once"); 3.14 }
once
bar: scala.Double = 3.14

scala> bar
line8: scala.Double = 3.14

scala> bar
line9: scala.Double = 3.14

scala> def foo = { Console.println("every time"); 13 }
foo: => scala.Int

scala> foo
every time
line11: scala.Int = 13

scala> foo
every time
line12: scala.Int = 13

object Demo1 extends Application
{
  class ValueHolder
  {
    def value = { 0 }
  }

  def doSomething[ B <: ValueHolder ]( holder: B ) {
    holder.value
  }

  doSomething( new ValueHolder )
}

// vim:ts=2:sts=2:sw=2:expandtab

class ValueHolder
{
    int value() { return 0; }
}

class AnotherValueHolder
{
    float value() { return 0.0; }
}

void
doSomething(T)( T holder )
{
    holder.value;
}

void
main()
{
    doSomething( new ValueHolder );
    doSomething( new AnotherValueHolder );
}

Dcl                ::= def FunDcl
FunDcl             ::= FunSig ‘:’ Type
Def                ::= def FunDef
FunDef             ::= FunSig [‘:’ Type] ‘=’ Expr
FunSig             ::= id [FunTypeParamClause] ParamClauses
FunTypeParamClause ::= [’ TypeParam {‘,’ TypeParam} ‘]’
ParamClauses       ::= {ParamClause} [[nl] ‘(’ implicit Params ‘)’]
ParamClause        ::= [nl] ‘(’ [Params] ’)’}
Params             ::= Param {‘,’ Param}
Param              ::= {Annotation} id [‘:’ ParamType]
ParamType          ::= Type
                    | ‘=>’ Type
                    | Type ‘*’

scala> val x = 1
x: scala.Int = 1

scala> def f = x
f: => scala.Int

scala> def g { x }
g: => scala.Unit

scala> def g2: unit = x
g2: => scala.Unit