vendethiel/calimero.cl

Common Lisp Shell

calimero

Calimero is a Common Lisp Shell.

Usage

Run from sources:

make run
# aka sbcl --load run.lisp

choose your lisp:

LISP=ccl make run

or build and run the binary:

$ make build
$ ./calimero
...

Roswell integration

Roswell is an implementation manager and script launcher.

A POC script is in the roswell/ directory.

Your users can install the script with vendethiel/calimero.

Dev

Tests are defined with Fiveam.

Run them from the terminal with make test. You should see a failing test.

$ make test
Running test suite TESTMAIN
 Running test TEST1 f
 Did 1 check.
    Pass: 0 ( 0%)
    Skip: 0 ( 0%)
    Fail: 1 (100%)

 Failure Details:
 --------------------------------
...

Makefile:15: recipe for target 'test' failed

$ echo $?
2

On Slime, load the test package and run run!.

---

Licence: BSD

calimero.cl's Issues

add subcommands

so x (y). Probably should use the 1st (and only) emitted data.
Should error if insta done or multiple output (use | array gather).

add lambdas

need to think about Things™ a lot

add a command macro/EDSL

we need a macro that macrolets emit to emit data.
macro because funcall emit is zzz.
we need to either export symbols for emit or emit-data or take them as an arglist

do the butlast/dlambda(last) dance probably.

either one of

(with-input
 (emit :data "NYI"))
(with-input
 (emit-data "NYI"))
(with-input (emit emit-data)
 (emit-data "NYI"))
(with-input emit (emit-data)
 (emit-data "NYI"))
(with-input emit ((:data emit-data))
 (emit-data "NYI"))

Use a defgeneric with `:method` for one-file cases

add an async command

Something that uses (cmd (done)) that delays it after getting the request

Use uiop:define-package

• since we only ever :use :cl we can remove it entirely
• can use :reexport in lieu of cl-reexport (probably)
• remove trivial-package-nicknames

add `xargs`

maybe it should take a lambda

pipeline

Add a hashmap method combination

Errors should have a method to return a list of their data.
They can return an alist or a plist, then we merge those into a hashmap

use proper data types

we want actual data types, not [[String]]. Closer to PowerShell or even Nu.

The data package has what we need. This is pretty much the values an interpreter could produce (after all, our commands are CPS-ish coroutines...).

We need:

• string
• int
• list of X
• records of list of X=>Y
  need to consider tables (headers shared)

Add check (on `output`) that no data is emitted after `done`

Basically, "safer" CPS-ish code that makes sure we're not a in done state

use conditions

Add repl object

Should hold CWD at least. maybe history.

rewrite `ls` to return tables

Now that we have tables, ls should return filename size ... or something.

properly parse commands