rockymadden

trait Functor[T[_]]{
  def fmap[A,B](f:A=>B)(ta:T[A]):T[B]
}

trait Applicative[T[_]] extends Functor[T]{
  def pure[A](a:A):T[A]
  def <*>[A,B](tf:T[A=>B])(ta:T[A]):T[B]
}

trait Monad[M[_]] extends Applicative[M]{

rockymadden

/**
 * A functional Conway's game of life.
 */
package object conwaydef {

  type Coord[A] = (Int, Int) => A
  type Calculator = Coord[Coord[Boolean] => Boolean]
  type Size = Int

  def nextCell(old: Boolean)(mates: Int) = if (mates > 3) false else if (mates == 3) true else (old && mates == 2)

rockymadden

case class Score(p1: Int, p2: Int)

// Alles ist eine Expression
val score = Score(5, 1)

val winner = if (score.p1 > score.p2) "Player 1" else "Player 2"
val looser = if (score.p1 > score.p2) "Player 2" else "Player 1"

// Tupel
val winnerLooser =

rockymadden

import scala.collection.immutable.ListMap


sealed abstract class Validated[+T]
case class Valid[+T](value:T) extends Validated[T]
case class Error(message:String) extends Validated[Nothing]


class ValidationException(s:String) extends Exception(s)

rockymadden

trait Functor[T[_]]{
  def fmap[A,B](f:A=>B)(ta:T[A]):T[B]
}

trait Applicative[T[_]] extends Functor[T]{
  def pure[A](a:A):T[A]
  def <*>[A,B](tf:T[A=>B])(ta:T[A]):T[B]
}

trait Monad[M[_]] extends Applicative[M]{

rockymadden

class A
class A2 extends A
class B

trait M[X]

//
// Upper Type Bound
//
def upperTypeBound[AA <: A](x: AA): A = x

rockymadden

package pong.functional
    
sealed trait Event
  
sealed trait Action
object Action {
  case object MoveUp       extends Action
  case object MoveDown     extends Action
  case object ShootMissile extends Action
}