int foo = 1;
cout << sizeof foo << endl; // 4

unsigned int foo = 1;
cout << foo << endl; // 1

unsigned int foo = -100;
cout << foo << endl; // 4 294 967 196

unsigned short foo = 1;
cout << sizeof foo << endl; // 2

string foo = "hello!";
int bar = 100;
foo = bar; // нет ошибок от компилятора
cout << foo << endl; // 'd' ???

string name = "John";
int age = 40;
name = age;
cout << name << endl; // '('

string name = "John";
int age = 40;
void* vp = &age;
*(string*)vp = name;
cout << age << endl; // 1752123912

val foo: Int = 123
val bar: String = foo // Type mismatch: inferred type is Int but String was expected

val foo: Int = 123
val bar: String = foo as String // java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String

val foo: Int = 123
val bar: String? = foo as? String // нет ошибки
print(bar) // null

let a = "привет";
console.log(a); // "привет"
a = 123;
console.log(a); // 123

function sqr(n) {
  return n * n;
}
const result = sqr("привет!");

function sqr(n) {
  if (isFinite(n)) {
    return n * n;
  }
  return 1;
}
const result = sqr("привет!");

typeof [] // 'object'
typeof null // 'object'
isFinite("") // true

let foo = true;
// ...
foo = 1234567890;

// объединение для хранения значения
union ValueUnion {
  bool boolValue; // bool-значение (1 байт)
  double doubleValue; // число (8 байт)
  void *objectPtr; // указатель на участок памяти (8 байт из-за 64-битной адресации памяти)
};
// поддерживаемые типы значений
enum class Type : char {
  number = 1,
  boolean = 2,
  object = 4
};
// описание значения
struct ValueWrapper {
  Type type; // тип значения (1 байт)
  ValueUnion value; // значение (8 байт)
};
// набор сеттеров
void setNumber(ValueWrapper *value, double data) {
  value->type = Type::number;
  value->value.doubleValue = data;
}
void setBool(ValueWrapper *value, bool data) {
  value->type = Type::boolean;
  value->value.boolValue = data;
}
void setObjPtr(ValueWrapper *value, void *data) {
  value->type = Type::object;
  value->value.objectPtr = data;
}
int main() {
  cout << sizeof(ValueWrapper) << endl; // 16
  auto *pValueWrapper = new ValueWrapper;
  // записываем число
  setNumber(pValueWrapper, 100);
  cout << pValueWrapper->value.doubleValue << endl; // 100
  // записываем boolean
  setBool(pValueWrapper, true);
  cout << pValueWrapper->value.boolValue << endl; // 1
  auto *strP = new string("hello!");
  // записываем указатель на участок памяти
  setObjPtr(pValueWrapper, strP);
  cout << *(string*)pValueWrapper->value.objectPtr << endl; // hello!
  return 0;
}

const foo: number = 123;
const bar: string = foo; // Type 'number' is not assignable to type 'string'

Array.prototype.filter = () => ':(';
[1, 2, 3].filter(isEven); // ':('

type Foo = { a: string, b: number };
const foo: Foo = { a: "привет", b: 123 };
someExternalFunction(foo); // внешний код, написанный не нами
console.log(foo.b); // ???

type Foo = { a: string, b: number };
function handleFoo(foo: Foo) {
  // ...
}
handleFoo({a: "hello!", b: 123 }); // OK
handleFoo({a: "hello!", b: 123, c: 456 }); // Argument of type '{ a: string; b: number; c: number; }' is not assignable to parameter of type 'Foo'. Object literal may only specify known properties, and 'c' does not exist in type 'Foo'.

type Foo = { a: string, b: number };
type Bar = { a: string, b: number, c: number };
function handleFoo(foo: Foo) {
  // ...
}
const bar: Bar = { a: "hello!", b: 123, c: 456 };
handleFoo(bar); // OK

type Foo = { a: string, b: number };
type Bar = { a: string, b: number, [key: string]: any};
function serializeFoo(foo: Foo) {
  return JSON.stringify(foo)
}
const bar: Bar = { a: "hello!", b: 123, ...tons of properties };
serializeFoo(bar); // OK

type Foo = {| a: string, b: number |}; // exact object type
type Bar = { a: string, b: number, c: number};
function serializeFoo(foo: Foo) {
  return JSON.stringify(foo)
}
const bar: Bar = { a: "hello!", b: 123, c: 123 };
serializeFoo(bar); // Cannot call `serializeFoo` with `bar` bound to `foo` because inexact `Bar` is incompatible with exact `Foo`

open class A(val foo: String)
class B(foo: String, val bar: String) : A(foo)
fun main() {
  val b: B = B("foo", "bar")
  val a: A = b // используем объект типа B в качества значения типа A
  serializeA(a) // OK
}

open class A(val foo: String)
class B(foo: String, val bar: String) : A(foo)
class PropertyInfo<T>(val name: String, val type: KType, val value: T)
fun main() {
  val b: B = B("foo value", "bar value")
  val a: A = b // используем объект типа B в качества значения типа A
  val items = A::class.memberProperties // получаем только поля типа A
    .map { PropertyInfo(it.name, it.returnType, it.getter.call(a)) }
  items.forEach { println("${it.name}: ${it.type} = ${it.value}") } // foo: kotlin.String = foo value
}