Compose.hs

-- .$Header: c:/Source/Haskell/Wrapper/Data/Flex/Test/RCS/Compose.hs,v 1.5 2010/04/24 00:59:15 dosuser Exp dosuser $
module Data.Flex.Test.Compose where

import Control.Monad (MonadPlus(..))
import Control.Monad.Trans (lift)
import Control.Monad.Writer (Writer)

import Data.Char (chr)

import Data.Type.TList ((:*:), TNil)

import Data.Flex.Compose
import Data.Flex.FlipT (FlipT(..), FWFlipMonad, FWFlipMonadPlus)
import Data.Flex.Wrap (FW, FlexiWrap(..), fWrap)
import Data.Flex.WrapCTC (FWCTC)

chrM :: Monad m => Int -> m Char
chrM = return . chr

data Tag1 = Tag1
type Tag1W = FW (Tag1 :*: TNil)

type Tag1T = FWCTC (FWCompMonadPlus :*: FWCompTrans :*: FWCompS :*: TNil)
    O Tag1W

type M1 = Tag1T Maybe
-- Monad
t0 :: M1 Int
t0 = return 65
t1 :: M1 Int -> (Int -> M1 Char) -> M1 Char
t1 = (>>=)
t2 :: M1 Char
t2 = t1 t0 $ return . chr

-- MonadTrans
t3 :: M1 Int
t3 = lift $ Just 0

-- MonadPlus
t3a :: M1 Int
t3a = mzero
t3b :: M1 Int
t3b = t3a `mplus` t0

type ReaderT1 r = FWCTC (FWCompDefaults :*: FWCompD :*: TNil) O ((->) r)
type ReaderT2 = ReaderT1 Int

type M2 = ReaderT2 Maybe
-- Monad
t4 :: M2 Int
t4 = return 65
t5 :: M2 Int -> (Int -> M2 Char) -> M2 Char
t5 = (>>=)
t6 :: M2 Char
t6 = t5 t4 $ return . chr

-- MonadTrans
t7 :: M2 Int
t7 = lift $ Just 0

-- MonadPlus
t7a :: M2 Int
t7a = mzero
t7b :: M2 Int
t7b = t7a `mplus` t4

data Tag2 = Tag2
type Tag2W = FW (Tag2 :*: TNil)

type M3 = Tag1T Tag2W
-- Monad
t8 :: M3 Int
t8 = return 65
t9 :: M3 Int -> (Int -> M3 Char) -> M3 Char
t9 = (>>=)
t10 :: M3 Char
t10 = t9 t8 $ return . chr

-- MonadTrans
t11 :: Tag2W Int
t11 = FlexiWrap 0
t12 :: M3 Int
t12 = lift t11

-- PComposable m Maybe
type M4 = FWCTC (FWCompMaybeMonadPlus :*: FWCompP :*: TNil) O Tag1W Maybe
-- Monad
t13 :: M4 Int
t13 = return 65
t14 :: M4 Int -> (Int -> M4 Char) -> M4 Char
t14 = (>>=)
t15 :: M4 Char
t15 = t14 t13 $ return . chr

-- MonadPlus
t15a :: M4 Int
t15a = mzero
t15b :: M4 Int
t15b = t15a `mplus` t13

type M5 = Tag1T []
-- Monad
t16 :: M5 Int
t16 = return 65
t17 :: M5 Int -> (Int -> M5 Char) -> M5 Char
t17 = (>>=)
t18 :: M5 Char
t18 = t17 t16 $ return . chr

-- MonadTrans
t18a :: M5 Int
t18a = lift []

-- MonadPlus
t18b :: M5 Int
t18b = mzero
t18c :: M5 Int
t18c = t18b `mplus` t16

type M6 = Tag1T (Either String)
-- Monad
t19 :: M6 Int
t19 = return 65
t20 :: M6 Int -> (Int -> M6 Char) -> M6 Char
t20 = (>>=)
t21 :: M6 Char
t21 = t20 t19 $ return . chr

-- MonadTrans
t21a :: M6 Int
t21a = lift $ Right 0

-- MonadPlus
t21b :: M6 Int
t21b = mzero
t21c :: M6 Int
t21c = t21b `mplus` t19

type M7 = Tag1T (Writer [String])
-- Monad
t22 :: M7 Int
t22 = return 65
t23 :: M7 Int -> (Int -> M7 Char) -> M7 Char
t23 = (>>=)
t24 :: M7 Char
t24 = t23 t22 $ return . chr

-- MonadTrans
t25 :: M7 Int
t25 = lift $ return 0

-- Flip(ped) instances
type MaybeT = FWCTC
    (FWFlipMonadPlus :*: FWFlipMonad :*:
        FWCompMonadPlus :*: FWCompTrans :*: FWCompP :*: TNil
    )
    (FlipT O) Maybe

type M8 = MaybeT Tag1W
-- Monad
t26 :: M8 Int
t26 = return 65
t27 :: M8 Int -> (Int -> M8 Char) -> M8 Char
t27 = (>>=)
t28 :: M8 Char
t28 = t27 t26 $ return . chr

-- MonadTrans
t29 :: Tag1W Int
t29 = FlexiWrap 0
t30 :: M8 Int
t30 = lift t29

-- MonadPlus
t30a :: M8 Int
t30a = mzero
t31a :: M8 Int
t31a = t30a `mplus` t26

type ListT =
    FWCTC (FWFlipMonad :*: FWCompTrans :*: FWCompS :*: TNil) (FlipT O) []

type M9 = ListT Tag1W
-- Monad
t31 :: M9 Int
t31 = return 65
t32 :: M9 Int -> (Int -> M9 Char) -> M9 Char
t32 = (>>=)
t33 :: M9 Char
t33 = t32 t31 $ return . chr

-- MonadTrans
t34 :: Tag1W Int
t34 = return 0
t35 :: M9 Int
t35 = lift t34

type WriterT = FWCTC (FWFlipMonad :*: FWCompTrans :*: FWCompS :*: TNil)
    (FlipT O) (Writer [String])

type M10 = WriterT Tag1W
-- Monad
t36 :: M10 Int
t36 = return 65
t37 :: M10 Int -> (Int -> M10 Char) -> M10 Char
t37 = (>>=)
t38 :: M10 Char
t38 = t37 t36 chrM

-- MonadTrans
t39 :: Tag1W Int
t39 = t34
t40 :: M10 Int
t40 = lift t39

type EitherT = FWCTC (FWFlipMonad :*: FWCompTrans :*: FWCompS :*: TNil)
    (FlipT O) (Either String)

type M11 = EitherT Tag1W
-- Monad
t41 :: M11 Int
t41 = return 65
t42 :: M11 Int -> (Int -> M11 Char) -> M11 Char
t42 = (>>=)
t43 :: M11 Char
t43 = t42 t41 chrM

-- MonadTrans
t44 :: Tag1W Int
t44 = t34
t45 :: M11 Int
t45 = lift t44

type Tag1FT = FWCTC (FWFlipMonad :*: FWCompTrans :*: FWCompS :*: TNil)
    (FlipT O) Tag1W

type M12 = Tag1FT Tag2W
-- Monad
t46 :: M12 Int
t46 = return 65
t47 :: M12 Int -> (Int -> M12 Char) -> M12 Char
t47 = (>>=)
t48 :: M12 Char
t48 = t47 t46 chrM

-- MonadTrans
t49 :: Tag2W Int
t49 = return 0
t50 :: M12 Int
t50 = lift t49

type M13 = Tag1FT Maybe
-- Monad
t51 :: M13 Int
t51 = return 65
t52 :: M13 Int -> (Int -> M13 Char) -> M13 Char
t52 = (>>=)
t53 :: M13 Char
t53 = t52 t51 chrM

-- MonadTrans
t54 :: Maybe Int
t54 = return 0
t55 :: M13 Int
t55 = lift t54

-- vim: expandtab:tabstop=4:shiftwidth=4