SA>Замечательный язык, не правда ли?! простой, выразительный, элегантный и эффективно решающий типичные проблемы.

> [1,2,3].map(parseInt)
< [1, NaN, NaN]

> ['10','10','10','10','10'].map(parseInt)
< [10, NaN, 2, 3, 4]

var ref = function (value) {
    if (value && value.then)
        return value;
    return {
        then: function (callback) {
            var result = defer();
            // XXX
            enqueue(function () {
                result.resolve(callback(value));
            });
            return result.promise;
        }
    };
};

S>array.Map( (value,index) => ParseInt(value,index) );
S>

array.map(function (e) { return parseInt(e) });

[1, 2, 3].map(Number);

// вот два метода, запускающие что-то асинхронно.
let f1 = () => new Promise(...);
let f2 = () => new Promise(...);

// если надо запустить их в параллель:
f1();
f2();

// а если надо последовательно:
f1().then( f2 ); // после окончания первого промиса будет выполнена f2, получен новый промис и запущен.

// отсюда частый косяк людей, которые делают связку, не изучив документацию или учебник пишут так:
f1().then( f2() ); // упс, так это же получился запуск двух промисов в параллель!

template<class T, class Deleter = std::default_delete<T>> 
class unique_ptr;

> const arr = new Array(4);
[undefined, undefined, undefined, undefined]

> arr.map((elem, index) => index);
[undefined, undefined, undefined, undefined]

1) 
doSomething().then(function () {
  return doSomethingElse();
});

2)
doSomething().then(function () {
  doSomethingElse();
});

3)
doSomething().then(doSomethingElse());

4)
doSomething().then(doSomethingElse);

success()
.then(function() { console.log('1+'); return fail(); }, function () {console.log('1-'); })
.then(function() { console.log('2+'); }, function () {console.log('2-'); return success();})
.then(function() { console.log('3+'); }, function () {console.log('3-'); })
.done();

SA>doSomething().then(doSomethingElse);
SA>

doSomething()
    .then(doSomethingElseInAnyCase)
    .next(doSomethingElseOnSuccess)
    .recovery(doSomethingElseOnError);

>> [1,2,3].map(parseInt)
F>< [1, NaN, NaN]
F>

parseInt(1, 0);   # зависит о реализации, скорее всего 1 по основанию 10
parseInt(2, 1);   # 2 - не число по основанию 1
parseInt(3, 2);   # 3 - не число по основанию 2

>> ['10','10','10','10','10'].map(parseInt)
F>< [10, NaN, 2, 3, 4]
F>

await doSomething();
return doSomethingElse();

function delay(ms) {
    return new Promise(function (resolve) {
        setTimeout(resolve, ms);
    });
}
async function asyncAwait() {
    console.log("Knock, knock!");
    await delay(1000);
    console.log("Who's there?");
    await delay(1000);
    console.log("async/await!");
}

array.Map( (value,index) => ParseInt(value,index) );

Это странный аргумент из разряда «настоящие программисты не читают мануалы».

var when = function (value, _callback, _errback) {
    var result = defer();
    var done;

    _callback = _callback || function (value) {
        return value;
    };
    _errback = _errback || function (reason) {
        return reject(reason);
    };

    // XXX
    var callback = function (value) {
        try {
            return _callback(value);
        } catch (reason) {
            return reject(reason);
        }
    };
    var errback = function (reason) {
        try {
            return _errback(reason);
        } catch (reason) {
            return reject(reason);
        }
    };

    enqueue(function () {
        ref(value).then(function (value) {
            if (done)
                return;
            done = true;
            result.resolve(ref(value).then(callback, errback));
        }, function (reason) {
            if (done)
                return;
            done = true;
            result.resolve(errback(reason));
        });
    });

    return result.promise;
};

и таки язык должен [ограничивать]. если не может, я его выкидываю. и так делают все нормальные программисты испокон веков.

var arr=['10', '10', '10']
for( item in arr  ) console.log(parseInt(item))

TSP>var arr=['10', '10', '10']
TSP>for( item in arr  ) console.log(parseInt(item))
TSP>

TSP>И получаем 0 1 2

let list = [4, 5, 6];

for (let i in list) {
   console.log(i); // "0", "1", "2",
}

for (let i of list) {
   console.log(i); // "4", "5", "6"
}

var ref = function (value) {
    if (value && value.then)
        return value;
    return {
        then: function (callback) {
            var result = defer();
            // XXX
            enqueue(function () {
                result.resolve(callback(value));
            });
            return result.promise;
        }
    };
};

map (+) [1,2,3]

will be generated as:

var numbers = [1, 2, 3];
for (var _i = 0; _i < numbers.length; _i++) {
var num = numbers[_i];
console.log(num);
}

def foo (*args):
    print args
def bar (fn):
    fn(1, 2)
bar(foo)