var array = [1, 2, 3];

var sum = 0;

for (var i = 0; i++; i < 3) {
  sum = sum + array[i];
}

print(sum);

arraySum([first]) := first;

arraySum([first, rest...]) :=
    first + arraySum(res);

print(arraySum([1, 2, 3])); // 6

array() = [1, 2, 3];

reduce([x], f) = x;
reduce([x, xs...], f) = f(x, reduce(xs));

sum(a, b) = a + b;

arraySum(xs) = reduce(xs, sum);

print(arraySum(array()));

function inc(x) {
  return x + 1;
}

var twice = function(f) {
  return function(x) {
    return f(f(x));
  };
};

var Plus2 = twice(inc);

console.log(inc(5)); // 6
console.log(Plus2(5)); // 7

import _ from 'lodash';

var obj = {
  x: [1, 2, 3],
  y: [4, 5, 6]
};

var accumulator = [];

for (var key in obj) {
  var subarray = obj[key];

  for (var i = 0; i < subarray.length; i++) {
    accumulator.push(subarray[i] * 2);
  }
}

var result = 0;

for (var j = 0; j < accumulator.length; j++) {
  result = result + accumulator[j];
}

import _ from 'lodash';

var obj = {
  x: [1, 2, 3],
  y: [4, 5, 6]
};

var result = _(obj)
  .values()
  .flatten()
  .map(x => x * 2)
  .reduce((a, b) = a + b)
  .value();

import _ from 'lodash';

var obj = {
  x: [1, 2, 3],
  y: [4, 5, 6]
};

var result = _(obj)
  .values() // [ [1, 2, 3], [3, 4, 5] ]
  .flatten() // [1, 2, 3, 4, 5, 6]
  .map(x => x * 2) // [2, 4, 6, 8, 10, 12]
  .reduce((a, b) = a + b)
  .value(); // результат

var timeout = async function(value, time) {
  return new Promise((resolve) => {
    setTimeout(() => resolve(x), time * 1000);
  });
};

timeout('a', 5);
timeout('b', 2);
timeout('c', 3);

// b c a
// in 5 seconds


async function synchronizeMe() {
  var a = await timeout('a', 5);
  var b = await timeout('b', 2);
  var c = await timeout('c', 3);

  // a b c
  // in 10 seconds

  return a + b + c;
}

var result = await synchronizeMe();

console.log(result); // 'abc';

import {Boo} from 'boolib';
import {Generic} from 'genericlib';

export class Foo extends Boo {
  private a: string;
  public readonly b: number;

  @AnnotationExample("with param")
  constructor() {}

  private somePrivateMethod<T>(
    x: Generic<T>,
    f: (number) => string[],
    obj: any): number|string {

    const z = (a) => {
      const b = a + x.y;

      return b;
    };

    const oneliner = (a, b) => a + b;

    const { c: number[]; d: { e: string, g: number } } = obj;

    console.log(c[0] + g);

    return 10;
  }
}