module test

import StdEnv, StdGeneric, StdMaybe

import Data.Either, Data.Func

:: Box b a =: Box b
derive bimap Box
unBox (Box b) :== b
box b :== Box b
reBox x :== box (unBox x)

:: GGFuns st a =
	{ int    :: st -> Either String (Int, st)
	, bool   :: st -> Either String (Bool, st)
	, real   :: st -> Either String (Real, st)
	, char   :: st -> Either String (Char, st)

	, unit   :: st -> Either String (UNIT, st)
//	, cons   :: (st -> Either String (a, st)) GenericConsDescriptor st -> Either String (CONS b, st)
//	, field  :: (st -> Either String (a, st)) GenericFieldDescriptor st -> Either String (FIELD b, st)
//	, record :: (st -> Either String (a, st)) GenericRecordDescriptor st -> Either String (RECORD b, st)
//	, object :: (st -> Either String (a, st)) GenericTypeDefDescriptor st -> Either String (OBJECT b, st)
//	, pair   :: (st -> Either String (al, st)) (st -> Either String (br, st)) st -> Either String (PAIR bl br, st)
//	, either :: (st -> Either String (al, st)) (st -> Either String (br, st)) st -> Either String (EITHER bl br, st)
	}

ggcast :: (GGFuns st a) -> GGFuns st c
ggcast d = {d & int=d.int}

generic gGeneric a :: (GGFuns st a) st -> Either String (a, st)

gGeneric{|Int|} d st = d.int st
gGeneric{|Bool|} d st = d.bool st
gGeneric{|Real|} d st = d.real st
gGeneric{|Char|} d st = d.char st

gGeneric{|UNIT|} d st = d.unit st
//gGeneric{|CONS of gcd|} f d st = d.cons (f (ggcast d)) gcd st
//gGeneric{|FIELD of gfd|} f d st = d.field (f (ggcast d)) gfd st
//gGeneric{|OBJECT of gtd|} f d st = d.object (f (ggcast d)) gtd st
//gGeneric{|RECORD of grd|} f d st = d.record (f (ggcast d)) grd st
//gGeneric{|PAIR|} fl fr d st = d.pair (fl (ggcast d)) (fr (ggcast d)) st
//gGeneric{|EITHER|} fl fr d st = d.either (fl (ggcast d)) (fr (ggcast d)) st

gDefault :: a | gGeneric{|*|} a
gDefault = fromRight o snd $
	{ int=basic 0, bool=basic True, real=basic 0.0, char=basic 'a', unit=basic UNIT
	}
where
	basic c = \_->Right (c, ())

Start = 42