(Note I am talking about my 1common-lisp/0time-iterator.lisp)
On the off chance that it is directly useful, I wrote 40 somewhat daunting
lines of code that directly do roughly what I think C was describing.
Aside from the program being useful, my thinking is to provide a
counterpoint to most date programming online examples. Common lisp in
particular and programming in general sometimes has unreliable commentary by
non-lispers (sez me). I will try to be complete here (more than I think many
people might need).
I installed a lisp compiler, ecl, like this as root:
```openbsd
pkg_add ecl
```
Or on some linuxes:
```gentoo
emerge ecls
```
(I don't know why that s is there)
```debian
apt-get install -y ecl
```
and download my lisp code, time-iterator.lisp. The code has several notes
where number values might like to be changed.
One way of running time-iterator.lisp is like this:
```ksh
ecl --load time-iterator.lisp
```
$ ecl --load time-iterator.lisp
;;; Loading "/path/of/time-iterator.lisp"
date:29 month:12 year:1969
date:1 month:1 year:1970
date:4 month:1 year:1970
date:28 month:1 year:1970
date:31 month:1 year:1970
date:3 month:2 year:1970
date:27 month:2 year:1970
date:2 month:3 year:1970
date:5 month:3 year:1970
date:29 month:3 year:1970
date:1 month:4 year:1970
date:4 month:4 year:1970
date:28 month:4 year:1970
date:1 month:5 year:1970
date:4 month:5 year:1970
$
```
Portability:
At the end of the program I use the ecl compiler's si:quit. In sbcl that
would be sb-ext:quit.
Mechanism:
I (defvar variablename) some variables, or (defparameter parametername) when
value will not be changeable.
Then I (setq variablename new-value) inside a 'let. It's like this (but this
is not useful/from the program)
(defvar *foo*)
(let ((a 3) (b 4))
(setq *foo* (* a b)))
(princ *foo*)
> 12
Let provides locally scoped variables.
In lisp normally everything you write is a list like this:
(function argument argument)
So we know by position in the list that in
(* a b)
#'* is a function and a and b its arguments. Similarly,
(setq *foo* (* a b))
Has the special function #'setq, with the arguements *foo* and (* a b).
Innermost lists are evaluated first.
The loop facility:
I just used #'loop to do almost everything. Loops are kind of like this:
> (loop for x from 1 to 10 by 2 do (princ x) do (terpri) finally (terpri))
1
3
5
7
9
NIL
>
Any whitespace in lisp, including newlines is treated the same. (terpri)
sends a newline to the terminal. Another way to do that loop would be:
> (loop for x in (list 1 3 5 7 9) do (princ x) do (terpri) finally (terpri))
In general there can be lots of fors and lots of dos, and it's common to put
additional loops inside a do.
PS:
A different view on time/date programming in lisp that is well known follows
http://cl-cookbook.sourceforge.net/dates_and_times.html
PPS:
I forgot the most important part. C if you look into lisp, I would love to
know more from Japan about Kyoto Common Lisp (the parent of ECL). The copy-
right on the free software license starts at
Copyright (C) 1984 Taiichi Yuasa and Masami Hagiya
which I guess is why ECL's
> (describe 'get-decoded-time)
includes an explanation that Japan's time zone is -9, and that the year is
Christian and not long-live-Emperor.
