Loopless Manual

This manual documents Loopless, which contains utilities that provide a compelling alternative to LOOP for the vast majority of its use-cases. Most of these utilities are straightforward to learn and use, and are consistent in style with other standard Common Lisp constructs. All of them are easily composable with the rest of the language, unlike LOOP's monolithic approach.

The project's home is http://www.loopless.org.

Originally authored by Jean-Philippe Paradis <hexstream@gmail.com>.

This project is in the public domain.
See the Unlicense appendix for details.

• Introduction: This will give you a good idea of what Loopless is and why it exists.
• LOOP --> Loopless: Several examples of loop --> Loopless conversion.
• Reference: This comprehensively documents all utilities provided by Loopless.
• Unlicense: Loopless and its manual are in the public domain.
• Avoiding Conflicts: Loopless exports a few symbols which may cause conflicts.
• Star Suffix: Several Loopless utilities have ‘*’ as a suffix. Here's why.
• Index: An entry for each Concept, Function and Macro.

--- The Detailed Node Listing ---

Introduction

• Loopless over LOOP: What's wrong with loop? How can Loopless help you avoid its usage or reject it outright?
• Utilities: An overview of the utilities provided by Loopless.
• Getting Started: How to load Loopless.

Converting from loop to Loopless style

• Alists and Plists: How to process alists (both types) and plists elegantly and uniformly.
• COLLECTING/WITH-COLLECTORS: Easy and efficient accumulation of values into one or multiple lists.
• FOR* Examples: for* lets you use loop's ``for-as-arithmetic'' and ``for-as-equals'' anywhere.
• Trivial Operators: Examples for while*, dovector, and other intuitive operators.
• Advanced Examples: Combining several Loopless utilities to tackle more complex scenarios.

Loopless Reference

• Quick Reference: A table with a tiny description of each symbol exported by Loopless.
• MAPCAR-like Functions: Mapping functions following the lead of mapcar and friends.
• DOLIST-like Macros: Iteration macros following the lead of dolist and friends.
• Collection Macros: Easy and efficient collection of values into one (or multiple) list(s).
• FOR*: Use a subset of loop's for clause to step variables in conjunction with any looping construct whatsoever.
• WHILE*: Execute an implicit tagbody repeatedly while a condition holds true.
• COMPOSE: Takes a list of functions and returns a function that will pass its argument ``through'' those functions when called.

mapcar-like Functions

• Overview: There's an handy summary table of mapcar-like functions here.
• MAPALIST[*] and friends: Map over alists, whether ``cdr-valued'' or ``cadr-valued''.
• MAPPLIST and friends: Map over plists.
• MAPVECTOR and friends: Map over vectors.
• MAPTIMES[*] and friends: Map over integers, with or without an iteration argument.

dolist-like Macros

• Overview: There's an handy summary table of dolist-like macros here.
• DOCONS: Iterate over the conses of a list.
• DOALIST[*]: Iterate over an alist, whether ``cdr-valued'' or ``cadr-valued''.
• DOPLIST: Iterate over a plist.
• DOVECTOR: Iterate over a vector.
• DOTIMES*: Same as dotimes but without an iteration variable.

Collection Macros

• COLLECTING: Collect values into a list efficiently, then return that list.
• WITH-COLLECTORS: Collect values into multiple lists efficiently, then return those lists as multiple values.