Nested asynchronous objects are a problem with Promises/A+, since you can't nest promises.
Compare Data.Task:
function AsyncMap() {
this.data = {}
}
// :: String, a -> Task<b, Unit>
AsyncMap.prototype.set = function(key, value) {
function id(a) { | |
return a | |
} | |
function compose(f, g){ return function(x) { | |
return f(g(x)) | |
}} | |
function partial(f, x) { | |
return function(y) { |
var models = [{ | |
name: 'Jonathan', | |
location: 'Earth' | |
}, { | |
name: 'Joe', | |
location: 'Mars' | |
}] | |
var ps = models.map(function(model) { |
module ConcatChurch is | |
import Prelude | |
# -- Helpers --------------------------------------------------------- | |
export $a get => match $a with | |
| $a' :: _ => $a' | |
end | |
export $a to-number => $a depth-start: 0 | |
where |
Nested asynchronous objects are a problem with Promises/A+, since you can't nest promises.
Compare Data.Task:
function AsyncMap() {
this.data = {}
}
// :: String, a -> Task<b, Unit>
AsyncMap.prototype.set = function(key, value) {
/** Consider the interface | |
interface Mappable<A> { | |
map: (A → B) → Mappable<B> | |
} | |
*/ | |
function Identity(value) { |
You appear to be advocating a new:
// :: String -> String | |
function concat(a){ return function(b){ | |
return a + b | |
}} | |
// :: (a -> b -> c) -> (b -> a -> c) | |
function flip(f){ return function(a){ return function(b) { | |
return f(b)(a) | |
}}} |
module Expression using: Platform where | |
open Platform Math expose [sqrt, +, -, *, /, π] | |
open Platform IO expose [print] | |
type Circle = { radius :: Double } | |
type Square = { side :: Double } | |
let { _ | side: s } area = s * s -- inferred type: { a | side :: Double } -> Double | |
let { _ | radius: r } area = π * r * r -- inferred type: { a | radius :: Double } -> Double |
Objeto é a noção de uma entidade que é definida inteiramente pelo seu comportamento. E esse comportamento é dinâmicamente selecionado. Em outras palavras, eu "peço" um objeto para "andar," e como ele vai fazer isso é inteiramente definido pelo objeto.
O exemplo:
objeto.anda()
Captura bem essa idéia. Eu tenho uma mensagem "anda," mas eu não consigo dizer o que essa função faz direto do meu código, porque isso depende no comportamento dinâmico da execução do programa (em uma linguagem estáticamente tipada você consegue optimizar isso, mas o raciocínio do código continua o mesmo).
/* | |
[DESAFIO / LANGUAGE WAR] Implemente um programa na sua linguagem favorita onde o usuário digita um número x, e o programa calcula o somatório dos x primeiros números pares da sequência fibonacci, e imprime a soma dos algarismos desse número. | |
Por exemplo, quando x = 5, a resposta é 17, pois: | |
1. A sequência fibonacci é 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233,... | |
2. Os 5 primeiros números pares são 0, 2, 8 e 34, 144. | |
3. O somatório disso é 188. | |
4. Somando os algarismos, 1+8+8 = 17 |