scala> val x: boolean = true
x: boolean = true

scala> x.asInstanceOf[java.lang.Object]
unnamed5: java.lang.Object = true

scala> val y: double = 1.0
y: double = 1.0

scala> y.asInstanceOf[java.lang.Object]
unnamed6: java.lang.Object = 1.0

scala>> val x: boolean = true
A>x: boolean = true

scala>> x.asInstanceOf[java.lang.Object]
A>unnamed5: java.lang.Object = true

scala>> val y: double = 1.0
A>y: double = 1.0

scala>> y.asInstanceOf[java.lang.Object]
A>unnamed6: java.lang.Object = 1.0
A>

import java.sql._;
class DataBase
 {
   ....
   def executeFor[A](_sql: String): A =
    {
     ......
     A macth
      {
       case ..... => r.getString(1).asInstanceOf[A];
       case ..... => r.getInt(1).asInstanceOf[A];
      };
     ......
    }
   ....
 };

object pm4 extends Application {
  
  class ResultSet {
     def getInt(col: int): int = 1
     def getDouble(col: int): double = 1.0
     def getString(col: int): String = "Hello"
     def value[A](col: int)(implicit f: (ResultSet, int) => A): A = f(this, col)  
  }
  
  implicit def viewRsToInt(rs: ResultSet, col: int): int = rs.getInt(col)
  implicit def viewRsToDouble(rs: ResultSet, col: int): double = rs.getDouble(col)
  implicit def viewRsToString(rs: ResultSet, col: int): String = rs.getString(col)
  
  val rs = new ResultSet
  
  // Указываем чего точно хочем
  val i =  rs.value[int](1)
  println(i);
  val s = rs.value[String](2)
  println(s);

  // через абстрактный тип T  
  type T = double
  val t = rs.value[T](3)
  println(t)

}

$ scalac -d target pm4.scala
$ scala -cp target pm4                    
1
Hello
1.0

select (
  "age" is smallint,
  "name" is clob,
  "salary" is int )
from ("persons" naturalJoin "employees")
where (
  "gender" == "M" and
  ("city" == "lausanne" or "city" == "geneva"))
orderBy "age"

scala> class U(val v: int) {}
scala> val m=new U(1)
m: U = U@5a936b
scala> m match { case l: U => println("" + l + " " + m) }
line6$object$$iw$$iw$U@5a936b line6$object$$iw$$iw$U@5a936b

object test {
  class A {
    def myMethod() = println("hello")
    def myAnotherMethod() = println("hello")
  }
  
  class B(a: A) {
    def myTest() = (1 :: 2 :: Nil) map (_ + 1)
    def mySuper() = a.myAnotherMethod _
  }
}

target
|-- test$.class
|-- test$A.class
|-- test$B$$anonfun$0.class
|-- test$B$$anonfun$1.class
|-- test$B.class
`-- test.class

$ javap test\$A
Compiled from "methods.scala"
public class test$A extends java.lang.Object implements scala.ScalaObject{
    public test$A();
    public void myAnotherMethod();
    public void myMethod();
    public int $tag();
}

$ javap test\$B
Compiled from "methods.scala"
public class test$B extends java.lang.Object implements scala.ScalaObject{
    public final test$A test$B$$a;
    public test$B(test$A);
    public scala.Function0 mySuper();
    public scala.List myTest();
    public int $tag();
}

$ javap test\$B\$\$anonfun\$0
Compiled from "methods.scala"
public final class test$B$$anonfun$0 extends java.lang.Object implements scala.Function1,scala.ScalaObject,java.io.Serializable{
    public test$B $outer;
    public test$B$$anonfun$0(test$B);
    public final java.lang.Object apply(java.lang.Object);
    public test$B test$B$$anonfun$$$outer();
    public final int apply(int);
    public int $tag();
    public scala.Function1 andThen(scala.Function1);
    public scala.Function1 compose(scala.Function1);
    public java.lang.String toString();
}

Если у меня есть два класса (интерфейса) с методом getSize(), то это не значит, что они одинаковые.

trait KiloSizes { 
   trait kg; 
   def getSize():kg = new kg {val v=1} 
}

trait ItemSizes { 
   trait sht;
   def getSize():sht = new sht {val v=2} 
}

trait AllSizes extends KiloSizes with ItemSizes {}

<console>:6: error: error overriding method getSize in trait KiloSizes of type ()AllSizes.this.kg;
 method getSize in trait ItemSizes of type ()AllSizes.this.sht needs `override' modifier
trait AllSizes extends KiloSizes with ItemSizes {}
^

trait AllSizes extends KiloSizes with ItemSizes { 
   override def getSize: kg = super[KiloSizes].getSize() 
}

:6: error: error overriding method getSize in trait ItemSizes of type ()AllSizes.this.sht;
 method getSize has incompatible type ()AllSizes.this.kg
trait AllSizes extends KiloSizes with ItemSizes { override def getSize: kg = super[KiloSizes].getSize() }
                                                           ^

trait AllSizes extends KiloSizes with ItemSizes { 
    override def getSize: kg = super[KiloSizes].getSize(); 
    override def getSize: sht = super[ItemSizes].getSize 
}

:6: error: method getSize is defined twice
trait AllSizes extends KiloSizes with ItemSizes { 
    override def getSize: kg = super[KiloSizes].getSize(); 
    override def getSize: sht = super[ItemSizes].getSize 
}

C:\Program Files\scala\bin>scala test
java.lang.ClassCastException: test$
        at test$.main(Test.scala:11)
        at test.main(Test.scala)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
        at java.lang.reflect.Method.invoke(Unknown Source)
        at scala.tools.nsc.ObjectRunner$.run(ObjectRunner.scala:75)
        at scala.tools.nsc.MainGenericRunner$.main(MainGenericRunner.scala:106)
        at scala.tools.nsc.MainGenericRunner.main(MainGenericRunner.scala)

C:\Program Files\scala\bin>

public class TestJava
{
    public int getSize()
    {
        return 10;
    }
    public static void main(String[] args) {
        TestJava object = new TestJava();
        ((KiloSize)object).getSize();
        ((ItemSize)object).getSize();
    }
}

interface KiloSize
{
    public int getSize();
}

interface ItemSize
{
    public int getSize();
}

Exception in thread "main" java.lang.ClassCastException: TestJava
    at TestJava.main(TestJava.java:42)

object test {
   trait KiloSize {
      def getSize() : int;
   }

   trait ItemSize {
      def getSize() : int;
   }

   def getSize() : int = 10;

   def sz[T](a: => T) = a match {
      case k: KiloSize => k.getSize()
      case i: ItemSize => i.getSize()
      case t: test.this.type => t.getSize()
      case _ => throw new Error("What is this?")
   }

   def main(args: Array[String]) = {
     println(sz(this))
     println(sz(new KiloSize { override def getSize(): int = 20 }))
     println(sz(new ItemSize { override def getSize(): int = 30 }))
     println(sz(1))
   }
}

 scala -cp target test             
10
20
30
java.lang.Error: What is this?
        at test$.sz(methods.scala:26)
        at test$.main(methods.scala:33)
...

object test {
  
  trait WithSize {
    val getSize: ()=> int
  }
  
  trait KiloSize {
      def kilos() : int;
  }

  trait ItemSize {
     def items() : int;
  }

  class KiloEntity extends WithSize {

    val getSize = mySize.kilos _
    val mySize = new KiloSize { override def kilos() = 1 }
  }

  class ItemEntity extends WithSize {

    val getSize = myItems.items _
    val myItems = new ItemSize { override def items() = 2 }
  }
  
  def size(sizeable: WithSize) {
    println(sizeable.getSize())
  }

  def main(args: Array[String]) = {
     val k = new KiloEntity
     size(k)
     val i = new ItemEntity
     size(i)
  }
}

Haskell: [ (x, y) | x<-[0,1,2,3], y <- [0,1,2,3], x < y]
Python: [(x, y) for x in [0,1,2,3] for y in [0,1,2,3] if x < y]
Scala: for( x <- 0::1::2::3::Nil; y <- 0::1::2::3::Nil if x < y) yield (x,y)
Lisp: (comprehension (cons x y) 
           ((x '(0 1 2 3)) (y '(0 1 2 3))) 
           ((< x y)))

СОП (Семантически Ориентированное Программирование) — новая парадигма, в которой предлагается программировать непосредственно в семантических (смысл, значение) понятиях. Работу программистов часто сравнивают с переводом текста с одного языка на другой. Семантически Ориентированное Программирование можно сравнить с написанием автоматического переводчика с языка на котором удобно формулировать программу на понятный компьютеру язык, и в дальнейшем специалист (может быть далёкий от программирования) сможет писать программу в удобной ему форме, полностью отвечающей предметной области.

СОП не накладывает никаких ограничений на парадигму программирования – можно писать программы и с процедурной, и в функциональной и в логической парадигме. СОП нейтрален по отношению к ним, ведь сама среда разработки оперирует понятиями концепций, семантических значениях. И как программист выберет набор понятий, в которых он пишет программу – в такой и будет написана программа. В этом смысле (функционального ли программирования, процедурного ли) описание набора семантических понятий ничем не отличается от создания специализированного DSL (domain-specific language) языка.

Однако, надо заметить, что отдельно взятая среда разработки программ основанная на СОП не является панацеей. Он позволяет программировать в любой парадигме, создавать новые и добавлять расширения в имеющиеся языки программирования – но не может гарантировать, что созданные программы будут эффективно исполнятся на целевой платформе. Например, реализация ленивых (lazy) вычислений для виртуальной машины Java (JVM) будет крайне неэффективной – чрезмерно требовательной к ресурсам и медленной в исполнении, просто в силу архитектуры JVM. Это одна из причин, по которым полная реализация СОП парадигмы предполагает не только создание среды разработки программ, но и среды исполнения (runtime, VM) основанной на тех-же принципах, гибко настраиваемой под конкретные нужды отдельных программных проектов. Ещё одной причиной желательности создания новой виртуальной среды исполнения программ является необходимость использовать потенциальные преимущества новых аппаратных платформ ближайшего будущего, но об этом чуть позже.

Книга { название, аннотация }

[SQLTable: ТаблицаКниг]
class Book {

  [SQLField: индекс, primary key] id : int

  [SQLField: название, not null, 80 chars] title : string

  [SQLField: аннотация, maybe null, long varchar] annotation : long string

  private dirty : bool

 }

Такой «точкой», на которой держатся все современные технологии программирования является текстовое представление кода. Точнее, все компиляторы или WYSIWYG редакторы работают с так называемым «внутренним представлением» кода, синтаксическим деревом узлов, каждое из которых содержит удобное для компьютера представление о синтаксических конструкциях. То есть компиляторы работают так

Текст программы -> Синтаксическое дерево -> Машинный код.

СОП предлагает изменить эту схему, и писать программу непосредственно в виде дерева узлов, соответствующих семантике (смысловым понятиям, конкретным предметным значениям), а отображение (возможно текстовое, возможно графическое) будет строится автоматически на основе семантического дерева. То есть СОП предлагает работать так

Текстовое и графическое отображение <-> Семантическое дерево -> Машинный код.

Немедленным следствием такого подхода становится возможность выбирать более удобный (в том числе и субъективно, для конкретного программиста) способ отображения кода. Например, одни больше привыкли писать

if (a > 0) x = a; else x = 0;

а другим более привычна запись

if a > 0 then x := a else x := 0 end

Передача данных и управления между
разными слоями становится настолько сложной и тормознутой, что это перечёркивает
все преимущества разделения проекта на разные части. И мы опять у разбитого корыта.

программиста, который использует работу другого программиста — не должно волновать как он её сделал.

scala> val ls = 1 :: 2 :: Nil
ls: List[Int] = List(1, 2)

scala> ls.toArray
unnamed1: Array[Int] = [I@4854f6 << обрати внимание, что тут именно нейтив массив, а не boxed

override def toArray[B >: A]: Array[B] = {
   val result = new Array[B](size)
   copyToArray(result, 0)
   result
}

class MyType[T] {
  def oops = new T()
}

 i.bind("list",list.getClassName(),list);

 public class Main 
  {
   public static LinkedList<String> list = new LinkedList<String>();
   ....
   public static void main(String[] _args)
    {
     ....
     list.add("Hello world!!");
     i.interpet("Console.println(embededscala.Main.list.get(0))");
     ....
    }
  }

A>Haskell: [ (x, y) | x<-[0,1,2,3], y <- [0,1,2,3], x < y]
A>Python: [(x, y) for x in [0,1,2,3] for y in [0,1,2,3] if x < y]
A>Scala: for( x <- 0::1::2::3::Nil; y <- 0::1::2::3::Nil if x < y) yield (x,y)
A>Lisp: (comprehension (cons x y) 
A>           ((x '(0 1 2 3)) (y '(0 1 2 3))) 
A>           ((< x y)))

A>

A>А теперь вопрос: где гибче синтаксис и язык и где лучше понимаемость кода? И самое интересное: почему в самом гибком языке нужно явно указывать, что это у нас comprehension?

$[(x, y) | x in [0,1,2,3], y in [0,1,2,3], x < y]

Книга { название, аннотация }
 

[SQLTable: ТаблицаКниг]
class Book {

  [SQLField: индекс, primary key] id : int

  [SQLField: название, not null, 80 chars] title : string

  [SQLField: аннотация, maybe null, long varchar] annotation : long string

  private dirty : bool

 }

[SQLTable: ТаблицаКниг]
class Book {

  [SQLField: индекс, primary key] id : int

  [SQLField: название, not null, 80 chars] title : string

  [SQLField: аннотация, maybe null, long varchar] annotation : long string

  private dirty : bool

 }

Книга { название, аннотация }

Удобнее было бы написать читабельную строчку кода. Вот как выглядит описание цикла for в Nemerle:
  macro @for (init, cond, change, body)
  syntax ("for", "(", Optional (init), ";", Optional (cond), ";",
          Optional (change), ")", body) 
  {

M>А у него ещё нет проверки на правильность строк в аннотациях, если что — в рантайме баги вылазят