├── Control
    └── Monad
    │   └── Royal.hs
├── README.md
└── Setup.hs


/Control/Monad/Royal.hs:
--------------------------------------------------------------------------------
 1 | -----------------------------------------------------------------------------
 2 | -- |
 3 | -- Module      :  Control.Monad.Royal
 4 | -- Copyright   :  (c) Atze van der Ploeg 2015
 5 | -- License     :  BSD-style
 6 | -- Maintainer  :  atzeus@gmail.org
 7 | -- Stability   :  royal
 8 | -- Portability :  royal
 9 | --
10 | -- Introducing his majesty the Royal Monad.
11 | --
12 | -- Royal Monads (or relative polymonads) generalize monads, polymonads _and_ relative monads.
13 | --
14 | -- Therefore Royal Monads (capitalize to emphasise royalness) are the king of monads! 
15 | -- 
16 | -- The ultimate abstraction! 
17 | -- 
18 | -- Ditch your boring old relative, poly or ordinary monad, and start programming with the king of monads! 
19 | -- 
20 | -- Bow before the ultimate generality of the Royal Monad!
21 | 
22 | {-# LANGUAGE UndecidableInstances,FlexibleInstances,MultiParamTypeClasses #-}
23 | module Control.Monad.Royal where
24 | 
25 | 
26 | class RoyalReturn m r where
27 |   royalReturn :: r a -> m a
28 | 
29 | -- |
30 | -- laws (same as monad, but much more Royal):
31 | --
32 | -- prop> royalBind m royalReturn = m
33 | --
34 | -- prop> royalBind (royalReturn x) f = f x 
35 | --
36 | -- prop> royalBind m (\x -> royalBind (f x) g) = royalBind (royalBind m f) g
37 | --
38 | class (RoyalReturn m r, RoyalReturn n r, RoyalReturn p r) => 
39 |      RoyalMonad m n p r where
40 |   royalBind   :: m a -> (r a -> n b) -> p b
41 | 
42 | 
43 | 
44 | 
45 | {- | Relative monads
46 |  laws:
47 | 
48 | prop> relativeBind m royalReturn = m
49 | 
50 | prop> relativeBind (royalReturn x) f = f x 
51 | 
52 | prop> relativeBind m (\x -> relativeBind (f x) g) = relativeBind (relativeBind m f) g
53 | 
54 | -}
55 | class RoyalReturn m r => RelMonad m r where
56 |   relativeBind :: m a -> (r a -> m b) -> m b
57 | 
58 | class NonRoyalReturn m where
59 |   rreturn :: a -> m a
60 | 
61 | 
62 | {- | Relative monads
63 |  laws:
64 | 
65 | prop> polyBind m rreturn = m
66 | 
67 | prop> polyBind (rreturn x) f = f x 
68 | 
69 | prop> polyBind m (\x -> polyBind (f x) g) = polyBind (polyBind m f) g
70 | 
71 | -}
72 | class (NonRoyalReturn m, NonRoyalReturn n, NonRoyalReturn p) =>
73 |     PolyMonad m n p where
74 |   polyBind :: m a -> (a -> n b) -> p b
75 | 
76 | newtype Id a = Id { fromId :: a} 
77 | 
78 | instance NonRoyalReturn m => RoyalReturn m Id where
79 |   royalReturn (Id x) = rreturn x
80 | 
81 | instance PolyMonad m n p => RoyalMonad m n p Id where
82 |   royalBind m f = polyBind m (f . Id)
83 | 
84 | instance Monad m => NonRoyalReturn m where
85 |   rreturn = return
86 | 
87 | instance Monad m => RoyalMonad m m m Id where
88 |   royalBind m f = m >>= (f . Id)
89 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # RoyalMonad
 2 | 
 3 | All hail the Royal Monad!
 4 | 
 5 | Introducing his majesty the Royal Monad.
 6 | 
 7 | Royal Monads (or relative polymonads) generalize monads, polymonads _and_ relative monads.
 8 | 
 9 | Therefore Royal Monads (capitalize to emphasise royalness) are the king of monads! 
10 | 
11 | The ultimate abstraction! 
12 | 
13 | Ditch your boring old relative, poly or ordinary monad, and start programming with the king of monads! 
14 | 
15 | Bow before the ultimate generality of the Royal Monad!
16 | 


--------------------------------------------------------------------------------
/Setup.hs:
--------------------------------------------------------------------------------
1 | import Distribution.Simple
2 | main = defaultMain
3 | 


--------------------------------------------------------------------------------