🚀 go-pugleaf

In article <1991Mar27.161304.17666@daffy.cs.wisc.edu> quale@saavik.cs.wisc.edu (Douglas E. Quale) writes:
>In Common Lisp,
>
>(defun compose (f g)
>  (lambda (&rest) (funcall f (apply g &rest))))
>
>I think it looks better in Scheme,
>
>(define (compose f g)
>  (lambda x (f (apply g x))))
>
>These definitions use dynamic typing to obtain polymorphism.
>
Yes, in LISP it's dynamic typing that gives you the polymorphism, but
you don't have to have dynamic typing.  Let's do the same definition
in ML, which is statically typed:
  - fun compose(f,g) x = f(g x);
  > val compose = fn : (('a -> 'b) * ('c -> 'a)) -> ('c -> 'b)
(I wrote the line starting with '-', the system responded with the the
line starting with '>'.)
This compose function is typed and still polymorphic.  Some examples:
  - fun inc x = x+1;
  > val inc = fn : int -> int
  - compose(not,not) true;
  > true : bool
  - compose(inc,compose(inc,inc)) 0;
  > 3 : int
  - compose(inc,not) true;
  Type clash  in:  (compose (inc,not))
  Looking  for a:  int
  I have found a:  bool




	-- Lennart Augustsson
[This signature is intentionally left blank.]