LukaHorvat

module Sudoku where

import Data.Map (Map)
import qualified Data.Map as Map
import Data.Char
import Data.List

newtype Board = Board (Map (Int, Int) Int)

instance Show Board where

LukaHorvat

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module SliderPuzzle where

import Prelude hiding (Either(..))
import Data.Vector (Vector, (//), (!?))
import qualified Data.Vector as Vec
import Control.Arrow (second, (***))
import Control.Monad.State.Strict
import Data.Set (Set)
import qualified Data.Set as Set

LukaHorvat

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module SliderPuzzle where

import Prelude hiding (Either(..))
import Data.Vector (Vector, (//), (!?))
import qualified Data.Vector as Vec
import Control.Arrow (second, (***))
import Control.Monad.State.Strict
import Data.Set (Set)
import qualified Data.Set as Set

LukaHorvat

-

LukaHorvat

{-# LANGUAGE TypeFamilies, FlexibleInstances #-}
module Logic where

import Data.Maybe
import Data.Map (Map)
import qualified Data.Map as Map
import Data.List (nub)

data Logic = Logic :& Logic
           | Logic :| Logic

LukaHorvat

{-# LANGUAGE ScopedTypeVariables, TypeFamilies, GADTs, DataKinds, MultiParamTypeClasses
           , FlexibleInstances, FlexibleContexts, PolyKinds #-}
module Main where

import Data.Proxy
import Prelude hiding ((+))
import qualified Prelude

data Nat = Zero | Succ Nat

LukaHorvat

        public static Gen<ConsList<T>> Sequence<T>(this ConsList<Gen<T>> list)
        {
            if (list.IsNil) return Return(ConsList.Nil<T>());
            return list.Head.Bind(t =>
               list.Tail.Sequence().Bind(ts =>
                   Return(ts.Prepend(t))));
        }
        public static Gen<T> Return<T>(T value) => FromGenerator(rnd => value);
        public static Gen<TB> Ap<T, TB>(this Gen<Func<T, TB>> gf, Gen<T> gen) =>
            gf.Bind(f => gen.Bind(a => Return(f(a))));

LukaHorvat

{-# LANGUAGE TemplateHaskell, FlexibleInstances #-}
module Parsing.AST where

import Test.QuickCheck
import Halt.AST
import Halt.Utility
import Control.Applicative
import Data.Char
import Data.List
import Halt.Printing.Pretty

LukaHorvat

module Brainfuck
    ( executeString
    ) where

import Data.Map (Map)
import qualified Data.Map as Map
import Data.Vector (Vector)
import qualified Data.Vector as Vector
import Control.Monad.Trans.State
import Control.Monad.Trans.Maybe

LukaHorvat

connectStatement :: String -> State -> Statement -> State
connectStatement name state stmt = case stmt of
    AST.Line expr     -> connectExpression name expr state
    AST.If cond th el -> let s = connectStatement name (connectExpression name state cond) th in case el of
        Just ex -> connectExpression name s ex
        Nothing -> s
    AST.While cond s -> connectStatement name (connectEpxression name state cond) s
    AST.Routine ss   -> foldl (connectStatement name) state ss
    _                ->
        let (this, expr) = case stmt of