> From: Hans Aberg <[email protected]>
> Cc: [email protected]
>
> On 1 Dec 2010, at 18:35, Joel James Adamson wrote:
>
> >> I am writing on a parser that translates normal
> >> function syntax in to Guile code.
> >>
> >> It seems natural to translate (f, g) x into ((f g) x),
If "(f, g) x" is (in normal syntax) supposed to mean:
apply f to g resulting in a function that is applied to x,
then that is "natural", but whether that is normal
syntax, I can not say. I'm liberal on this.
Normal syntax is whatever you want, but step
one is to get clear on what you want.
Speaking for myself, I have never before seen that
syntax with that meaning, so I would hesitatate
to call it "normal". But if you define it, you can
call it what you will.
> >> and () x into (() x), but I'm not sure if the
> >> lists (f g) and () can be made acting as functions
> >> this way.
I have not only never seen the "normal syntax" in
use here, but I have no guess what it is supposed
to mean. In Scheme "(() x)" means nothing at all.
In fact it is so far from meaningful that I can
not guess how to fix it.
> > (f g) would evaluate as a composition as long as
> > f takes a procedure as an argument and returns a
> > function that takes x as its argument. No problems
> > there. Alternatively you could think of f
> > returning a function of x when it evaluates g.
This is wrong terminology.
The expression (f g) applies f to g.
The composition of f and g is (lambda (x) (f (g x))).
> Yes, but in standard syntax would be natural to let (f, g)(x) evaluate
> to (f(x), g(x)), producing a list of two elements. In Guile, that
> would be something involving "map". If I try in Haskell, I can let
> (sin, cos)(2) be the same as
> map (g 2) [sin, cos] where g x = \f -> f x
> -> [0.909297426825682,-0.416146836547142]
> But when I try that similar constructs in Guile, I get problems with
> evaluation.
Works for me
guile> (let ()
(define (g x)(lambda (f)(f x)))
(map (g 2) (list sin cos)))
(0.909297426825682 -0.416146836547142)
There are other ways to write it, but that
is the most direct translation of your Haskell
into Scheme.
-- Keith
