The Little Calculist

good programming

function captured() {
   try {
       handler->();
       throw "throw";
   }
   finally {
       alert("finally!");
   }
}

function handler(k) {
   k();
}
function foo(x) { f(x); g(x, 2 * x, null); return x + 4; }
{ {()} g(42, 2 * 42, null); return 42 + 4; }
{ g(42, (), null); return 42 + 4; }
{ {()} }
function mightFail(k) {
  // ...
  throw "boo!";
}
function main() {
  try {
      mightFail->()
  }
  catch (x) {
      return 42
  }
}
main() // uncaught exception: "boo!"
#define MY_ENUM_LIST(m) \
   m(RED, 0), \
   m(GREEN, 1), \
   m(BLUE, 2)

#define DEF_ENUM_ENTRY(c, v) c = v
#define QUOTE_ENUM_ENTRY(c, v) #c

typedef enum rgb {
   MY_ENUM_LIST(DEF_ENUM_ENTRY)
} rgb;

const char *rgb_names[] = {
   MY_ENUM_LIST(QUOTE_ENUM_ENTRY)
};
(define (fact-iter n acc)
  (if (zero? n)
      (error 'fact "stop!")
      (fact-iter (sub1 n) (* n acc))))
(fact-iter 3 1)
(require (planet dherman/tail:4))
(define-syntax #%app trace-app)
(provide (all-defined-out))
(require (rename-in (planet dherman/tail:5) [trace-app #%app]))
(require (only-in (planet dherman/tail:5) [trace-app #%app]))
let val y = 1
in
  if true then
      λx.x+y
  else
      λz.z
end
let val y = 1
in
  if true then
      (λ(env, x).x+#y(env), {y=y})
  else
      (λ(env,z).z, {})
end
let val y = 1
in
  if true then
      pack {y:int} with (λ(env,x).x+#y(env), {y=y})
      as ∃t.((t × int) → int) × t
  else
      pack {} with (λ(env,z).z, {})
      as ∃t.((t × int) → int) × t
end
(lib "string.ss" "scheme")
scheme/string
int x, *y, z[3];
int x, f(char);
int *p, x;
int *f(char);
int (*f)(char);
int (*(foo[3]))(char);
> `#hash((x . ,(+ 1 2)))
#hash((x . 3))
typedef int my_int;
my_int x;
> (define ls '(1 2 3))
> `#(unquote ls)
#(1 2 3)
> `#,ls
#,ls
> (define time.h
   (make-header
     #reader (planet dherman/c/reader) {
         struct tm {
             int tm_sec;
             int tm_min;
             int tm_hour;
             int tm_mday;
             int tm_mon;
             int tm_year;
             int tm_wday;
             int tm_yday;
             int tm_isdst;
         };
     }))
> (define time-abi
   (compile-header time.h
     (system-compiler #:include<> '("time.h") gcc)))
> (layout-size (time-abi 'tm))
36
> (layout-offset (time-abi 'tm) 'tm_sec)
0
> (layout-offset (time-abi 'tm) 'tm_year)
20
> (define (f) (display (g 42)))
> (define-syntax g (syntax-rules () ((g x) (quote x))))
> (f)
> (define/inline (f) (g 42))
> (define/inline (g n) (add1 n))
> (f)
> (define (foo x) (f x))
> (define (f x) (add1 x))
> (foo 41)
42
> (define-syntax f (syntax-rules () ((f e) (quote e))))
> (foo 41)
x
{-# LANGUAGE RankNTypes, TypeOperators #-}

f1 :: ∀ a b . a → b → b
f1 x y = y

f2 :: ∀ b a . a → b → b
f2 x y = y

h :: (∀ a b . a → b → b) → c → d → d
h f x y = f x y

a = h f1
b = h f2
(function() {
  eval("var x = 10")
  return x
})()
function test() {
  var x = 'outer'
  return (function() {
              {
                  let x = 'inner'
                  eval("var x = 'eval'")
              }
              return x
          })()
}
function test() {
  var x = 'outer'
  return (function() {
              try { throw 'inner' }
              catch(x) { eval("var x = 'eval'") }
              return x
          })()
}
{
  2 + 2;
}
for (var i = 0; i < n; i++)
  f(i);
> (define bp (debug <expression>))
> bp
#<breakpoint>
> (show-control bp)
(require (planet dherman/debug))
let gravity = 9.8<m/s^2>
+: float<'u> -> float<'u> -> float<'u>
+: float<log 'u> -> float<log 'v> -> float<log ('u · 'v)>
(define-datatype Expr
 [Var ([name : Symbol])]
 [Abs ([var : Symbol] [body : Expr])]
 [App ([rator : Expr] [rand : Expr])])
(begin
 (define-struct: Var ([name : Symbol]))
 (define-struct: Abs ([var : Symbol] [body : Expr]))
 (define-struct: App ([rator : Expr] [rand : Expr]))
 (define-type-alias Expr (U Var Abs App)))
(define-struct thing (foo bar))
infix <:
(<:) :: Ty -> Ty -> Bool
x <: y = x `subtype` y -- for some auxiliary subtype function
t1 <: t2 <: t3
> (eqv? +NaN.0 +NaN.0)
#t
> (eq? +NaN.0 +NaN.0)
#t
> (= +NaN.0 +NaN.0)
#f
> (equal? +NaN.0 +NaN.0)
#t
signature VISITOR = sig
    datatype cmd = Stop | Skip | Cont

    type ('a, 'z) method = 'a * 'z -> 'z * cmd

    type 'z visitor = { visitExpr : (Ast.expr, 'z) method,
                        visitStmt : (Ast.stmt, 'z) method,
                        visitDecl : (Ast.decl, 'z) method }

    val foldExpr : 'z visitor * Ast.expr * 'z -> 'z
    val foldStmt : 'z visitor * Ast.stmt * 'z -> 'z
    val foldDecl : 'z visitor * Ast.decl * 'z -> 'z
end;
type children = Ast.expr list * Ast.stmt list * Ast.decl list

fun exprChildren (e : Ast.expr) : children = ...
fun stmtChildren (e : Ast.stmt) : children = ...
fun declChildren (e : Ast.decl) : children = ...
type 'z cont = 'z -> 'z

fun cont (result : 'z, cmd : cmd)
         (skipk : 'z cont)
         (contk : 'z cont)
    : 'z =
    case cmd of
        Stop => result
      | Skip => skipk result
      | Cont => contk result

fun foldExprK (v as { visitExpr, ... }, expr, init) k =
    cont (visitExpr (expr, init))
         (fn x => foldAllK v (exprChildren expr) x k)
         k

and foldStmtK (v as { visitStmt, ... }, stmt, init) k =
    cont (visitStmt (stmt, init))
         (fn x => foldAllK v (stmtChildren stmt) x k)
         k

and foldDeclK (v as { visitDecl, ... }, decl, init) k =
    cont (visitDecl (decl, init))
         (fn x => foldAllK v (declChildren decl) x k)
         k

and foldAllK (v : 'z visitor)
             ((exprs, stmts, decls) : children)
             (init : 'z)
             (k : 'z cont)
    : 'z =
    let
        fun foldList f (v, asts, init) k =
            case asts of
                [] => k init
              | [ast] => f (v, ast, init) k
              | ast::asts => f (v, ast, init)
                               (fn x => foldList f (v, asts, x) k)
    in
        foldList foldExprK (v, exprs, init) (fn result =>
            foldList foldStmtK (v, stmts, result) (fn result =>
                foldList foldDeclK (v, decls, result) k))
    end
fun id x = x

fun foldExpr x = foldExprK x id
fun foldStmt x = foldStmtK x id
fun foldDecl x = foldDeclK x id
> fun foo (k : int -> 'a) (x : int) = ...;
> val raisek (x : int) = raise (Fail (Int.toString x));
> val fooRaise = foo raisek;
Warning: type vars not generalized because of value restriction...
(function(){try{(function(){true||(yield)})().next()}catch(e){return e}})()

The Little Calculist

I've moved!

RAII vs finally

A Theory of Typed Hygienic Macros

Effective ML

Cyclic reference graphs FTW

Single-frame continuations for Harmony, ctd

Harmony first-class activations

Thinking about continuations

The design space of continuations

Delimited continuations? In ECMAScript?

Generalizing Javadot

Eich's Law

Wading into the C

Computer Science Education Week

Ezra: Function calls are not stack frames

Proposed json.plt change

Mitchfest blog

Quote of the day

Mitchfest program

Call for Participation: Scheme Workshop 2009

Selectively disabling tail recursion

Linguistic tools for diagnostics

Contractiveness not required for regularity

Regular => Subtree set finiteness => Termination of memoized algorithm

Call for Participation: Symposium in Honor of Mitchell Wand

Lexical syntax thought

Follow-up on effect masking and backtracking

Continuation marks in exceptions

Effect masking vs. purity

Representing failure

Typed closure conversion

PLT System Facilities (Software Components): Module name resolvers

Matthew Flatt running for SIGPLAN member-at-large

Memo to myself: directions for `svn unfail'

Dear David Herman

Your lambda-cube is puny.

Hand-writing derivations

Make a miniature model first

PLT System Facilities (Software Components): Namespaces

Cognitive dissonance and correctness

's Birthday is Coming Up...

Whoa

PLT System Facilities (Software Components): Modules

Ooh, that's pretty

PLT System Facilities (Software Components): Lexical scope

The PLT Scheme Operating System

I feel much better about myself

My first PLT patch

The C Typedef Parsing Problem

History lesson

A funny reader context

Using C to talk to C

Quiz answer

Quiz question

Java, we don't care about you

A page of the dissertation

Fexprs? in Scheme?

I want my Unicode keyboard

Sign o' the times

A small peeve

Hats off to Duff

Author's summary

Maybe vs. exception vs. failure thunk in Scheme

Sweet

Fun programming exercise

Once you've already implemented it...

Updated javascript.plt

Unordered multi-arity binders

Today's JavaScript kookiness

That's not supposed to happen...

Clojure metadata

Quote of the day

Web inching towards actors?

Representing the cost of control

JavaScript completion value: pros and cons

Most productive conference trip ever

Debugger as library

Units of measure in F#

True unions, revisited