• Table of contents
• Install
  • With Quicklisp
  • With a core image
  • With a binary. Use CIEL's custom REPL.
• Usage
  • Use CIEL at startup
• Libraries
• Language extensions
• Final words
• How to generate the documentation

Table of contents   TOC

• Install

  • With Quicklisp
  • With a core image
  • With a binary. Use CIEL's custom REPL.

• Usage

  • Use CIEL at startup
• Libraries
• Language extensions
• Final words
• How to generate the documentation

Install

You will probably need the following system dependencies (names for a Debian system):

libmagic-dev libc6-dev gcc  # from magicffi

With Quicklisp

You need a Lisp implementation and Quicklisp installed.

CIEL is not yet on Quicklisp, but it is on Ultralisp.

So, either clone this repository:

git clone https://github.com/ciel-lang/CIEL ~/quicklisp/local-projects/CIEL

either install the Ultralisp distribution and pull the library from there:

(ql-dist:install-dist "http://dist.ultralisp.org/" :prompt nil)

Then, load the .asd file (with asdf:load-asd or C-c C-k in Slime), quickload "ciel":

(ql:quickload "ciel")

and enter the ciel-user package:

(in-package :ciel-user)

With a core image

You need a Lisp implementation, but you don't need Quicklisp.

Build a core image for your lisp with all CIEL's dependencies:

sbcl --load build-image.lisp

and use it:

sbcl --core ciel-core --eval '(in-package :ciel-user)'

Then you can configure Slime to have the choice of the Lisp image to start. See below in /mirrors/ciel/src/commit/eba9f86cffbe3994663ca8ac3c4ea02b6ca0eac0/%2AUse%20CIEL%20at%20startup

We will distribute ready-to-use core images can not distribute core images, you must build it yourself.

With a binary. Use CIEL's custom REPL.

You don't need anything, just download the CIEL executable and run its REPL. You need to build the core image yourself though.

• we provide an experimental binary for Debian systems: go to https://gitlab.com/vindarel/ciel/-/pipelines, download the latest artifacts, unzip the ciel-v0.zip archive and run ciel-v0/ciel.

TODO: build it for different platforms.

To build it, clone this repository and run make build.

Start it with ./ciel.

You are dropped into a custom Lisp REPL, freely based on sbcli.

This REPL is more user friendly than the default SBCL one:

• it has readline capabilities, meaning that the arrow keys work by default (wouhou!) and there is a persistent history, like in any shell.
• it has multiline input.
• it has TAB completion.
• it handles errors gracefully: you are not dropped into the debugger and its sub-REPL, you simply see the error message.
• it has optional syntax highlighting.
• it has an optional lisp critic that scans the code you enter at the REPL for instances of bad practices.
• it has a shell pass-through: try !ls.
• it has documentation lookup shorthands: use :doc symbol or ? after a symbol to get its documentation: ciel-user> (dict ?.
• it has developer friendly macros: use (printv code) for an annotated trace output.
• and it defines more helper commands:

  %help => Prints this general help message
  %doc => Prints the available documentation for this symbol
  %? => Inspect a symbol: %? str
  %w => Writes the current session to a file <filename>
  %d => Dumps the disassembly of a symbol <sym>
  %t => Prints the type of a expression <expr>
  %lisp-critic => Toggles the lisp-critic
  %q => Ends the session.

See more in the documentation.

Usage

Create a package and "use" ciel in addition of cl:

  (defpackage yourpackage
    (:use :cl :ciel))

You can also use generic-ciel, based on generic-cl:

  (defpackage yourpackage
    (:use :cl :generic-ciel))

generic-cl allows us to define our + or equalp methods for our own objects (and more).

Use CIEL at startup

You can enter the CIEL-USER package when you start your Lisp image from your editor.

A working, but naive and slow-ish approach is to add this in your ~/.sbclrc:

(ql:quickload "ciel")
(in-package :ciel-user)
(ciel-user-help)

A faster way is to use CIEL's core and to use SLIME's or your editor's feature to configure multiple Lisps.

You need to:

• build CIEL's core for your machine (make image),
• add this to your Emacs init file:

  (setq slime-lisp-implementations
        `((sbcl    ("sbcl" "--dynamic-space-size" "2000"))  ;; default. Adapt if needed.
          (ciel-sbcl  ("sbcl" "--core" "/path/to/ciel/ciel-core" "--eval" "(in-package :ciel-user)"))))
  (setq slime-default-lisp 'ciel-sbcl)

• and start a new Lisp process.
• optional: if you didn't set it as default with slime-default-lisp, then start a new Lisp process with M-- M-x slime (alt-minus prefix), and choose ciel-sbcl. You can start more than one Lisp process from SLIME.

The Lisp process should start as fast as the default SBCL.

Libraries

We import, use and document libraries to fill various use cases: generic access to data structures, functional data structures, string manipulation, JSON, database access, web, URI handling, GUI, iteration helpers, type checking helpers, syntax extensions, developer utilities, etc.

See the documentation.

To see the full list of dependencies, see the ciel.asd project definition or this dependencies list.

Language extensions

We provide arrow macros, easy type declaratons in the function lambda list, macros for exhaustiveness type checking, pattern matching, etc.

See the documentation.

Final words

That was your life in CL:

and now:

How to generate the documentation

See src/ciel.lisp and run (generate-dependencies-page-reference).