Something fun, then! Normally everything I do is extremely
difficult. A friend of mine who is a self-taught qt expert
showed me a poker game he was making. I decided to have a
quick go at it myself. Now, about a decade ago some friends
of mine got excited about Texas Hold 'em. I've never been
to a casino, and I disapprove of them, but I did play some
(free) poker with my friends and kind of know the rules.

I put my working draft in my common lisp directory,
poker.lisp. It requires #:alexandria, the canonical common
lisp extra-standard common functions. Some highlights that
I found not to be well-documented at various place online
(why would you even look at the web at this point):

1. Feeding a string into standard input
```
(let ((string
       (format nil "~@{~a~%~}" "the test" "line strings")))
(with-input-from-string (*standard-input* string)
        (print (read-line))
        (print (read-line))))
```
Remember common lisp has everything: By capturing *standard-
input* with that macro, I have access to lisp's access to
standard input. A related function I didn't use might be:

2. Capturing standard output as a string
```
(let ((string (with-output-to-string (*standard-output*)
              (apropos 'with-output-to))))
(print string))
```
Will of course search all visible namespaces for names with
"with-output-to" in them. This, combined with #'documentation
#'describe and #'inspect are handy introspection.

3. Inspecting namespace contents and documentation in lisp
```
(documentation 'documentation 'function)
(documentation '*standard-input* 'variable)
(documentation 'loop 'function)

(inspect '*standard-input*)
(describe '*standard-input*)
```
As seen on 'loop, #'documentation considers a macro as a
'function. However unstandardized macros with definitions
given by the particular compiler you are using, like
'with-output-to-string are not considered as a 'function
by 'documentation. I would #'macroexpand them and inspect
the component parts, which will be supported by
'documentation. #'apropos and #'inspect are often useful
for those compiler macros.