darkf

module Eval (bf_eval) where
import qualified Data.Vector.Mutable as MV
import Control.Monad.ST (runST)
import Data.Char (chr)
import Reducer

bf_eval :: [ISC] -> String
bf_eval instrs =
  runST $ bf_eval' instrs
	where

darkf

If we extend the Possum language to include optional parentheses, which group together tokens (atoms and constants), and when evaluated act as function applications, and when quoted act as homoiconic representations of a program.

Consider the following pseudo-Possum program:

defun compose f g is
  -> x is
    f g x
  end
end

darkf

import Control.Monad.State (State, runState, evalState, get, put)
import qualified Data.Map as M

data AST = Add AST AST
		 | Def String AST
		 | Var String
		 | StrConst String
		 | IntConst Int
		 deriving (Show, Eq)

darkf

-- Interpreter for a simple dynamically typed pattern matching language
-- Copyright (c) 2013 darkf
-- Written on 10/18/2013

import Control.Monad.State (State, runState, evalState, get, put)
import qualified Data.Map as M

data AST = Add AST AST
     | Def String AST
		 | Var String

darkf

import math
import sdl

const
    WIDTH = 1024
    HEIGHT = 768

    TIMESTEP = 1000 div 30 # 30 fps

    THING_WIDTH = 32

darkf

#include <functional>
#include <map>
#include <typeinfo>
#include <iostream>

struct Event {
	virtual ~Event() {}
};
struct TestEvent : Event {
	std::string msg;

darkf

import Data.Maybe (fromJust)

data Type = IntTy
		  | ArrowTy Type Type
	deriving (Show, Eq)

data Term = Const Int
		  | Var String
		  | Abs String Type Term
		  | App Term Term

darkf

#lang racket

(define (obj state msg)
  (match msg
    ['init (cons state (curry obj state))]
    ['get-x (cons state (curry obj state))]
    [(list 'set-x x) (cons x (curry obj x))]
    ['ping (cons "pong" (curry obj state))]))

(define-syntax-rule (send! obj msg)

darkf

module Main where

import Test.Hspec
import VM

($=) = shouldBe

main :: IO ()
main = hspec $ do
	describe "runVM" $ do

darkf

{-# LANGUAGE LambdaCase #-}

import Control.Concurrent
import Control.Concurrent.Chan
import Control.Monad
import Network.Socket
import System.IO

data MainMessage = Accept Socket SockAddr
                 | MsgReceived String