# guile 1.8.5

Version of implementation GNU Guile of programming language Lisp

A version of GNU Guile released in May 2008.

## Examples:

### Hello, World! - Lisp (388):

Printing a message is a side effect of this command. Depending on the chosen implementation, the command will return either the message printed, or `Unspecified return value`.

``````(write "Hello, World!")
``````

### Factorial - Lisp (389):

This example uses tail-recursive factorial calculation. Note that GNU Guile and MIT/GNU Scheme print correct result, while JScheme has values of factorial starting with 13! wrong due to overflow.

``````(define (factorial x)
(if (< x 2)
1
(* x (factorial (- x 1)))))

(do ((i 0 (+ i 1)))
((> i 16))
(display (string-append (number->string i) "! = "))
(display (number->string (factorial i)))
(newline))
``````

### Fibonacci numbers - Lisp (390):

This example uses recursive definition of Fibonacci numbers.

``````(define (fibonacci x)
(if (< x 2)
x
(+ (fibonacci (- x 1)) (fibonacci (- x 2)))))

(do ((i 1 (+ i 1)))
((> i 16))
(display (string-append (number->string (fibonacci i)) ", ")))
(display "...")
(newline)
``````

### Quadratic equation - Lisp (472):

`begin` is used to execute several commands in row.

``````(define A (read))
(define D (- (* B B) (* 4 A C)))
(if (= A 0)
(display "Not a quadratic equation.")
(begin
(define k1 (/ B -2 A))
(define k2 (/ (sqrt (abs D)) 2 A))
(if (= D 0)
(begin (display "x = ") (display k1))
(if (> D 0)
(begin (display "x1 = ") (display (+ k1 k2)) (newline) (display "x2 = ") (display (- k1 k2)))
(begin (display "x1 = (") (display k1) (display ", ") (display k2) (display ")") (newline)
(display "x2 = (") (display k1) (display ", ") (display (- k2)) (display ")"))))))
``````

### CamelCase - Lisp (473):

This program shows how to use regular expressions from `regex` module. First two commands load the necessary modules. The third one reads a line from input stream using `read-line` command (`rdelim` module) — unlike plain `read`, it consumes characters till the end of line, not till the first whitespace — and converts it to lowercase.

The fourth command finds all matches for a regexp which describes a sequence of lowercase letters. Then it replaces each match with a return of a certain function applied to it (bound using `lambda`). In this case the function is `string-titlecase` which converts the first character of the string to uppercase.

Finally, the fifth command removes all non-letter characters from the string.

``````(use-modules (ice-9 regex))
(use-modules (ice-9 rdelim))
(define text (string-downcase (read-line)))
(define text (regexp-substitute/global #f "[a-z]+"  text 'pre (lambda (m) (string-titlecase (match:substring m))) 'post))
(define text (regexp-substitute/global #f "[^a-zA-Z]+"  text 'pre 'post))
(display text)
``````