Difference between revisions of "The Other Prelude"
CaleGibbard (talk | contribs) |
Uchchwhash (talk | contribs) m (→See also) |
||
(31 intermediate revisions by 9 users not shown) | |||
Line 1: | Line 1: | ||
+ | == Call For Contribution == |
||
− | [[Category:Proposals]] |
||
+ | This fun project, called ''The Other Prelude'', is a creative reconstruction of the standard Prelude. By disregarding history and compatibility, we get a clean sheet. |
||
− | == Call for contribution == |
||
− | This fun project, called "The Other Prelude", and is a creative reconstruction of the standard Prelude. By disregarding history and compatibility, we get a clean sheet. |
||
− | == |
+ | == Committee == |
− | The principal is to make the names very readable for both beginners and category theorists (if any). |
||
+ | This project has no committee whatsoever. Issues are discussed on [[Talk:The Other Prelude|the talk page]]. |
||
− | == Guidelines == |
||
− | * The prelude should not contain any "projection" functions (like <hask>fst</hask> and <hask>snd</hask>. They go to the Extension module. |
||
+ | == Naming Conventions == |
||
+ | * Function names should be easy for beginners to consume. |
||
− | == Issues == |
||
+ | * Specifically, ''The Other Prelude'' naming convention is to use |
||
− | * Should alphanumeric names be preferred over symbols when defining a class? |
||
+ | ** descriptive symbols for functions that are naturally infix (''e.g.'', <hask>mplus</hask> is replaced by <hask>(++)</hask>) |
||
+ | ** whole English words and camelCase for functions (''e.g.'', <hask>orElse</hask> but not <hask>fmap</hask>) |
||
+ | == Design Philosophy == |
||
+ | === Taking Typeclasses Seriously === |
||
− | == The hierarchy == |
||
+ | Following [[Not just Maybe]], functions should be generalized whenever possible. Of course, efficiency might be a concern but this is a fun project anyway. |
||
+ | * <hask>concat</hask> means the same thing as <hask>join</hask>. We propose we don't use <hask>concat</hask> at all. |
||
+ | * <hask>concatMap</hask> is just <hask>(>>=)</hask>. That is, monadic functions are preferred over the same functions with different name. |
||
+ | |||
+ | === The Hierarchy === |
||
+ | |||
+ | Although, not Haskell98, hierarchical modules are already in Haskell2010. We take it for granted. |
||
* <hask>TheOtherPrelude</hask> - Minimalistic module. |
* <hask>TheOtherPrelude</hask> - Minimalistic module. |
||
− | * <hask>TheOtherPrelude. |
+ | * <hask>TheOtherPrelude.Utilities</hask> - Convenient definitions. The reasoning behind its existence is that we want the Prelude to be very concise. It should not steal good names. |
+ | * <hask>TheOtherPrelude.Legacy</hask> - providing as much backwards compatibility as possible |
||
+ | |||
+ | == Open Issues == |
||
+ | |||
+ | * When the same function has an infix and a prefix implementation, should one of them be outside the class to enforce consistency? |
||
+ | * Should Prelude functions use <hask>Integer</hask> instead of <hask>Int</hask>? Maybe <hask>Integral n => n</hask> or <hask>Ix i => i</hask> in some cases? |
||
+ | * Should <hask>String</hask> be a class rather than a type synonym? |
||
+ | * The current proposal lacks a well thought <hask>fail</hask> mechanism. Should it be integrated into <hask>MonadZero</hask>, or have a class of his own, or remain in the <hask>Monad</hask> class? |
||
+ | |||
+ | == Reality == |
||
+ | |||
+ | What we have here right now is not ready to be adopted by existing projects. The [[class system extension proposal]] might make a difference. |
||
+ | |||
+ | == The Code == |
||
− | == The code == |
||
Currently, the code is in Wiki form. If people do agree that the collaborative decisions begot something pretty, we'll have a group of files in darcs.haskell.org some time. |
Currently, the code is in Wiki form. If people do agree that the collaborative decisions begot something pretty, we'll have a group of files in darcs.haskell.org some time. |
||
− | The |
+ | The imaginary Prelude as it stands: |
+ | |||
+ | === <hask>TheOtherPrelude.hs</hask> === |
||
<haskell> |
<haskell> |
||
+ | {-# LANGUAGE NoImplicitPrelude #-} |
||
− | import Prelude () -- hide everything |
||
+ | |||
+ | module TheOtherPrelude where |
||
+ | |||
+ | import Prelude (id, const, flip, (.)) |
||
+ | -- hide almost everything |
||
+ | -- in fact, we could do better, by just defining them here |
||
+ | |||
+ | -- The idea is to rename 'fmap'. |
||
+ | -- Both map :: (a -> b) -> [a] -> [b] (in []) |
||
+ | -- and (.) :: (a -> b) -> (e -> a) -> (e -> b) (in (->) e) |
||
+ | -- are good names, and are intuitively prefix and infix respectively. |
||
+ | -- 'map' is aliased as (.) below. |
||
− | -- the idea is to remove 'fmap' |
||
− | -- and map :: (a -> b) -> [a] -> [b] to be a special case |
||
− | -- as well as having (.) :: (a -> b) -> (e -> a) -> (e -> b) as a |
||
− | -- special case from the Functor instance for ((->) e) |
||
− | -- Both notations can be provided to allow for clarity in different situations. |
||
class Functor f where |
class Functor f where |
||
map :: (a -> b) -> f a -> f b |
map :: (a -> b) -> f a -> f b |
||
− | (.) :: (a -> b) -> f a -> f b |
||
− | map = (.) |
||
− | (.) = map |
||
+ | -- definitely a bad idea, sorry Cale! |
||
− | -- should the Functor hierarchy proposal be adopted? |
||
+ | -- (.) :: (Functor f) => (a -> b) -> f a -> f b |
||
− | -- |
||
− | -- |
+ | -- (.) = map |
− | class Monad m where |
||
− | (>>=) :: m a -> (a -> m b) -> m b |
||
− | (>>) :: m a -> m b -> m b |
||
− | return :: a -> m a |
||
− | fail :: String -> m a |
||
− | -- |
||
− | -- YES -- |
||
− | -- the following has been shamelessly copied |
||
− | -- from the functor hierarchy proposal wiki page |
||
− | class Functor f => Applicative f where |
||
− | return :: a -> f a |
||
− | (<*>) :: f (a -> b) -> f a -> f b -- or should this be named 'ap'? |
||
− | -- or something even better? |
||
− | -- could this nice looking function |
||
− | -- refactor the liftM* idioms? |
||
− | |||
+ | class (Functor p) => Applicative p where |
||
− | -- my undestanding is that this is the default for monad |
||
+ | -- Minimal complete definition: return and (<@>). |
||
− | (>>) :: Applicative f => f a -> f b -> f b |
||
+ | pure :: a -> p a -- value lifting |
||
− | fa >> fb = (map (const id) fa) <*> fb |
||
+ | -- actually I think we should |
||
+ | -- stick to return |
||
+ | -- to make do notation work |
||
+ | (<@>) :: p (a -> b) -> p a -> p b -- lifted application |
||
+ | (>>) :: p a -> p b -> p b -- when the second is independent of the first |
||
+ | pa >> pb = (const id) . pa <@> pb |
||
− | -- this leaves little left for the actual Monad class |
||
+ | --map f pa = return f <@> pa -- see Class system extension proposal, below |
||
− | class (Applicative f) => Monad f where |
||
− | (>>=) :: f a -> (a -> f b) -> f b |
||
− | join :: f (f a) -> f a |
||
− | |||
− | x >>= f = join (map f x) |
||
− | join x = x >>= id |
||
+ | apply :: (Applicative p) => p (a -> b) -> p a -> p b |
||
− | -- end of Functor hierarchy dilemma |
||
+ | apply = (<@>) |
||
+ | class (Applicative m) => Monad m where |
||
− | -- zero will be used when pattern matching against refutable patterns in |
||
+ | -- Minimal complete definition: one of join or (>>=). |
||
+ | (>>=) :: m a -> (a -> m b) -> m b -- bind |
||
+ | join :: m (m a) -> m a -- combining levels of structure |
||
+ | |||
+ | ma >>= k = join (map k ma) |
||
+ | join mma = mma >>= id |
||
+ | --mf <@> ma = mf >>= flip map ma -- see Class system extension proposal, below |
||
+ | --ma >> mb = ma >>= const mb |
||
+ | --map f ma = ma >>= return . f -- this depends on (.), which is map! Be careful. |
||
+ | |||
+ | -- We copy from the MonadPlus reform proposal (link below) now. |
||
+ | -- 'zero' will be used when pattern matching against refutable patterns in |
||
-- do-notation as well as to provide support for monad comprehensions. |
-- do-notation as well as to provide support for monad comprehensions. |
||
− | class (Monad m) => MonadZero m where |
||
− | zero :: m a |
||
− | class ( |
+ | class (Monad mz) => MonadZero mz where |
− | + | -- Should satisfy 'left zero': zero >>= f = zero |
|
+ | zero :: mz a |
||
− | class (MonadZero |
+ | class (MonadZero mp) => MonadPlus mp where |
+ | -- Should satisfy 'monoid': |
||
− | orElse :: m a -> m a -> m a |
||
+ | -- zero ++ b = b; b ++ zero = b |
||
+ | -- (a ++ b) ++ c = a ++ (b ++ c) |
||
+ | -- and 'left distribution': |
||
+ | -- (a ++ b) >>= f = (a >>= f) ++ (b >>= f) |
||
+ | (++) :: mp a -> mp a -> mp a |
||
+ | class (MonadZero mo) => MonadOr mo where |
||
+ | -- Should satisfy 'monoid': |
||
+ | -- zero `orElse` b = b; b `orElse` zero = b |
||
+ | -- (a `orElse` b) `orElse` c = a `orElse` (b `orElse` c) |
||
+ | -- and 'left catch': |
||
+ | -- (return a) `orElse` b = a |
||
+ | orElse :: mo a -> mo a -> mo a |
||
+ | |||
+ | class (Monad m) => MonadFail m where |
||
+ | fail :: String -> m a |
||
</haskell> |
</haskell> |
||
+ | === <hask>TheOtherPrelude/Utilities.hs</hask> === |
||
− | How to use it, as it stands, |
||
<haskell> |
<haskell> |
||
+ | module TheOtherPrelude.Utilities where |
||
− | import Prelude () -- hide everything |
||
− | import |
+ | import Prelude () -- hide everything |
+ | |||
− | import qualified TheOtherPrelude.Monad.Kleisli as M -- standard convention |
||
+ | -- this is the if-then-else proposal |
||
+ | -- the name has been chosen to reflect the magic of Church booleans! |
||
+ | -- the order of arguments matches that of maybe and either. |
||
+ | boolean x _ True = x |
||
+ | boolean _ y False = y |
||
+ | </haskell> |
||
+ | |||
+ | == How To Use == |
||
+ | |||
+ | <haskell> |
||
+ | -- ''The Other Prelude'' is an alternative, not a replacement. |
||
+ | -- So we need to hide everything from the Prelude |
||
+ | --import Prelude () |
||
+ | -- Now that we have it, |
||
+ | {-# LANGUAGE NoImplicitPrelude #-} |
||
+ | -- This is just an example assuming there is nothing to hide |
||
+ | import TheOtherPrelude |
||
+ | |||
+ | -- Hopefully, this module will contain lift,... |
||
+ | -- Standard convention is to use M.lift (instead of liftM) |
||
+ | -- import qualified TheOtherPrelude.Monad.Kleisli as M |
||
</haskell> |
</haskell> |
||
== See also == |
== See also == |
||
− | * [[Mathematical prelude discussion]] - A numeric Prelude. Could this be merged into this one? |
||
− | * [[Prelude extensions]] and [[Prelude function suggestions]] - Unlike "The Other Prelude" they ''enhance'' the Prelude. |
||
− | * [[Functor hierarchy proposal]] - making "Monad m" imply "Functor m" |
||
− | * [[If-then-else]] - making "if" a function |
||
− | * [http://software.complete.org/missingh/static/doc/ MissingH] - functions "missing" from the haskell Prelude/libraries |
||
+ | * [[Class system extension proposal]] - Makes this proposal worth reading at last |
||
+ | * [[Quantified contexts]] - Another important issue |
||
+ | * [[Functor hierarchy proposal]] - Making <hask>Monad m</hask> imply <hask>Functor m</hask> (adopted by ''The Other Prelude''). |
||
+ | * [[Functor-Applicative-Monad Proposal]] - in essence the same proposal, perhaps showing this sentiment is more common than assumed |
||
+ | * [[If-then-else]] - Making <hask>if</hask> a function (partially adopted by ''The Other Prelude'', we are silent on the bigger issue of sugar). |
||
+ | * [http://software.complete.org/missingh/static/doc/ MissingH] - Functions "missing" from the Haskell Prelude/libraries. |
||
+ | * [[MonadPlus reform proposal]] - Clarifies ambiguities around MonadPlus laws (adopted by ''The Other Prelude'') |
||
+ | * [[Mathematical prelude discussion]] - A [[Numeric Prelude]] in good shape already. Will a merger be ever possible? |
||
+ | * [[Prelude extensions]] and [[List function suggestions]] - Unlike ''The Other Prelude'' they ''enhance'' the Prelude. |
||
+ | * [[Not just Maybe]] - Instead of writing inside a specific monad (i.e. Maybe) write functions generalized on (Monad m)=> where possible. |
||
+ | |||
+ | [[Category:Proposals]] |
||
[[Category:Mathematics]] |
[[Category:Mathematics]] |
||
[[Category:Code]] |
[[Category:Code]] |
Latest revision as of 22:37, 22 December 2010
Call For Contribution
This fun project, called The Other Prelude, is a creative reconstruction of the standard Prelude. By disregarding history and compatibility, we get a clean sheet.
Committee
This project has no committee whatsoever. Issues are discussed on the talk page.
Naming Conventions
- Function names should be easy for beginners to consume.
- Specifically, The Other Prelude naming convention is to use
- descriptive symbols for functions that are naturally infix (e.g.,
mplus
is replaced by(++)
) - whole English words and camelCase for functions (e.g.,
orElse
but notfmap
)
- descriptive symbols for functions that are naturally infix (e.g.,
Design Philosophy
Taking Typeclasses Seriously
Following Not just Maybe, functions should be generalized whenever possible. Of course, efficiency might be a concern but this is a fun project anyway.
concat
means the same thing asjoin
. We propose we don't useconcat
at all.concatMap
is just(>>=)
. That is, monadic functions are preferred over the same functions with different name.
The Hierarchy
Although, not Haskell98, hierarchical modules are already in Haskell2010. We take it for granted.
TheOtherPrelude
- Minimalistic module.TheOtherPrelude.Utilities
- Convenient definitions. The reasoning behind its existence is that we want the Prelude to be very concise. It should not steal good names.TheOtherPrelude.Legacy
- providing as much backwards compatibility as possible
Open Issues
- When the same function has an infix and a prefix implementation, should one of them be outside the class to enforce consistency?
- Should Prelude functions use
Integer
instead ofInt
? MaybeIntegral n => n
orIx i => i
in some cases? - Should
String
be a class rather than a type synonym? - The current proposal lacks a well thought
fail
mechanism. Should it be integrated intoMonadZero
, or have a class of his own, or remain in theMonad
class?
Reality
What we have here right now is not ready to be adopted by existing projects. The class system extension proposal might make a difference.
The Code
Currently, the code is in Wiki form. If people do agree that the collaborative decisions begot something pretty, we'll have a group of files in darcs.haskell.org some time.
The imaginary Prelude as it stands:
TheOtherPrelude.hs
TheOtherPrelude.hs
{-# LANGUAGE NoImplicitPrelude #-}
module TheOtherPrelude where
import Prelude (id, const, flip, (.))
-- hide almost everything
-- in fact, we could do better, by just defining them here
-- The idea is to rename 'fmap'.
-- Both map :: (a -> b) -> [a] -> [b] (in [])
-- and (.) :: (a -> b) -> (e -> a) -> (e -> b) (in (->) e)
-- are good names, and are intuitively prefix and infix respectively.
-- 'map' is aliased as (.) below.
class Functor f where
map :: (a -> b) -> f a -> f b
-- definitely a bad idea, sorry Cale!
-- (.) :: (Functor f) => (a -> b) -> f a -> f b
-- (.) = map
class (Functor p) => Applicative p where
-- Minimal complete definition: return and (<@>).
pure :: a -> p a -- value lifting
-- actually I think we should
-- stick to return
-- to make do notation work
(<@>) :: p (a -> b) -> p a -> p b -- lifted application
(>>) :: p a -> p b -> p b -- when the second is independent of the first
pa >> pb = (const id) . pa <@> pb
--map f pa = return f <@> pa -- see Class system extension proposal, below
apply :: (Applicative p) => p (a -> b) -> p a -> p b
apply = (<@>)
class (Applicative m) => Monad m where
-- Minimal complete definition: one of join or (>>=).
(>>=) :: m a -> (a -> m b) -> m b -- bind
join :: m (m a) -> m a -- combining levels of structure
ma >>= k = join (map k ma)
join mma = mma >>= id
--mf <@> ma = mf >>= flip map ma -- see Class system extension proposal, below
--ma >> mb = ma >>= const mb
--map f ma = ma >>= return . f -- this depends on (.), which is map! Be careful.
-- We copy from the MonadPlus reform proposal (link below) now.
-- 'zero' will be used when pattern matching against refutable patterns in
-- do-notation as well as to provide support for monad comprehensions.
class (Monad mz) => MonadZero mz where
-- Should satisfy 'left zero': zero >>= f = zero
zero :: mz a
class (MonadZero mp) => MonadPlus mp where
-- Should satisfy 'monoid':
-- zero ++ b = b; b ++ zero = b
-- (a ++ b) ++ c = a ++ (b ++ c)
-- and 'left distribution':
-- (a ++ b) >>= f = (a >>= f) ++ (b >>= f)
(++) :: mp a -> mp a -> mp a
class (MonadZero mo) => MonadOr mo where
-- Should satisfy 'monoid':
-- zero `orElse` b = b; b `orElse` zero = b
-- (a `orElse` b) `orElse` c = a `orElse` (b `orElse` c)
-- and 'left catch':
-- (return a) `orElse` b = a
orElse :: mo a -> mo a -> mo a
class (Monad m) => MonadFail m where
fail :: String -> m a
TheOtherPrelude/Utilities.hs
TheOtherPrelude/Utilities.hs
module TheOtherPrelude.Utilities where
import Prelude () -- hide everything
-- this is the if-then-else proposal
-- the name has been chosen to reflect the magic of Church booleans!
-- the order of arguments matches that of maybe and either.
boolean x _ True = x
boolean _ y False = y
How To Use
-- ''The Other Prelude'' is an alternative, not a replacement.
-- So we need to hide everything from the Prelude
--import Prelude ()
-- Now that we have it,
{-# LANGUAGE NoImplicitPrelude #-}
-- This is just an example assuming there is nothing to hide
import TheOtherPrelude
-- Hopefully, this module will contain lift,...
-- Standard convention is to use M.lift (instead of liftM)
-- import qualified TheOtherPrelude.Monad.Kleisli as M
See also
- Class system extension proposal - Makes this proposal worth reading at last
- Quantified contexts - Another important issue
- Functor hierarchy proposal - Making
Monad m
implyFunctor m
(adopted by The Other Prelude). - Functor-Applicative-Monad Proposal - in essence the same proposal, perhaps showing this sentiment is more common than assumed
- If-then-else - Making
if
a function (partially adopted by The Other Prelude, we are silent on the bigger issue of sugar). - MissingH - Functions "missing" from the Haskell Prelude/libraries.
- MonadPlus reform proposal - Clarifies ambiguities around MonadPlus laws (adopted by The Other Prelude)
- Mathematical prelude discussion - A Numeric Prelude in good shape already. Will a merger be ever possible?
- Prelude extensions and List function suggestions - Unlike The Other Prelude they enhance the Prelude.
- Not just Maybe - Instead of writing inside a specific monad (i.e. Maybe) write functions generalized on (Monad m)=> where possible.