Page 3 - Scheme

Hi,

heres 99 Bottles of beer on a wall in scheme.

Displeaser

Thats a little to advanced for me

heres the ever faithful Hello World program.

Displeaser

Ok I know what lambda( ) is ( Python ) but.. what is it doing there in scheme? How does that part work... even though in my tutorial i am in that part.. but that code is a bit different.

one thing that may seem trivial but which is actually really important is indentation and layout - you should use and get used to the idiomatic style because everyone else's code will be written that way, and you need to be able to read it properly, just as you need other people to read your code easily. So never put a paren on it's own line and always line up code that's in the same scope. Again, this would be handled for you by a good editor

You will realise the importance of this if you end up posting code on comp.lang.scheme sometime. That's probably also the best place to start looking at other people's code, from fragments to whole apps.

both functions (deliberately) contain infinite loops - if you go to the parent dir there are infinite loops in scores of languages, for some reason...

Scheme's/any lisps's lambda is much more powerful than the python construct, in that it creates first class objects (which you already know are anonymous functions) and isn't limited to one line or whatever. The way scope/lexical closure is treated is more powerful too.

Nice, thanx.

Hey jamieB do you have any of those "Simple as it can get" scheme tutorials?

If you check out the Scheme article on the Language Resources thread, you'll find scads of tutorials. Here are a few I specifically recommend:

Scheme in Short (admittedly, I'm biased towards this one )
Teach Yourself Scheme in Fixnum Days
Scheme for C Programmers
THe Scheme Programing Language: An Alternate Worldview

Also, several entire textbooks are online, including Structure and Interpretation of Computer Programs, mentioned above, and
How to Design Programs, which is a bit easier to swallow but has some quirks about how it uses the language.

As for the great editor debate, while I am usually an Emacs partisan, in this case I would recommend Dr Scheme, which comes with one of the best language-specific IDEs I know of, and has support for a number of variants of the language (though in most cases, you would want it set to 'Standard (R5RS)', unless you were studying from a book that uses the different versions, like How To Design Programs does). The tutorial 'Learning to Program with DrScheme' covers both the language itself and how to use the IDE (though it is a bit dated now). The interpreter and IDE are open source, and there pre-compiled installers available for Windows, FreeBSD, Mac, and certain some of the more common Linux distros.

As for programs in Scheme, well, I could point to my own Hex dump example, but that's hardly an example of good code. If you do a search on 'Scheme' here in DevShed, you'll find some previous threads, like these:

Scheme: Reduce and Filter
Can this really be done in Scheme?
Scheme 'Sieve of Eratosthenes' variant, with memoization
Space and time for a few procedures

Hm I should troll with more attention next time.. thanx.

One more page to add: Scheme Idioms on Ward's Wiki. Actually, there are quite a few wiki pages on Scheme there, though not all of the are favorable, to say the least

btw.. for a minute there i could not access the forum.. it was loading slow.. so i memod you saying thanx for DR Scheme.

You might also want to see what is said on Ward's Wiki about the lambda function and lambda calculus in general. To make a long story short, lambda is a function for creating functions; when you write something like


What it is really doing is generating a function that takes an argument x and applies the + function to x and 1, then binds the function to the variable name ++.

(And yes, you can use ++ as a function or variable name, if you really wanted to, though it's not generally advised.)

The form

Is really just a shortcut way of doing the same thing (it actually is a macro, which replaces that with the first example).

Scheme (and the other Lisp languages) take a very different approach towards programming than languages like C or Java, and it can take a bit of getting used to.

How would i retrive user inputs? Was meaning to ask this before.. forgot, Im just still a little curious, even though I'm learning as I go. Also thanx again.

The short answer is, (read) and (read-char). However, that's just the starting point.

In the R5RS Scheme, stream I/O is handled through the port abstraction. To open a port, you would use

(open-input-file filename)
or
(open-input-file filename)

as appropriate, which would return a port handle for the named file. To close the port when finished, you would call
(close-input-port port)
or
(close-input-port port)

as appropriate. Alternately, you could call use

(call-with-input-file string proc)
or
(call-with-output-file string proc)
Which opens the port, calls proc with the port object as it's argument, and then closes the port when the called function returns.

For the I/O itself, the primitive functions are

(read-char [port])
(peek-char [port])
(read [port])
(write-char char [port])
(write expression [port])
(display expression [port])

The port arguments in these are optional; If you call these with no with no port argument, they asume the default ports (the equivalent of stdin and stdout for C). If you call a function using (with-input-from-file) or (with-output-to-file), it has the effect of redirecting the default ports to the one given as the filename argument.

(read-char) reads exactly one character from input; if more than one character was input, then it will continue to read the enter characters until the buffer is empty or has been flushed somehow. (peek-char) reads a single character without removing it from the input buffer; it is used for lookahead in parsing and similar roles.

(read) gets a single Scheme expression, whether it is a symbol, a string, a number, or a list; thus, if you have a function

then if you enter John Jacob Jingleheimer Schmitt, it will read in John as a symbol (not as a text string), and each subsequent call would read opne of the names as a single symbol until the buffer is empty. On the other hand, if you were to enter (John Jacob Jingleheimer Schmitt), it would read the whole input text as a single list, and if you entered "John Jacob Jingleheimer Schmitt", it would treat it as a single text string.

Not surprisingly, (write-char) writes out a single character. (display) and (write) work similarly, except that where (display) outputs the value of the expression or symbol, (write) outputs the Scheme representation of it; e.g., if you printed a string using (display), it would be shown without the double-quotes, while (write) would show the quotes; (display) would output the character literal #\a, it would print the character a, while (write) would print the character literal as it appears in the code, #\a; and so on.

The predicates (input-port?) and (output-port?) test the argument and returns #f if it is anything other than a port of the approriate type. (eof-object?) returns #t if the port in question has reached the end-of-file marker, #t if it hasn't. (char-ready? [port]) returns #t if there is a character in the port buffer ready to be read, #f otherwise.

This is the just the basic I/O that's built into the language; there are several libraries which expand on these. The following SRFIs cover I/O in one manner or another:

• SRFI-6 (basic string ports)
• SRFI-23(Error reporting mechanism)
• SRFI-28 (basic format strings)
• SRFI-36 (I/O Conditions)
• SRFI-48 (Intermediate Format Strings)
• SRFI-54 (Formatting)

(Note that despite it's title, SRFI-40 is not about I/O; the 'streams' in question are a rather different abstraction).

The SLIB library also define several I/O functions (many of which overlap the SRFIs), and the Scheme Cookbook has several useful functions and patterns for file I/O as well.