yasuabe

module Simpath.Edge where

import Prelude hiding (either)
import Data.Function
import Data.Set (Set)
import Control.Applicative
import qualified Data.Set as Set
import qualified Data.Foldable as Foldable

type Node = Int

yasuabe

{-# LANGUAGE FlexibleContexts #-}
module Simpath.Frontier where

import Control.Applicative
import Control.Monad
import Control.Monad.State (State, state, get, put, runState)
import Data.Set (Set)
import qualified Data.Set as Set
import qualified Data.Foldable as Foldable
import Simpath.Common

yasuabe

module Simpath.CounterMap where

import Data.Map (Map)
import qualified Data.Map as Map
import qualified Data.Foldable as Foldable
import Data.Function
import qualified Simpath.Frontier as F
import Simpath.Frontier (Frontier)
import Simpath.Border (Border)

yasuabe

module Simpath.Border where

import Control.Monad.State (State, get, put, evalState)
import Simpath.Common
import Simpath.Edge
import Data.Set (Set)
import qualified Data.Set as Set

data Border = Border { edge :: Edge, done :: Maybe Int } deriving (Show)

yasuabe

module Simpath.Common where

justIf :: Bool -> a -> Maybe a
justIf b a = if b then Just a else Nothing

mapOrElse :: (a -> b) -> b -> Maybe a -> b
mapOrElse f b ma = case ma of { Just a -> f a; _ -> b }

yasuabe

import System.Environment
import Simpath.Border (borders)
import Simpath.Edge (Edge, edge, modify)
import Simpath.CounterMap

gridEdges :: Int -> [Edge]
gridEdges size = upper ++ lower
  where
    upper = snd $ foldl (\(c, ts) n -> (c + n, ts ++ edgesAt n c)) (0, []) [1 .. size-1]
      where edgesAt n acc = map (+ acc) [1 .. n] >>= addPair

yasuabe

import scala.language.higherKinds

import cats.data.StateT
import cats.free.Free
import cats.~>
import cats.instances.all._

import iota.TListK.:::
import iota.{CopK, TNilK}
import Free.inject

yasuabe

import cats.Functor
import cats.syntax.functor._

// hylomorphism -----------------
type Algebra[F[_],   B] = F[B] => B
type Coalgebra[F[_], A] = A    => F[A]

def hylomorphism[F[_]: Functor, A, B](
    alg:   Algebra[F, B],
    coalg: Coalgebra[F, A])(seed: A): B =

yasuabe

package fp_tdd

import org.scalacheck.Prop.forAll
import org.scalacheck.Properties

object Chapter01 extends Properties("Ch01") {
// ======== TODO ========
// $5 + 10 CHF = $10 if rate is 2:1
// Make "amount" private
// Dollar side effect

yasuabe

package fp_tdd

import org.scalacheck.Prop.forAll
import org.scalacheck.Properties

object Chapter02 extends Properties("Ch02") {
  // ======== TODO ========
  // $5 + 10 CHF = $10 if rate is 2:1
  // Make "amount" private
  // Money rounding?