> [SNIP]
>
> I don't think this is ambigous -- do is a keyword, so no record field update
> can be assumed after it.
Okay, I thought about it some more and I agree.
So, as it stands the proposal is to add the following pieces of sugar:
1) ({assignments}) becomes \x->x{assignments}
2) x{as, field =, bs} becomes \y->x{as, field = y, bs}
3) x{as, field, bs} becomes \f->x{as, field = f (field x), bs}
So then if we see:
({field=})
this gets desugared to
\x -> x{field=}
which gets again desugared to
\x -> \y -> x{field = y}
Similarly,
({field})
becomes
\x -> x{field}
becomes
\x -> \f -> x{field = f (field x)}
The only "problem" i see with this is that I would probably want the
lambda terms to be in the other order, so, just as you would write:
apField f x
you would write:
({field}) f x
But this is backwards...putting a call to flip in sort of defeats the
purpose.
One thing that could be done would be to rewrite the rules as:
1) {field=} becomes \y -> ({field=y})
2) {field} becomes \f -> ({field $= f}) -- assuming $= exists
3) {stuff} becomes \x -> x{stuff}
where "stuff" has no dangling = and $= and stuf flike that
If we go this route, I would suggest that instead of just {field} in #2,
we make it {field $=} to keep parallelism with the $= thingy and to make
it clear that we're doing function application.
So, again,
{field =}
==> \y -> {field=y} -- rule 1, there's a dangling =
==> \y -> \x -> x{field=y} -- rule 3, no dangling things
and similarly:
{field $=}
==> \f -> {field $= f} -- rule 2, there's a dangling $=
==> \f -> \x -> x{field $= f}-- rule 3, no dnagling things
I believe this is still amenable to fitting in the syntax without pouncing
on anything.
Assuming I can ever get my cvs'd copy of ghc to compile (sigh), I would be
willing to implement this if there are no objections...
- Hal
_______________________________________________
Haskell mailing list
[EMAIL PROTECTED]
http://www.haskell.org/mailman/listinfo/haskell
