darkf

import operator

def evaluate(input):
  ops = {'+': operator.add, '-': operator.sub, '*': operator.mul}

	def e(toks, s_num, s_ops):
		if toks == []:
			return s_num.pop()

		try:

darkf

# Twisted TCP/IP proxy
# You would set REAL_IP to the IP of the server you want to proxy
# then override the domain name in your hosts file. Run this,
# and then it should proxy through.
# I don't think this works with more than one concurrent client, and in that case you should refactor this code a bit. (Sorry.)
# Copyright (c) 2013 darkf; licensed under CC-0 (or in the public domain if applicable)

from twisted.internet.protocol import Factory, ClientFactory, Protocol
from twisted.protocols.basic import LineReceiver
from twisted.internet import reactor, defer

darkf

# Twisted HTTP proxy
# You would set REAL_IP to the IP of the server you want to proxy
# then override the domain name in your hosts file. Run this,
# and then it should proxy through.
# Copyright (c) 2013 darkf; licensed under CC-0 (or in the public domain if applicable)

from twisted.web import proxy, http
from twisted.internet import reactor
import urlparse
from urllib import quote as urlquote

darkf

type Map k v = [(k, v)]
 
newMap :: (Eq k) => [(k, v)] -> Map k v
newMap = id
 
mapLookup :: (Eq k) => Map k v -> k -> Maybe v
mapLookup [] k = Nothing
mapLookup (x:xs) k
    | fst x == k = Just $ snd x
    | otherwise = mapLookup xs k

darkf

/* 2013/3/4 by darkf - licensed under WTFPL - cesar cipher program */
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[]) {
    int key, i, len;
    char output[128];
    
    if(argc != 3) {
        fprintf(stderr, "usage: %s CIPHER KEY\n", argv[0]);

darkf

(* Ugly imperative code, meant to be the start of something else - ideally `iter ()` would become `iter ip`. *)

type value = Int of int
  	   | Str of string

type op = Nop
		| Push of value
		| Dup
		| Mul
		| Add

darkf

loop for i to 10
  print i
end

In the parser we encounter loop. It's not a function or a special form, but it is a macro. We pass it off to the macro transformer function, which spits out an AST node, and we add that, instead of the original (illegal) code.

The loop macro can be defined like:

darkf

data Tok = Op Char | NumTok Int

op '+' = (+)
op '*' = (*)
op _ = \_ _ -> 666

eval toks =
  eval' toks []
	where
	eval' [] s = head s

darkf

(define (compose f g)
  (lambda (x)
    (f (g x))))
 
(define (composeN acc f n)
  (if (zero? n)
    acc
    (composeN (compose acc f) f (- n 1))))
 
(define (even? n)

darkf

open Printf
 
type node =
  | Call of string * node list
  | Int of int
 
let rec toString = function
  | Call (fn, args) -> sprintf "(%s %s)" fn (String.concat " " (List.map toString args))
  | Int i -> sprintf "%d" i