+"(defmacro! or (fn* (& xs) (if (empty? xs) nil (if (= 1 (count xs)) (first xs) (let* (condvar (gensym)) `(let* (~condvar ~(first xs)) (if ~condvar ~condvar (or ~@(rest xs)))))))))"
+```
+
+For extra information read [Peter Seibel's thorough discussion about
+`gensym` and leaking macros in Common Lisp](http://www.gigamonkeys.com/book/macros-defining-your-own.html#plugging-the-leaks).
+
+
+#### Optional additions
+
+* Add metadata support to other composite data types (lists, vectors
+ and hash-maps), and to native functions.
+* Add the following new core functions:
+ * `time-ms`: takes no arguments and returns the number of
+ milliseconds since epoch (00:00:00 UTC January 1, 1970), or, if
+ not possible, since another point in time (`time-ms` is usually
+ used relatively to measure time durations). After `time-ms` is
+ implemented, you can run the performance micro-benchmarks by
+ running `make perf^quux`.
+ * `conj`: takes a collection and one or more elements as arguments
+ and returns a new collection which includes the original
+ collection and the new elements. If the collection is a list, a
+ new list is returned with the elements inserted at the start of
+ the given list in opposite order; if the collection is a vector, a
+ new vector is returned with the elements added to the end of the
+ given vector.
+ * `string?`: returns true if the parameter is a string.
+ * `number?`: returns true if the parameter is a number.
+ * `fn?`: returns true if the parameter is a function (internal or
+ user-defined).
+ * `macro?`: returns true if the parameter is a macro.
+ * `seq`: takes a list, vector, string, or nil. If an empty list,
+ empty vector, or empty string ("") is passed in then nil is
+ returned. Otherwise, a list is returned unchanged, a vector is
+ converted into a list, and a string is converted to a list that
+ containing the original string split into single character
+ strings.
+* For interop with the target language, add this core function:
+ * `quux-eval`: takes a string, evaluates it in the target language,
+ and returns the result converted to the relevant Mal type. You
+ may also add other interop functions as you see fit; Clojure, for
+ example, has a function called `.` which allows calling Java
+ methods. If the target language is a static language, consider
+ using FFI or some language-specific reflection mechanism, if
+ available. The tests for `quux-eval` and any other interop
+ function should be added in `quux/tests/stepA_mal.mal` (see the
+ [tests for `lua-eval`](../lua/tests/stepA_mal.mal) as an example).
+
+### Next Steps
+
+* Join the #mal IRC channel. It's fairly quiet but there are bursts of
+ interesting conversation related to mal, Lisps, esoteric programming
+ languages, etc.
+* If you have created an implementation for a new target language (or
+ a unique and interesting variant of an existing implementation),
+ consider sending a pull request to add it into the main mal
+ repository. The [FAQ](../docs/FAQ.md#will-you-add-my-new-implementation)
+ describes general requirements for getting an implementation merged
+ into the main repository.
+* Take your interpreter implementation and have it emit source code in
+ the target language rather than immediately evaluating it. In other
+ words, create a compiler.
+* Pick a new target language and implement mal in it. Pick a language
+ that is very different from any that you already know.
+* Use your mal implementation to implement a real world project. Many
+ of these will force you to address interop. Some ideas:
+ * Web server (with mal as CGI language for extra points)
+ * An IRC/Slack chat bot
+ * An editor (GUI or curses) with mal as a scripting/extension
+ language.
+ * An AI player for a game like Chess or Go.
+* Implement a feature in your mal implementation that is not covered
+ by this guide. Some ideas:
+ * Namespaces
+ * Multi-threading support
+ * Errors with line numbers and/or stack traces.
+ * Lazy sequences
+ * Clojure-style protocols
+ * Full call/cc (call-with-current-continuation) support
+ * Explicit TCO (i.e. `recur`) with tail-position error checking