dvanhorn

Memoization is fundamentally a top-down computation and dynamic
programming is fundamentally bottom-up.  In memoization, we observe
that a computational *tree* can actually be represented as a
computational *DAG* (the single most underrated data structure in
computer science); we then use a black-box to turn the tree into a
DAG.  But it allows the top-down description of the problem to remain
unchanged.

In dynamic programming, we make the same observation, but construct
the DAG from the bottom-up.  That means we have to rewrite the

swannodette

(defn distincto
  "s is a sequence of sequence of vars.
   ensure that vars in each particular sequence
   take on distinct values."
  [s]
  (if (seq s)
    (let [vars (first s)]
      (all
        (distinctfd vars)
        (distincto (next s))))

matthewp

(function() {
  "use strict";

  Object.defineProperty(HTMLLinkElement.prototype, 'template', {
    get: function() {
      if(!/template/i.test(this.rel)) {
        return "";
      }

      var req = new XMLHttpRequest();

rsms

; ModuleID = 'struct1'

;    Object = struct
;      foo = 1
%ObjectT = type <{ i64 }>  ; foo
@ObjectS = private unnamed_addr constant %ObjectT <{ i64 1 }>
;    Shape = struct Object
;      color = 0xff0000
;      area = func () 0
;      fillColor = func () @color / @area!

alandipert

(extend-type js/RegExp
  cljs.core/IFn
  (-invoke ([this s] (re-matches this s))))

(#"foo.*" "foobar") ;=> "foobar"
(#"zoo.*" "foobar") ;=> nil

(filter #".*foo.*" ["foobar" "goobar" "foobaz"]) ;=> ("foobar" "foobaz")

fjolnir

The bridge is now located at https://github.com/fjolnir/TLC

datagrok

This article is now published on my website: Prefer Subshells for Context.

hrldcpr

One-line Tree in Python

Using Python's built-in defaultdict we can easily define a tree data structure:

def tree(): return defaultdict(tree)

That's it!

jlongster

;; Requires Outlet to run: https://github.com/jlongster/outlet
;;
;; Run with: `ol main.ol <input-file>`
;; 
;; This is a meta-circular evaluator for a basic Lisp. It is
;; mostly taken from SICP 4.1*. I wanted to see if I could write a
;; debugger with it. Turns out if I want control over control flow I
;; need a register-based interpreter.
;;
;; * http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-26.html#%_sec_4.1

dherman

// Version 1. Simple recursive function. Blows the stack for large nodes.
function replace(node, from, to) {
    switch (node.type) {
      case IF:
        return {
            type: IF,
            test: replace(node.test, from, to),
            then: replace(node.then, from, to),
            else: replace(node.else, from, to)
        };