open class A(virtual var v : int)
open class B(v : Int) : A(v)
open class C(v : Int) : A(v)

class D(v : Int) : B(v), C(v) {
  override var v : Int
    get() = this<B>.v
    set(value) { this<B>.v = value }
}

open class A(virtual var v : int)
open class B(v : Int) : A(100)
open class C(v : Int) : A(200)

class D(v : Int) : B(v), C(v) { ... }

VD> H>На 99.99% это сильно не тянет. Берешь Spy++ и находишь кучу нативных контролов

VD> H>ServerExplorer — дерево нативное, Solution Explorer — дерево нативное, Object browser — дерево нативное (у WPF'а, похоже, совсем туго с деревьями ),

VD> H>Properties — винформсовые оберточки

Например, визуальная часть на WPF

VD> H> Более того, открываешь диалог Options, а он вообще весь нативный

VD> H>Attach to process, Code snippets manager, Add-in manager, External tools это все полностью нативные диалоги. И это мне просто лень все проверять, т.ч. твои 99.99% это красивая фантазия и не более

VD> H>Чудно, но я как бы о гуе

VD> H>Нужно же будет куда-то применять DirectUI. WPF вот что-то не пошел совсем. Разгонят одних индусов, наберут других и спираль начнет новых виток

VD> Слова "стала тормознутой" говорили про все версии студии. Только через год-два те же слова уже говорили про следующую версию, а текущая оказывалась шустрой и пушистой .

VD> H>Оно и понятно, куда без натива в нативной то среде

VD> Естественно. Возможно сей факт как-то сгладит батхерт вызываемый у некторых товарищей тем фактом, что доля менеджед-кода в студии с каждым годом увеличивается .

case tree @ TreeWrapper(left, right) =>

A>На самом деле нет ни одной причины не объявить Tree как case class. Так что на мой взгляд он просто привередничает

x => y => x * y

- Some(4) == 4;;
error: comparing values of types option.Some[int-] and int with reference equali
ty
hint: upcast one of the values to object if this is desired

> Some 4 = 4;;

  Some 4 = 4;;
  ---------^

stdin(1,10): error FS0001: This expression was expected to have type
    int option
but here has type
    int

> (Some 4 :> obj) = (4 :> obj);;
val it : bool = false

VD>Надо будет к немерлу прикрутить

$[f(x, y) | x in xs, y in ys]

maybe{ let! x = mx; let! y = my; return f x y }

(x!=null && y!=null) ? x + y : null

def getPoint = (1,2,3)
val t = getPoint
//t._1, t._2, t._3 вместо t.x, t.y, t.z

А хочется так:
def getPoint = (x=1,y=2,z=3)
val t = getPoint
t.x, t.y, t.z

A>Кэйс классы у них есть, но названия они им не дали, и именуют "classes that declare all their primary constructor parameters val"

strings filter {it.length == 5} sortby {it} map {it.toUpperCase()}

C>strings filter {it.length == 5} sortby {it} map {it.toUpperCase()}
C>

from s in strings where s.length == 5 orderby s select s.toUpperCase()

strings.Where(s => s.length == 5).OrderBy(s => s).Select(s => s.toUpperCase())

decomposer fun Any?.Tree() : (Tree?, Tree?)? 
{ 
  if (this is Tree) return (left=this.left, right=this.right) return null 
}
//И дальше спокойно матчим

//Есть класс:
class Tree {
   val left : Tree;
   val right : Tree;
}

//Хочешь PM по этому классу делать? А вот обломись!

//Нужно делать что-то типа:
implicit object TreeWrapper {
   def unapply(t : Tree) = {
      (t.left, t.right)
  }
}

//Теперь можно делать так:
val tr : Tree = ....;

match(tr) {
    case TreeWrapper(t) => Console.print(t._1, t._2);
}
//Если хотим вместо неименованых параметров _1, _2 
//использовать left и right - то нужно делать отдельный case-class

VD>from s in strings where s.length == 5 orderby s select s.toUpperCase()
VD>

VD>strings.Where(s => s.length == 5).OrderBy(s => s).Select(s => s.toUpperCase())
VD>

C>//Есть класс:
C>class Tree {
C>   val left : Tree;
C>   val right : Tree;
C>}

C>//Хочешь PM по этому классу делать? А вот обломись!

C>//Нужно делать что-то типа:
C>implicit object TreeWrapper {
C>   def unapply(t : Tree) = {
C>      (t.left, t.right)
C>  }
C>}

C>//Теперь можно делать так:
C>val tr : Tree = ....;

C>match(tr) {
C>    case TreeWrapper(t) => Console.print(t._1, t._2);
C>}
C>//Если хотим вместо неименованых параметров _1, _2 
C>//использовать left и right - то нужно делать отдельный case-class
C>

class Test {
    class Tree(val left : Tree, val right : Tree)

    implicit object TreeWrapper {
        def unapply(t : Tree) = Some(t.left, t.right)
    }

    def main(args: Array[String]) {
        val tr : Tree = null;

        tr match {
            case TreeWrapper(t1, t2) => println(t1, t2);
        }
    }
}

//Пример 1
def getPoint = (x=1,y=2,z=3)

val f = getPoint()
println(f.x);

//Пример 2
case class GeoPosition(val degLat : Int, val degLong : Int, 
   val height : Int, val minutesLat : Int, val minutesLong : Int, val ts : Timestamp);

x match {
    case GeoPosition(_, _, _, 11) => println("Высота 11 метров!!");
//Упс. Слегка промахнулись. Это не высота, а минуты широты.
...
}

arr map {k,v => "Key: "+k+",val: "+v }

class helloWorld extends Specification {
  "'hello world' has 11 characters" in {
     "hello world".size must be equalTo(11)
  }
  "'hello world' matches 'h.* w.*'" in {
     "hello world" must be matching("h.* w.*")
  }
}

VD>x => y => x * y
VD>

for(int f=0;f<10;++f)
   if (f==2)
      doSomething();

A>Соответственно, если язык написан от скуки, то они будут его дописывать и дописывать. А значит он будет стремиться к Скале, теряя свою простоту

Мы хотим писать идею на котлине сразу же, как только котлин хоть как-то задышит...

class A {}
class B : A {}

def a = A();
def b = B();

def c = a == b; // Не компилируется в Nemerle, но компилируется в C#
def d = a : object == b; // Компилируется