Basic syntax

Like many newLISP sequence functions, find-all is defined for both strings and lists. The basic syntax is:

Strings: (find-all pattern target [expression [option]])
Lists:   (find-all pattern target [expression [comparison-function]])

String searches and regular expressions

The most basic string search finds occurrences of one string inside of another.

(set 'str "Now is the time for all good men to come to the aid of their country.")
(find-all "the" str)
; ("the" "the" "the")

There are three occurrences (including one within the word, ‘their’). To find only occurrences of ‘the’ as a complete word, a regular expression is used:

(find-all {\bthe\b} str $0 0)
; ("the" "the")

The first parameter is a regular expression, defined in curly braces to eliminate the need to double-escape entities (like b). The final parameter, 0, is the PCRE option (a full list of options is available in the newLISP documents for regex.

The third parameter is key to one of the more powerful features of find-all – substitution. The expression parameter is applied to each element found. Inside of this expression, the global variable $0 represents the entire matched element. In a regular expression search, captured matches are available via subsequently enumerated variables: $1, $2, etc.

For example, to convert all occurrences of ‘the’ to upper case in the resulting list:

(find-all {\bthe\b} str (upper-case $0) 0)
;("THE" "THE")

Here is a short program to count the number of occurrences of some common words in the text of War and Peace:

(set 'text (read-file "war_and_peace.txt"))
(set 'words (find-all {\b\S+\b} text $0 1)) ; split into words
 
(println (format "%12s: %6d" "Total words" (length words)))
(letn ((common-words '("and" "or" "the"))
       (counts (map 'list common-words (count common-words words))))
  (dolist (word counts)
    (println (format "%12s: %6d" (word 0) (word 1)))))

With the results:

 Total words: 564345
         and:  21023
          or:   1542
         the:  31702

This isn’t necessarily efficient; finding all words and then counting occurrences of three specific words in a list of more than half a million elements results in a lot of wasted time. The regular expression used also includes opening and closing punctuation in the word (i.e. a quote that begins “The…” would result in a missed occurrence of ‘the’, because the list would contain “The instead. It also does not account for case when counting occurrences.

Here is a more efficient version:

(set 'common-words '("and" "or" "the"))
(set 're (format {\b(%s)\b} (join common-words "|")))
(set 'occurrences (find-all re text (lower-case $0) 1))
(println (map 'list common-words (count common-words occurrences)))
; (("and" 22267) ("or" 1582) ("the" 34619))

Note that find-all is recursive and newLISP has a limited stack size, which can be set during execution with the -s switch:

newlisp -s 500000 common_counts.lsp

The previous example would hit the default stack limit of 2,048. This can be solved by using map instead of find-all‘s substitution expression:

(set 'common-words '("and" "or" "the"))
(set 're (format {\b(%s)\b} (join common-words "|")))
(set 'occurrences (map 'lower-case (find-all re text $0 1)))
(println (map 'list common-words (count common-words occurrences)))
; (("and" 22267) ("or" 1582) ("the" 34619))

The substitution expression is also useful to cause side effects, squeezing even more efficiency out of the algorithm. Here, find-all increments a count of each word and stores it in a dictionary.

(define counts:counts)
 
(set 'common-words '("and" "or" "the"))
(set 're (format {\b(%s)\b} (join common-words "|")))
(find-all re text (counts (lower-case $0) (+ 1 (or (counts (lower-case $0)) 0))) 1)
 
(dolist (w common-words)
  (println (format "%4s: %6d" w (counts w))))
 
 ; and:  22267
 ;  or:   1582
 ; the:  34619

This algorithm is quite fast, although still somewhat weighty in RAM, since it stores the entire text before doing its work.

List searches

find-all list searches are (arguably) nearly as powerful as regular expressions. By default, find-all compares elements of target with pattern using match, and the default expression is the entire matched element ($0):

(set 'target '((a 1) (b 2) (c 3) (d 4 5)))
 
(find-all '(? ?) target)
; ((a 1) (b 2) (c 3))
 
(find-all '(d *) target)
; ((d 4 5))

Using the substitution expression, lists may be unified or matched further:

(find-all '(? ?) target (unify '(Letter Number) $0))
; (((Letter a) (Number 1)) ((Letter b) (Number 2)) ((Letter c) (Number 3)))

Simple list searches using other comparators than match are straight-forward:

(find-all 4 '(1 2 3 4 5) $0 >)
; (1 2 3)
 
(find-all 4 '(1 2 3 4 5) (+ 1 $0) >)
; (2 3 4)

find-all is convenient for searching XML. newLISP parses XML into a tree. For example:

(xml-type-tags nil nil nil nil)
(set 'xml (xml-parse (get-url "http://www.weather.gov/xml/current_obs/index.xml")
    (+ 1 2 4 16)))

For more info on parsing XML in newLISP, see this article and the newLISP documentation.

The XML at the url above lists weather stations. Here is an example station entry, under the root element, “wx_station_index”:

<station>
	<station_id>TAPA</station_id>
	<state>AG</state>
	<station_name>Vc Bird Intl Airport Antigua</station_name>
	<latitude>17.117</latitude>
	<longitude>-61.783</longitude>
	<html_url>http://weather.noaa.gov/weather/current/TAPA.html</html_url>
	<rss_url>http://weather.gov/xml/current_obs/TAPA.rss</rss_url>
	<xml_url>http://weather.gov/xml/current_obs/TAPA.xml</xml_url>
</station>

assoc is useful for finding a path in a parsed XML list:

(set 'stations-xml (assoc (xml "wx_station_index")))

However, assoc only returns the first element of the list that matches. In the XML article linked above, pop-assoc was used to collect elements iteratively:

(set 'stations '())
(while (assoc (xml "wx_station_index" "station"))

That is a handy way of collecting all elements, especially in an irregular document. With find-all, elements may be found just as easily and without modifying the original list:

(find-all '("station" *) (assoc (xml "wx_station_index")))

From there, it is just as simple to aggregate the values from each element:

(set 'station-pattern
    '("station"
        ("station_id" ?)
        ("state" ?)
        ("station_name" ?)
        ("latitude" ?)
        ("longitude" ?)
        ("html_url" ?)
        ("rss_url" ?)
        ("xml_url" ?)))
 
(find-all '("station" *) (assoc (xml "wx_station_index"))
    (match station-pattern $0))

This returns a list of the node values for each station. The data can be applied to a different associative structure easily using unify:

(find-all '("station" *) (assoc (xml "wx_station_index"))
    (unify '(Id State Name Lat Lon Html Rss Xml)
        (match station-pattern $0)))

Each element in this list this creates looks like:

((Id "TAPA")
 (State "AG")
 (Name "Vc Bird Intl Airport Antigua")
 (Lat "17.117")
 (Lon "-61.783")
 (Html "http://weather.noaa.gov/weather/current/TAPA.html")
 (Rss "http://weather.gov/xml/current_obs/TAPA.rss")
 (Xml "http://weather.gov/xml/current_obs/TAPA.xml"))

A completely impractical example

There are further implications of find-all‘s ability to cause side effects in the substitution expression. To download the XML for each individual station, something like this could be done (don’t really do this – it will attempt to spawn more than 2,000 processes):

(set 'processes
    (find-all '("station" *) (assoc (xml "wx_station_index"))
      (spawn (sym (lookup "station_name" $0) 'WEATHER)
             (get-url (lookup "xml_url" $0)))))
 
(sync 30000) ; wait 30 seconds for all downloads to finish

Assuming that the application is able to download the XML file for more than 2,000 stations in 30 seconds (and that there is no hard limit to forked processes, as there is in OSX), the context WEATHER will contain the XML for all stations.

The infeasability of this example aside, it demonstrates, as an example, how easily a user-supplied XML file could be used to script a newLISP application.

Further documentation

• find-all
• unify
• match
• regex
• xml-parse

Submit article

Much of the module uses the small convenience classes to “serialize” SQL expressions. Most of the module’s classes have :serialize methods that render the encapsulated data as a string. For example, the Field class:

(let ((f (Field "table" "fieldname")))
    (:serialize f))
=> "table.fieldname"

…or the Condition class:

(let ((c (Condition ">" "salary" 65000)))
    (:serialize c))
=> "salary > '65000'"

Note that values are enclosed in single quotes for ANSI compliance. The most interesting function in the module, however, is sql:expr, which uses the match-based primitives in the functional module to generate various types of expressions:

(sql:expr "employees" "first_name")
=> "employees.first_name"
 
(sql:expr "LIKE" "first_name" "Stev%")
=> "first_name LIKE 'Stev%'"
 
(sql:expr "OR" (sql:expr "LIKE" "first_name" "Stev%")
               (sql:expr "LIKE" "last_name" "John%"))
=> "((first_name LIKE 'Stev%') OR (last_name LIKE 'John%'))"
 
(sql:expr 6)
=>"6"
 
(sql:expr 'myapp:employees)
=> "employees"
 
(sql:expr "CONV" "AF" 16 10)
=> "CONV('AF',16,10)"
 
(sql:expr "LIKE" (sql:expr "employees" "first_name") "Stev%")
=> "employees.first_name LIKE 'Stev%'"

Additional functions directly express select, update, insert, and delete statements or handle data type conversions (such as parsing SQL datetimes).

Functional

Another addition to Artful Code’s module list is the functional module. This library provides some basic conditionals that make use of match to process data. These macros express program logic by associating blocks of code with the structure of data.

Here is an example using match-case. match-case accepts a single expression and a series of forms that describe what to do based on its structure. Each case form consists of a match expression, a list of variables to be locally bound to the result of the match, and an individual form to evaluate in a local scope with the matched variables bound:

(let ((x '(1 2 3 4 5)))
    (match-case x
        ((? ? ?) (a b c)
         (println "a b and c do not get bound here, because they do not match x"))
        ((? ? ? *) (a b c d)
         (println "a = 1, b = 2, c = 3, and d = '(4 5)"))))

Here, the second block would match because (? ? ? *) matches against (1 2 3 4 5) and creates the binding association, ((a 1) (b 2) (c 3) (d (4 5))).

Also included in the module is match-cond, which is more powerful than match-case. match-cond works like cond, except that instead of a user-defined conditional, the first form in each case is a list of pattern, symbol-list, and target. See the documentation for more details.

Edit (2009-02-16): the functional module in mentioned in this post has been replaced with the matching module.

Submit article

Common Lisp’s destructuring-bind uses unification to bind local variables, much like let. Given a list of arbitrary depth, destructuring-bind can “extract” its elements and bind them in a lexical block.

(setf lst '("foo" "bar" ("baz" "bat")))
(destructuring-bind (a b c) lst
    (format t "~A, ~A, and ~A" a b c))
; => foo, bar, and (baz bat)

newLISP has a unification function and a bind function that can do much the same thing.

(set 'lst '("foo" "bar" ("baz" "bat")))
(bind (unify '(A B C) lst))
(println A ", " B ", and " C)
; => foo, bar, and ("baz" "bat")

Unfortunately, attempting to use a unification in a local scope does not work so easily:

(let (unify '("foo" "bar" ("baz" "bat")))
    (println A ", " B ", and " C))
; => symbol is protected in function let : unify

This can be worked around with a macro and letex, which provides similar functionality to Common Lisp’s macro template syntax (except that it uses quoted, locally bound symbols, rather than backticks to insert values):

(define-macro (destructuring-bind)
  (letex ((unifier (args 0))
          (target (args 1))
          (body (rest (rest (args)))))
    (let unifier
      (bind (unify 'unifier 'target))
      (dolist (expr 'body)
        (eval expr)))))

This is a reasonable approximation of the CL destructuring-bind macro, although don’t try and pass (args) directly to it (this is a limitation of macros in newLISP; (args) would evaluate to a list of destructuring-macro‘s arguments, not the calling function’s.

This implementation locally initializes the variables to be unified to nil and then binds them to the result of unify. Once bound, it iterates over the expressions in the body of the form.

cond can be used to match against various patterns of arguments passed to a function:

(define (foo)
    (cond
        ((unify '(A B C) (args)) (do something))
        ((unify '(A B) (args)) (do something else))))

This makes routing of different arities possible, but not convenient. With a couple of macros, we can go a step further and create a destructuring-case conditional that accepts the target list for unification and a series of conditionals, as with cond:

(define-macro (cond-form)
  (letex ((target (eval (args 0)))
          (unifier (nth 0 (eval (args 1))))
          (body (nth 1 (eval (args 1)))))
         '((unify 'unifier 'target)
            (destructuring-bind unifier target
              body))))
 
(define-macro (destructuring-case)
  (letex ((target (first (args))) (conditions (rest (args))))
         (eval (cons cond (map (fn (c) (cond-form target c))
                               'conditions)))))
 
(set 'lst '("foo" "bar" ("baz" "bat")))
(destructuring-case lst
  ((A B C) (println A ", " B ", and " C))
  ((A B) (println A " and " B))
  ((A) (println A)))
 
; => foo, bar, and ("baz" "bat")

Although this does not permit a function to be defined multiple times in terms of its arity, it does enable equivalent functionality, albeit within the function body:

(define (test)
  (let ((params (args)))
    (destructuring-case params
      ((A B C) (println "Case 1: " A ", " B ", and " C))
      ((A B) (println "Case 2: " A " and " B))
      ((A) (println "Case 3: " A)))))
 
(test "foo" "bar" '("baz" "bat"))
; => foo, bar, and ("baz" "bat")

Links:

• unification
• unify (newLISP)
• destructuring-bind

Submit article

Python’s partial() is contained in the functools module (included since Python 2.5, I believe). The first argument passed must be the function to be curried, and the rest are positional or keyword arguments that will be used to curry the passed function.

A common case where partials are useful is in defining a compare function for a list. It often happens that the list must be sorted according to rules defined at runtime. A partial application can simplify the process, especially if there is a complex sort algorithm. Assume a list of Items, items. The list will be sorted according to get_sort_attribute(), which returns the name of the attribute of Item which will be used to perform the sort, and get_sort_direction, which returns either “desc” or “asc.” Rather than using a long series of if/else statements and calling the sort() method in various ways, partial() can be used to progressively modify the sort.

To sort a list this way, we might have something like:

(def compare(a, b):
    attr = get_sort_attribute()
    dir = get_sort_direction()
    value_a = getattr(a, attr)
    value_b = getattr(b, attr)
    if dir == 'desc':
        return cmp(value_b, value_a)
    else:
        return cmp(value_a, value_b)
items.sort(compare)

This can get pretty long-winded, especially if our function, compare, performs complex operations before performing the comparison. Here is the same thing using partial applications to compose our function instead:

from functools import partial
 
# Wrap getattr in a lambda so that can accept keyword arguments
attribute_getter = partial(lambda object, name:
    getattr(object, name), name=get_sort_attribute())
sort_fn = partial(items.sort, key=attribute_getter)
if get_sort_direction() == 'desc':
    sort_fn = partial(sort_fn, reversed=True)
sort_fn()

This is certainly more concise. I found a nice little currying function for Javascript here (edit: it was pointed out in a reader’s comment (here and at dzone) that this version of curry does not work on previously curried functions; below it is a modified version which will function as expected):

/*
function curry(fn, scope) {
    var scope = scope || window;
    var args = [];
    for (var i=2, len = arguments.length; i < len; ++i) {
        args.push(arguments[i]);
    };
    return function() {
        /* one big problem here is that the following statement
        is not returning the applied function. */
        fn.apply(scope, args);
    };
}
*/
 
function curry(fn, scope) {
    var scope = scope || window;
    var args = [];
    for (var i = 2; i < arguments.length; i++) {
        args.push(arguments[i]);
    }
    return function() {
        // this takes care of the arguments problem
        var fn_args = [];
        for (var i = 0; i < args.length; i++) {
            fn_args.push(args[i]);
        }
        for (var i = 0; i < arguments.length; i++) {
            fn_args.push(arguments[i]);
        }
        // this takes care of the null return problem
        return fn.apply(scope, fn_args);
    };
}

I often use this in my Django web projects. I will include a basic error function which inserts an error message into an element with a particular id on the base template. Note that I use jQuery in the following examples.

function err(target, msg) {
    $('#' + target).html(msg);
}

In templates that extend that template, I can then use currying to modify that for a particular location defined in this template:

var err = curry(err, window, 'err_div_in_this_template');

I can further use this to create custom error callbacks for ajax functions:

var err404 = curry(err, window, "The server could not be contacted.");

Now, err404 is the equivalent of:

function err404() {
    $('#' + 'err_div_in_this_template').html("The server could not be contacted.");
}

Obviously, this is a pretty trivial example, but it does a good job of showing a real-world use for currying.

Submit article

My previous experience with Java was as a less experienced programmer and I had some difficulty with the type system. I learned on dynamically typed languages. My first experience with static typing was in modern functional languages, where type was inferred automatically by the compiler. Explicit type declarations felt archaic and overly wordy.

My experience this time around, however, was more positive. This is primarily due to three factors.

NetBeans

NetBeans is Sun’s Java IDE. Because it is mostly limited to Java, its syntax formating is excellent. It takes a lot of code to abstract the ability of an IDE to format multiple languages (in particular, the ability to format both C-style languages and Lisp-style languages using the same application primitives presents difficulty). NetBeans has the Apple advantage in this; one language to support means that it can have excellent support for that language. Of course, this means that projects that use multiple languages are more difficult to develop using NetBeans, so perhaps this tradeoff is not worth it.

Java’s self-documentation is very nice, too. NetBean’s code-hinting is superior to most, although it can get in the way.

The GUI builder is also extremely nice. Swig and AWT can be a real trial in a language as wordy as Java (although I think Sun prefers us to call it “explicit.”)

Classes

I initially had some difficulty writing entire programs in objects. Most languages I use that are object oriented are multi-paradigm. Classes are available, but then utilized within functional or procedural code. Because of this, I tend to regard classes as a sort of extra-powerful type struct, only to be used when a type becomes complex enough that the extra work of encapsulated it within a class becomes advantageous.

It’s (unfortunately) common to see new Lisp programmers try to simulate OO in Lisp using closures and hashes (especially if they’ve read a few Paul Graham essays). I don’t particularly see that OO improves Lisp; closures and templates provide roughly the same functionality. Exactly replicating closures in OOP or objects in functional programming would be moot. They are different styles; Java-style programming is as uncomfortable in Lisp as Lisp-style programming is in Java.

While writing my initial applications, though, I realized something: classes are a formalized closure syntax. They are a function that builds functions and closes over their variables.

This freed me to use a style of abstraction in Java that felt much more comfortable to me without the drawback of attempting to use the wrong paradigm for the language. I could now program using classes and objects in a manner consistent with how I mentally model my applications.

Something I missed quite a bit was pattern matching. It is very helpful to declare local variables based on the pattern of the argument(s) passed to a function, but that would not be useful in Java, since the primary type mechanism in Java is the class rather than the list. Method overloading provides much of the same functionality, but idiomatic of Java.

Write once, run everywhere

Lisp pioneered the virtual machine. Lisp is compiled into code that is run within the Lisp interpreter. But Lisp is not commonly installed on computers, so distribution of Lisp software becomes a real challenge. One of the advantages of having a huge amount of money behind a language is that Java is installed on virtually every computer a program may end up on.

It’s common in Lisp to have to code various parts of the program differently depending on the operating system and Lisp distribution. For example, very few Lisps support multi-threading on OSX. It makes it agonizing to write threaded software for a multi-platform application.

Java does not have this problem. A feature is available on all platforms or none at all. While this means that the language sometimes suffers from the lack of a particular feature, it also means that there is a guarantee against discovering too late that a feature used in the core of your program will not limit its utility on other operating systems.

Conclusion

Java is better than I had given it credit for. With NetBeans taking care of checking your work for you, I am beginning to suspect that the many buggy Java programs are due to poor programming rather than a problem inherent in Java itself.

I still have some doubts as to how useful it would be for a very large project; my experience has been that object orientation and inheritance results in unnecessary complexity.

For small projects and GUI applications, though, Java seems to be a fair choice.

Submit article

What is functional programming?

Functional programming is a programming technique based on lambda calculus that stresses application of functions to data (or other functions) and side-effect-free programming style. This contrasts with imperative programming, the style used in C, Java, PHP, Python (well, sometimes) and others, which emphasizes declarations that change the state of data (known as destructive functions in functional programming).

Immutable state

In an imperative program, a variable is declared, and then the value of that variable is modified to produce the changes desired. For example, in PHP:

$x = 0;
$x++; // x is now equal to 1
$x++; // x is now equal to 1

In this example, $x is a variable, = is an assignment operator (meaning a sort of function that changes the state of the left-hand-side expression, which typically must be a variable of some sort), and ++ is the postfix increment operator (an operator that increases the value of variable by one).

In strict functional programming, the value assigned to x would be immutable. Attempting to change it would cause an error. The only way to represent a value that is based on the value of x would be to use a function that accepts x as a parameter. For example, using Erlang:

n_plus_two(N) -> N + 2.
X = 0.
Y = n_plus_two(X).

Although a bit contrived, this example shows how a new variable must be created if the incremented value of X is to be stored. However, in many cases, storing a variable is not necessary. Often, temporary storage inside a local variable (such as a let expression or function scope) is all that is necessary.

Application of functions

Functional languages are often expression-based. This means that everything is an expression, as opposed to imperative languages in which expressions are typically permitted only on the right-hand side of an operator. In functional programming, functions are applied to their arguments. For example, the following expressions produce the same result in newLISP:

(+ 1 2 3 4 5) ; => 15
(apply + '(1 2 3 4 5) ; => 15

In fact, what apply is actually doing is breaking down the list into smaller chunks and applying the function, +, to each set:

(+ (+ (+ (+ 1 2) 3) 4) 5)

Another useful function is map. Map applies a function to all elements in a list. Lambdas are extremely helpful when mapping to a list. For example:

(map (fn (n) (+ 1 n)) '(1 2 3 4 5)) ; => '(2 3 4 5 6)

Applicative programming is helpful for collecting and filtering from lists as well. The newLISP function filter removes all elements from a list for which the passed function does not evaluate non-nil.

(filter (fn (n) (string? n)) '(1 2 "three" "four" 5)) ; => ("three" "four")

Currying / partial applications

Another handy technique common to functional languages is currying. Curry is a function that returns a function (or a higher order function, as it is known in functional languages). In many functional languages, currying is built in. Here is an example in OCaml:

let add_numbers x y = x + y;;
let increment_by_ten = add_numbers 10;;
let x = increment_by_ten 5;; (* => 15 *)

In this example, the function add_numbers takes two numeric arguments (in OCaml, they must specifically be integers). increment_by_ten takes the function, add_numbers, and associates the first argument with 10. The function returned by this currying operation looks like this:

let increment_by_ten 10 y = 10 + y;;

This is called implicit currying, or partial application. In languages like newLISP, currying is a function:

(define (add-numbers x y) (+ x y))
(set 'increment-by-ten (curry add-numbers 10))

Recursion

Recursion is another technique commonly used in functional programming. A recursive function calls itself. This is the equivalent of a loop in an imperative language (arguments about efficiency aside). To add a series of numbers using imperative syntax, iteration would be necessary. For example, in Python:

def sum(*args):
  n = 0
  for x in args:
    n = n + x
  return n
sum(1,2,3,4,5) # => 15

Here is an example in newLISP of a sum function that uses recursion to add a list of arguments:

(define (sum list-of-ints)
  (cond
    ((null? list-of-ints) 0)
    (true (+ (first list-of-ints) (sum (rest list-of-ints))))))
(sum '(1 2 3 4 5)) ; => 15

The important thing to remember with recursion is that each application of the function must test its arguments. For example, if a function applies itself to every argument in a list, it needs to test the list for length with every recursion (the cond, (null? list-of-ints), in the example). This is called the base case. The base case stops the function from an infinite loop by defining the conditions under which the function stops. Recursion is a powerful and elegant technique that can seriously reduce the amount of code it takes to create an outcome.

To get a better hold on these concepts, here are some concrete examples. First, we will show the imperative solution, then we will show how to implement the same result using functional techniques.

Growing a string

This is a common task in scripting languages, especially web programming and database operations. Let’s build a simple SQL query using the global constant, ‘table’ and a list of strings, ‘fields’.

PHP:

$table = "address_book";
$fields = array("id", "first_name", "last_name", "phone", "email");
$sql = "SELECT";
foreach ($fields as $i => $field)
{
  $sql = $sql . "`$table`.`$field`";
  if ($i < count($fields))
  {
    $sql = $sql . ", ";
  }
}
$sql = $sql . " FROM $table";

newLISP:
<

(let ((table "address_book")
   (fields '("id" "first_name" "last_name" "phone" "email")))
  (format "SELECT %s FROM %s"
    (join (map (fn (field) (format "`%s`.`%s`" table field)) fields) ", ")
    table))

Formatted output from a list

We want to build an HTML table from the results of the query we just formed. We have the data in an array (using mysql_fetch_array() in PHP, for example), $results.

PHP:

echo "<table><tr>";
foreach ($fields as $field)
{
  echo "<th>$field</th>";
}
echo "</tr>";
foreach ($results as $row)
{
  echo "<tr>";
  foreach ($row as $value)
  {
    echo "<td>{$value}</td>";
  }
}
echo "</table>";

newLISP:

(let ((row-format (curry format "<tr>%s</tr>"))
      (field-format (curry format "<th>%s</th>"))
      (value-format (curry format "<td>%s</td>")))
     (println (format
       "<table>%s%s</table>"
       (row-format (join (map field-format fields)))
       (join
         (map row-format
           (map join
             (map (curry map value-format) results)))))))

Notice the currying of map to the already-curried value-format in the second example.

Common pitfalls

Infinite recursion

Always remember the base case in recursive functions. There has to be a stopping point!

Efficiency

In functional languages, functions are first class objects that can be manipulated, curried, returned from other functions and passed as arguments to other functions. Because calling a user-defined function incurs a certain amount of overhead, using a lambda with a function such as map can create efficiency issues. The cost of applying a first class object over and over is typically higher than that of an imperative loop.

Different languages have different solutions to this. Many functional languages (in particular, Schemes and MLs) optimize tail recursion (this is recursion where the final action of a function is the recursive call) by converting it into a loop in the lower level language. newLISP does not do this. Instead, it offers iterative expressions (such as for, while, dolist, et al) that avoid the problem altogether, since imperative loops can be used in almost all tail recursions.

Expressiveness

Map is a very expressive function.
(map println '("Hello" "world")) is certainly more expressive than foreach ($words as $word) { echo $word . "\n"; }. However, in deeply nested lists, mapping a function deeply can create difficult-to-read code. In these situations, it is better to create either locally curried function definitions or use an imperative control structure instead.

Remember the mantra: expressive, efficient, elegant, then idiomatic.

Submit article