Heimdell

{-# LANGUAGE DataKinds, GADTs, KindSignatures #-}

data RedBlack :: (Bool -> *) where
    Red :: RedBlack 'False -> RedBlack 'True
    Black :: RedBlack a -> RedBlack b
    Stop :: RedBlack a

test = Red $ Black $ Red $ Stop

Heimdell

{-# LANGUAGE TemplateHaskell #-}

module Card where

import Test.QuickCheck

import Control.Lens

data Card = Of { _rank :: Rank, _suit :: Suit }

Heimdell

module InvertedReg where

import Control.Monad
import Control.Applicative

import Data.Monoid

data Generator s = Gen { generate :: [s] }

Heimdell

require 'gtk3'

class App

  def self.create &block
    @@framestack      = [Gtk::Window.new]
    @@registration_on = true

    flow { self.instance_eval &block }

Heimdell

not_implemented = function () {
    throw "Implement me!"
}

map_list     = not_implemented
map_nullable = not_implemented
map_function = not_implemented

assert_equal = function (x, y) {

Heimdell

{-# LANGUAGE DeriveFunctor #-}

module AST where

data AST var
    = Constant String
    | Variable var String
    | (:->)   [var] (AST var)
    | Call    (AST var) [AST var]

Heimdell

let getline return = 
    getchar -> c:
    if equal c "\n" ?
        return ""
    else
        getline -> s:
        return (+ c s);

let putline string next =

Heimdell

#lang racket

; await (s -> (s, parser))
; yield (result, parser)
; stop  (error)
(define (await state-transform) `(await ,state-transform))
(define (yield result next)     `(yield ,result ,next))
(define (stop  error)           `(stop  ,error))

Heimdell

{-# LANGUAGE RankNTypes #-}

import Data.Traversable (for)

import Data.Functor.Identity
import Data.Functor.Constant

type Lens s t a b = forall f . Applicative f => (a -> f b) -> (s -> f t)

Heimdell

#lang racket

(define (partition good? list return)
    (match list
        [(list)
            (return `() `())]

        [(list head tail ...)
            (partition good? tail (λ (accepted rejected)