[update applicative module and add Data.Functor
John Meacham <john@repetae.net>**20100709060140
 Ignore-this: d4cd00f0730129a607fa9569586b2fd0
] hunk ./lib/applicative/Control/Applicative.hs 41
+import Data.Functor
hunk ./lib/applicative/Control/Applicative.hs 175
-(<$>) :: Functor f => (a -> b) -> f a -> f b
-f <$> a = fmap f a
+--(<$>) :: Functor f => (a -> b) -> f a -> f b
+--f <$> a = fmap f a
hunk ./lib/applicative/Control/Applicative.hs 179
-(<$) :: Functor f => a -> f b -> f a
-(<$) = (<$>) . const
+--(<$) :: Functor f => a -> f b -> f a
+--(<$) = (<$>) . const
hunk ./lib/applicative/Data/Traversable.hs 34
+        mapAccumL,
+        mapAccumR,
hunk ./lib/applicative/Data/Traversable.hs 107
+--instance Ix i => Traversable (Array i) where
+--        traverse f arr = listArray (bounds arr) `fmap` traverse f (elems arr)
+
hunk ./lib/applicative/Data/Traversable.hs 122
+-- left-to-right state transformer
+newtype StateL s a = StateL { runStateL :: s -> (s, a) }
+
+instance Functor (StateL s) where
+        fmap f (StateL k) = StateL $ \ s ->
+                let (s', v) = k s in (s', f v)
+
+instance Applicative (StateL s) where
+        pure x = StateL (\ s -> (s, x))
+        StateL kf <*> StateL kv = StateL $ \ s ->
+                let (s', f) = kf s
+                    (s'', v) = kv s'
+                in (s'', f v)
+
+-- |The 'mapAccumL' function behaves like a combination of 'fmap'
+-- and 'foldl'; it applies a function to each element of a structure,
+-- passing an accumulating parameter from left to right, and returning
+-- a final value of this accumulator together with the new structure.
+mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
+mapAccumL f s t = runStateL (traverse (StateL . flip f) t) s
+
+-- right-to-left state transformer
+newtype StateR s a = StateR { runStateR :: s -> (s, a) }
+
+instance Functor (StateR s) where
+        fmap f (StateR k) = StateR $ \ s ->
+                let (s', v) = k s in (s', f v)
+
+instance Applicative (StateR s) where
+        pure x = StateR (\ s -> (s, x))
+        StateR kf <*> StateR kv = StateR $ \ s ->
+                let (s', v) = kv s
+                    (s'', f) = kf s'
+                in (s'', f v)
+
+-- |The 'mapAccumR' function behaves like a combination of 'fmap'
+-- and 'foldr'; it applies a function to each element of a structure,
+-- passing an accumulating parameter from right to left, and returning
+-- a final value of this accumulator together with the new structure.
+mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
+mapAccumR f s t = runStateR (traverse (StateR . flip f) t) s
+
addfile ./lib/base/Data/Functor.hs
hunk ./lib/base/Data/Functor.hs 1
+{-# OPTIONS_JHC -N #-}
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Functor
+-- Copyright   :  (c) The University of Glasgow 2001
+-- License     :  BSD-style (see the file libraries/base/LICENSE)
+-- 
+-- Maintainer  :  libraries@haskell.org
+-- Stability   :  provisional
+-- Portability :  portable
+--
+-- Functors: uniform action over a parameterized type, generalizing the
+-- 'map' function on lists.
+
+module Data.Functor
+    (
+      Functor(fmap, (<$)),
+      (<$>),
+    ) where
+
+import Jhc.Monad
+
+infixl 4 <$>
+
+-- | An infix synonym for 'fmap'.
+(<$>) :: Functor f => (a -> b) -> f a -> f b
+(<$>) = fmap
hunk ./lib/base/base.cabal 14
+        Data.Functor,
hunk ./lib/jhc/Jhc/Monad.hs 13
+infixl 4  <$
+
+
hunk ./lib/jhc/Jhc/Monad.hs 17
-    fmap              :: (a -> b) -> f a -> f b
+    fmap :: (a -> b) -> f a -> f b
+    (<$) :: a -> f b -> f a
+
+    a <$ fb = fmap (const a) fb
+