newLISP Fan Club

Quote from: "Jeff"Because "i was 5" is the value of the catch.  It was not caught into any symbol, so there was no output.  If you run it inside the repl, the entire expression will evaluate to "i was 5", but only the print statement will print things out.



Here is a more comprehensive tutorial I wrote on newLisp error handling and flow control using catch/throw:



http://artfulcode.nfshost.com/files/simple-error-handling-in-newlisp.html">//http://artfulcode.nfshost.com/files/simple-error-handling-in-newlisp.html

Quote from: "Jeff"When visually parsing a lisp list, evaluate from the inside out.  After learning to do this, lisp's syntax will become so much easier to visualize than imperative programming, because with lisp you are, basically, writing the actual internal structure of the program, rather than a more declarative syntax that would get parsed and turned into something resembling the lisp structure.



When writing a lisp program, write from the bottom-up.  It's all about abstraction.  First, you write the most primitive elements your program will need.  Then, you write other functions that will use those functions in order to abstract the more low-level stuff.  In the end, you write a much smaller set of functions/macros that will be the api to the program.  These have convenient syntax and build on the lower level elements of the program.

Quote from: "cormullion"

Quote from: "dukester"Let's see if I'm getting this:



(upper-case (println "hello world"))



is a list of 2 functions and some data... correct?



1st-- println  function does its thing and displays the data

2nd-- upper-case function does _its_ thing on the data

3rd-- REPL displays the last item in the list



Am I close?

Yes! :-)



To put it another way, (upper-case (println "hello world")) is a list in which the argument to the 'upper-case' function is another list which contains a function call and an argument (or data as you call it).



1 - A println function call in a list returns a value. As a useful and pleasant side effect , it displays some string data somewhere and adds a newline to it too as it does so.



2 - upper-case now has a chance to do its 'thing' with the string that it's handed by the inner list. It doesn't 'know' where the string has come from, or what it originally looked like before it was procesed, and knows nothing of standard output or displays either. It sees a string - that's good enough, and all it needs to know.



3 - The result of the evaluation of the 'upper-case' function is displayed by the newLISP interpreter. This isn't the original data, but the value of the 'upper-case' function call, which in turn depended on the value of the 'println' function call.



So - can you predict how the following is evaluated?

Code Select Expand

(upper-case (reverse (lower-case "ABC")))

Look at the innermost list first.



hope this helps!

Quote from: "Jeff"That's exactly right.  Anything printed will have the additional side effect of printing the value of the expression entered.  READ-EVAL-PRINT-LOOP means that the expression is read, evaluated, the value is printed, and then then started over.  Printing a statement returns the text printed, so (println "Hello world") both prints "Hello world" and then evaluates to "Hello world", so the repl will print out the value in the course of evaluating the expression, and then display the result of that expression.  If you were to type (upper-case (println "hello world")), it would first print "hello world", then print the value of the entire expression, "HELLO WORLD".

Quote from: "cormullion"late but....



I usually edit in an editor (TextWrangler at present) and hit the 'run' command. It works fine. Recently, trying to track

Quote from: "cormullion"
down some error of mine, I've started running functions in the terminal. So:



[ I'm editing then I save ...]

[ Command-Tab to terminal running newlisp]

> (load "file.lsp")

> (debug (function-exp))



and then I'm in the debugger, stepping through the function. Although the debugger is simple, I like that simplicity.

QuoteI've put

Code Select Expand

(trace-highlight "27[0;32m" "27[0;0m")

into my init.lsp file, because I can never remember the codes. Now, when tracing a function, the current expression is in green... I'm starting to appreciate the way you can type in any expression at any point in the executing code.

Quote from: "Lutz"At the end of this page:



http://www.turtle.dds.nl/newlisp/index.html">http://www.turtle.dds.nl/newlisp/index.html



you find a nice screenshot of running a shell inside a split window in Vim.



Lutz