• 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

With Quicklisp

You need a Lisp implementation and Quicklisp installed.

CIEL is not yet on Quicklisp (but it is on Ultralisp), so clone this repository and load the .asd (with load or C-c C-k in Slime).

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

Then, quickload it:

(ql:quickload "ciel")

and enter the ciel-user package, instead of the default common-lisp-user (or cl-user):

(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 --eval '(in-package :ciel-user)'

TODO: we will distribute ready-to-use core images.

With a binary. Use CIEL's custom REPL.

You don't need anything, just download the CIEL executable and run its REPL.

TODO: build it on CI for different platforms.

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

Start it with ./ciel-repl.

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
  %? => Gets help on a symbol <sym>: :? 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    ("/usr/bin/sbcl" "--dynamic-space-size" "2000"))  ;; default. Adapt if needed.
          (ciel-sbcl  ("/usr/bin/sbcl" "--core" "/path/to/ciel/ciel"))))
  (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).