From: gavino
Subject: Where is the clisp MANUAL?
Date: 
Message-ID: <1151968925.362536.87700@m73g2000cwd.googlegroups.com>
Where is the manual on how to use this supposedly more powerful tool?
Eric Raymond disses lisp for python......but Paul Graham says its by
far the best.

From: Ken Tilton
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <H2lqg.581$Hl7.332@fe12.lga>
gavino wrote:
> Where is the manual on how to use this supposedly more powerful tool?
> Eric Raymond disses lisp for python......but Paul Graham says its by
> far the best.
> 

hmmm, you might have the details wrong. graham was talking before python 
  really was on its game, i think he is a big pythonista now. Lisp is 
more  a fun research thing, nothing you want to use for serious work. 
Python and/or Ruby are what most of use for Real Work.

hth, kenny

-- 
Cells: http://common-lisp.net/project/cells/

"I'll say I'm losing my grip, and it feels terrific."
    -- Smiling husband to scowling wife, New Yorker cartoon
From: ···············@yahoo.com
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <1152110078.042581.164090@m73g2000cwd.googlegroups.com>
Danger, Will Robinson!
[robot frantically waving arms]
Irony!
Irony!
Irony!
From: Luís Oliveira
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <m2psgmtcry.fsf@deadspam.com>
"gavino" <········@yahoo.com> writes:
> Where is the manual on how to use this supposedly more powerful tool?

First off, clisp the name of a particular implementation of Common
Lisp. There are several more.

The language has a specification. See:
http://www.lispworks.com/documentation/HyperSpec/Front/index.htm

There are several books. See <http://www.cliki.net/Online%20Tutorial>.
Many people would recommend "Practical Common Lisp" in particular:
<http://www.gigamonkeys.com/book/>.

-- 
Luís Oliveira
luismbo (@) gmail (.) com
http://student.dei.uc.pt/~lmoliv/
From: Pascal Bourguignon
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <87odw6uivu.fsf@thalassa.informatimago.com>
"gavino" <········@yahoo.com> writes:

> Where is the manual on how to use this supposedly more powerful tool?
> Eric Raymond disses lisp for python......but Paul Graham says its by
> far the best.

clisp's manual is at: 

    http://clisp.cons.org/impnotes/index.html

But you'll need the Common Lisp Reference: 

    http://www.lispworks.com/documentation/HyperSpec/Front/index.htm

and if you're asking this question it means you're a newbie, so you'll
need a tutorial too:

    http://www-cgi.cs.cmu.edu/afs/cs.cmu.edu/user/dst/www/LispBook/index.html
    http://www.gigamonkeys.com/book/

For more information:
    
    http://www.cliki.net/index


-- 
__Pascal Bourguignon__                     http://www.informatimago.com/

NEW GRAND UNIFIED THEORY DISCLAIMER: The manufacturer may
technically be entitled to claim that this product is
ten-dimensional. However, the consumer is reminded that this
confers no legal rights above and beyond those applicable to
three-dimensional objects, since the seven new dimensions are
"rolled up" into such a small "area" that they cannot be
detected.
From: gavino
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <1151996367.668426.327570@b68g2000cwa.googlegroups.com>
Interesting.
Is the tourestsky tutorial applicable to todays CLISP?

Pascal Bourguignon wrote:
> "gavino" <········@yahoo.com> writes:
>
> > Where is the manual on how to use this supposedly more powerful tool?
> > Eric Raymond disses lisp for python......but Paul Graham says its by
> > far the best.
>
> clisp's manual is at:
>
>     http://clisp.cons.org/impnotes/index.html
>
> But you'll need the Common Lisp Reference:
>
>     http://www.lispworks.com/documentation/HyperSpec/Front/index.htm
>
> and if you're asking this question it means you're a newbie, so you'll
> need a tutorial too:
>
>     http://www-cgi.cs.cmu.edu/afs/cs.cmu.edu/user/dst/www/LispBook/index.html
>     http://www.gigamonkeys.com/book/
>
> For more information:
>
>     http://www.cliki.net/index
>
>
> --
> __Pascal Bourguignon__                     http://www.informatimago.com/
>
> NEW GRAND UNIFIED THEORY DISCLAIMER: The manufacturer may
> technically be entitled to claim that this product is
> ten-dimensional. However, the consumer is reminded that this
> confers no legal rights above and beyond those applicable to
> three-dimensional objects, since the seven new dimensions are
> "rolled up" into such a small "area" that they cannot be
> detected.
From: Hrvoje Blazevic
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <e8d4cd$dn0$1@ss408.t-com.hr>
gavino wrote:
> Interesting.
> Is the tourestsky tutorial applicable to todays CLISP?
> 

Yes.

-- Hrvoje
From: Pascal Bourguignon
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <87y7v9tyxf.fsf@thalassa.informatimago.com>
"gavino" <········@yahoo.com> writes:

> Interesting.
> Is the tourestsky tutorial applicable to todays CLISP?

Actually, any Common Lisp implementation can be applied with almost
all Lisp material from any time, thanks to the concensual approach of
the Common Lisp standard.  Note how the adjective "common" is adjoined
to the name "lisp" to form the "Common Lisp" name.

For example, here is how you can run a lisp program written in 1966 in
a Common Lisp of 2006.  Rendez-vous in 30 years to see how you can run
a 1996 perl program in perl 2036...

See the wang program from:
http://community.computerhistory.org/scc/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf#page=52
Chapter VIII.
A Complete LISP Program - the Wang Algorithm for the Propositional Calculus.

----(wang-cl.lisp)------------------------------------------------------
(shadow '(trace untrace))
(defun trace   (functions) (eval `(cl:trace   ,@functions)))
(defun untrace (functions) (eval `(cl:untrace ,@functions)))

(defun define (definitions)
  (dolist (def definitions)
    (eval (if (and (consp (second def)) (eq 'lambda (car (second def))))
              `(progn (defun        ,(first def) ,@(cdr (second def)))
                      (defparameter ,(first def) ,(second def)))
              `(defparameter ,(first def) ,(second def))))))

(defun stop (arguments) (throw 'driver-end-of-deck nil))
(defun fin  (arguments) (throw 'driver-end-of-deck nil))
(defun test (arguments) (princ arguments) (terpri))

(defun driver (path)
  (with-open-file (cards path)
    (catch 'driver-end-of-deck
      (loop (let ((first-char (read-char cards)))
              (if (char= #\* first-char)
                  (read-line cards)     ; comment
                  (progn
                    (unread-char first-char cards)
                    (let* ((command   (read cards))
                           (arguments (if (member command '(stop fin test))
                                          (list (read-line cards))
                                          (read cards))))
                      (print (apply command arguments))))))))))

(driver "wang.job")
----(wang.job)----------------------------------------------------------
* M948-1207 LEVIN, LISP, TEST, 2,3,250,0
        TEST WANG ALGORITHM FOR THE PROPOSITIONAL CALCULUS 
 
DEFINE (( 
(THEOREM (LAMBDA (S) (TH1 NIL NIL (CADR S) (CADDR S)))) 
 
(TH1 (LAMBDA (A1 A2 A C) (COND ((NULL A) 
        (TH2 A1 A2 NIL NIL C)) (T 
        (OR (MEMBER (CAR A) C) (COND ((ATOM (CAR A)) 
        (TH1 (COND ((MEMBER (CAR A) A1) A1) 
        (T (CONS (CAR A) A1))) A2 (CDR A) C)) 
        (T (TH1 A1 (COND ((MEMBER (CAR A) A2) A2) 
        (T (CONS (CAR A) A2))) (CDR A) C)))))))) 
 
(TH2 (LAMBDA (A1 A2 C1 C2 C) (COND 
        ((NULL C) (TH A1 A2 C1 C2)) 
        ((ATOM (CAR C)) (TH2 A1 A2 (COND 
        ((MEMBER (CAR C) C1) C1) (T 
        (CONS (CAR C) C1))) C2 (CDR C))) 
        (T (TH2 A1 A2 C1 (COND ((MEMBER 
        (CAR C) C2) C2) (T (CONS (CAR C) C2))) 
        (CDR C)))))) 
 
(TH (LAMBDA (A1 A2 C1 C2) (COND ((NULL A2) (AND (NOT (NULL C2)) 
        (THR (CAR C2) A1 A2 C1 (CDR C2)))) (T (THL (CAR A2) A1 (CDR A2) 
        C1 C2))))) 
 
(THL (LAMBDA (U A1 A2 C1 C2) (COND 
        ((EQ (CAR U) (QUOTE NOT)) (TH1R (CADR U) A1 A2 C1 C2)) 
        ((EQ (CAR U) (QUOTE AND)) (TH2L (CDR U) A1 A2 C1 C2)) 
        ((EQ (CAR U) (QUOTE OR)) (AND (TH1L (CADR U) A1 A2 C1 C2) 
        (TH1L (CADDR U) A1 A2 C1 C2) )) 
        ((EQ (CAR U) (QUOTE IMPLIES)) (AND (TH1L (CADDR U) A1 A2 C1 
        C2) (TH1R (CADR U) A1 A2 C1 C2) )) 
        ((EQ (CAR U) (QUOTE EQUIV)) (AND (TH2L (CDR U) A1 A2 C1 C2) 
        (TH2R (CDR U) A1 A2 C1 C2) )) 
        (T (ERROR (LIST (QUOTE THL) U A1 A2 C1 C2))) 
        ))) 
 
(THR (LAMBDA (U A1 A2 C1 C2) (COND 
        ((EQ (CAR U) (QUOTE NOT)) (TH1L (CADR U) A1 A2 C1 C2)) 
        ((EQ (CAR U) (QUOTE AND)) (AND (TH1R (CADR U) A1 A2 C1 C2) 
        (TH1R (CADDR U) A1 A2 C1 C2) )) 
        ((EQ (CAR U) (QUOTE OR)) (TH2R (CDR U) A1 A2 C1 C2)) 
        ((EQ (CAR U) (QUOTE IMPLIES)) (TH11 (CADR U) (CADDR U) 
         A1 A2 C1 C2)) 
        ((EQ (CAR U) (QUOTE EQUIV)) (AND (TH11 (CADR U) (CADDR U) 
        A1 A2 C1 C2) (TH11 (CADDR U) (CADR U) A1 A2 C1 C2) )) 
        (T (ERROR (LIST (QUOTE THR) U A1 A2 C1 C2))) 
        ))) 
 
(TH1L (LAMBDA (V A1 A2 C1 C2) (COND 
        ((ATOM V) (OR (MEMBER V C1) 
        (TH (CONS V A1) A2 C1 C2) )) 
        (T (OR (MEMBER V C2) (TH A1 (CONS V A2) C1 C2) )) 
        ))) 
 
(TH1R (LAMBDA (V A1 A2 C1 C2) (COND 
        ((ATOM V) (OR (MEMBER V A1) 
        (TH A1 A2 (CONS V C1) C2) )) 
        (T (OR (MEMBER V A2) (TH A1 A2 C1 (CONS V C2)))) 
        ))) 
 
(TH2L (LAMBDA (V A1 A2 C1 C2) (COND 
        ((ATOM (CAR V)) (OR (MEMBER (CAR V) C1) 
        (TH1L (CADR V) (CONS (CAR V) A1) A2 C1 C2))) 
        (T (OR (MEMBER (CAR V) C2) (TH1L (CADR V) A1 (CONS (CAR V) 
        A2) C1 C2))) 
        ))) 
 
(TH2R (LAMBDA (V A1 A2 C1 C2) (COND 
        ((ATOM (CAR V)) (OR (MEMBER (CAR V) A1) 
        (TH1R (CADR V) A1 A2 (CONS (CAR V) C1) C2))) 
        (T (OR (MEMBER (CAR V) A2) (TH1R (CADR V) A1 A2 C1 
        (CONS (CAR V) C2)))) 
        ))) 
 
(TH11 (LAMBDA (VI V2 A1 A2 C1 C2) (COND 
        ((ATOM VI) (OR (MEMBER VI C1) (TH1R V2 (CONS VI A1) A2 C1 
        C2))) 
        (T (OR (MEMBER VI C2) (TH1R V2 A1 (CONS VI A2) C1 C2))) 
        ))) 
)) 
 
TRACE ((THEOREM TH1 TH2 TH THL THR TH1L TH1R TH2L TH2R TH11)) 
 
THEOREM 
((ARROW (P) ((OR P Q)))) 
 
UNTRACE ((THEOREM TH1 TH2 THR THL TH1L TH1R TH2L TH2R TH11)) 
 
THEOREM 
((ARROW ((OR A (NOT B))) ((IMPLIES (AND P Q) (EQUIV P Q))) )) 
 
STOP)))    )))     )))     ))) 
FIN     END OF LISP RUN        M948-1207 LEVIN
------------------------------------------------------------------------


[60]> (load"wang-cl.lisp")
;; Loading file wang-cl.lisp ...
WANG ALGORITHM FOR THE PROPOSITIONAL CALCULUS 

NIL 
WARNING: DEFUN/DEFMACRO: redefining TH; it was traced!
NIL 
;; Tracing function THEOREM.
;; Tracing function TH1.
;; Tracing function TH2.
;; Tracing function TH.
;; Tracing function THL.
;; Tracing function THR.
;; Tracing function TH1L.
;; Tracing function TH1R.
;; Tracing function TH2L.
;; Tracing function TH2R.
;; Tracing function TH11.
(THEOREM TH1 TH2 TH THL THR TH1L TH1R TH2L TH2R TH11) 
1. Trace: (THEOREM '(ARROW (P) ((OR P Q))))
2. Trace: (TH1 'NIL 'NIL '(P) '((OR P Q)))
3. Trace: (TH1 '(P) 'NIL 'NIL '((OR P Q)))
4. Trace: (TH2 '(P) 'NIL 'NIL 'NIL '((OR P Q)))
5. Trace: (TH2 '(P) 'NIL 'NIL '((OR P Q)) 'NIL)
6. Trace: (TH '(P) 'NIL 'NIL '((OR P Q)))
7. Trace: (THR '(OR P Q) '(P) 'NIL 'NIL 'NIL)
8. Trace: (TH2R '(P Q) '(P) 'NIL 'NIL 'NIL)
8. Trace: TH2R ==> (P)
7. Trace: THR ==> (P)
6. Trace: TH ==> (P)
5. Trace: TH2 ==> (P)
4. Trace: TH2 ==> (P)
3. Trace: TH1 ==> (P)
2. Trace: TH1 ==> (P)
1. Trace: THEOREM ==> (P)
(P) 
(THEOREM TH1 TH2 THR THL TH1L TH1R TH2L TH2R TH11) 
1. Trace: (TH 'NIL '((OR A (NOT B))) 'NIL '((IMPLIES (AND P Q) (EQUIV P Q))))
2. Trace: (TH '(A) 'NIL 'NIL '((IMPLIES (AND P Q) (EQUIV P Q))))
3. Trace: (TH '(A) '((AND P Q)) 'NIL '((EQUIV P Q)))
4. Trace: (TH '(Q P A) 'NIL 'NIL '((EQUIV P Q)))
4. Trace: TH ==> (P A)
3. Trace: TH ==> (P A)
2. Trace: TH ==> (P A)
2. Trace: (TH 'NIL '((NOT B)) 'NIL '((IMPLIES (AND P Q) (EQUIV P Q))))
3. Trace: (TH 'NIL 'NIL '(B) '((IMPLIES (AND P Q) (EQUIV P Q))))
4. Trace: (TH 'NIL '((AND P Q)) '(B) '((EQUIV P Q)))
5. Trace: (TH '(Q P) 'NIL '(B) '((EQUIV P Q)))
5. Trace: TH ==> (P)
4. Trace: TH ==> (P)
3. Trace: TH ==> (P)
2. Trace: TH ==> (P)
1. Trace: TH ==> (P)
(P) 
;; Loaded file wang-cl.lisp
T
[61]> 


Note, the output obviously differ in the form, but the semantics are
the same, notably the result of the theorem function calls is "true"
both in 2006 Common Lisp and in 1966 LISP 1.5.

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/

READ THIS BEFORE OPENING PACKAGE: According to certain suggested
versions of the Grand Unified Theory, the primary particles
constituting this product may decay to nothingness within the next
four hundred million years.
From: gavino
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <1152085944.688379.162320@m79g2000cwm.googlegroups.com>
SO you would completely reccomend lisp as the nicest programming tool
even to someone new to programming?  I really would liek to invest in
learning the best thing if it really is better, but don't see many
others using lisp it seems.  I guess I am stubborn.
Pascal Bourguignon wrote:
> "gavino" <········@yahoo.com> writes:
>
> > Interesting.
> > Is the tourestsky tutorial applicable to todays CLISP?
>
> Actually, any Common Lisp implementation can be applied with almost
> all Lisp material from any time, thanks to the concensual approach of
> the Common Lisp standard.  Note how the adjective "common" is adjoined
> to the name "lisp" to form the "Common Lisp" name.
>
> For example, here is how you can run a lisp program written in 1966 in
> a Common Lisp of 2006.  Rendez-vous in 30 years to see how you can run
> a 1996 perl program in perl 2036...
>
> See the wang program from:
> http://community.computerhistory.org/scc/projects/LISP/book/LISP%201.5%20Programmers%20Manual.pdf#page=52
> Chapter VIII.
> A Complete LISP Program - the Wang Algorithm for the Propositional Calculus.
>
> ----(wang-cl.lisp)------------------------------------------------------
> (shadow '(trace untrace))
> (defun trace   (functions) (eval `(cl:trace   ,@functions)))
> (defun untrace (functions) (eval `(cl:untrace ,@functions)))
>
> (defun define (definitions)
>   (dolist (def definitions)
>     (eval (if (and (consp (second def)) (eq 'lambda (car (second def))))
>               `(progn (defun        ,(first def) ,@(cdr (second def)))
>                       (defparameter ,(first def) ,(second def)))
>               `(defparameter ,(first def) ,(second def))))))
>
> (defun stop (arguments) (throw 'driver-end-of-deck nil))
> (defun fin  (arguments) (throw 'driver-end-of-deck nil))
> (defun test (arguments) (princ arguments) (terpri))
>
> (defun driver (path)
>   (with-open-file (cards path)
>     (catch 'driver-end-of-deck
>       (loop (let ((first-char (read-char cards)))
>               (if (char= #\* first-char)
>                   (read-line cards)     ; comment
>                   (progn
>                     (unread-char first-char cards)
>                     (let* ((command   (read cards))
>                            (arguments (if (member command '(stop fin test))
>                                           (list (read-line cards))
>                                           (read cards))))
>                       (print (apply command arguments))))))))))
>
> (driver "wang.job")
> ----(wang.job)----------------------------------------------------------
> * M948-1207 LEVIN, LISP, TEST, 2,3,250,0
>         TEST WANG ALGORITHM FOR THE PROPOSITIONAL CALCULUS
>
> DEFINE ((
> (THEOREM (LAMBDA (S) (TH1 NIL NIL (CADR S) (CADDR S))))
>
> (TH1 (LAMBDA (A1 A2 A C) (COND ((NULL A)
>         (TH2 A1 A2 NIL NIL C)) (T
>         (OR (MEMBER (CAR A) C) (COND ((ATOM (CAR A))
>         (TH1 (COND ((MEMBER (CAR A) A1) A1)
>         (T (CONS (CAR A) A1))) A2 (CDR A) C))
>         (T (TH1 A1 (COND ((MEMBER (CAR A) A2) A2)
>         (T (CONS (CAR A) A2))) (CDR A) C))))))))
>
> (TH2 (LAMBDA (A1 A2 C1 C2 C) (COND
>         ((NULL C) (TH A1 A2 C1 C2))
>         ((ATOM (CAR C)) (TH2 A1 A2 (COND
>         ((MEMBER (CAR C) C1) C1) (T
>         (CONS (CAR C) C1))) C2 (CDR C)))
>         (T (TH2 A1 A2 C1 (COND ((MEMBER
>         (CAR C) C2) C2) (T (CONS (CAR C) C2)))
>         (CDR C))))))
>
> (TH (LAMBDA (A1 A2 C1 C2) (COND ((NULL A2) (AND (NOT (NULL C2))
>         (THR (CAR C2) A1 A2 C1 (CDR C2)))) (T (THL (CAR A2) A1 (CDR A2)
>         C1 C2)))))
>
> (THL (LAMBDA (U A1 A2 C1 C2) (COND
>         ((EQ (CAR U) (QUOTE NOT)) (TH1R (CADR U) A1 A2 C1 C2))
>         ((EQ (CAR U) (QUOTE AND)) (TH2L (CDR U) A1 A2 C1 C2))
>         ((EQ (CAR U) (QUOTE OR)) (AND (TH1L (CADR U) A1 A2 C1 C2)
>         (TH1L (CADDR U) A1 A2 C1 C2) ))
>         ((EQ (CAR U) (QUOTE IMPLIES)) (AND (TH1L (CADDR U) A1 A2 C1
>         C2) (TH1R (CADR U) A1 A2 C1 C2) ))
>         ((EQ (CAR U) (QUOTE EQUIV)) (AND (TH2L (CDR U) A1 A2 C1 C2)
>         (TH2R (CDR U) A1 A2 C1 C2) ))
>         (T (ERROR (LIST (QUOTE THL) U A1 A2 C1 C2)))
>         )))
>
> (THR (LAMBDA (U A1 A2 C1 C2) (COND
>         ((EQ (CAR U) (QUOTE NOT)) (TH1L (CADR U) A1 A2 C1 C2))
>         ((EQ (CAR U) (QUOTE AND)) (AND (TH1R (CADR U) A1 A2 C1 C2)
>         (TH1R (CADDR U) A1 A2 C1 C2) ))
>         ((EQ (CAR U) (QUOTE OR)) (TH2R (CDR U) A1 A2 C1 C2))
>         ((EQ (CAR U) (QUOTE IMPLIES)) (TH11 (CADR U) (CADDR U)
>          A1 A2 C1 C2))
>         ((EQ (CAR U) (QUOTE EQUIV)) (AND (TH11 (CADR U) (CADDR U)
>         A1 A2 C1 C2) (TH11 (CADDR U) (CADR U) A1 A2 C1 C2) ))
>         (T (ERROR (LIST (QUOTE THR) U A1 A2 C1 C2)))
>         )))
>
> (TH1L (LAMBDA (V A1 A2 C1 C2) (COND
>         ((ATOM V) (OR (MEMBER V C1)
>         (TH (CONS V A1) A2 C1 C2) ))
>         (T (OR (MEMBER V C2) (TH A1 (CONS V A2) C1 C2) ))
>         )))
>
> (TH1R (LAMBDA (V A1 A2 C1 C2) (COND
>         ((ATOM V) (OR (MEMBER V A1)
>         (TH A1 A2 (CONS V C1) C2) ))
>         (T (OR (MEMBER V A2) (TH A1 A2 C1 (CONS V C2))))
>         )))
>
> (TH2L (LAMBDA (V A1 A2 C1 C2) (COND
>         ((ATOM (CAR V)) (OR (MEMBER (CAR V) C1)
>         (TH1L (CADR V) (CONS (CAR V) A1) A2 C1 C2)))
>         (T (OR (MEMBER (CAR V) C2) (TH1L (CADR V) A1 (CONS (CAR V)
>         A2) C1 C2)))
>         )))
>
> (TH2R (LAMBDA (V A1 A2 C1 C2) (COND
>         ((ATOM (CAR V)) (OR (MEMBER (CAR V) A1)
>         (TH1R (CADR V) A1 A2 (CONS (CAR V) C1) C2)))
>         (T (OR (MEMBER (CAR V) A2) (TH1R (CADR V) A1 A2 C1
>         (CONS (CAR V) C2))))
>         )))
>
> (TH11 (LAMBDA (VI V2 A1 A2 C1 C2) (COND
>         ((ATOM VI) (OR (MEMBER VI C1) (TH1R V2 (CONS VI A1) A2 C1
>         C2)))
>         (T (OR (MEMBER VI C2) (TH1R V2 A1 (CONS VI A2) C1 C2)))
>         )))
> ))
>
> TRACE ((THEOREM TH1 TH2 TH THL THR TH1L TH1R TH2L TH2R TH11))
>
> THEOREM
> ((ARROW (P) ((OR P Q))))
>
> UNTRACE ((THEOREM TH1 TH2 THR THL TH1L TH1R TH2L TH2R TH11))
>
> THEOREM
> ((ARROW ((OR A (NOT B))) ((IMPLIES (AND P Q) (EQUIV P Q))) ))
>
> STOP)))    )))     )))     )))
> FIN     END OF LISP RUN        M948-1207 LEVIN
> ------------------------------------------------------------------------
>
>
> [60]> (load"wang-cl.lisp")
> ;; Loading file wang-cl.lisp ...
> WANG ALGORITHM FOR THE PROPOSITIONAL CALCULUS
>
> NIL
> WARNING: DEFUN/DEFMACRO: redefining TH; it was traced!
> NIL
> ;; Tracing function THEOREM.
> ;; Tracing function TH1.
> ;; Tracing function TH2.
> ;; Tracing function TH.
> ;; Tracing function THL.
> ;; Tracing function THR.
> ;; Tracing function TH1L.
> ;; Tracing function TH1R.
> ;; Tracing function TH2L.
> ;; Tracing function TH2R.
> ;; Tracing function TH11.
> (THEOREM TH1 TH2 TH THL THR TH1L TH1R TH2L TH2R TH11)
> 1. Trace: (THEOREM '(ARROW (P) ((OR P Q))))
> 2. Trace: (TH1 'NIL 'NIL '(P) '((OR P Q)))
> 3. Trace: (TH1 '(P) 'NIL 'NIL '((OR P Q)))
> 4. Trace: (TH2 '(P) 'NIL 'NIL 'NIL '((OR P Q)))
> 5. Trace: (TH2 '(P) 'NIL 'NIL '((OR P Q)) 'NIL)
> 6. Trace: (TH '(P) 'NIL 'NIL '((OR P Q)))
> 7. Trace: (THR '(OR P Q) '(P) 'NIL 'NIL 'NIL)
> 8. Trace: (TH2R '(P Q) '(P) 'NIL 'NIL 'NIL)
> 8. Trace: TH2R ==> (P)
> 7. Trace: THR ==> (P)
> 6. Trace: TH ==> (P)
> 5. Trace: TH2 ==> (P)
> 4. Trace: TH2 ==> (P)
> 3. Trace: TH1 ==> (P)
> 2. Trace: TH1 ==> (P)
> 1. Trace: THEOREM ==> (P)
> (P)
> (THEOREM TH1 TH2 THR THL TH1L TH1R TH2L TH2R TH11)
> 1. Trace: (TH 'NIL '((OR A (NOT B))) 'NIL '((IMPLIES (AND P Q) (EQUIV P Q))))
> 2. Trace: (TH '(A) 'NIL 'NIL '((IMPLIES (AND P Q) (EQUIV P Q))))
> 3. Trace: (TH '(A) '((AND P Q)) 'NIL '((EQUIV P Q)))
> 4. Trace: (TH '(Q P A) 'NIL 'NIL '((EQUIV P Q)))
> 4. Trace: TH ==> (P A)
> 3. Trace: TH ==> (P A)
> 2. Trace: TH ==> (P A)
> 2. Trace: (TH 'NIL '((NOT B)) 'NIL '((IMPLIES (AND P Q) (EQUIV P Q))))
> 3. Trace: (TH 'NIL 'NIL '(B) '((IMPLIES (AND P Q) (EQUIV P Q))))
> 4. Trace: (TH 'NIL '((AND P Q)) '(B) '((EQUIV P Q)))
> 5. Trace: (TH '(Q P) 'NIL '(B) '((EQUIV P Q)))
> 5. Trace: TH ==> (P)
> 4. Trace: TH ==> (P)
> 3. Trace: TH ==> (P)
> 2. Trace: TH ==> (P)
> 1. Trace: TH ==> (P)
> (P)
> ;; Loaded file wang-cl.lisp
> T
> [61]>
>
>
> Note, the output obviously differ in the form, but the semantics are
> the same, notably the result of the theorem function calls is "true"
> both in 2006 Common Lisp and in 1966 LISP 1.5.
>
> --
> __Pascal Bourguignon__                     http://www.informatimago.com/
>
> READ THIS BEFORE OPENING PACKAGE: According to certain suggested
> versions of the Grand Unified Theory, the primary particles
> constituting this product may decay to nothingness within the next
> four hundred million years.
From: ··············@hotmail.com
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <1152109713.836868.156390@v61g2000cwv.googlegroups.com>
gavino wrote:
> SO you would completely reccomend lisp as the nicest programming tool
> even to someone new to programming?  I really would liek to invest in
> learning the best thing if it really is better, but don't see many
> others using lisp it seems.  I guess I am stubborn.

Gavino--

  If by "stubborn" you mean your apparent willingness to accept
throw-away opinions of supposed experts or newsgroup postings
justifying the mass opinion over one's own thoughtful investigation, I
suggest a much better investment of your time would be to overcome your
own stubborness.

--Joe
From: Pascal Bourguignon
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <87d5cks6sa.fsf@thalassa.informatimago.com>
"gavino" <········@yahoo.com> writes:

> SO you would completely reccomend lisp as the nicest programming tool
> even to someone new to programming?  

Most definitely!


Since you're new to programming, I'd recommend to start with:
Common Lisp: A Gentle Introduction to Symbolic Computation
http://www-cgi.cs.cmu.edu/afs/cs.cmu.edu/user/dst/www/LispBook/index.html
and read Practical Common Lisp
http://www.gigamonkeys.com/book/
later.


> I really would like to invest in learning the best thing if it
> really is better, but don't see many others using lisp it seems.  
> I guess I am stubborn.

-- 
__Pascal Bourguignon__                     http://www.informatimago.com/

"You can tell the Lisp programmers.  They have pockets full of punch
 cards with close parentheses on them." --> http://tinyurl.com/8ubpf
From: funkyj
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <1152123562.349536.133700@m73g2000cwd.googlegroups.com>
Pascal Bourguignon wrote:
> "gavino" <········@yahoo.com> writes:
>
> > SO you would completely reccomend lisp as the nicest programming tool
> > even to someone new to programming?
>
> Most definitely!

I'll provide some caveats:

* Getting your lisp environment up and running can be a painful
  process.  You can avoid much of this pain by using the 'lispbox'
  distribution (http://www.gigamonkeys.com/lispbox/).

  Anecdote: I have been using CLisp from Cygwin with SLIME (SLIME CVS
  head from 2006-jan-20, also tried 2006-jun-20), rather than lispbox.
  I recently upgraded from CLisp 2.35 to 2.38 and now SLIME is broken.
  (stupid me -- why did I try to "fix" something that wasn't broken!!)
  You don't want this sort of annoyance.  If you stick with lispbox
  you won't have it.  It has been my experience that those other
  languages you mention do a better job of making the environment easy
  to setup.

* If you want to perform simple tasks then Perl or Python might be
  better because they have huge well documented libraries that in many
  cases will do 90% of the heavy lifting your program needs to do
  (e.g. parse an XML document into a DOM and the provide methods for
  operating on said DOM and translating the DOM back into XML).


  --fj
From: ······@corporate-world.lisp.de
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <1152129268.967865.34660@75g2000cwc.googlegroups.com>
funkyj wrote:
> Pascal Bourguignon wrote:
> > "gavino" <········@yahoo.com> writes:
> >
> > > SO you would completely reccomend lisp as the nicest programming tool
> > > even to someone new to programming?
> >
> > Most definitely!
>
> I'll provide some caveats:
>
> * Getting your lisp environment up and running can be a painful
>   process.  You can avoid much of this pain by using the 'lispbox'
>   distribution (http://www.gigamonkeys.com/lispbox/).
>
>   Anecdote: I have been using CLisp from Cygwin with SLIME (SLIME CVS
>   head from 2006-jan-20, also tried 2006-jun-20), rather than lispbox.
>   I recently upgraded from CLisp 2.35 to 2.38 and now SLIME is broken.
>   (stupid me -- why did I try to "fix" something that wasn't broken!!)
>   You don't want this sort of annoyance.  If you stick with lispbox
>   you won't have it.  It has been my experience that those other
>   languages you mention do a better job of making the environment easy
>   to setup.

Your experience seems to be limited to one Lisp implementation.

>
> * If you want to perform simple tasks then Perl or Python might be
>   better because they have huge well documented libraries that in many
>   cases will do 90% of the heavy lifting your program needs to do
>   (e.g. parse an XML document into a DOM and the provide methods for
>   operating on said DOM and translating the DOM back into XML).

Why would any 'simple' task involve complex stuff like DOM and XML?
With Lisp you can get rid of XML and DOM for many practical
purposes.

> 
> 
>   --fj
From: Joe Marshall
Subject: Re: Where is the clisp MANUAL?
Date: 
Message-ID: <1152127842.236743.218850@b68g2000cwa.googlegroups.com>
gavino wrote:
> SO you would completely recommend lisp as the nicest programming tool
> even to someone new to programming?

It depends.  If the someone were interested in becoming a top-notch
software engineer
or computer scientist, then I'd recommend Lisp.  If the someone simply
wants to hack
some dancing hamsters on his web page, or simplify some complex M$Word
operation,
I'd point them at a reference manual for the product they are using.

> I really would like to invest in
> learning the best thing if it really is better, but don't see many
> others using lisp it seems.

Does popularity matter that much to you?  If so, I suggest Java, C, and
Visual Basic.  They certainly aren't the nicest languages by a long
shot, but you'll have plenty of company for your misery.