RC divides execution into three distinct phases: mutation, reference counting collection, and cycle collection.

We have implemented both types of collector: a multiprocessor concurrent reference counting collector with cycle collection

Полиморфи́зм — возможность объектов с одинаковой спецификацией иметь различную реализацию. Язык программирования поддерживает полиморфизм, если классы с одинаковой спецификацией могут иметь различную реализацию — например, реализация класса может быть изменена в процессе наследования[1]. Кратко смысл полиморфизма можно выразить фразой: «Один интерфейс, множество реализаций».

var f = (int x) => x * 2;

void Write(string data) {}

Java is closer than C# thanks to the excellent work in HotSpot-like VMs which employ code pitching and stack allocation.

I’ve seen many people run away from garbage collection back to C++, with a sour taste permeating their mouths. (To be fair, this is only partly due to garbage collection itself; it’s largely due to poor design patterns, frameworks, and a lost opportunity to do better in the language.)

val A = List(1 to 10 : _*)
A foreach println

  @inline override final
  def foreach[B](f: A => B) {
    var these = this
    while (!these.isEmpty) {
      f(these.head)
      these = these.tail
    }
  }

  override /*IterableLike*/
  def foreach[U](f: A => U): Unit = {
    var i = 0
    val len = length
    while (i < len) { f(this(i)); i += 1 }
  }

function concatenate(a, b);

Matrix3x3 concatenate(Matrix3x3 a, Matrix3x3 b);

#include <iostream>

template<typename F, typename ...Args>
auto apply(F f, Args... args)
{
    return f(args...);
}

double foo(int x, double y)
{
    return x + y;
}

int main()
{
    std::cout << apply(foo, 1, 0.1);
}

def apply(f, *args):
    return f(*args)

def foo(x, y):
    return x + y

print apply(foo, 1, 0.1)

А>function concatenate(a, b);
А>

А>Matrix3x3 concatenate(Matrix3x3 a, Matrix3x3 b);
А>

template<SemiGroupElement T>
T concatenate(T a, T b);

template<typename SemiGroupElement>
SemiGroupElement concatenate(SemiGroupElement a, SemiGroupElement b);

template <class T, class Integer, class MonoidOperation>
T power(T x, Integer n, MonoidOperation op);

foo(lambda x: bar(x, 1))

foo(x => bar(x, 1));

foo([](auto x){ return bar(x, 1); });

template<typename F, typename ...Args>
auto apply(F f, Args... args)
{
    return f(args...);
}

foo([](auto x){ return bar(x, 1); });

foo(lambda x: bar(x, 1))