Objective-C тянет за собой наследие NeXTSTEP плюс довольно отличающийся от Java-подобных языков синтаксис. Swift, похоже, проще и традиционнее в этом плане и позволит легче влиться тем, кто не может совладать с Objective-C. Ну и вдобавок, надо же свой язык запилить, а то вон — у всех конкурентов уже есть :)
Вот рассказал бы кто — будет возможность создания кастомных итераторов? Я имею ввиду не генераторы, а произвольные объекты которые можно передавать в оператор for..of.
Сейчас в Фаерфоксе такое можно делать, определяя у объекта метод "@@ iterator" (т.е. внутреннее имя этого метода в спецификации), но обязательность этой возможности вроде бы не задекларирована. Знает ли кто-нибудь об этой возможности?
Иногда мне импонирует подход Scala, где immutable-типы данных конструируются не с помощью new, а с помощью объекта-конструктора, который имеет такое же название как и имя типа конструируемого экземпляра. В этом случае есть возможность создавать объекты не одного типа, а производных этого типа, в зависимости от переданных параметров.
Что-то вроде этого
function Animal(animalType, name) {
if (this instanceof Animal) {
throw new Error('Should be called without "new" keyword');
}
var instanceType = ({
'dog': Dog,
'cat': Cat,
'cow': Cow
})[animalType];
if (typeof instanceType == 'undefined') {
throw new Error('Unknown type of the animal');
}
return new instanceType(name);
}
Animal.prototype.say = function() { throw new Error('Not implemented'); };
// -----------------------------------------------------------------------------
function Dog(name) {
this.name = name;
}
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;
Dog.prototype.say = function() { return this.name + ' says Woof!'; };
// -----------------------------------------------------------------------------
function Cat(name) {
this.name = name;
}
Cat.prototype = Object.create(Animal.prototype);
Cat.prototype.constructor = Cat;
Cat.prototype.say = function() { return this.name + ' says Meow!'; };
// -----------------------------------------------------------------------------
function Cow(name) {
this.name = name;
}
Cow.prototype = Object.create(Animal.prototype);
Cow.prototype.constructor = Cow;
Cow.prototype.say = function() { return this.name + ' says Mooo!'; };
// -----------------------------------------------------------------------------
var animals = [
Animal('dog', 'Sparky'),
Animal('cat', 'James'),
Animal('cow', 'Mathilda')
];
animals.forEach(function(animal) {
console.log([animal.constructor.name, animal instanceof Animal,
animal.say()].join(', '));
});
/*
Dog, true, Sparky says Woof!
Cat, true, James says Meow!
Cow, true, Mathilda says Mooo!
*/
Т.е. есть возможность абстрагироваться от проверки конкретных значений параметров, когда это не требуется и просто вызывать конструктор Animal получая экземпляр нужного подтипа.
Тут цели разные. onComplete — это способ получения и вывода значения из под Future (или ошибки, если она произошла). Цепочки асинхронных блоков, разумеется, нужно конструировать с помощью map, flatMap и recover, ибо все эти функции сами порождают новый Future.
У инстанса Future есть метода onComplete который принимает функцию, которая принимает Try как параметр. Если Future обработал корректно — будет Success, если нет — Failure. Это, наверное, самый правильный способ работать с Future.
В Firefox все нормально.
Сейчас в Фаерфоксе такое можно делать, определяя у объекта метод "@@ iterator" (т.е. внутреннее имя этого метода в спецификации), но обязательность этой возможности вроде бы не задекларирована. Знает ли кто-нибудь об этой возможности?
Т.е. есть возможность абстрагироваться от проверки конкретных значений параметров, когда это не требуется и просто вызывать конструктор Animal получая экземпляр нужного подтипа.
Я предпочитаю, например, каноничное "| 0".
Boolean(x) === falseЗачем? Неужели так читаемее?
Простите за хейтерский тон.
Еще есть метода onSuccess и onFailure.
Можно здесь почитать
UPD: хотя recover тоже круто