Or: functor? I 'ardly know 'er!
Monads are difficult to explain without sounding either patronizing or condescending: I would sound patronizing if I came up with some facile analogy and I would be condescending to describe it categorically.
Instead, I'll frame a problem and piece-by-piece solve the problem with what will turn out to be a monad.
| // VERSION 1 - Arrays | |
| // 1 It should have a place to store todos | |
| // 2 It should have a way to display todos | |
| // 3 It should have a way to add new todos | |
| // 4 It should have a way to change a todo | |
| // 5 It should have a way to delete a todo | |
| /*-------------------------------------*/ |
| (in-package #:nlp.embeddings) | |
| (named-readtables:in-readtable rutilsx-readtable) | |
| (eval-always | |
| (rename-package "BKNR.SKIP-LIST" "BKNR.SKIP-LIST" '("SKLIST"))) | |
| (defun gather-freq-dict (vecs dir &key (cutoff 0) (dump-file "/tmp/dict.txt")) | |
| (let ((dict #h(equal)) | |
| (idxs #h(equal)) |
| (defun play-game (max-players last-marble) | |
| (let ((scores (make-hash-table)) | |
| (marbles (deque 0))) | |
| (dotimes (marble (1+ last-marble)) | |
| (case (mod (1+ marble) 23) | |
| (0 (drotate marbles 7) | |
| (incf (gethash (rem marble max-players) scores 0) | |
| (+ 1 marble (popl marbles)))) | |
| (t (drotate marbles -2) | |
| (pushl (1+ marble) marbles)))) |
| (set-dispatch-macro-character #\# #\M #'read-dimensional-number) | |
| (set-dispatch-macro-character #\# #\I #'read-dimensional-number) | |
| (defun read-dimensional-number (s c n) | |
| (declare (ignore n)) | |
| (let* ((prev-case (readtable-case *readtable*)) | |
| (val (unwind-protect | |
| (progn (setf (readtable-case *readtable*) :preserve) | |
| (symbol-name (read s nil))) | |
| (setf (readtable-case *readtable*) prev-case))) |
RUTILS is split into two parts: core (package rutils) and contrib (package rutilsx). These are aggregate packages that just re-export the symbols that are provided by the specific packages like rutils.anaphora or rutils.list. Overall, there are 17 parts of the core, which are described, in more detail, in this tutorial. They include (with some changes and additions) 3 facilities, which are also available from separate libraries: SPLIT-SEQUENCE, ITERATE, and ANAPHORA. Besides, it defines 2 lightweight wrapper data structures: pair and hash-set.
There's also the package rtl that includes the core plus short names for a lot of basic Lisp operations.
Contrib holds "experimental" stuff (in the sense that it's not totally conventional even for me) that, gradually, migrates to core. I won't talk more about it in the tutorial: those who are interested can check on their own or ask questions.
| (defclass dwim-graph () ()) | |
| (defmethod cl-dot:graph-object-node ((graph (eql 'dwim-graph)) object) | |
| (make-instance 'cl-dot:node | |
| :attributes (list :label (format nil "~A" object) | |
| :shape :circle))) | |
| (defmacro dwim-graph ((file &key (directed t)) &body edges) | |
| `(progn | |
| (eval-when (:compile-toplevel :load-toplevel :execute) |