LISP else

Quote:

Original post by Trap documentation for if Your code is totally wrong. Somewhat similar code in c would be (translating errors too) *** Source Snippet Removed *** What editor are you using? (defun is-digit(x) (and (<= x 9) (>= x 0))) is way shorter, but only works if x is a number

if(x == 0) return true;   else      if((x == 1) return true;         else...                                      if(x == 9) return true;                                          else return false;

Quote:

Original post by Anonymous Poster LISP's if construct is as follows. (if condition then else) else can be omitted. This code: (if(eql x 0) T), doesn't have an else clause. It's getting run, and then it drops through to the next thing no matter what. What editor are you using? Emacs (and I'm sure others) can indent LISP for you so that nesting errors become glaringly obvious. Hope I was helpful.

(defun isDigit(x)   (if(eql x 0) T)      (if(eql x 1) T)

(defun isDigit(x)   (if(eql x 0) T      (if(eql x 1) T....                                            nil)))

Quote:

Original post by Anonymous Poster Yes, but actually you might be better off with a cond here anyway. Looks much better than lots of chained ifs. (cond ((= x 0) t) ((= x 1) t) ((= x 2) t) ... (t nil))

Quote:

Instead of nesting if statements as before, the set of conditions (if A B (if C D E)) can be expressed using cond. It would look like this: (cond (A B) (C D) (t E))

Quote:

Original post by CyberSlag5k I'm quite new to LISP and am trying to write an auxiliary isDigit function tell if the atom passed to it is a digit. The last line there flags an error saying "An object cannot start with #/". Is that not the way you would do an "else"?

(if <test> <true-expr> <false-expr>)

(defun isDigit(x)   (if(eql x 0) T      (if(eql x 1) T         (if(eql x 2) T            (if(eql x 3) T               (if(eql x 4) T                  (if(eql x 5) T                     (if(eql x 6) T                        (if(eql x 7) T                           (if(eql x 8) T                              (if(eql x 9) T                                 nil)))))))))))

(defun isDigit (x)    (case x ((0 1 2 3 4 5 6 7 8 9) t)        (otherwise nil)))(defun isDigit (x)    (and (numberp x) (<= x 9) (>= x 0)))(defun isDigit (x)    (if (member x '(0 1 2 3 4 5 6 7 8 9)) t))

Quote:

Original post by Anonymous Poster The (t nil) part is pretty much what default: would do in a C switch statement.

if A then Belse   if C then D      else E

Quote:

(defun isDigit (x) (case x ((0 1 2 3 4 5 6 7 8 9) t) (otherwise nil)))

Quote:

Original post by CyberSlag5k cond, eh? Just looked it up in the doc. Looks cool, though I don't understand that final (t nil). The doc has this:

(cond (test action...)      (test action...)      (test action...)      ...      )

Quote:

Quote: Instead of nesting if statements as before, the set of conditions (if A B (if C D E)) can be expressed using cond. It would look like this: (cond (A B) (C D) (t E)) I don't really get that. And don't I want to be using eql instead of =? Or is = also a comparison?

Quote:

Try Lisp in a Box which includes Emacs, SLIME and a module for CLISP. I only use very few features of it, but they make using Lisp so much more comfortable. Hyperspec-Lookup, parens highlighting and autoindent.

Quote:

Practical Common Lisp a good introduction to lisp.

(defun myPush(input, stack, output)   (if(or (nil input) (nil isDigit((car input))) interpret(input, 'illegal, 'illegal))      interpret((cdr input), append((car input) stack), output))

Quote:

Original post by Trap You don't need the comma in this place.

Quote:

Read an introduction on Lisp before mindlessly writing stuff. Some simple things: -everything in () is a list -the first element in every list is the name of the function to be called, the rest are the arguments -elements in a list are seperated by whitespace

Quote:

Emacs with SLIME is way better than Emacs alone (about as much as Emacs is better than Notepad). It offers "Lisp in Emacs" + autocompletion + onlinehelp + loading files into Lisp via a simple keychord + a lot more.

Quote:

Original post by Trap some more errors in your code: func(args) is c-style, (func args) is lisp Everything after a ( has to be something callable (if it is evaluated, some macros like "let" don't evaluate all arguments). (or (nil... doesn't make sense.

Quote:

(or (nil... doesn't make sense.