philipnilsson

import Text.Parsec
import Control.Applicative hiding ((<|>))
import qualified Data.Map as M
import Data.Either (partitionEithers)
import Data.List (intercalate)
import System.IO (hPutStrLn, stderr)

data Word = Splice String | Word String
          deriving (Ord, Eq, Show)

philipnilsson

import System.Random
import Control.Monad

count = length . filter id

avenge = do
  x <- replicateM 8 randomIO
  return $ count x <= 4

test n = do

philipnilsson

data Pair a = Pair a a

data Exp typ where
  Vec :: Exp a -> Exp a -> Exp (Pair a)
  Const :: Int -> Exp Int

-- with type

type RHS typ = String

philipnilsson

vShader :: SC.Shader GLfloat
vShader = do
  pos     <- attribute vec3 "position"
  a_color <- attribute vec3 "a_color"
  color   <- varying   vec3 "color"
  
  gl_Position =: pos .: 1
  color =: pos

fShader :: SC.Shader GLfloat

philipnilsson

module Main where

import Engine

pretty elem 
  = elem $= texture (fromFile "slim.jpg")

scene = 
  pretty cube $= rotateX 2t $= rotateY 3t

philipnilsson

combine :: [Either a b] -> ((a,b) -> c) -> [c]
combine xs f = combine' (Nothing, Nothing) xs 
  where
  combine' (_, Just y) (Left l:xs) =
    f (l,y) : combine' (Just l, Just y) xs
  combine' (Just x, _) (Right l:xs) =
    f (x,l) : combine' (Just x, Just l) xs
  combine' (_, y) (Left l : xs)  =
    combine' (Just l, y) xs
  combine' (x, _) (Right l : xs) =

philipnilsson

nonEmptySubsequences = foldr comb []
  where comb x xs = xs ++ fmap (x:) ([]:xs)
                    
findSum p = filter (p.sum) . nonEmptySubsequences
hasSum  p = not.null . findSum p


-- Trying it in the REPL

philipnilsson

-- | Experimental and very simple quasi-quotation of ECMAScript in
-- Haskell. Doesn't support anti-quotation as of now.

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
module Language.ECMAScript5.Syntax.QuasiQuote (js, jsexpr, jsstmt) where

import qualified Language.Haskell.TH as TH
import Language.Haskell.TH.Quote
import Text.Parsec hiding (parse)

philipnilsson

-- | Experimental and very simple quasi-quotation of ECMAScript in
-- Haskell. Doesn't support anti-quotation as of now.

{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE Rank2Types #-}
module Language.ECMAScript5.Syntax.QuasiQuote (js, jsexpr, jsstmt) where

import qualified Language.Haskell.TH as TH
import Language.Haskell.TH.Quote

philipnilsson

#include <stdio.h>

int main(void) {
  int n, e, i = 0;
  scanf("%d\n", &n);
  scanf("%d", &e);
  int sum = e, first = e, last = e, len = 1;
  int delta;
  while (++i < n) {
    scanf(" %d", &e);