Skip to content

Instantly share code, notes, and snippets.

everything happens so much oh no

Quil robotlolita

everything happens so much oh no
View GitHub Profile
robotlolita /
Last active Nov 6, 2021
Why `xs.each(f)` should not be considered a "loop".

First and foremost, let's take a look at the following pieces of code. The first one is something you should be rather familiar with, and the second one is also a somewhat familiar idiom these days (at least in languages with higher-order functions):

// Example 1:
30 + 12

// Example 2:
View left-join.js
// Frees the `[].slice` method to accept `this` as the first actual argument,
// rather than a special argument.
var toArray =[].slice)
// To make searching efficient (O(1)), we switch the
// list of things to a HashMap, which allows we to
// retrieve an item by its name in constant time.
function indexBy(field, list) {
return list.reduce(function(result, item) {
result[item[field]] = item
robotlolita /
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?

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:


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 ValidarFormularioNovo.js
const Validation = require('folktale/validation');
const { Success, Failure } = Validation;
// valida se uma string não é vazia
const hasText = (value, name) =>
if (value != "") Success(value)
else Failure([{ code: 'required', name }]);
// valida se uma selecao não é vazia
const hasSelection = (value, name) =>

Unclutter calendar:

javascript:void (() => { Array.from(document.querySelectorAll('.calendar .item')).filter(x => !/\b(green|yellow)\b/.test(x.className)).forEach(x => x.parentNode.removeChild(x)); Array.from(document.querySelectorAll('.browse__content .section')).filter(x => { const a = x.querySelector('h2'); return x.textContent.trim() === a.textContent.trim() }).forEach(x => x.parentNode.removeChild(x)) })()
robotlolita / gist:7216015
Created Oct 29, 2013
Basically, every time the subject "correctness" comes up. Every. Single. Time. Damn, no wonder we have bugs everywhere.
View gist:7216015
<dmanderson> Oh Domo :)
<dmanderson> Nice templater
<Sorella> Oh.
<dmanderson> I've been using an underscore to JST compiler as of late, but
this looks really nice.
<Sorella> I don't quite like Domo, but sure.
<Sorella> Oh Lord, don't use Underscore's templating. Like,
really. Don't. Just. Don't.
<dmanderson> No I'm using JST
<dmanderson> writing the templates in underscore
robotlolita / gist:1966465
Last active Jul 17, 2017
Really naïve and small subset of Lisp
View gist:1966465
ometa NaiveLispParser {
fromTo :x :y = seq(x) (~seq(y) char*) seq(y),
space = ^space | fromTo(';', '\n'),
symbol = '+' | '=' | '-' | '_' | '*' | '%' | '!' | '/' | '^' | '>' | '<',
idChars = symbol | letterOrDigit,
nil = spaces "nil" -> #nil,
id = spaces idChars+:id -> [#id, id.join('')],
num = spaces digit+:d -> [#num, Number(d.join(''))],
funcall = "(" expr:hd (spaces expr)*:tl ")" -> [hd, tl],
robotlolita /
Last active May 10, 2017
Why Purr is awful

You appear to be advocating a new:

  • functional
  • imperative
  • object-oriented
  • procedural
  • stack-based
  • "multi-paradigm"
  • lazy
  • eager
  • statically-typed
View key-gen.js
var fs = require("fs");
var helpers = require("./helpers");
var path = require("path");
function readFile(path, options) {
return new Promise(function(resolve, reject) {
fs.readFile(path, options, function(err, data) {
if (err) reject(err);
else resolve(data);
View promises.js
'use strict';
var promise = {
state: 'pending',
value: null,
dependencies: [],
then: function(expression) {