hahaha! class is over! no more lisp!!!
no more (((((( and that )))))))!!!
haahaha!!
--
______ Meow
\ OO / _/
:(__ =)
U \\
http://www.sci.csupomona.edu/~cchow
····@usa.pipeline.com(Boaz Chow) wrote:
>hahaha! class is over! no more lisp!!!
>
>no more (((((( and that )))))))!!!
>
>haahaha!!
>--
> ______ Meow
> \ OO / _/
> :(__ =)
> U \\
>http://www.sci.csupomona.edu/~cchow
Ha ha ha! Class is over! No more C!!!
{see?
input(hee hee hee)
{nested Whee!}}
Help [pant pant] ...*Help* me!!!... [gasp] I can't walk. I'm an
overloaded operator.
How anyone can say "stdio.h" is more congenial than ( ) ?
In article <··········@news.cis.okstate.edu>, Mark McConnell
<·······@math.okstate.edu> wrote:
> ····@usa.pipeline.com(Boaz Chow) wrote:
> >hahaha! class is over! no more lisp!!!
> >
> >no more (((((( and that )))))))!!!
> >
> >haahaha!!
> >--
> > ______ Meow
> > \ OO / _/
> > :(__ =)
> > U \\
> >http://www.sci.csupomona.edu/~cchow
>
> Ha ha ha! Class is over! No more C!!!
>
> {see?
> input(hee hee hee)
> {nested Whee!}}
>
> Help [pant pant] ...*Help* me!!!... [gasp] I can't walk. I'm an
> overloaded operator.
>
> How anyone can say "stdio.h" is more congenial than ( ) ?
Cretin!
---------------------------------------------------------------------
Jack Harper Bank Systems 2000, Inc.
e-mail: ·······@bs2000.com 350 Indiana Street, Suite 350
voice: 303-277-1892 fax: 303-277-1785 Golden, Colorado 80401 USA
"21st Century Banking Applications"
Private Label Optical Bank Card Systems
Visit our Web Page: http://www.bs2000.com/talos
---------------------------------------------------------------------
····@usa.pipeline.com(Boaz Chow) wrote:
> hey guys! Lisp is old. it is the second computer language developed by
> that "Cant-Talk-So-Well" british professor.
Let's get straight. I've seen John McCarthey (US citizen I think)
'-ed as the inventor of Lisp. Is he a fake or what???
But anyway, I think Lisp as we know it is reaching the age of
retirement and should have a successor that dares stand by its
heritage. So, I spent 10 years designing and implementing a
thing I call PILS. It's now a rather full blown programming
system, runs on Windows 95, based on a 386 assembly coded
interpreter.
This is not intended as an advocacy for PILS. But I would
like to discuss strengths and weaknesses of Lisp and some of
the design desicions I made for PILS.
(Presently, I only maintain a danish PILS version but I wrote
some documentation in English and I can produce an English
version should the need arise. PILS is free but requires MS
Windows 95 or NT 3.51.)
I'll present a few crucial design steps here, in the hope that
some experienced Lisp'ers will comment on them, and maybe
get curious about trying it.
STEP 1:
I integrated pattern matching into the base language, using
generalized patterns rather than the old DEFUN thing, disposing
of CAR and CDR in the process. (Any sensible Lisp'er should
agree this was long due.)
STEP 2:
Like Scheme, I insisted on using lexical scoping. I disposed of
global variables as well as property lists, leaving symbols as
bare values whose attributes (even their names) are to be
determined by searching a chain of valid declarations. The
interpreter recognizes the first 100-odd symbols as built-in
functions; any user supplied functions are stored in a chain of
declarations. (I think many Lisp'ers would prefer it that way
if it weren't for efficiency reasons and sturdy habits.)
STEP 3:
I disposed of the CONS and implemented a somewhat richer
set of data structures. The 2-element CONS is mathematically
sound and simple but it takes too many of them to build things.
After some experimenting, I ended up with 5 brands of nodes:
- lists (not linked lists but grow/shrinkable nodes)
- nodes (for function calls)
- statements (for FEXPR style function calls)
- nests (special nodes for chaining declarations)
- rule sets (DEFUNs, bundled and indexed for speed)
Similarly, I spilt the atoms into three variants: functions, variables
and labels. Nodes have all their elements evaluated before being
applied, statements none. The function symbols are seen as constants.
Any function can be called EXPR or FEXPR style at will.
STEP 4:
The syntax was redesigned, giving it an Algol-like look while
maintaining the Data=Program consistency.
(Lisp originally had a nice Algol-like syntax for programs; the
notation in use today was meant for data only. Lisp programmers
sacrificed readability for the Data=Program paradigm. In PILS,
they can have both.)
Statements are right-associative, to allow for nested constructions
without getting buried in parentheses.
STEP 5:
Adding objects to PILS was trivially easy. An object is a context.
Functions declared inside can be called from outside as member
functions. More refined access control can be achieved by
explicitly building the context. Most of what C++ programmers
do - and a lot they wish they could do - is possible this way, but
on object rather than class base.
STEP 6:
Function declarations are partial. They contain a pattern and an
action part which may solve a case by throwing a result. The throw
comes in a tail recursive variant - the ".ok" statement - that kicks
the stack (saying: "I'll do it") and then evaluates an expression. A
rule can also refer to another function (saying: "try the office next
door, or I can't help you").
Throws and kicks are all guarded by lexical scope. (This protects
your FEXPR constructs from getting kicks in their private parts -
no pun intended.)
STEP 7:
Stay dirty. Kick, throw, assign, assign, assign. If you like to throw
dirt, do it with the := operator, PILS allows you to assign to the
result of a function, no SETxxx bullfrogs.
I'll conclude this with a snippet of "real-world" code from the
PILS programming system (sort of MFC equivalent). It provides
the Win32 programmer's window objects with a member function
that sets or reads the text of the window (title bar, or contents of
an Edit control):
{ text.;
.value
( length: @GetWindowTextLength. handle;
.no length: blank.;
text: blank. (length + 1) 0;
@GetWindowText. handle text #text;
text <+# 1 <== ''; $$$ remove zero padding $
.if text- value;
.ok; .give text: value?;
@SetWindowText. handle (value ++ ··@) $$$ add zero padding $ }
I won't explain in detail but it allows the programmer to write:
FirstPane text. := SecondPane text. := FirstPane text.
to swap the contents of two text panes, etc.
But stick with Lisp if you like SETF better.
BTW, I like Lisp. It was a great starting point for
developing PILS.
Ole Nielsby
········@login.dknet.dk