# The Other Prelude

### From HaskellWiki

(Difference between revisions)

m (use "Integer" instead of "Int") |
Nmessenger (Talk | contribs) m (combined Functor (.) and map type decls) |
||

Line 34: | Line 34: | ||

-- Both notations can be provided to allow for clarity in different situations. | -- Both notations can be provided to allow for clarity in different situations. | ||

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

− | map | + | map, (.) :: (a -> b) -> f a -> f b |

− | + | ||

map = (.) | map = (.) | ||

(.) = map | (.) = map |

## Revision as of 09:36, 28 December 2006

## Contents |

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

## 2 Naming conventions

The principal is to make the names very readable for both beginners and category theorists (if any).

## 3 Guidelines

- The prelude should not contain any "projection" functions (like andfst. They go to the Extension module.snd

## 4 Issues

- Should alphanumeric names be preferred over symbols when defining a class?
- Why do many functions in Prelude use instead ofInt? IMO,Integershould be THE preferred datatype for everything (examples: length, splitAt, replicate, drop, take, ...)!Integer

## 5 The hierarchy

- - Minimalistic module.TheOtherPrelude
- - Convenient definitions.TheOtherPrelude.Extension

## 6 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 imaginery Prelude as it stands,

import Prelude () -- hide everything -- 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 map, (.) :: (a -> b) -> f a -> f b map = (.) (.) = map -- 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? (>>) :: f a -> f b -> f b fa >> fb = (map (const id) fa) <*> fb -- this leaves little left for the actual Monad class class (Applicative m) => Monad m where (>>=) :: m a -> (a -> m b) -> m b join :: m (m a) -> m a x >>= f = join (map f x) join x = x >>= id -- end of Functor hierarchy dilemma -- zero will be used when pattern matching against refutable patterns in -- do-notation as well as to provide support for monad comprehensions. class (Monad m) => MonadZero m where zero :: m a class (MonadZero m) => MonadPlus m where (++) :: m a -> m a -> m a class (MonadZero m) => MonadOr m where orElse :: m a -> m a -> m a

How to use it, as it stands,

import Prelude () -- hide everything import TheOtherPrelude -- get everything import qualified TheOtherPrelude.Monad.Kleisli as M -- standard convention

## 7 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
- MissingH - functions "missing" from the haskell Prelude/libraries