graue

four primitives: run*, ==, conde, fresh

(run* (q)
  (== q #t))

; for what values of q is q equal to true?

answer: q must also be #t, so
'(#t)    ; answer comes back in a list

graue

extern mod std;
use core::num::IntConvertible;
use core::ops::Modulo;

fn find_even<T:Copy+Modulo<T,T>+IntConvertible+cmp::Eq>(vec: &[T]) -> Option<T> {
    let zero: T = IntConvertible::from_int(0);
    let two: T = IntConvertible::from_int(2);
    for vec.each |x| {
        if *x % two == zero {
            return Some(*x);

graue

extern mod std;
use core::task::spawn;
use core::comm::{stream, Port, Chan, SharedChan};

// Purely functional doubler
// No need to combine computation / means of sending it in the same function
// In a real example, this could be an expensive computation
fn double(x: int) -> int {
    x * 2
}

graue

Using TJ Holowaychuk's "watch" with make

Note: I edited this and turned it into a blog post - read that instead.

While poking around some random projects by the prolific TJ Holowaychuk, I came upon his version of watch, which simply executes a given command periodically.

The idea is to pair it with make to run tests and automatically rebuild/recompile code. Since make tracks dependencies and looks at file modification times, it won't do anything if the relevant source files haven't changed.

There's a program called watch that comes with Linux, but it doesn't play as nicely with make. In particular, it clears the screen every time the command is run. For pairing this with make, we want new output to be printed whenever make actually does anything, and otherwise we want it to be silent.

graue

---
layout: nil
---
<?xml version="1.0"?>
<feed xmlns="http://www.w3.org/2005/Atom">

  <title>Divagations of a graphomane</title>
  <link href="http://scott.mn/"/>
  <link type="application/atom+xml" rel="self" href="http://scott.mn/posts.atom"/>
  <updated>{{ site.time | date_to_xmlschema }}</updated>

graue

NOTE: Scroll down for explanation (the difference turns out to be scoping, not closures per se).


$ cat juices.lua 
local fruits = {"apple", "orange", "grape"}
local juicers = {}

for i,v in ipairs(fruits) do
    local fruit = v
    juicers[i] = function() return fruit .. " juice" end

graue

-- delay effect

local wrap      = require "util.wrap"
local HistArray = require "util.histArray"




-- Convert a millisecond measurement to a whole number of samples.
local function msToSamples(ms)

graue

local HistArray = require "histArray"

-- The HistArray module provides an array that automatically purges
-- old values. It lets you write code like:
--
-- y[n] = c1*x[n] + c2*x[n-1] + c3*x[n-2]
--                - c4*y[n-1] - c5*y[n-2]
--
-- If x and y are HistArrays created with history size 2, all samples from
-- x[n-3] and y[n-3] and below will be purged (accessing them is an error)

graue

1 bag frozen blueberries
4 bananas
unsweetened applesauce
egg replacer
firm tofu
vegetable broth

graue

upstream potsfyi {
    server 127.0.0.1:8000 fail_timeout=0;
}

server {
    listen 4004;
    server_name _;
    keepalive_timeout 10;

    location / {