I have to admit that I occasionally resort to goto myself. This week was one such an occasion. But before you pick up your torch and farming implement of choice and join the mob heading for my castle gates, please consider that  Dijkstra’s letter was complaining about unrestricted goto, which was a popular feature of languages at the time. It was an unstructured precursor of the subroutine and structured programming, which put goto on a leash and taught it not to bark at the neighbors. In restricting goto to local jumps, as most modern languages supporting the feature do, the beast became much less fearsome. In fact, a while loop is just a structured goto, as is try/catch (albeit with a little extra magic.)

Perl, of course, does not impose such restrictions on a programmer (although it does prohibit jumping into blocks that require initialization, such as other functions.) With a little discipline, though, goto is a feature and quite useful. It can be used to make extremely complex loops explicit and easy to follow as well as allow a loop to break to any outer loop in the current call stack.

As an example, I recently wrote a function to increment a string of arbitrary alphanumeric characters, where letters must maintain their case but increment as base-26 numbers and numbers increment normally (base 10). For example, if a letter increments past z, it becomes a and the next character to the left is then incremented. The increment logic fit into a function that took two of these strings and calculated all possible values in between to support some limited set operations against two alphanumeric ranges.

My original code for the increment logic was grisly at best. It took a series of nested while loops and state variables that were incremented or decremented as needed. I avoided recursion because the sequences were of arbitrary length. Breaking the code into subroutines made it more complex to maintain loop state. Using goto allowed me to break apart the logic into blocks without the overhead or state-passing necessary to shoehorn the logic into subroutines. I was able to label each part clearly and jump between them as needed to increment or “carry the 1.” I reduced the size of the code to just a couple dozen lines, including safety checks, and found that the goto code was much easier to read and reason about.

That said, I want to emphasize strongly that goto should be kept local. Jumping to outer function calls makes the logic of a program difficult to reason about and changes scope in confusing ways. But as a way of structuring complex loops and iterative logic, you just can’t beat goto.

Submit article

What I like about TextMate

Let me repeat that I like TextMate. I have happily used it for years. It has some wonderful features. It is reasonably fast and its indentation is great. It has a great selection of plugins for a wide variety of languages and is easy to extend with new language modules. It has a decent macro system based on regular expressions that, while not nearly as powerful as scripted editors, provides 80% of what most users need.

Problems with TextMate

TextMate, for all its sterling qualities – and there are many – has a few problems that, while not deal-breakers in themselves, together provide a less-than-satisfactory experience.

Split-windows

This is a rather stark issue, and is a feature that has been promised in the next release. Nevertheless, its absence often means either filling my screen with open TextMate windows or firing up emacs when I need to look at many files at once – or many parts of the same file at once. C, in particular, tends toward long functions, and is especially painful to write in TextMate.

Large files

TextMate handles many open files well, but a single large file will hang the entire application. I can accept a large file taking a long time to load, but please! Load the file in the background, so that I can keep working. Even opening a large file in a second window blocks the entire application. Find and replace also choke on larger documents, sometimes taking minutes to complete.

Key-bindings

TextMate’s key-bindings can be puzzling. Many common commands (especially in Python), such as converting between spaces and tabs in a document, don’t have bindings and are several levels deep in the menu. Other commands of dubious utility are given simple bindings, such as “Execute line/selection inserting result” (control-R.) Many have extremely difficult combinations, such as control-alt-command-D to toggle to project drawer, or control-option-shift-P to toggle text mode (and then – because several bundles use this same key-binding, god knows why – you are given a drop-down to choose which command you wanted.)

Choosing a new editor

I was initiated into the cult of emacs in college and have used it for several years. I’ve played with BBEdit (which I think is horribly cluttered and completely lost in the pre-OSX world), NetBeans, and Eclipse (which is, amazingly, slower and clunkier than NetBeans.) I love emacs’ extensibility and its indentation is second to none. It suffers from the key-binding issue as well, though. Becoming efficient in emacs is a journey, not a destination. I find myself spending more time navigating its arcane and bureaucratic configuration system than actually writing code in it.

NetBeans in some ways seems very polished, and the new Python module is very good (I have written about this before.) Refactoring across files is extremely useful. It has good debugger integration. Unfortunately, tight integration with any particular language costs a great deal in load times and can lead to an unresponsive UI. And for god’s sake – why does it have to be such a chore to open a file outside of a project?

Panic’s Coda is pretty and has some neat features, but in the end, SubEthaEdit (its editor) has poor syntax support and its extension system feels very clunky. Editra is nice, but slow and buggy on OSX.

Vim

After a disappointing look around the net for better choices, I decided to give Vim another try. I had a passing familiarity with some of its basic functionality from my days as a system administrator, it is scriptable, and it has a large number of plugins for syntax support.

Lack of distractions

Overall, I am satisfied with Vim’s minimalism. Its indentation is pretty second rate, but I can live with it. Vim feels extremely comfortable. Over the years, Vim has gently washed away all of the “features” of an editor that actually get in the programmer’s way and come up with a system that drastically increases productivity and makes coding a more satisfying experience.

Load speed

While not the primary measure of an editor, load time is important. How many programmers (myself included) give up on Eclipse or NetBeans right away because it takes more than half a minute to start up? Load time is one of those things that, while really just an annoyance, can completely color the experience of using a program. Vim loads quickly. It is one less thing to get in the way of productivity.

Efficiency

Nothing beats Vim for efficiency. If you ever wonder why so many applications have modes that mimic Vim, it is because once you learn Vim’s bindings, there is nothing faster. Jumping around a file with precision is a breeze. Coming from emacs, I expected it to take a lot longer to become comfortable with Vim’s style and bindings, but it has a much milder learning curve than emacs. Search and replace is also fast and easy to use. I quickly found myself giving up MacVim in favor of the command line. Copy and paste – the biggest barrier to command-line editors for me – is fast and easy with Vim’s visual mode.

Other features

Vim 7 has auto-complete, although I rarely use it. I’m much more comfortable with an enormous stack of O’Reilly books. Vim’s code folding is also very nice. I generally turn code folding off because it slows most editors down so drastically, but it does not appear to affect Vim.

Two of Vim’s features really stand out for me: reformatting text and retabbing a document. I love being able to convert a file’s tabs to spaces just by typing :retab. It is much more efficient than having to go through two levels of menus in TextMate. And being able to reformat Python doc strings is very useful. It removes an annoyance that can make updating documentation a real chore.

Conclusion

Vim strikes the perfect balance for me. At first glance, it seems archaic, especially for those born after the mouse became standard. After a few days of using it, though, I find myself enabling Vim bindings mode in any application that has it, using the Vimperator plugin for Firefox, and wishing that OSX’s terminal was more easily scriptable. If you haven’t used Vim, give it a chance. Coming from a graphic editor like TextMate, it is a much different experience and, arguably, a more satisfying one.

Here are some other folks’ experiences with the transition in both directions:

• Coming home to Vim
• From Vim to TextMate

Edit [2009-08-03 15:50]: added links to similar stories

Submit article

Take this trivial example:

from django.db import models
 
class Sport(object):
    name = models.CharField(max_length=50)
 
class Season(models.Model):
    starts = models.DateField()
    ends = models.DateField()
    sport = models.ForeignKey(Sport)
 
class Team(object):
    name = models.CharField(max_length=100)
    sport = models.ForeignKey(Sport)
 
class Game(object):
    season = models.ForeignKey(Season)
    home_team = models.ForeignKey(Team, related_name="home_games")
    away_team = modesl.ForeignKey(Team, related_name="away_games")

In the admin change form for Game, it is obviously desirable to only permit teams to be selected that match the Season‘s Sport. Unfortunately, because fields are defined on the class rather than the instance (such as inside of __init__), there is no obvious way to create a relationship based on the values in the instance.

Inside the ModelAdmin class is the method get_formset(self, request, obj=None, **kwargs). The parameter obj stores the current instance, if any. The significance of this is that this method is a hook with access to the instance data and is called for every form as it is built.

That makes it possible to filter the Teams based on the current form’s instance.

from django.contrib import admin
from django import forms
from myapp.models import Team, Game
 
def game_form_factory(sport):
    class RuntimeGameForm(forms.ModelForm):
        home_team = forms.ModelChoiceField(label="Home",
                queryset=Team.objects.filter(sport=sport))
        away_team = forms.ModelChoiceField(label="Away",
                queryset=Team.objects.filter(sport=sport))
 
        class Meta:
            model = Game
 
    return RuntimeGameForm
 
class GameAdmin(admin.modelAdmin):
    model = Game
 
    def get_formset(self, request, obj=None, **kwargs):
        if obj is not None:
            self.form = game_form_factory(obj.season.sport)
        return super(GameAdmin, self).get_formset(request, obj, **kwargs)

Here is how it works. When the GameAdmin form is built, get_formset is called. If this is an edit form (add form’s will not have instance data) the Game instance is passed as the obj parameter. In this case, the instance sets the form attribute to be the result of calling game_form_factory, which is a class factory function.

What if we want the Game form to be an inline form for the Season form? The major difference with inline form sets is that the instance passed to get_formset is now that of the parent form, rather than the form set model (in this case, Season instead of Game.)

The class factory function remains essentially unchanged. The Game admin model requires only a small change.

class GameAdminInline(admin.TabularInline):
    model = Game
 
    def get_formset(self, request, obj=None, **kwargs):
        if obj is not None:
            self.form = game_form_factory(obj.sport) # obj is a Season
        return super(GameAdminInline, self).get_formset(request, obj,
                **kwargs)

Submit article

void strtoupper(char *str)
{
    if (str) {  // null ptr check, courtesy of Michael
        while (*str != '\0') {
            // destructively modify the contents at the current pointer location
            // using the dereference operator to access the value at the current
            // pointer address.
            *str = toupper(*str);
            ++str;
        }
    }
}
 
int main()
{
    char my_str[] = "hello world";
    strtoupper(my_str);
    printf("%s", my_str);
    return 0;
}

my_str is actually a pointer to a block of memory holding chars. This allows us to use address math to access indices of the array and modify them using the dereference operator. In fact, an array index such as my_str[3] is identical to the expression *(my_str + 3).

char my_str[] = "hello world";
*my_str = toupper(*my_str);
*(my_str + 6) = toupper(*(my_str + 6));
printf("%s", my_str); // prints, "Hello World"

However, if my_str is declared as a char pointer to the string literal “hello world” rather than a char array, these operations fail:

char *my_str = "hello world";
*my_str = toupper(*my_str); // fails
*(my_str + 6) = toupper(*(my_str + 6)); // fails
printf("%s", my_str);

Let’s explore the difference between the two declarations.

char *a = "hello world";
char b[] = "hello world";

In the compiled program, it is likely that “hello world” is stored literally inside the executable. It is effectively an immutable, constant value. Pointing char *a to it provides the scope with read-only access to an immutable block of memory. Therefore, attempting to assign a value might cause other code that points to the same memory to behave erratically (read this response to the above post on Stack Overflow for an excellent explanation of this behavior.)

The declaration of char b[] instead declares a locally allocated block of memory that is then filled with the chars, “hello world”. b is now a pointer to the first address of that array. The complete statement, combining the declaration and assignment, is shorthand. Dispensing with the array size (e.g., char instead of char[12]) is permitted as the compiler is able to ascertain its size from the string literal it was assigned.

In both cases the pointer is used to access array indices:

int i;
for (i = 0; a[i] != '\0'; ++i)
    printf("%c", toupper(a[i]));

However, only with b is the program able to modify the values in memory, since it is explicitly copied to a mutable location on the stack in its declaration:

int i;
for (i = 0; b[i] != '\0'; ++i)
    b[i] = toupper(b[i]);
printf("%s", b);

Submit article

Storing sessions in a database is a good solution. Backups are easier; persistence and pruning orphaned sessions are simpler. Security is available through the database server’s security. We will use MySQL, since it is the best supported in newLISP.

Setting up the database

First, we need a table in which to store session data. Using a MySQL TIMESTAMP column will provide us with an automatically updating time stamp on the last modification of the session, which we will use below to find old sessions to remove.

CREATE TABLE sessions (
	sid VARCHAR(255) PRIMARY KEY,
	DATA TEXT NOT NULL,
	ts TIMESTAMP
)

Designing the storage module

Several functions need to be defined to handle storing data. First, we must ensure that the MySQL module is loaded and initialized. We will do this in a separate module that we will call DBSessions.

(context 'DBSessions)
 
(unless (sym "MYSQL" 'MySQL nil) ; do not reinitialize if already loaded
  (module "mysql5.lsp") ; with newlisp 10.1, this will change to "mysql.lsp"
  (MySQL:init)
  (MySQL:connect "127.0.0.1" "user" "secret" "somedb"))
 
(context 'MAIN)

Next, we define a function to create or resume a session from the database. Sessions are stored in memory as contexts, making our job easier. Our function will query MySQL to see if the session id exists, and either create a new session and insert it or retrieve an existing session and load it. The function Web:session-id gives us the current session id from the session cookie or creates a new one and sends the client a cookie to store it. Web:session-context returns a symbol pointed to the context storing the current session.

(define (open-session)
  (when (MySQL:query (format "SELECT data FROM sessions WHERE sid = '%s'" (MySQL:escape (Web:session-id))))
    (let ((data (MySQL:fetch-row)))
      (if data
        ;; Evaluate the serialized context into the current session context
        (eval-string (first data) (Web:session-context))
        ;; Create a new session and save it
        (MySQL:query (format "INSERT INTO sessions (sid, data) VALUES ('%s', '%s')"
          (MySQL:escape (Web:session-id))
          (MySQL:escape (source (Web:session-context)))))))))

Next, we need a function to write any changes to the session to storage. Since the session is stored as a context, this is quite simple.

(define (close-session)
  (MySQL:query (format "UPDATE sessions SET data = '%s' WHERE sid = '%s'"
    (MySQL:escape (source (Web:session-context)))
    (MySQL:escape (Web:session-id)))))

We also need a function to delete entire sessions when necessary. This is also simple.

(define (delete-session)
  (MySQL:query (format "DELETE FROM sessions WHERE sid = '%s'"
    (MySQL:escape (Web:session-id)))))

Finally, a function to cull old sessions from the database. For this, we use the variable Web:SESSION_MAX_AGE to determine which sessions have expired.

(define (clean-sessions)
  (MySQL:query (format "DELETE FROM sessions WHERE NOW() >= DATE_ADD(ts, INTERVAL %d SECOND)"
    Web:SESSION_MAX_AGE)))

Registering the handler in Web

Last, the handler functions need to be registered in the Web module.

(Web:define-session-handlers
  open-session close-session delete-session clean-sessions)

Putting it all together

(unless (sym "MYSQL" 'MySQL nil) ; do not reinitialize if already loaded
  (module "mysql5.lsp") ; with newlisp 10.1, this will change to "mysql.lsp"
  (MySQL:init)
  (MySQL:connect "127.0.0.1" "user" "secret" "somedb"))
 
(context 'DBSessions)
 
(define (open-session)
  (when (MySQL:query (format "SELECT data FROM sessions WHERE sid = '%s'" (MySQL:escape (Web:session-id))))
    (let ((data (MySQL:fetch-row)))
      (if data
        ;; Evaluate the serialized context into the current session context
        (eval-string (first data) (Web:session-context))
        ;; Create a new session and save it
        (MySQL:query (format "INSERT INTO sessions (sid, data) VALUES ('%s', '%s')"
          (MySQL:escape (Web:session-id))
          (MySQL:escape (source (Web:session-context)))))))))
 
(define (close-session)
  (MySQL:query (format "UPDATE sessions SET data = '%s' WHERE sid = '%s'"
    (MySQL:escape (source (Web:session-context)))
    (MySQL:escape (Web:session-id)))))
 
(define (delete-session)
  (MySQL:query (format "DELETE FROM sessions WHERE sid = '%s'"
    (MySQL:escape (Web:session-id)))))
 
(define (clean-sessions)
  (MySQL:query (format "DELETE FROM sessions WHERE NOW() >= DATE_ADD(ts, INTERVAL %d SECOND)"
    Web:SESSION_MAX_AGE)))
 
(Web:define-session-handlers
  open-session close-session delete-session clean-sessions)
 
(context 'MAIN)

Submit article

The official CGI module has some real issues. First, it combines POST and GET variables into a single structure. This has two serious consequences: 1) the application has no way to determine the method by which a parameter is passed (that information is completely lost), and 2) name clashes between GET and POST result in the loss of one or the other parameter (in the case of the CGI module, GET information would be overwritten.)

Another issue in the CGI module is with the put-page function, which breaks if “%>” is used inside of a code island, even legitimately, such as in a string.

Web fixes both of these problems and provides a number of other features, including:

• ASP/PHP-style templates
• Getting/setting cookies, GET, and POST parameters
• Entity encoding and decoding
• HTTP header control
• Sessions
• Custom session storage
• URL building and parsing
• URL encoding and decoding
• Query string building and parsing

Additionally, Web does not suffer from the GET/POST issues that the CGI module does, nor does it mishandle tags inside of code.

HTTP Headers

Headers are set using Web:header, which accepts two parameters – the header name and the header value. By default, one header is already set: Content-type: text/html. Headers are output using Web:send-headers, which is called before any other output. The convenience function Web:redir redirects the browser to the passed URL.

GET and POST

GET and POST variables are accessed using Web:get and Web:post, which may be called in two ways. When called with a single parameter, these functions act like lookup and return the GET/POST parameter with the named key. When called with no parameters, they return an association list of the corresponding query.

Cookies

Cookies must be set before headers are sent. They are set using the Web:cookie function, which accepts up to six parameters.

;; Set a basic cookie
(cookie "foo" "bar")
;; Access a cookie value
(cookie "foo")
;; Delete a cookie by setting expires to now
(cookie "foo" nil (date-value))
;; Set a cookie that expires in an hour
(cookie "foo" "bar" (+ (date-value) (* 60 60)))

See the documentation for a full list of accepted parameters.

Sessions

By default, sessions use file-based storage (located at /tmp). They are controlled with a few simple functions. The default exit function is wrapped to ensure that Web:close-session is called at the end of a script (at least, a script that calls exit at its end.)

(Web:open-session)
(Web:session "foo" "bar") ; store "foo" as "bar"
(Web:send-headers) ; start output
(println "<p><strong>foo is:</strong> " (Web:session "foo") "</p>")
(exit 0)

It is a simple matter to design and use custom storage handlers. The function Web:define-session-handlers allows customization of which functions are called to begin/load, close/write, delete a session, and clear old sessions. See the documentation for a list of helpful functions and variables for custom storage handlers.

Templates

Templates work almost identically to the official CGI module, with a few differences. First, Web:eval-template is called with a string, rather than a file, to permit other storage methods and programmatic building of templates. Second, <%= .. %> may be substituted for the default opening tag as a shortcut for <% (print … ) %>. Last, the opening and closing tags may be customized by setting values of Web:OPEN_TAG and Web:CLOSE_TAG. The shortcut tag will always be Web:OPEN_TAG appended with and equal sign.

Encoding and decoding

There are several functions to make encoding, decoding, and escaping strings easier for dealing with URLs, javascript, and HTML entities.

Web:escape takes a string and encodes the basic HTML character entities (apostrophe, quote, ampersand, and left and right angle brackets.) Web:unescape provides the reverse. The function Web:escape-js does no encoding of entities, but instead ensures that a string may be safely output in javascript string without causing syntax errors.

Web:encode-entities encodes all HTML entities, including a number of entities that are not fully supported by all browser. The full list of entities is derived from Wikipedia. Its reverse, Web:decode-entities, translates entities back into their character equivalents.

The functions Web:url-encode and Web:url-decode deal with hex-encoding/decoding strings for use in URLs.

Query strings are easily created using Web:build-query, modeled after the PHP function http_build_query. Its counterpart, Web:parse-query, takes a query string and turns it into an association list.

For URLs, it is simpler to use Web:build-url, which takes a URL and any number of association lists which it uses to build a complete URL. Each alist may overwrite parameters from the previous, including any parameters on the passed URL.

(let ((url "http://www.artfulcode.net/?s=newlisp"))
  (println (Web:build-url url '(("s" "newlisp web module") ("foo" "bar")))))
;; => http://www.artfulcode.net/?s=newlisp+web+module&foo=bar

It also has a counterpart, Web:parse-url, which breaks a URL up into an association list of its component parts.

Download

You can find it in the repository or download it directly here.

Submit article

PHP was designed with the reverse in mind. In its first release, it could have been considered to be a DSL for web-based applications. It was written to specifically address the needs to writing web applications, and is now building toward a more general purpose language. In all likelihood, this is the wrong way around. It certainly does not fall into the bottom-up design Shangri-La of which Paul Graham is such a proponent.

In reality, though, web-based applications are driving the industry. PHP is still very relevant in that domain. From very early on, PHP was centered on functionality that is considered basic to any web-based framework. Functionality without which each library is simply a thin wrapper over CGI. Features like easy access to GET and POST variables, session handling, header control, and database access have been built into PHP from, if not the beginning, then close enough that dinosaurs like myself don’t remember it ever being otherwise.

PHP has its own share of frameworks, too, which allow the programmer to painstakingly map SQL schema to XML or vice versa. They carefully abstract the logic out of the view and force the programmer to jump through hoops to write a simple application (although, for complex applications, this often makes the programmer’s life *much* easier.)

PHP does not need any of this. In fact, the most pragmatic framework I have used to date for PHP is the Simple PHP Framework, which is just a set of useful classes to automate some of the more tedious areas of web development. What it does not do is get in the programmer’s way. It is Occam’s razor at work in the world of web development. From the SPF website, quoting a non-existent link:

“All the web frameworks in the world won’t turn a shitty programmer into a good one.”

What PHP is not is elegant. It does not have beauty of prose, nor those features that make languages like ML and Lisp so exciting, such as closures, functions-as-objects, or lazy evaluation. Instead, PHP is, above all, a practical language. Instead, it has less sexy features, such as built-in support for XML, XSLT, and Xpath, support most databases, and the built-in ability to serialize to and from JSON and cookie strings.

It is easy to overlook how simple PHP makes many tasks that are complex in other frameworks. For example, Django’s form library is large and complex. I’ve no doubt that most other frameworks have equally Byzantine systems for developing reusable forms. In PHP, one might just write:

function input($type, $name, $display, $value)
{
    < ?
        <label>< ?= $display ?>
        <input type="<?= $type ?/>" value="< ?= $value ?>" />
    ?>
}

The function could be refined to separate the template and the code by putting the HTML into a separate include:

function input($type, $name, $dispaly, $value)
{
    include 'templates/input.inc.php';
}

Simple, right? Which is not to say that PHP’s faults are not legion. That said, I think that PHP sometimes does a better job of building toward general purpose programming than many other languages do of building toward web development.

Submit article

Forms are created by extending the abstract Phorm class. Validation is simple and easy to implement. Django users especially will find Phorms’ validation familiar:

require_once('lib/phorms/phorms.php');
 
function required($value)
{
  if ($value == '' || is_null($value))
    throw new ValidationError('This field is required.');
}
 
class CommentForm extends Phorm
{
  protected function define_fields()
  {
    // Define form fields
    $this->post_id = new HiddenField(255);
    $this->first_name = new TextField("First name", 25, 255, array('required'));
    $this->last_name = new TextField("Last name", 25, 255, array('required'));
    $this->email = new EmailField("Email address", 25, 255, array('required'));
    $this->url = new URLField("Home page", 25, 255);
    $this->number = new IntegerField("Favorite number", 7, array('required'));
    $this->message = new LargeTextField('Message', 5, 40, array('required'));
    $this->notify = new BooleanField('Reply notification');
 
    // Add some help text
    $this->notify->set_help_text('Email me when my comment receives a response.');
    $this->email->set_help_text('We will never give out your email address.');
  }
}

Setting default values is simple:

$form = new CommentForm(Phorm::POST, true, array('post_id'=>42, 'notify'=>true));

And form validation is a breeze:

$valid = $form->is_valid();

Phorm instances serialize to an HTML table and provide methods to open and close the form:

echo $form->open($_SERVER['PHP_SELF']);
echo $form;
echo $form->close();

The Phorms library:

• supports file and image uploads
• has easy to use validation
• is extensible by subclassing the build-in PhormField and PhormWidget classes
• is completely documented with phpdoc

You can download it from my projects page or directly.

Update: fixed a couple bugs and put API docs online.

Submit article

Download it here.

Async provides a simple process pool that allocates a number of worker threads
that may then be utilized collectively without having to deal directly with
threads. Results of jobs sent to the pool are “future” objects, called Asyncs.
Asyncs’ values are then acquired by calling Async.sync, which blocks until the
value has been set by the pool. A supervisor thread monitors the worker threads
and restarts any that terminate abnormally.

Usage is simple:

// create a pool of four processes
Pool pool = Pool(4)
 
// send a job to the pool
Async result = Pool->send(exp, 10);
 
// get the result
result->sync();
// => 22026.46484375
 
// alternately, you can call an async
result();
// => 22026.46484375
 
// pools can conveniently map across a sequence
Async mapped_result = pool->map(exp, enumerate(5));
mapped_result->sync();
// => ({ 1.0, 2.718281745910645, 7.389056205749512, 20.08553695678711, 54.59814834594727 })
 
// or iterate without collecting return values
int x = 0;
pool->iter(lambda (int n) { x += n; }, enumerate(100));
write("%d", x);
// => 4950
 
// close the pool, blocking until all workers have terminated
pool->close();

Submit article