Personal tools

The Other Prelude

From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
m (added link to NotJustMaybe)
m (See also)
 
(20 intermediate revisions by 8 users not shown)
Line 1: Line 1:
[[Category:Proposals]]
 
 
 
== Call For Contribution ==
 
== 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.
 
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 ==
 
== Committee ==
This project has no committee whatsoever. Haskell community discussed the issues [[Talk:The Other Prelude|here]].
+
  +
This project has no committee whatsoever. Issues are discussed on [[Talk:The Other Prelude|the talk page]].
   
 
== Naming Conventions ==
 
== Naming Conventions ==
  +
 
* Function names should be easy for beginners to consume.
 
* Function names should be easy for beginners to consume.
 
* Specifically, ''The Other Prelude'' naming convention is to use
 
* Specifically, ''The Other Prelude'' naming convention is to use
Line 13: Line 13:
 
** whole English words and camelCase for functions (''e.g.'', <hask>orElse</hask> but not <hask>fmap</hask>)
 
** whole English words and camelCase for functions (''e.g.'', <hask>orElse</hask> but not <hask>fmap</hask>)
   
== The Hierarchy ==
+
== Design Philosophy ==
Although, not Haskell 98, hierarchical modules will definitely be in Haskell'. We take it for granted.
+
  +
=== 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.
  +
* <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.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.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 ==
 
== Open Issues ==
* Should Prelude functions use <hask>Integer</hask> instead of <hask>Int</hask>?
+
  +
* 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?
 
* 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 imaginery Prelude as it stands,
+
The imaginary Prelude as it stands:
=== <hask>TheOtherPrelude</hask> ===
 
<haskell>
 
-- module: TheOtherPrelude
 
import Prelude () -- hide everything
 
   
  +
=== <hask>TheOtherPrelude.hs</hask> ===
   
-- the idea is to remove 'fmap'.
+
<haskell>
-- both map :: (a -> b) -> [a] -> [b] ('fmap' for the monad [])
+
{-# LANGUAGE NoImplicitPrelude #-}
-- and (.) :: (a -> b) -> (e -> a) -> (e -> b) ('fmap' for the (->) e monad)
 
-- are good names, and are intuitively prefix and infix respectively.
 
class Functor f where
 
-- 'fmap' is guilty of nothing but a bad name
 
map, (.) :: (a -> b) -> f a -> f b
 
   
-- implementing either is enough
+
module TheOtherPrelude where
map = (.)
 
(.) = map
 
   
  +
import Prelude (id, const, flip, (.))
  +
-- hide almost everything
  +
-- in fact, we could do better, by just defining them here
   
-- the following has been shamelessly copied,
+
-- The idea is to rename 'fmap'.
-- from the Functor hierarchy proposal[1] wiki page.
+
-- Both map :: (a -> b) -> [a] -> [b] (in [])
class Functor f => Applicative f where
+
-- and (.) :: (a -> b) -> (e -> a) -> (e -> b) (in (->) e)
-- lifting a value
+
-- are good names, and are intuitively prefix and infix respectively.
return :: a -> f a
+
-- 'map' is aliased as (.) below.
   
-- should this be named 'ap'? is 'ap' a good name?
+
class Functor f where
-- can you come up with a better name?
+
map :: (a -> b) -> f a -> f b
-- can it refactor the liftM* type gymnastics?
 
(<*>) :: f (a -> b) -> f a -> f b
 
 
-- when the second is independent of the first
 
(>>) :: m a -> m b -> m b
 
   
-- is there a better definition?
+
-- definitely a bad idea, sorry Cale!
fa >> fb = (map (const id) fa) <*> fb
+
-- (.) :: (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
   
-- this leaves little left for the actual Monad class
+
pa >> pb = (const id) . pa <@> pb
class Applicative m => Monad m where
+
--map f pa = return f <@> pa -- see Class system extension proposal, below
-- the binding operation, gist of a monad
 
(>>=) :: m a -> (a -> m b) -> m b
 
   
-- throwing out the outer monad
+
apply :: (Applicative p) => p (a -> b) -> p a -> p b
join :: m (m a) -> m a
+
apply = (<@>)
   
-- intuitive definitions
+
class (Applicative m) => Monad m where
x >>= f = join (map f x)
+
-- Minimal complete definition: one of join or (>>=).
join x = x >>= id
+
(>>=) :: 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 shamelessly copy from the MonadPlus reform proposal[2] 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 m => MonadZero m where
+
-- Should satisfy 'left zero': zero >>= f = zero
zero :: m a
+
zero :: mz a
 
   
-- should satisfy 'monoid'
+
class (MonadZero mp) => MonadPlus mp where
-- zero ++ b = b, b ++ zero = b, (a ++ b) ++ c = a ++ (b ++ c)
+
-- Should satisfy 'monoid':
-- and 'left distribution'
+
-- zero ++ b = b; b ++ zero = b
-- (a ++ b) >>= f = (a >>= f) ++ (b >>= f)
+
-- (a ++ b) ++ c = a ++ (b ++ c)
class MonadZero m => MonadPlus m where
+
-- and 'left distribution':
(++) :: m a -> m a -> m a
+
-- (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
   
-- should satisfy 'monoid'
+
class (Monad m) => MonadFail m where
-- zero `orElse` b = b, b `orElse` zero = b
+
fail :: String -> m a
-- (a `orElse` b) `orElse` c = a `orElse` (b `orElse` c)
 
-- and 'left catch'
 
-- (return a) `orElse` b = a
 
class MonadZero m => MonadOr m where
 
orElse :: m a -> m a -> m a
 
 
</haskell>
 
</haskell>
   
[1]: [[Functor hierarchy proposal]]<br />
+
=== <hask>TheOtherPrelude/Utilities.hs</hask> ===
[2]: [[MonadPlus reform proposal]]
 
   
=== <hask>TheOtherPrelude.Utilities</hask> ===
 
 
<haskell>
 
<haskell>
-- module: TheOtherPrelude.Utilities
+
module TheOtherPrelude.Utilities where
 
 
import Prelude () -- hide everything
 
import Prelude () -- hide everything
   
 
-- this is the if-then-else proposal
 
-- this is the if-then-else proposal
 
-- the name has been chosen to reflect the magic of Church booleans!
 
-- the name has been chosen to reflect the magic of Church booleans!
boolean True x _ = x
+
-- the order of arguments matches that of maybe and either.
boolean False _ y = y
+
boolean x _ True = x
+
boolean _ y False = y
 
</haskell>
 
</haskell>
  +
 
== How To Use ==
 
== How To Use ==
  +
 
<haskell>
 
<haskell>
 
-- ''The Other Prelude'' is an alternative, not a replacement.
 
-- ''The Other Prelude'' is an alternative, not a replacement.
 
-- So we need to hide everything from the Prelude
 
-- So we need to hide everything from the Prelude
import Prelude ()
+
--import Prelude ()
+
-- Now that we have it,
  +
{-# LANGUAGE NoImplicitPrelude #-}
 
-- This is just an example assuming there is nothing to hide
 
-- This is just an example assuming there is nothing to hide
import TheOtherPrelude
+
import TheOtherPrelude
   
 
-- Hopefully, this module will contain lift,...
 
-- Hopefully, this module will contain lift,...
 
-- Standard convention is to use M.lift (instead of liftM)
 
-- Standard convention is to use M.lift (instead of liftM)
import qualified TheOtherPrelude.Monad.Kleisli as M
+
-- import qualified TheOtherPrelude.Monad.Kleisli as M
 
</haskell>
 
</haskell>
   
 
== See also ==
 
== See also ==
* [[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.
+
* [[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 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).
 
* [[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.
 
* [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'')
 
* [[MonadPlus reform proposal]] - Clarifies ambiguities around MonadPlus laws (adopted by ''The Other Prelude'')
* [http://haskell.org/hawiki/NotJustMaybe NotJustMaybe] - Instead of writing inside a specific monad (i.e. Maybe) write functions generalized on (Monad m)=> where possible.
+
* [[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

Contents

[edit] 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.

[edit] 2 Committee

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

[edit] 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.,
      mplus
      is replaced by
      (++)
      )
    • whole English words and camelCase for functions (e.g.,
      orElse
      but not
      fmap
      )

[edit] 4 Design Philosophy

[edit] 4.1 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 as
    join
    . We propose we don't use
    concat
    at all.
  • concatMap
    is just
    (>>=)
    . That is, monadic functions are preferred over the same functions with different name.

[edit] 4.2 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

[edit] 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
    Integer
    instead of
    Int
    ? Maybe
    Integral n => n
    or
    Ix 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 into
    MonadZero
    , or have a class of his own, or remain in the
    Monad
    class?

[edit] 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.

[edit] 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:

[edit] 7.1
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

[edit] 7.2
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

[edit] 8 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

[edit] 9 See also