@@ -0,0 +1,524 @@
1+diff -ur hackage-package-transformers-0.5.5.0/Control/Applicative/Backwards.hs ghc-package-transformers-0.5.5.0/Control/Applicative/Backwards.hs
2+--- hackage-package-transformers-0.5.5.0/Control/Applicative/Backwards.hs 2017-10-04 23:58:48.000000000 +0800
3++++ ghc-package-transformers-0.5.5.0/Control/Applicative/Backwards.hs 2001-09-09 09:46:40.000000000 +0800
7+ import Data.Functor.Classes
8++#if MIN_VERSION_base(4,12,0)
9++import Data.Functor.Contravariant
12+ import Prelude hiding (foldr, foldr1, foldl, foldl1, null, length)
13+ import Control.Applicative
15+ {-# INLINE traverse #-}
16+ sequenceA (Backwards t) = fmap Backwards (sequenceA t)
17+ {-# INLINE sequenceA #-}
19++#if MIN_VERSION_base(4,12,0)
20++-- | Derived instance.
21++instance Contravariant f => Contravariant (Backwards f) where
22++ contramap f = Backwards . contramap f . forwards
23++ {-# INLINE contramap #-}
25+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Class.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Class.hs
26+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Class.hs 2017-10-04 23:58:48.000000000 +0800
27++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Class.hs 2001-09-09 09:46:40.000000000 +0800
32+-One might define a parsing monad by adding a state (the 'String' remaining
33++The first example is a parser monad in the style of
35++* \"Monadic parsing in Haskell\", by Graham Hutton and Erik Meijer,
36++/Journal of Functional Programming/ 8(4):437-444, July 1998
37++(<http://www.cs.nott.ac.uk/~pszgmh/bib.html#pearl>).
39++We can define such a parser monad by adding a state (the 'String' remaining
40+ to be parsed) to the @[]@ monad, which provides non-determinism:
42+ > import Control.Monad.Trans.State
46+ This example is a cut-down version of the one in
47+-\"Monad Transformers and Modular Interpreters\",
49++* \"Monad Transformers and Modular Interpreters\",
50+ by Sheng Liang, Paul Hudak and Mark Jones in /POPL'95/
51+ (<http://web.cecs.pdx.edu/~mpj/pubs/modinterp.html>).
53+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Error.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Error.hs
54+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Error.hs 2017-10-04 23:58:48.000000000 +0800
55++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Error.hs 2001-09-09 09:46:40.000000000 +0800
57+ import Control.Monad.Signatures
58+ import Control.Monad.Trans.Class
59+ import Data.Functor.Classes
60++#if MIN_VERSION_base(4,12,0)
61++import Data.Functor.Contravariant
64+ import Control.Applicative
65+ import Control.Exception (IOException)
67+ instance (Error e, MonadIO m) => MonadIO (ErrorT e m) where
68+ liftIO = lift . liftIO
70++#if MIN_VERSION_base(4,12,0)
71++instance Contravariant m => Contravariant (ErrorT e m) where
72++ contramap f = ErrorT . contramap (fmap f) . runErrorT
75+ -- | Signal an error value @e@.
77+ -- * @'runErrorT' ('throwError' e) = 'return' ('Left' e)@
78+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Except.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Except.hs
79+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Except.hs 2017-10-04 23:58:48.000000000 +0800
80++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Except.hs 2001-09-09 09:46:40.000000000 +0800
82+ -- Stability : experimental
83+ -- Portability : portable
85+--- This monad transformer extends a monad with the ability throw exceptions.
86++-- This monad transformer extends a monad with the ability to throw exceptions.
88+ -- A sequence of actions terminates normally, producing a value,
89+ -- only if none of the actions in the sequence throws an exception.
91+ import Control.Monad.Signatures
92+ import Control.Monad.Trans.Class
93+ import Data.Functor.Classes
94++#if MIN_VERSION_base(4,12,0)
95++import Data.Functor.Contravariant
97+ import Data.Functor.Identity
99+ import Control.Applicative
101+ {-# INLINE mzipWith #-}
104++#if MIN_VERSION_base(4,12,0)
105++instance Contravariant m => Contravariant (ExceptT e m) where
106++ contramap f = ExceptT . contramap (fmap f) . runExceptT
107++ {-# INLINE contramap #-}
110+ -- | Signal an exception value @e@.
112+ -- * @'runExceptT' ('throwE' e) = 'return' ('Left' e)@
113+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Identity.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Identity.hs
114+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Identity.hs 2017-10-04 23:58:48.000000000 +0800
115++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Identity.hs 2001-09-09 09:46:40.000000000 +0800
117+ import Control.Monad.Signatures
118+ import Control.Monad.Trans.Class (MonadTrans(lift))
119+ import Data.Functor.Classes
120++#if MIN_VERSION_base(4,12,0)
121++import Data.Functor.Contravariant
124+ import Control.Applicative
125+ import Control.Monad (MonadPlus(mzero, mplus))
130++#if MIN_VERSION_base(4,12,0)
131++instance Contravariant f => Contravariant (IdentityT f) where
132++ contramap f = IdentityT . contramap f . runIdentityT
133++ {-# INLINE contramap #-}
136+ -- | Lift a unary operation to the new monad.
137+ mapIdentityT :: (m a -> n b) -> IdentityT m a -> IdentityT n b
138+ mapIdentityT f = IdentityT . f . runIdentityT
139+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/List.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/List.hs
140+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/List.hs 2017-10-04 23:58:48.000000000 +0800
141++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/List.hs 2001-09-09 09:46:40.000000000 +0800
143+ import Control.Monad.Signatures
144+ import Control.Monad.Trans.Class
145+ import Data.Functor.Classes
146++#if MIN_VERSION_base(4,12,0)
147++import Data.Functor.Contravariant
150+ import Control.Applicative
151+ import Control.Monad
152+ #if MIN_VERSION_base(4,9,0)
153+ import qualified Control.Monad.Fail as Fail
155++import Control.Monad.Fix
156+ #if MIN_VERSION_base(4,4,0)
157+ import Control.Monad.Zip (MonadZip(mzipWith))
161+ {-# INLINE mplus #-}
163++instance (MonadFix m) => MonadFix (ListT m) where
164++ mfix f = ListT $ mfix (runListT . f . head) >>= \ xs -> case xs of
166++ x:_ -> (x:) <$> (runListT . mfix) ((mapListT . fmap) tail . f)
167++ {-# INLINE mfix #-}
169+ instance MonadTrans ListT where
173+ {-# INLINE mzipWith #-}
176++#if MIN_VERSION_base(4,12,0)
177++instance Contravariant m => Contravariant (ListT m) where
178++ contramap f = ListT . contramap (fmap f) . runListT
179++ {-# INLINE contramap #-}
182+ -- | Lift a @callCC@ operation to the new monad.
183+ liftCallCC :: CallCC m [a] [b] -> CallCC (ListT m) a b
184+ liftCallCC callCC f = ListT $
185+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Maybe.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Maybe.hs
186+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Maybe.hs 2017-10-04 23:58:48.000000000 +0800
187++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Maybe.hs 2001-09-09 09:46:40.000000000 +0800
189+ import Control.Monad.Trans.Class
190+ import Control.Monad.Trans.Except (ExceptT(..))
191+ import Data.Functor.Classes
192++#if MIN_VERSION_base(4,12,0)
193++import Data.Functor.Contravariant
196+ import Control.Applicative
197+ import Control.Monad (MonadPlus(mzero, mplus), liftM)
199+ {-# INLINE mzipWith #-}
202++#if MIN_VERSION_base(4,12,0)
203++instance Contravariant m => Contravariant (MaybeT m) where
204++ contramap f = MaybeT . contramap (fmap f) . runMaybeT
205++ {-# INLINE contramap #-}
208+ -- | Lift a @callCC@ operation to the new monad.
209+ liftCallCC :: CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b
210+ liftCallCC callCC f =
211+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/RWS/Lazy.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/RWS/Lazy.hs
212+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/RWS/Lazy.hs 2017-10-04 23:58:48.000000000 +0800
213++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/RWS/Lazy.hs 2001-09-09 09:46:40.000000000 +0800
215+ import Control.Monad.IO.Class
216+ import Control.Monad.Signatures
217+ import Control.Monad.Trans.Class
218++#if MIN_VERSION_base(4,12,0)
219++import Data.Functor.Contravariant
221+ import Data.Functor.Identity
223+ import Control.Applicative
225+ liftIO = lift . liftIO
226+ {-# INLINE liftIO #-}
228++#if MIN_VERSION_base(4,12,0)
229++instance Contravariant m => Contravariant (RWST r w s m) where
230++ contramap f m = RWST $ \r s ->
231++ contramap (\ ~(a, s', w) -> (f a, s', w)) $ runRWST m r s
232++ {-# INLINE contramap #-}
235+ -- ---------------------------------------------------------------------------
236+ -- Reader operations
238+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/RWS/Strict.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/RWS/Strict.hs
239+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/RWS/Strict.hs 2017-10-04 23:58:48.000000000 +0800
240++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/RWS/Strict.hs 2001-09-09 09:46:40.000000000 +0800
242+ import Control.Monad.IO.Class
243+ import Control.Monad.Signatures
244+ import Control.Monad.Trans.Class
245++#if MIN_VERSION_base(4,12,0)
246++import Data.Functor.Contravariant
248+ import Data.Functor.Identity
250+ import Control.Applicative
252+ liftIO = lift . liftIO
253+ {-# INLINE liftIO #-}
255++#if MIN_VERSION_base(4,12,0)
256++instance Contravariant m => Contravariant (RWST r w s m) where
257++ contramap f m = RWST $ \r s ->
258++ contramap (\ (a, s', w) -> (f a, s', w)) $ runRWST m r s
259++ {-# INLINE contramap #-}
262+ -- ---------------------------------------------------------------------------
263+ -- Reader operations
265+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Reader.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Reader.hs
266+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Reader.hs 2017-10-04 23:58:48.000000000 +0800
267++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Reader.hs 2001-09-09 09:46:40.000000000 +0800
269+ import Control.Monad.IO.Class
270+ import Control.Monad.Signatures
271+ import Control.Monad.Trans.Class
272++#if MIN_VERSION_base(4,12,0)
273++import Data.Functor.Contravariant
275+ import Data.Functor.Identity
277+ import Control.Applicative
279+ {-# INLINE mzipWith #-}
282++#if MIN_VERSION_base(4,12,0)
283++instance Contravariant m => Contravariant (ReaderT r m) where
284++ contramap f = ReaderT . fmap (contramap f) . runReaderT
285++ {-# INLINE contramap #-}
288+ liftReaderT :: m a -> ReaderT r m a
289+ liftReaderT m = ReaderT (const m)
290+ {-# INLINE liftReaderT #-}
291+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/State/Lazy.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/State/Lazy.hs
292+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/State/Lazy.hs 2017-10-04 23:58:48.000000000 +0800
293++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/State/Lazy.hs 2001-09-09 09:46:40.000000000 +0800
295+ import Control.Monad.IO.Class
296+ import Control.Monad.Signatures
297+ import Control.Monad.Trans.Class
298++#if MIN_VERSION_base(4,12,0)
299++import Data.Functor.Contravariant
301+ import Data.Functor.Identity
303+ import Control.Applicative
305+ liftIO = lift . liftIO
306+ {-# INLINE liftIO #-}
308++#if MIN_VERSION_base(4,12,0)
309++instance Contravariant m => Contravariant (StateT s m) where
310++ contramap f m = StateT $ \s ->
311++ contramap (\ ~(a, s') -> (f a, s')) $ runStateT m s
312++ {-# INLINE contramap #-}
315+ -- | Fetch the current value of the state within the monad.
316+ get :: (Monad m) => StateT s m s
317+ get = state $ \ s -> (s, s)
318+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/State/Strict.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/State/Strict.hs
319+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/State/Strict.hs 2017-10-04 23:58:48.000000000 +0800
320++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/State/Strict.hs 2001-09-09 09:46:40.000000000 +0800
322+ import Control.Monad.IO.Class
323+ import Control.Monad.Signatures
324+ import Control.Monad.Trans.Class
325++#if MIN_VERSION_base(4,12,0)
326++import Data.Functor.Contravariant
328+ import Data.Functor.Identity
330+ import Control.Applicative
332+ liftIO = lift . liftIO
333+ {-# INLINE liftIO #-}
335++#if MIN_VERSION_base(4,12,0)
336++instance Contravariant m => Contravariant (StateT s m) where
337++ contramap f m = StateT $ \s ->
338++ contramap (\ (a, s') -> (f a, s')) $ runStateT m s
339++ {-# INLINE contramap #-}
342+ -- | Fetch the current value of the state within the monad.
343+ get :: (Monad m) => StateT s m s
344+ get = state $ \ s -> (s, s)
345+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Writer/Lazy.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Writer/Lazy.hs
346+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Writer/Lazy.hs 2017-10-04 23:58:48.000000000 +0800
347++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Writer/Lazy.hs 2001-09-09 09:46:40.000000000 +0800
349+ import Control.Monad.IO.Class
350+ import Control.Monad.Trans.Class
351+ import Data.Functor.Classes
352++#if MIN_VERSION_base(4,12,0)
353++import Data.Functor.Contravariant
355+ import Data.Functor.Identity
357+ import Control.Applicative
359+ {-# INLINE mzipWith #-}
362++#if MIN_VERSION_base(4,12,0)
363++instance Contravariant m => Contravariant (WriterT w m) where
364++ contramap f = mapWriterT $ contramap $ \ ~(a, w) -> (f a, w)
365++ {-# INLINE contramap #-}
368+ -- | @'tell' w@ is an action that produces the output @w@.
369+ tell :: (Monad m) => w -> WriterT w m ()
370+ tell w = writer ((), w)
371+diff -ur hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Writer/Strict.hs ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Writer/Strict.hs
372+--- hackage-package-transformers-0.5.5.0/Control/Monad/Trans/Writer/Strict.hs 2017-10-04 23:58:48.000000000 +0800
373++++ ghc-package-transformers-0.5.5.0/Control/Monad/Trans/Writer/Strict.hs 2001-09-09 09:46:40.000000000 +0800
375+ import Control.Monad.IO.Class
376+ import Control.Monad.Trans.Class
377+ import Data.Functor.Classes
378++#if MIN_VERSION_base(4,12,0)
379++import Data.Functor.Contravariant
381+ import Data.Functor.Identity
383+ import Control.Applicative
385+ {-# INLINE mzipWith #-}
388++#if MIN_VERSION_base(4,12,0)
389++instance Contravariant m => Contravariant (WriterT w m) where
390++ contramap f = mapWriterT $ contramap $ \ (a, w) -> (f a, w)
391++ {-# INLINE contramap #-}
394+ -- | @'tell' w@ is an action that produces the output @w@.
395+ tell :: (Monad m) => w -> WriterT w m ()
396+ tell w = writer ((), w)
397+diff -ur hackage-package-transformers-0.5.5.0/Data/Functor/Constant.hs ghc-package-transformers-0.5.5.0/Data/Functor/Constant.hs
398+--- hackage-package-transformers-0.5.5.0/Data/Functor/Constant.hs 2017-10-04 23:58:48.000000000 +0800
399++++ ghc-package-transformers-0.5.5.0/Data/Functor/Constant.hs 2001-09-09 09:46:40.000000000 +0800
403+ import Data.Functor.Classes
404++#if MIN_VERSION_base(4,12,0)
405++import Data.Functor.Contravariant
408+ import Control.Applicative
409+ import Data.Foldable
411+ bitraverse f _ (Constant a) = Constant <$> f a
412+ {-# INLINE bitraverse #-}
415++#if MIN_VERSION_base(4,12,0)
416++instance Contravariant (Constant a) where
417++ contramap _ (Constant a) = Constant a
418++ {-# INLINE contramap #-}
420+diff -ur hackage-package-transformers-0.5.5.0/Data/Functor/Reverse.hs ghc-package-transformers-0.5.5.0/Data/Functor/Reverse.hs
421+--- hackage-package-transformers-0.5.5.0/Data/Functor/Reverse.hs 2017-10-04 23:58:48.000000000 +0800
422++++ ghc-package-transformers-0.5.5.0/Data/Functor/Reverse.hs 2001-09-09 09:46:40.000000000 +0800
425+ import Control.Applicative.Backwards
426+ import Data.Functor.Classes
427++#if MIN_VERSION_base(4,12,0)
428++import Data.Functor.Contravariant
431+ import Prelude hiding (foldr, foldr1, foldl, foldl1, null, length)
432+ import Control.Applicative
434+ traverse f (Reverse t) =
435+ fmap Reverse . forwards $ traverse (Backwards . f) t
436+ {-# INLINE traverse #-}
438++#if MIN_VERSION_base(4,12,0)
439++-- | Derived instance.
440++instance Contravariant f => Contravariant (Reverse f) where
441++ contramap f = Reverse . contramap f . getReverse
442++ {-# INLINE contramap #-}
444+diff -ur hackage-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Compose.hs ghc-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Compose.hs
445+--- hackage-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Compose.hs 2017-10-04 23:58:48.000000000 +0800
446++++ ghc-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Compose.hs 2001-09-09 09:46:40.000000000 +0800
450+ import Data.Functor.Classes
451++#if MIN_VERSION_base(4,12,0)
452++import Data.Functor.Contravariant
455+ import Control.Applicative
456+ #if __GLASGOW_HASKELL__ >= 708
458+ instance (Alternative f, Applicative g) => Alternative (Compose f g) where
459+ empty = Compose empty
460+ Compose x <|> Compose y = Compose (x <|> y)
462++#if MIN_VERSION_base(4,12,0)
463++instance (Functor f, Contravariant g) => Contravariant (Compose f g) where
464++ contramap f (Compose fga) = Compose (fmap (contramap f) fga)
466+diff -ur hackage-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Product.hs ghc-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Product.hs
467+--- hackage-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Product.hs 2017-10-04 23:58:48.000000000 +0800
468++++ ghc-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Product.hs 2001-09-09 09:46:40.000000000 +0800
471+ import Data.Foldable (Foldable(foldMap))
472+ import Data.Functor.Classes
473++#if MIN_VERSION_base(4,12,0)
474++import Data.Functor.Contravariant
476+ import Data.Monoid (mappend)
477+ import Data.Traversable (Traversable(traverse))
478+ #if __GLASGOW_HASKELL__ >= 702
480+ instance (MonadZip f, MonadZip g) => MonadZip (Product f g) where
481+ mzipWith f (Pair x1 y1) (Pair x2 y2) = Pair (mzipWith f x1 x2) (mzipWith f y1 y2)
484++#if MIN_VERSION_base(4,12,0)
485++instance (Contravariant f, Contravariant g) => Contravariant (Product f g) where
486++ contramap f (Pair a b) = Pair (contramap f a) (contramap f b)
488+diff -ur hackage-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Sum.hs ghc-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Sum.hs
489+--- hackage-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Sum.hs 2017-10-04 23:58:48.000000000 +0800
490++++ ghc-package-transformers-0.5.5.0/legacy/pre711/Data/Functor/Sum.hs 2001-09-09 09:46:40.000000000 +0800
493+ import Data.Foldable (Foldable(foldMap))
494+ import Data.Functor.Classes
495++#if MIN_VERSION_base(4,12,0)
496++import Data.Functor.Contravariant
498+ import Data.Monoid (mappend)
499+ import Data.Traversable (Traversable(traverse))
500+ #if __GLASGOW_HASKELL__ >= 702
502+ instance (Traversable f, Traversable g) => Traversable (Sum f g) where
503+ traverse f (InL x) = InL <$> traverse f x
504+ traverse f (InR y) = InR <$> traverse f y
506++#if MIN_VERSION_base(4,12,0)
507++instance (Contravariant f, Contravariant g) => Contravariant (Sum f g) where
508++ contramap f (InL xs) = InL (contramap f xs)
509++ contramap f (InR ys) = InR (contramap f ys)
511+diff -ur hackage-package-transformers-0.5.5.0/transformers.cabal ghc-package-transformers-0.5.5.0/transformers.cabal
512+--- hackage-package-transformers-0.5.5.0/transformers.cabal 2017-10-04 23:58:48.000000000 +0800
513++++ ghc-package-transformers-0.5.5.0/transformers.cabal 2001-09-09 09:46:40.000000000 +0800
515+ synopsis: Concrete functor and monad transformers
517+ A portable library of functor and monad transformers, inspired by
518+- the paper \"Functional Programming with Overloading and Higher-Order
521++ * \"Functional Programming with Overloading and Higher-Order
522+ Polymorphism\", by Mark P Jones,
523+ in /Advanced School of Functional Programming/, 1995
524+ (<http://web.cecs.pdx.edu/~mpj/pubs/springschool.html>).