[Haskell] Overriding Prelude functions

[André Pang]

Hi all,

Inspired by a bit of hackery today, I managed to find a nice way to 
re-define Prelude functions in modular way.  There may be some 
functions in the Prelude that you would like to redefine: in this 
example, we redefine the "lookup" function, which normally has a type 
signature of

   lookup :: forall b a. (Eq a) => a -> [(a, b)] -> Maybe b

Here, we make lookup a bit more generic, so that we can look up any 
data structure that is "lookupable" -- we override the Prelude's lookup 
function with our own.  The motivation is that there may be a module 
which provides you many useful functions, but unfortunately has 
namespace clashes with your own module.  One example is that you've 
defined a generic 'zip' function named gzip, which could substitute 
perfectly for the Prelude's own zip function, but you have to call it 
gzip only because the function name 'zip' is already taken.  The 
advantage of this is that you can smoothly integrate extra 
functionality with already-existing functions by overriding them -- and 
by providing the extra functionality in a module, you leave it up to 
the module user whether they want to take advantage of that 
functionality or not.

The essential idea is to define a module (e.g. MyPrelude), which does 
the following:

   module MyPrelude(module Prelude, lookup) where

   import qualified Prelude as P
   import Prelude hiding (lookup)

   lookup = ... (your own definition here) ...

That module re-exports the Prelude and its own lookup function.  Then, 
a module which wants to use the overridden lookup function does the 
following:

   {-# OPTIONS -fno-implicit-prelude #-}

   module UseLookup where

   import MyPrelude

   ... now uses MyPrelude's lookup function instead of Prelude's lookup 
...

A concrete implementation of this idea is below.  Have the appropriate 
amount of fun :).

MyPrelude.hs

   {-# OPTIONS -fglasgow-exts #-}

   module MyPrelude(module Prelude, lookup) where

   import qualified Prelude as P
   import Prelude hiding (lookup)

   import Data.FiniteMap
   import Data.Set

   -- override the lookup function, defined in the Prelude as:
   --
   -- lookup :: forall b a. (Eq a) => a -> [(a, b)] -> Maybe b

   class Lookup lookupable key value | lookupable -> key value where
     lookup :: Ord key => lookupable -> key -> Maybe value

   instance Lookup (FiniteMap key value) key value where
     lookup = lookupFM

   instance Lookup [(key, value)] key value where
     lookup = lookupListOfTuples

   instance Lookup (Set value) value value where
     lookup container element
       | elementOf element container = Just element
       | otherwise                   = Nothing

   lookupListOfTuples [] _ = Nothing
   lookupListOfTuples ((key, value):xs) key'
       | key == key' = Just value
       | otherwise   = lookupListOfTuples xs key'

UseLookup.hs:

   {-# OPTIONS -fno-implicit-prelude #-}

   module UseLookup where

   import Data.FiniteMap
   import Data.Set
   import MyPrelude

   fm = addToFM emptyFM "foo" "bar"

   set = mkSet ["foo"]

   tupleList = [("foo", "bar")]

An example session:

   *UseLookup> lookup fm "foo"
   Just "bar"
   *UseLookup> lookup fm "baz"
   Nothing
   *UseLookup> lookup set "foo"
   Just "foo"
   *UseLookup> lookup tupleList "foo"
   Just "bar"
   *UseLookup>


-- 
% Andre Pang : trust.in.love.to.save