int x = 42
x = 42                   // тип можно и не указывать, он будет выведен
(a,b) => a+b             // лямбда, все типы выводятся
(int a, int b) => a+b    // лямбда с указанием типов аргументов
(a,b) => int: a+b        // лямбда с указанием типа результата
f(int a, int b) => a+b   // определение функции. заметьте, как легко
f(a, b) => int: a+b      //  превращать лямбду в ф-ю и обратно
inc(x) => int: x+1       //
(int) -> int g = inc     // переменная функционального типа, нет проблем его иметь слева
map((#a) -> #b f, [#a] xs) => ... // тут аргумент функ. типа, тоже все ок

да::когда<уже::наконец, этот, тип<закончится>> x = create_some_object();

let x: тут::Неинтересно<Можно, Пропустить<до::ЗнакаРавенства>> = create_some_object();

def function(x, y: Y):

let s = 42
// val s : int = 42

let say (name : string) = Console.WriteLine("Hello, " + name)

type Person(name) =
    class
        do printfn "Person name is %s" name
    end

type Worker(name) =
    class
        inherit Person(name)
        do printfn "Worker name is %s" name
    end

let person = Person("Bob")
let worker = Worker("Steve")
let steve = worker :> Person // успешное приведение к предку (вверх). ошибки не будет

try
    let bob = person :?> Worker
    None
with :? System.InvalidCastException as e ->
    printfn $"Ошибка приведение к потомку(вниз) {e.Message}"
    None

Nemerle - x : int
C#      - int x
C++     - int x

int x
x : int
x int

def x : object = expression;

def x = expression : object;

int -> string

string * string -> void

public MyFunc(value : int, func : int -> string) : string
{
   "Результат: " + func(value)
}

type Псевдоним = Тип;

public type IntToStringType = int -> string;

public MyFunc(value : int, func : IntToStringType) : string
{
   "Результат: " + func(value)
}

public string MyFunc(int value, int -> string func)
{
   return "Результат: " + func(value);
}

Foo obj(1,2,"hello")

Foo obj = new Foo(1,2,"hello")

obj(1,2,"hello") Foo;

val obj1: Foo = new Foo(1, 2, "hello");
val obj2 = new Foo(1, 2, "hello"); // с автовыводом типа

x int;

int x;

name : string

ID1 * ID2;

int * ptr;

x * y;

Каррирование функций

let magic a b c = a *. float_of_int (String.length b + c);;                   
magic 1.0 "test" 2;;

scala> def magic(a: Float, b: String, c: Int): Float =
     |   a * (b.length() + c)
magic: (a: Float, b: String, c: Int)Float

scala> :t  (magic _)
(Float, String, Int) => Float

scala> :t (magic _).curried
Float => (String => (Int => Float))

Обобщенные функции

class Test<A> {
  <B> B magic(A a, B b) {
    return b;
  }

  public static void main(String[]  args) {
    final Test<String> test = new Test<>();
    test.<Thread>magic(null, null);
  }
}

class Genc<A> {
  <B> Genc(A a, B b) {
  }

  public static void main(String[] args) {
    new <Integer>Genc<String>("Hello", 42);
  }
}

class Test<A> {
  B magic<B>(B b) {
    return b;
  }
}

void main() {
  Test<String> s = new Test<String>();
  s.magic<BigInt>(null);
}

class Test<A> {
  A magic<A>(A b) {
    return b;
  }
}

void main() {
  Test<String> s = new Test<String>();
  s.magic<BigInt>(BigInt.parse("123"));
}

class Test[A] {
  def magic[B](a: A, b: B): B = b
}

val t = new Test[Int]
t.magic[String](42, "Hi")

scala>> def magic(a: Float, b: String, c: Int): Float =
M>     |   a * (b.length() + c)
M>magic: (a: Float, b: String, c: Int)Float

scala>> :t  (magic _)
M>(Float, String, Int) => Float

scala>> :t (magic _).curried
M>Float => (String => (Int => Float))
M>

def magic(Float a, String b, Int c): Float =  a * (b.length() + c)

M>class Test<A> {
M>  <B> B magic(A a, B b) {
M>    return b;
M>  }

M>  public static void main(String[]  args) {
M>    final Test<String> test = new Test<>();
M>    test.<Thread>magic(null, null);
M>  }
M>}
M>

class Test<A> {
  func<B> magic(A a, B b) B {
    return b;
  }
}

int x;

x int;

 (func(float*[]) int*)* fp;

typedef float (*func_ptr)(int);
using func_ptr = float (*)(int);

Foo obj(1,2,"hello")

Foo obj = new Foo(1,2,"hello")

obj(1,2,"hello") Foo;

(defgeneric description (object)
  (:documentation "Return a description of an object."))

(defmethod description ((object integer))
  (format nil "The integer ~D" object))

(defmethod description ((object float))
  (format nil "The float ~3,3f" object))

vsb>>val obj1: Foo = new Foo(1, 2, "hello");
vsb>>val obj2 = new Foo(1, 2, "hello"); // с автовыводом типа
vsb>>

var i: Int = 1

scala> def magic(a: Float, b: String, c: Int): Float =
     |   a * (b.length() + c)
magic: (a: Float, b: String, c: Int)Float

scala> :t  (magic _)
(Float, String, Int) => Float

scala> :t (magic _).curried
Float => (String => (Int => Float))

(Float, String, Int) => Float magic = ...

class Test<A> {
  B magic<B>(B b) {

class Test[A] {
  def magic[B](a: A, b: B): B = b
}

def magic(Float a, String b, Int c): Float =  a * (b.length() + c)
val (Float, String, Int) => Float magic2 = magic _

class<A> Test {
  func<B> magic(A a, B b) B {
    return b;
  }
}

(x : T) = v

DM>И еще лишний символ :, код аж на целую букву длиннее.