DanielCollins

(define (unify a b)
  (cond ((and (pair? a)
              (pair? b)) (cons (unify (car a) (car b))
                               (unify (cdr a) (cdr b))))

        ((symbol? a) b) ; here i just return b, because a symbol matches anything. a more complex system would have a third argument
                        ; , the environment, that tracks existing bindings for a, and prevents conflicts. then, instead of returning b
                        ; we could update the environment with the binding for a = b, or issue a failure (in kanren language, #u)

        ((eq? a b) b)   ; a and b trivially unify without updating any bindings. here I just return their mutual value

devyn

import Prelude hiding (toInteger)
import Data.List

data Value = StringValue  String
           | IntegerValue Integer
           | NameValue    String
           | FuncValue    [String] AST
           | NilValue
           deriving Show

gnuvince

type nat = Zero | Succ of nat

let rec int_of_nat x =
  match x with
    | Zero -> 0
    | Succ x' -> 1 + int_of_nat x'

let rec nat_of_int x =
  match x with
    | 0 -> Zero

washort

Parsley Tutorial

From Regular Expressions To Grammars

Parsley is a pattern matching and parsing tool for Python programmers.

startling

-- | Some functions on directed graphs.
module Language.Coatl.Graph where
-- base
import Data.Maybe
-- containers
import Data.Map (Map)
import qualified Data.Map as M
import Data.Set (Set)
import qualified Data.Set as S
-- mtl

jameshfisher

Having read a few proofs that the halting problem is undecidable, I found that they were quite inaccessible, or that they glossed over important details. To counter this, I've attempted to re-hash the proof using a familiar language, JavaScript, with numerous examples along the way.

This famous proof tells us that there is no general method to determine whether a program will finish running. To illustrate this, we can consider programs as JavaScript function calls, and ask whether it is possible to write a JavaScript function which will tell us

kaeluka

-module(horr).
-export([malloc/0, free/1, read/1, write/2, test/0]).

% You can use `malloc` to get a globally sharable, mutable cell of memory.
% A difference to C's `malloc` is that such a cell doesn't have a certain size (you can't overflow)
% Memory is initialised with the atom `null`.
malloc() ->
    spawn(fun() -> mem(null) end).

% As processes are not garbage collected, you have to call `free` when you're done with your memory:

kreed131

---
-- kreed131.blogspot.com/2011/07/tcp.html
---

import Network.Socket hiding (send, sendTo, recv, recvFrom)
import Network.Socket.ByteString (send, recv)
import qualified Data.ByteString.Char8 as B8

import System.Environment (getArgs)

paf31

## Principal type-schemes for functional programs

**Luis Damas and Robin Milner, POPL '82**

> module W where

> import Data.List
> import Data.Maybe
> import Data.Function

cdiener

import sys; from PIL import Image; import numpy as np

chars = np.asarray(list(' .,:;irsXA253hMHGS#9B&@'))

if len(sys.argv) != 4: print( 'Usage: ./asciinator.py image scale factor' ); sys.exit()
f, SC, GCF, WCF = sys.argv[1], float(sys.argv[2]), float(sys.argv[3]), 7/4

img = Image.open(f)
S = ( round(img.size[0]*SC*WCF), round(img.size[1]*SC) )
img = np.sum( np.asarray( img.resize(S) ), axis=2)