Home > Archive > Scheme > May 2005 > An idea for a freak DWIM lisp-2
You are viewing an archived Text-only version of the thread.
To view this thread in it's original format and/or if you want to reply to
this thread please [click here]
| Author |
An idea for a freak DWIM lisp-2
|
|
| Sunnan 2005-05-04, 4:00 pm |
| I just thought of a specification for a weird lisp-2:
It has function and value cells but figures this out automagically (with
something like identifier-has-procedure?) without bothering the user.
It's somewhat backwards compatible with Scheme (you might want to
replace procedure? with identifier-has-procedure?), allows punning, and
have no need for explicit FUNCALL or #'. The idea should also generalize
to CL-like dialects, though Scheme is used for example code below:
(define a print)
(define a "hello")
(define (test x y) (x y))
(test a a) ; prints "hello"
Perverse!
(let ((list '(a b c d))) ; this doesn't shadow list
(list list))
=> ((a b c d))
(let ((list (lambda (x) 'hmmm))) ; this shadows list
(list list))
=> hmmm
Still allows all lovely/dubious scheme stuff like:
(rpn 1 1 +) ; my friend!
(define (bar) (identity bar))
(((((bar))))) => bar
and even some new stuff like
(define bar 'this-goes-into-value-cell)
(((((bar))))) => 'this-goes-into-value-cell ; given that the function
cell was defined as above
There's a slight problem with call-by-value, you'll have to tweak the
evaluation semantics. I think I've got some solutions to this somewhere
in my skull - it might suffice to change the semantics of
((lambda (new) ...) old)
to make new a shallow copy of all cells of the identifier old, instead
of just the value cell.
Maybe there are other problems (apart from the aesthetic and performance
(Sufficiently Smart Compiler(TM) to the rescue!) problems) I haven't
thought of yet, which'll make it unworkable.
I haven't bothered to implement this because it's so kink, and I'm lazy,
and I just thought of it, and I'm exhausted to the point of
hallucinations from an hour-long bike-ride, but do you think that anyone
would like this?
Regardless, it might be useful as a rhetorical device that both sides in
the ceaseless flamewar between lisp-1 and lisp-2 can use to their
advantage. Or maybe it can bring peace and prosperity to the world.
YEAH, RIGHT! AS IF THOSE CRACKSMOKERS WOULD EVER CHANGE THEIR MINDS, YOU
KNOW WHO I'M TALKING ABOUT. (Err... I'm talking about those with a
differing opinion in the namespace question than you, dear reader, of
course. Not you, I know you'd never touch the pipe, and I know that the
#\c in the name of your favourite lisp doesn't stand for HUGE FREAKING
ROCKS unlike THAT OTHER SHADY CAMP!)
I dub the idea DWIM-lisp-2.
(I don't claim to be the first to invent this - the lisp community has
seen its fair share of monstrosities over the last half-century - but I
haven't seen it, so I do claim independent reinvention.)
XOXOXO,
Sunnan
Follow-up set.
| |
| Kenny Tilton 2005-05-04, 4:00 pm |
|
Sunnan wrote:
> I just thought of a specification for a weird lisp-2:
Oh please please tell me the spec will still only be one page long! That
is soooooo important.
>
> It has function and value cells but figures this out automagically (with
> something like identifier-has-procedure?) without bothering the user.
I see. You realize Common Lisp is winning and that it is just a matter
of months before the Scheme rebellion is pushed into the sea. Of course
you want to negotiate.
Ha! The amnesty period ends on the last day of spring. Throw down your
arms and approach the Common Lisp camp with your hands over your head
holding a copy of Practical Common Lisp. It is a little longer than one
page, so we understand if you have to stop to rest your arms every few
yards.
>
> It's somewhat backwards compatible with Scheme (you might want to
> replace procedure? with identifier-has-procedure?), allows punning, and
> have no need for explicit FUNCALL or #'. The idea should also generalize
> to CL-like dialects, though Scheme is used for example code below:
>
> (define a print)
> (define a "hello")
> (define (test x y) (x y))
> (test a a) ; prints "hello"
>
> Perverse!
Ya think? What problem are you trying to solve, other than Scheme's
imminent extinction?
>
>
> (let ((list '(a b c d))) ; this doesn't shadow list
> (list list))
> => ((a b c d))
>
> (let ((list (lambda (x) 'hmmm))) ; this shadows list
> (list list))
> => hmmm
>
> Still allows all lovely/dubious scheme stuff like:
>
> (rpn 1 1 +) ; my friend!
>
> (define (bar) (identity bar))
> (((((bar))))) => bar
>
> and even some new stuff like
> (define bar 'this-goes-into-value-cell)
> (((((bar))))) => 'this-goes-into-value-cell ; given that the function
> cell was defined as above
>
> There's a slight problem with call-by-value, you'll have to tweak the
> evaluation semantics. I think I've got some solutions to this somewhere
> in my skull - it might suffice to change the semantics of
>
> ((lambda (new) ...) old)
>
> to make new a shallow copy of all cells of the identifier old, instead
> of just the value cell.
>
> Maybe there are other problems (apart from the aesthetic and performance
> (Sufficiently Smart Compiler(TM) to the rescue!) problems) I haven't
> thought of yet, which'll make it unworkable.
>
> I haven't bothered to implement this because it's so kink, and I'm lazy,
> and I just thought of it, and I'm exhausted to the point of
> hallucinations from an hour-long bike-ride, but do you think that anyone
> would like this?
>
> Regardless, it might be useful as a rhetorical device that both sides in
> the ceaseless flamewar between lisp-1 and lisp-2 can use to their
> advantage.
Ah, there is your mistake: "ceaseless". That rumbling you hear is the
Common Lisp tank coming up behind your Scheme track bike to administer a
cessation.
> Or maybe it can bring peace and prosperity to the world.
> YEAH, RIGHT! AS IF THOSE CRACKSMOKERS WOULD EVER CHANGE THEIR MINDS, YOU
> KNOW WHO I'M TALKING ABOUT. (Err... I'm talking about those with a
> differing opinion in the namespace question than you, dear reader, of
> course. Not you, I know you'd never touch the pipe, and I know that the
> #\c in the name of your favourite lisp doesn't stand for HUGE FREAKING
> ROCKS unlike THAT OTHER SHADY CAMP!)
>
> I dub the idea DWIM-lisp-2.
>
> (I don't claim to be the first to invent this - the lisp community has
> seen its fair share of monstrosities over the last half-century - but I
> haven't seen it, so I do claim independent reinvention.)
>
> XOXOXO,
> Sunnan
> Follow-up set.
yer gonna love FUNCALL.
:)
kenny
--
Cells? Cello? Cells-Gtk?: http://www.common-lisp.net/project/cells/
Why Lisp? http://lisp.tech.coop/RtL%20Highlight%20Film
"Doctor, I wrestled with reality for forty years, and I am happy to
state that I finally won out over it." -- Elwood P. Dowd
| |
| alex goldman 2005-05-04, 4:00 pm |
| Sunnan wrote:
>
> (let ((list '(a b c d))) ; this doesn't shadow list
> (list list))
> => ((a b c d))
>
> (let ((list (lambda (x) 'hmmm))) ; this shadows list
> (list list))
> => hmmm
(let ((list '()))
(procedure? list)) => ? ; as if we need more ambiguity
| |
| Sunnan 2005-05-04, 4:00 pm |
| I see that this is posted to both cls and cll. Did I misunderstand how
follow-up works?
alex goldman wrote:
> Sunnan wrote:
>
>
>
>
>
> (let ((list '()))
> (procedure? list)) => ? ; as if we need more ambiguity
>
As I tried to clarify, in "freak DWIM lisp-2", you use
"identifyer-has-procedure?" to find out whether or not the function cell
of the identifier list has been bound to a function. "procedure?"
doesn't exist.
| |
| Sunnan 2005-05-04, 4:00 pm |
| Kenny Tilton wrote:
> Oh please please tell me the spec will still only be one page long!
Well, actually, yeah.
> That is soooooo important.
Please, tell me that your sarcastic adverbs will still have less than
seven #\os!
> Ha! The amnesty period ends on the last day of spring. Throw down your
> arms and approach the Common Lisp camp with your hands over your head
> holding a copy of Practical Common Lisp. It is a little longer than one
> page, so we understand if you have to stop to rest your arms every few
> yards.
"Practical..."? What's that? I am an idealist! I WILL NEVAR SURRENDAR!
>
>
> Ya think? What problem are you trying to solve, other than Scheme's
> imminent extinction?
Either:
I was tossing the lisp-2 community a little breadcrumb - the ability to
use functions as arguments without the sharp-quote-eyesores - and/or I
was giving some people the opportunity to say that they LIKE
funcalls/sharp-quotes; and that it's not *only* the ability to go (list
list) that they're after.
Or:
I was tossing the lisp-1 community a little breadcrumb - the ability to
use identifiers for more than one thing at the same time, or... er...
hrm.. something something.
>
>
> Ah, there is your mistake: "ceaseless". That rumbling you hear is the
> Common Lisp tank coming up behind your Scheme track bike to administer a
> cessation.
Watch out, or I'll hit you with a flower!
> yer gonna love FUNCALL.
:)
(Have a nice spring. I hope it's a beautiful day where you are.)
Peace,
Sunnan
| |
| Kenny Tilton 2005-05-04, 8:59 pm |
|
Sunnan wrote:
> Kenny Tilton wrote:
>
>
>
> Well, actually, yeah.
Ah, well, the only complaints we are getting from the hordes of newbies
stampeding into c.l.l. is that /more/ things should be standardized,
such as threads, sockets, and FFI. So I think the Scheme bet on a small
spec qua language feature sleeps with the fish.
kenny
--
Cells? Cello? Cells-Gtk?: http://www.common-lisp.net/project/cells/
Why Lisp? http://lisp.tech.coop/RtL%20Highlight%20Film
"Doctor, I wrestled with reality for forty years, and I am happy to
state that I finally won out over it." -- Elwood P. Dowd
| |
| Sunnan 2005-05-04, 8:59 pm |
| Kenny Tilton wrote:
>
>
> Sunnan wrote:
>
>
>
> Ah, well, the only complaints we are getting from the hordes of newbies
> stampeding into c.l.l. is that /more/ things should be standardized,
> such as threads, sockets, and FFI. So I think the Scheme bet on a small
> spec qua language feature sleeps with the fish.
>
Not that this wasn't about primarily about Scheme vs CL, or about
specification size.
| |
| Geoffrey Summerhayes 2005-05-05, 4:00 pm |
|
"Sunnan" <sunnan@handgranat.org> wrote in message
news:4278B15A.5080603@handgranat.org...
*snip*
>
> Maybe there are other problems (apart from the aesthetic and performance
> (Sufficiently Smart Compiler(TM) to the rescue!) problems) I haven't
> thought of yet, which'll make it unworkable.
All lookups will probably have to be at run-time
I can do this in Lisp-1
(define (foo list)
(print list)
(map (lambda (fn) (fn 3 5)) list))
(foo (list + - / *))
and Lisp-2
(defun foo (list)
(print list)
(mapcar (lambda (fn) (funcall fn 3 5)) list))
(foo (list #'+ #'- #'/ #'*))
What does DWIM-lisp-2 do?
--
Geoff
| |
| alex goldman 2005-05-05, 8:58 pm |
| Geoffrey Summerhayes wrote:
> I can do this in Lisp-1
> What does DWIM-lisp-2 do?
I think the idea is to let you do
(define (foo list)
(list list))
| |
| Sunnan 2005-05-06, 4:02 am |
| Geoffrey Summerhayes wrote:
> "Sunnan" <sunnan@handgranat.org> wrote in message
> news:4278B15A.5080603@handgranat.org...
>
> *snip*
>
>
>
> All lookups will probably have to be at run-time
I don't *think* that should be necessary, but I might've missed something.
In DWIM-lisp-2, the semantics of the evaluation of the car position is
different from the semantics of the evaluation of the other positions.
> What does DWIM-lisp-2 do?
Oh, I just reread your post and reinterpreted this as a question about
how DWIM-lisp-2 would work.
The scheme example would run as is in DWIM-lisp-2.
This latter stuff I wrote, before I reread your post, as a reply to,
because I thought you meant "what is the point of DWIM-lisp-2" (which
might still be what you mean, I don't know).
> What does DWIM-lisp-2 do?
Allows you to do all stuff you can do with a lisp-1; simultaneously as
it lets you do all the stuff you can do with a lisp-2.
One (rather useless) thing you only can do with dwim-lisp-2 (afaik) is:
(define bar (lambda () (identity bar)))
(define bar 3)
(+ bar ((((bar)))) (((((bar))))))
=> 9
This will work like this:
the program will see that the identifier bar is used in a
non-car-position and will use the value cell, 3. The program will also
see the bars in car position, where it uses the function cell (lambda ()
(identity bar)) and will repeatedly eval it until it gets it in a
non-car-position, where it'll use the value cell, 3.
Maybe there is some useful stuff you can do, I haven't thought of any.
The main point was to make a way for schemers to see the relative flaws
and benefits of having multiple namespaces without drowning in all the
#' and funcalls, and a way for CL:ers to see the relative flaws and
benefits of not having #' and funcalls, without drowning in all of the
unable-to-do-(list list)-ness.
Now, some people (mainly CL:ers) have argued for #' and FUNCALL being
good things in themselves since they make explicit when you're using
functions as values.
Others (mainly schemers) have argued for having only one namespace as a
good thing because the same identifyer shouldn't refer to two different
things at the same time.
I'm actually somewhat in the latter camp but I'm still intrigued by this
idea of dwim-lisp-2.
I think everyone on earth would think that the *opposite* of dwim-lisp-2
would be totally crap.
I mean a lisp where you had to use #' and funcall but still only had one
namespace. :)
| |
| Geoffrey Summerhayes 2005-05-06, 4:02 am |
|
"Sunnan" <sunnan@handgranat.org> wrote in message news:A1Bee.136555$dP1.481702@newsc.telia.net...
> Geoffrey Summerhayes wrote:
>
> I don't *think* that should be necessary, but I might've missed something.
> In DWIM-lisp-2, the semantics of the evaluation of the car position is different from the semantics of the evaluation of the other
> positions.
>
>
> Oh, I just reread your post and reinterpreted this as a question about how DWIM-lisp-2 would work.
>
> The scheme example would run as is in DWIM-lisp-2.
Will it? I assumed that the print statement would attempt to print
the value-cell of + rather than the function-cell. The problem
when I say (list a b c) is that at that point it is unknown
whether I'm referring to the value-cells or the function-cells
so the list has to contain both unless the compiler can determine
absolutely which it should be. In the case of something like
print, the ambiguity remains.
In an interpretive environment, just interacting with the REPL,
a lot of times the information required won't be available. So
you have to make the list contain both.
--
Geoff
| |
| Sunnan 2005-05-06, 4:00 pm |
| Geoffrey Summerhayes wrote:
> "Sunnan" <sunnan@handgranat.org> wrote in message news:A1Bee.136555$dP1.481702@newsc.telia.net...
>
>
>
> Will it? I assumed that the print statement would attempt to print
> the value-cell of + rather than the function-cell.
Ah, so the (print list) was the thing to look at.
Well, in Scheme, that would print out a list of prodecures.
In chicken, it looks like
(#<procedure> #<procedure> #<procedure> #<procedure> )
In DWIM-lisp-2 this could work like this:
If the value cells of + - / * are undefined, it could just print out a
list of unspecified.
(#<unspecified> #<unspecified> #<unspecified> #<unspecified> )
(If both cells are undefined, it could exit with an unknown identifier
error.)
> The problem
> when I say (list a b c) is that at that point it is unknown
> whether I'm referring to the value-cells or the function-cells
> so the list has to contain both unless the compiler can determine
> absolutely which it should be. In the case of something like
> print, the ambiguity remains.
>
> In an interpretive environment, just interacting with the REPL,
> a lot of times the information required won't be available. So
> you have to make the list contain both.
Yes.
The following is supposed to work in DWIM-lisp-2:
(define foo +)
(define foo 41)
(define (bar baz) (baz baz baz))
(bar foo)
=> 82 ; both cells are defined and used
(define baz 23)
(bar +)
=> 46 ; + is defined, the value cell of baz is looked up in the lexical
scope
(define baz *)
(bar 12)
=> 144 ; 12 is defined, the function cell of baz is looked up in the
lexical scope
(bar fubar)
=> ERROR, unknown identifier
|
|
|
|
|