2) There are other reasons why I want to use Haskell-98 and would
like to be able to use other compilers. Thus, I'd want a pattern-binder
preprocessor (extending GHC is not as important to me).
I see. though I'd hope that as long as we keep our extensions simple and
general enough, the other implementations will pick them up anyway.
Here's my motivating example. Here's a fragment for an STG
interpreter in Haskell-98:
{{{
rule_CASE_ELIM (Case p alts, s, h, o) =
do
ConApp c as <- ptsTo p h
let matchAlt (Alt c' vs e) | c == c' = Just (vs,e)
matchAlt _ = Nothing
(vs,e) <- matchFirst matchAlt alts
return (e `sub` (vs,as), s, h, o)
}}}
yes, abstract machines have inspired many a pattern match extension!-)
are we in Maybe, or in anything more complex? view patterns don't seem to apply,
but pattern guards do, and lambda-match helps with the local function pattern
(ignoring the Match type tag for the moment; given the revival of interest in pattern
functions, eg., in view patterns, I ought to try and see whether I can get rid of the
type tag in my library for the special case of Maybe):
{{{
rule_CASE_ELIM =
(| (Case p alts, s, h, o)
| ConApp c as <- ptsTo p h
, (vs,e) <- matchFirst (| (Alt c' vs e) | c == c' ->(vs,e) ) alts
-> (e `sub` (vs,as), s, h, o) )
}}}
which isn't quite as abstract as the pattern binder/combinator version,
but at least I can see the scoping, which I am at a loss with in the pattern
binder version:
I'd like it to have a textual form just a little more abstract, I can
do that with pattern binders and some appropriate combinators:
{{{
rule_CASE_ELIM =
{ (Case p alts , s, h, o) }
&&& ptsTo p h === { ConApp c as }
&&& alts === matchFirst { Alt #c vs e }
.->
(e `sub` (vs,as), s, h, o)
}}}
I'll leave it as an exercise to figure out how the last is
parenthesized ;-).
ok, I give up. there seem to be some new combinators, and the pattern
binder variables are no longer distinguishable (via $). but unless you've
changed the translation as well, the only way the scopes are going to come
out right is if the layout is a lie, right? and how does the translation apply to
pattern binders not in an infix application, in particular, how do vs/e get to
the rhs of .->?
Claus
_______________________________________________
Haskell-prime mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/haskell-prime
