acowley

{-# LANGUAGE NamedFieldPuns, TupleSections #-}
-- |A Haskell program that demonstrates a simple "Hello, world!"
-- application using genetic algorithms. Based on code by John Svazic.
--
-- Author: Anthony Cowley

import Control.Applicative
import Control.Arrow (second)
import Control.Monad (liftM, replicateM)
import Control.Monad.Random

acowley

{-# OPTIONS -O #-}
-- Perform in-place updates on mutable data.
import Control.Applicative
import Control.Monad
import Data.IORef
import Data.Monoid
import Debug.Trace
import System.IO.Unsafe

-- Presumably we can duplicate the values we want to mutate. Here, we

acowley

{-# LANGUAGE ForeignFunctionInterface #-}
module Renderer.CLGLInterop (initFromGL) where
import Control.Parallel.CLUtil
import Foreign.Ptr (nullPtr, Ptr)

foreign import ccall "CGLGetCurrentContext"
  cGLGetCurrentContext :: IO (Ptr ())

foreign import ccall "CGLGetShareGroup"
  cGLGetShareGroup :: Ptr () -> IO (Ptr ())

acowley

(* Ported from Dan Peebles's proof at: https://gist.github.com/2356060 *)
Module SquaredTriangular.
Require Import Arith.

Definition N := nat.

(* Sigma notation for expressing sums. *)
Fixpoint Σ (x : N) (f : N -> N) : N :=
  match x with
  | 0 => 0

acowley

name:                cabal-test-test
version:             0.1.0.0
build-type:          Simple
cabal-version:       >=1.8

-- Library source in "src/lib", Internal module in "src/misc"
library
  exposed-modules:     MyLib.Foo
  other-modules:       MyLib.Internal.Bar
  hs-source-dirs:      src/lib, src/misc

acowley

{-# LANGUAGE ScopedTypeVariables #-}
import Control.Monad ((>=>))
import Data.ByteString (ByteString)
import qualified Data.ByteString as B
import qualified Data.ByteString.Unsafe as B
import Data.Vector.Storable (Vector)
import qualified Data.Vector.Storable as V
import Foreign.C.String (CStringLen)
import Foreign.Ptr (castPtr)
import Foreign.Storable (Storable(sizeOf))

acowley

{-# LANGUAGE ScopedTypeVariables #-}
import Data.Binary.Builder
import Data.Binary.Builder.Internal
import Foreign.Ptr (castPtr)
import Foreign.Storable (Storable(sizeOf,poke))

-- For testing
import Linear
import Data.ByteString.Lazy (ByteString)
import Data.Monoid ((<>))

acowley

{-# LANGUAGE DataKinds, FlexibleContexts, TypeOperators #-}
import Data.Vinyl

type Model = "model" ::: String

model :: Model
model = Field

type Car = PlainRec ["company":::String, Model, "year":::Int]

acowley

{-# LANGUAGE TypeFamilies, DataKinds, ScopedTypeVariables,
             MultiParamTypeClasses, TemplateHaskell, GADTs,
             FlexibleContexts #-}
import Data.Proxy
import Data.Singletons
import qualified Data.Foldable as F
import Linear (V2(..), V3(..))

data Mat (d::Dimension) (c::Channel) e

acowley

Keybase proof

I hereby claim:

• I am acowley on github.
• I am acowley (https://keybase.io/acowley) on keybase.
• I have a public key whose fingerprint is 42A1 A9F7 9A8F 7310 4DE7 6BED A23C 1208 D50A 574B

To claim this, I am signing this object: