paf31

module Main where

  import Prelude
  import Parsing
  import Either

  foreign import data JSON :: *

  foreign import toJSON "function toJSON (obj) { return obj; }" :: forall a. a -> JSON
  foreign import showJSON "function showJSON (obj) { return JSON.stringify(obj); }" :: JSON -> String

paf31

data Zero = Zero
 
data Succ a = Succ a
 
pred = \s -> case s of Succ a -> a
 
meters = \n -> 
  { multiply: \v -> v { value = n * v.value, meters = Succ (v.meters) }
  , divide: \v -> v { value = n / v.value, meters = pred (v.meters) }      
  }      

paf31

data Zero = Zero

data Succ a = Succ a

pred = \s -> case s of Succ a -> a

meters = \n v -> v { value = n * v.value, meters = Succ (v.meters) }

seconds = \n v -> v { value = n * v.value, seconds = Succ (v.seconds) }

paf31

{-# LANGUAGE PolymorphicComponents, GeneralizedNewtypeDeriving, DeriveDataTypeable #-}

import Data.Data
import Data.Maybe
import Data.Generics
import Data.Monoid
import Control.Applicative
import Control.Monad.State
import Control.Monad.Logic
import Control.Monad.Logic.Class

paf31

{-# LANGUAGE GeneralizedNewtypeDeriving #-} 

import Control.Applicative (Applicative(..), Alternative(..))
import Data.Function (fix)
import qualified Control.Category as C
import Control.Category ((>>>))
import qualified Control.Arrow as A
import Control.Arrow ((***))

newtype Pattern a b = Pattern { runPattern :: A.Kleisli Maybe a b } deriving (C.Category, A.Arrow)

paf31

{-# LANGUAGE DataKinds, GADTs, MultiParamTypeClasses, PolyKinds, TypeOperators, FlexibleInstances, TypeFamilies, UndecidableInstances #-}

import GHC.TypeLits

module Knockout where

data PrimType = String | Number

data Model
  = ObsPrim { primType :: PrimType }

paf31

pauseTime = 0.35

timePerThrow = 300

handMovement = 0.2

pattern = [5]

rotatePattern : Int -> [a] -> [a]
rotatePattern n xs =

paf31

{-# LANGUAGE FlexibleContexts #-}

module Markup where

import Text.Parsec
import qualified Text.Parsec.Token as P
import qualified Text.Parsec.Language as L
import qualified Text.Parsec.Expr as E
import Data.Char
import Data.List (groupBy, nub, (\\))

paf31

import Text.Parsec

data Tree a = Tip a | Branch (Tree (a, a)) deriving (Show)

tree :: Parsec String u (Tree Int)
tree = tree' $ do
  ds <- many digit
  return $ read ds
  where
  tree' :: Parsec String u a -> Parsec String u (Tree a)

paf31

{-# LANGUAGE GADTs #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}