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
}

rockymadden

class A
class A2 extends A
class B

trait M[X]

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

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

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

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

/**
 * 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

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

trait Pointed[F[_]] {
  def point[A](a: => A): F[A]
}

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

trait Show[A] {
  def shows(a: => A): String

rockymadden

package pong.imperative
    
sealed trait Event

class PongConnection {
  def isConnected(): Boolean = sys.error("not implemented")
  def readEvent(): Event     = sys.error("not implemented")
  def moveUp(): Unit         = sys.error("not implemented")
  def moveDown(): Unit       = sys.error("not implemented")
  def shootMissile(): Unit   = sys.error("not implemented")

rockymadden

module Main where

-- A simple directory summing thing for Haskell.
-- by Daniel Lyons <[email protected]>
-- BSD licensed.

import Control.Applicative

import Data.Either
import Data.Foldable