One of the most distinctive features of Common Lisp and Lisp in general, are its code-generation and code-manipulation capabilities.
Probably the best example is the
LOOP macro - a Swiss Army knife of iteration that can do pretty much anything. The following snippet iterates a list of random numbers collecting some statistics of its contents and does that while being very concise and readable:
(let ((random (loop with max = 500 for i from 0 to max collect (random max)))) (loop for i in random counting (evenp i) into evens counting (oddp i) into odds summing i into total maximizing i into max minimizing i into min finally (format t "Stats: ~A" (list min max total evens odds))))
Stats: (0 499 120808 261 240)
Let's suppose we have this class hierarchy:
It's a fairly specialized class hierarchy providing some functionality, let's say for the sake of this example that
SomeClass provides a kind of player-game interaction interface and
HierarchyWith defines it as a trigger based interaction (as in "a player does something - it triggers a response"). Our
ExampleClass represents an entity that can be triggered by the player and that generates some response and in addition to that is further specialised to have some concrete functionality - let's say it's a lever that a player determined enough can pull to flood something with delicious magma. As we clearly can see
ExampleClass is well-defined in terms of OOP, it's highly specialised and modular, but as an in-game entity it lacks a rather crucial functionality - it can't even be displayed on the screen. What do we do now?