module Hawk where

import Data.Stream hiding (map,unfold, tail)
import qualified Data.Stream (map, repeat, unfold, tail) 

import Control.Applicative

newtype Signal a = Signal (Stream a)

instance Functor Signal where
  fmap f (Signal s) = Signal (fmap f s)

instance Applicative Signal where
  pure x = Signal (pure x)
  (Signal fs) <*> (Signal xs) = Signal (fs <*> xs)

unsignal :: Signal a -> Stream a
unsignal (Signal s) = s

class Comonad d where
  coreturn :: d a -> a
  cobind :: (d a -> b) -> d a -> d b

instance Comonad Stream where
  coreturn (Cons x xs) = x
  cobind f d@(Cons x xs) = f d <:> cobind f xs

instance Comonad Signal where
  coreturn (Signal s) = coreturn s
  cobind f (Signal s) = Signal (cobind (f . Signal) s)

lift :: (a -> b) -> Signal a -> Signal b
lift f (Signal s) = Signal (Data.Stream.map f s)

select :: Signal Bool -> Signal a -> Signal a -> Signal a
select cs ts es = pure cond <*> cs <*> ts <*> es
  where
  cond c t e = if c then t else e

delay :: a -> Signal a -> Signal a
delay x (Signal xs) = Signal $ Cons x xs

unfold :: (b -> (a,b)) -> b -> Signal a
unfold f b = Signal (Data.Stream.unfold f b)

next :: Signal a -> Signal a
next (Signal xs) = Signal (Data.Stream.tail xs)