module Stunts.Main (id,(***)) where

import A(a,b)
import A.B

data Bool = True | False

data Maybe a
  = Nothing
  | Just a

main :: Screen
main = screen (A q w e (Just t n1)) a B (a B (q))

fun a@(B a@(C c)) = let
  q = a
    where
      a = c ()
  p = A c
  r = case a (A c a) q of
        _ -> ()
        _ -> ()
 in (a,c)

author =
  { name: "Phil"
  , interests: ["Functional Programming", "JavaScript"]
  }

lambdaFun = \_ a b (Just _) _ -> a ()

r = case (a (A c a) q) of
      _ -> if c :: Bool then () else ()
      _ -> ()

(*) :: Screen

one :: Int
one = n1 :: Int

infix 5 ...

($) :: forall a b. (a -> b) -> a -> b
($) f x = f x


foldStream :: forall l e m. (Stream l, Monoid m) => (e -> m) -> l -> m

showPerson :: forall r. { first :: String, last :: String | r} -> String

type Entry = { firstName :: String, lastName :: String, phone :: String }

getPhone :: Entry -> String
--TODO:
{-
getPhone e = e.phone

setX :: Number -> Point -> Point
setX val point = point { x = val }
-}
type PhoneBook = List Entry

class Functor f where
  (<$>) :: forall a b. (a -> b) -> f a -> f b

instance Functor State where
  (<$>) f a = a

class Foldable f where
  foldr :: forall a b. (a -> b -> b) -> b -> f a -> b
  foldl :: forall a b. (b -> a -> b) -> b -> f a -> b
  foldMap :: forall a m. (Monoid m) => (a -> m) -> f a -> m

class Partial a

head :: forall a. (Partial a) => [a] -> a

class (Monoid m) => Action m where
   act :: m -> a -> a

{-
  - add the remained syntax parts
  - write an example using lambdacube operations,
    e.g. self containing rotating cube (CPU + GPU + Data, only with time input nothing else)
    HINT: feedback between frames is out of scope at first, because it requires FRP features
-}