robotlolita

function id(a) {
  return a
}

function compose(f, g){ return function(x) {
  return f(g(x))
}}

function partial(f, x) {
  return function(y) {

robotlolita

var models = [{
    name: 'Jonathan',
    location: 'Earth'
}, {
    name: 'Joe',
    location: 'Mars'
}]

var ps = models.map(function(model) {

robotlolita

module ConcatChurch is
  import Prelude

  # -- Helpers ---------------------------------------------------------
  export $a get => match $a with
                   | $a' :: _ => $a'
                   end

  export $a to-number => $a depth-start: 0
                         where

robotlolita

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) {

robotlolita

/** Consider the interface

interface Mappable<A> {
  map: (A → B) → Mappable<B>
}

*/


function Identity(value) {

robotlolita

You appear to be advocating a new:

• functional
• imperative
• object-oriented
• procedural
• stack-based
• "multi-paradigm"
• lazy
• eager
• statically-typed

robotlolita

// :: 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)
}}}

robotlolita

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

robotlolita

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).

robotlolita

/*

[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