chansey97

#!/usr/bin/env scheme --script

(import (nanopass))

(define unique-var
  (let ()
    (define count 0)
    (lambda (name)
      (let ([c count])
        (set! count (+ count 1))

chansey97

#include <SWI-Prolog.h>
#include <stdio.h>
#include <stdlib.h>

typedef struct context              /* define a context structure */
{
 int max;
} context;

foreign_t

chansey97

#lang racket

(define the-key 'the-key)
(define the-spell-book 'the-spell-book)

(define person%
  (class object%
    (init-field items h)
    (super-new)         
    

chansey97

The introduction to Reactive Programming you've been missing

(by @andrestaltz)

---

This tutorial as a series of videos

If you prefer to watch video tutorials with live-coding, then check out this series I recorded with the same contents as in this article: Egghead.io - Introduction to Reactive Programming.

---

chansey97

#lang racket/base
(provide uniq)

;;;
;;; Uniq
;;; 

; The function uniq takes a list as input and returns a new list:
; adjacent elements are compared and omits any repeated elements.
; In other words, uniq works like the Unix utility uniq, but on list.

chansey97

{-# LANGUAGE DeriveFunctor #-}
module Crush(
  AST(..)
, crush
, crushMap
, crushMapM

  -- debugging
, buildAst
, printAst

chansey97

;guile 2.2.3
(use-modules (ice-9 local-eval))
(use-modules (ice-9 match))
(use-modules (srfi srfi-9))

(define-record-type Just
  (make-Just x)
  Just?
  (x Just-x))
 

chansey97

module Bridge where

import Data.List
import Data.Maybe
import qualified Data.Tree as DTree
import qualified Data.Map as Map

-- Note that user must ensure there is at least one (0, x) in pieces
pieces :: [Piece]
pieces = [(0,2), (2,2), (2,3), (3,4), (3,5), (0,1), (10,1), (9,10)]

chansey97

module Crush(
  AST(..)
, crush
, crushMap
, crushMapM

  -- debugging
, buildAst
, printAst
) where

chansey97

module PCP where
import           Data.List
import           Data.Tree

-- breadth-first traversal
levelf :: Forest a -> [[a]]
levelf = unfoldr f
  where f [] = Nothing
        f xs = Just (map rootLabel xs, concat $ map subForest xs)