# The Other Prelude

### From HaskellWiki

(Difference between revisions)

Nmessenger (Talk | contribs) (Imported Prelude(id, const), now it compiles.) |
Nmessenger (Talk | contribs) (comment fmt, added Class Heirarchy Proposal (commented-out since invalid)) |
||

Line 22: | Line 22: | ||

== Open Issues == |
== Open Issues == |
||

− | * Should <hask>Functor</hask> imply <hask>Monad</hask> or the other way around? |
||

* When the same function has an infix and a prefix implementation, should one of them be outside the class to enforce consistency? |
* 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>? |
+ | * 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? |
* 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? |
* 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? |
||

Line 30: | Line 29: | ||

== Reality == |
== Reality == |
||

− | What we have here right now is not ready to be adopted by existing projects. May be the [[class system extension proposal]] can make a difference. |
+ | 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 == |
||

Line 36: | Line 35: | ||

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 imaginary Prelude as it stands, |
+ | The imaginary Prelude as it stands: |

=== <hask>TheOtherPrelude.hs</hask> === |
=== <hask>TheOtherPrelude.hs</hask> === |
||

Line 43: | Line 42: | ||

module TheOtherPrelude where |
module TheOtherPrelude where |
||

− | import Prelude (id, const) -- hide everything |
+ | import Prelude (id, const, flip) -- hide almost everything |

+ | |||

+ | -- 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 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. |
||

class Functor f where |
class Functor f where |
||

map :: (a -> b) -> f a -> f b |
map :: (a -> b) -> f a -> f b |
||

(.) :: (Functor f) => (a -> b) -> f a -> f b |
(.) :: (Functor f) => (a -> b) -> f a -> f b |
||

− | (.) = map -- defined outside the class as an infix synonym for map. |
+ | (.) = map |

− | -- The following has been shamelessly copied from the |
||

− | -- Functor hierarchy proposal page (see links below). |
||

class (Functor p) => Applicative p where |
class (Functor p) => Applicative p where |
||

-- Minimal complete definition: return and (<*>). |
-- Minimal complete definition: return and (<*>). |
||

Line 63: | Line 56: | ||

(>>) :: p a -> p b -> p b -- when the second is independent of the first |
(>>) :: p a -> p b -> p b -- when the second is independent of the first |
||

− | -- Default definition: |
+ | pa >> pb = map (const id) pa <*> pb |

− | f >> g = (map (const id) f) <*> g |
+ | --map f pa = return f <*> pa -- see Class system extension proposal, below |

apply :: (Applicative p) => p (a -> b) -> p a -> p b |
apply :: (Applicative p) => p (a -> b) -> p a -> p b |
||

− | apply = (<*>) -- defined outside the class as a prefix synonym for (<*>). |
+ | apply = (<*>) |

class (Applicative m) => Monad m where |
class (Applicative m) => Monad m where |
||

Line 74: | Line 67: | ||

join :: m (m a) -> m a -- combining levels of structure |
join :: m (m a) -> m a -- combining levels of structure |
||

− | -- Default definitions: |
+ | ma >>= k = join (map k ma) |

− | x >>= f = join (map f x) |
+ | join mma = mma >>= id |

− | join x = x >>= 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 shamelessly copy from the MonadPlus reform proposal (link below) now. |
+ | -- We copy from the MonadPlus reform proposal (link below) now. |

-- 'zero' will be used when pattern matching against refutable patterns in |
-- '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. |
||

− | -- Should satisfy 'left zero': zero >>= f = zero |
+ | |

class (Monad mz) => MonadZero mz where |
class (Monad mz) => MonadZero mz where |
||

+ | -- Should satisfy 'left zero': zero >>= f = zero |
||

zero :: mz a |
zero :: mz a |
||

− | -- 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) |
||

class (MonadZero mp) => MonadPlus mp where |
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 |
(++) :: mp a -> mp a -> mp a |
||

− | -- 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 |
||

class (MonadZero mo) => MonadOr mo where |
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 |
orElse :: mo a -> mo a -> mo a |
||

</haskell> |
</haskell> |

## Revision as of 17:00, 3 February 2007

## Contents |

## 1 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.

## 2 Committee

This project has no committee whatsoever. Issues are discussed on the talk page.

## 3 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.*,is replaced bymplus)(++) - whole English words and camelCase for functions (
*e.g.*,but notorElse)fmap

- descriptive symbols for functions that are naturally infix (

## 4 The Hierarchy

Although, not Haskell 98, hierarchical modules will definitely be in Haskell'. We take it for granted.

- - Minimalistic module.TheOtherPrelude
- - Convenient definitions. The reasoning behind its existence is that we want the Prelude to be very concise. It should not steal good names.TheOtherPrelude.Utilities

## 5 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 instead ofInteger? MaybeIntorIntegral n => nin some cases?Ix i => i
- Should be a class rather than a type synonym?String
- The current proposal lacks a well thought mechanism. Should it be integrated intofail, or have a class of his own, or remain in theMonadZeroclass?Monad

## 6 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.

## 7 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:

### 7.1 TheOtherPrelude.hs

TheOtherPrelude.hs

module TheOtherPrelude where import Prelude (id, const, flip) -- hide almost everything -- 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 (.) :: (Functor f) => (a -> b) -> f a -> f b (.) = map class (Functor p) => Applicative p where -- Minimal complete definition: return and (<*>). return :: a -> p a -- value lifting (<*>) :: 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 = map (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

### 7.2 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! boolean True x _ = x boolean False _ y = y

## 8 How To Use

-- ''The Other Prelude'' is an alternative, not a replacement. -- So we need to hide everything from the Prelude import Prelude () -- 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

## 9 See also

- Class system extension proposal - Makes this proposal worth reading at last
- Functor hierarchy proposal - Making implyMonad m(adopted byFunctor m
*The Other Prelude*). - If-then-else - Making a function (partially adopted byif
*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 Prelude function suggestions - Unlike
*The Other Prelude*they*enhance*the Prelude. - NotJustMaybe - Instead of writing inside a specific monad (i.e. Maybe) write functions generalized on (Monad m)=> where possible.