fitzgen

function go_(machine, step) {
  while(!step.done) {
    try {
      var arr   = step(),
          state = arr[0],
          value = arr[1];

      switch (state) {
        case "park":
          setImmediate(function() { go_(machine, step); });

sdiehl

{-# Language GADTs #-}

module Homomorphisms where

import Control.Monad
import Control.Applicative

import Data.Monoid hiding (Endo)
import qualified Control.Category as C

timjb

Hello, my name ist {{name}} and I am {{age}} years old.

NicolasT

{-# LANGUAGE RebindableSyntax,
             KindSignatures,
             DataKinds,
             GADTs,
             GeneralizedNewtypeDeriving,
             StandaloneDeriving,
             FlexibleInstances,
             Rank2Types #-}

module Connection (

klutzy

// emscripten uses le32-unknown-nacl triple but rustc doesn't know it now.
// So just use similar target instead.
// `rustc hello.rs --target=i686-unknown-linux --emit-llvm -S --cfg libc`
// `emcc hello.ll -o hello.js`

// no `extern mod`.
#[no_std];
#[feature(macro_rules)];

use core::container::Container;

jvns

Step 0: A program, and prerequisites

We're going to be dealing with a "Hello, world!" program. Just one. There's going to be a bunch of fruit for discussion here. I'm going to be assuming you're on Linux, because we're gonna be talking about ELF and Macs use Mach-O and I don't know anything about Mach-O.

#include <stdio.h>

char *penguin = "Penguin";
char array[5] = {'a', 'b', 'c', 'd', 'e'};

jlongster

var fs = require('fs');
var path = require('path');
var sweet = require('sweet.js');

module.exports = function(grunt) {
    grunt.initConfig({
        sweetjs: {
            options: {
                modules: ['es6-macros'],
                sourceMap: true,

bobatkey

(* This is a demonstration of the use of the SML module system to
   encode (Generalized Algebraic Datatypes) GADTs via Church
   encodings. The basic idea is to use the Church encoding of GADTs in
   System Fomega and translate the System Fomega type into the module
   system. As I demonstrate below, this allows things like the
   singleton type of booleans, and the equality type, to be
   represented.

   This was inspired by Jon Sterling's blog post about encoding proofs
   in the SML module system:

yomimono

#!/bin/bash

#set -e
#set -x

fail() {
	echo $1
	[ -e ${EBS_DEVICE} ] && [ "$VOLUME_ID" != "" ] && [ $REGION != "" ] && {
		ec2-detach-volume --region $REGION $VOLUME_ID
		ec2-delete-volume --region $REGION $VOLUME_ID	

lmarburger

data Expr = Var String
          | Val Int
          | Add Expr Expr
          | Let (List (String, Int)) Expr

data Eval : Type -> Type where
  MkEval : (List (String, Int) -> Maybe a) -> Eval a

fetch : String -> Eval Int
fetch x = MkEval (\e => fetchVal e) where