home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / lang / gofer223.lha / demos / modular / Readme < prev    next >
Encoding:
Text File  |  1991-11-19  |  2.7 KB  |  73 lines
  1. ------------------------------------------------------------------------------
  2. The files in this directory are based on the programs described in:
  3.  
  4.     A Modular fully-lazy lambda lifter in Haskell
  5.     Simon L. Peyton Jones and David Lester
  6.     Software -- Practice and Experience
  7.     Vol 21(5), pp.479-506
  8.     MAY 1991
  9.  
  10. These files include:
  11.  
  12.     Readme       -- this file.
  13.  
  14.     Utility      -- implementation of various utility functions and
  15.                     data types including sets, bags and name supplies.
  16.                     The paper referred to above includes type signatures
  17.                     for the operations defined in this file but does not
  18.                     actually give definitions.  I trust that my own
  19.                     implementations of these functions will be satisfactory!
  20.  
  21.     LambdaLift   -- simple lambda lifter.  Contains code from the first
  22.                     half of the above paper.
  23.  
  24.     Laziness     -- transformations for fully-lazy lambda lifting.  Contains
  25.                     the remaining code from the above paper.
  26.  
  27.     Demo         -- demonstration of lamda lifting (normal and fully-lazy
  28.                     variants).  This hastily-written file contains definitions
  29.                     for a parser and input parser for the expressions used
  30.                     in the preceeding two files.  This file can only be loaded
  31.                     if the Parse file from MiniProlog has already been loaded
  32.                     into Gofer.  As it stands, this code uses non-standard
  33.                     features of Gofer and will not (i.e. should not!) be
  34.                     accepted by a Haskell compiler.
  35.  
  36. The modular fully-lazy lambda lifter and demonstration files can be loaded
  37. into Gofer with the command:
  38.  
  39.       gofer Utility LambdaLift Laziness ../prolog/Parse Demo
  40.  
  41. The find of results that can be obtained are illustrated by:
  42.  
  43. ? show example1
  44. let f = (\x.let g = (\y.(Plus (Times x x) y)) in (Plus (g 3) (g 4))) in (f 6)
  45.  
  46. ? ll example1  
  47.    1) $main = let f = SC1 in (f 6)
  48.    2) SC1 x = let g = (SC0 x) in (Plus (g 3) (g 4))
  49.    3) SC0 x y = (Plus (Times x x) y)
  50.  
  51. ? fll example1
  52.    1) $main = let f0 = SC1 in (f0 6)
  53.    2) SC1 x1 = let v4 = (Plus (Times x1 x1)) in
  54.                let g2 = (SC0 v4) in (Plus (g2 3) (g2 4))
  55.    3) SC0 v4 y3 = (v4 y3)
  56.  
  57.  
  58. ? show example2
  59. let f = (\x.letrec g = (\y.(Cons (Times x x) (g y))) in (g 3)) in (f 6)
  60.  
  61. ? ll example2
  62.    1) $main = let f = SC1 in (f 6)
  63.    2) SC1 x = letrec g = (SC0 g x) in (g 3)
  64.    3) SC0 g x y = (Cons (Times x x) (g y))
  65.  
  66. ? fll example2
  67.    1) $main = let f0 = SC1 in (f0 6)
  68.    2) SC1 x1 = let v4 = (Cons (Times x1 x1)) in
  69.                letrec g2 = (SC0 g2 v4) in (g2 3)
  70.    3) SC0 g2 v4 y3 = (v4 (g2 y3))
  71.  
  72. ------------------------------------------------------------------------------
  73.