Skip to content

Instantly share code, notes, and snippets.

Avatar
🐴
everything happens so much oh no

Quil robotlolita

🐴
everything happens so much oh no
View GitHub Profile
View seqs.js
function id(a) {
return a
}
function compose(f, g){ return function(x) {
return f(g(x))
}}
function partial(f, x) {
return function(y) {
View 0-promises.js
var models = [{
name: 'Jonathan',
location: 'Earth'
}, {
name: 'Joe',
location: 'Mars'
}]
var ps = models.map(function(model) {
@robotlolita
robotlolita / ConcatChurch.purr
Last active Aug 29, 2015
Concatenative stack-based language with church encoded data structures in Purr.
View ConcatChurch.purr
module ConcatChurch is
import Prelude
# -- Helpers ---------------------------------------------------------
export $a get => match $a with
| $a' :: _ => $a'
end
export $a to-number => $a depth-start: 0
where
View diffs.md

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) {
View mappables.js
/** Consider the interface
interface Mappable<A> {
map: (A → B) → Mappable<B>
}
*/
function Identity(value) {
@robotlolita
robotlolita / purr.md
Last active May 10, 2017
Why Purr is awful
View purr.md

You appear to be advocating a new:

  • functional
  • imperative
  • object-oriented
  • procedural
  • stack-based
  • "multi-paradigm"
  • lazy
  • eager
  • statically-typed
View applicative.js
// :: 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
robotlolita / expression-problem.hs
Last active Aug 29, 2015
Solving the expression problem in Harmonia (with structural typing through row-polymorphism and multi-methods)
View expression-problem.hs
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
robotlolita / oop.md
Last active Dec 27, 2018
O que é OOP? Por que Java não deve ser considerado uma linguagem com um bom suporte para esse paradigma?
View oop.md

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

View Language War.cpp
/*
[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