robotlolita

<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

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

The `doll` markup language is a *lightweight* markup language inspired
by /org-mode/, /markdown/, /ReStructuredText/ and regular /Emacs Lisp/
documentation, designed to be used as documentation comment syntax for
the Calliope project.


== Commands ===================================================================

TODO.

robotlolita

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:
xs.map(f)

robotlolita

// Frees the `[].slice` method to accept `this` as the first actual argument,
// rather than a special argument.
var toArray = Function.call.bind([].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

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

robotlolita

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

 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

You appear to be advocating a new:

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

robotlolita

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);
        })