The shelly Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The shelly Reference Manual

This is the shelly Reference Manual, version 0.8.6, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 12:34:11 2018 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

Shelly - Make Common Lisp shell-friendly.

Announcement: Release of v0.7.5

Perl5 isn't required to use Shelly from v0.7.0 because I rewrote it in shell script.

You can install the latest version by this command:

$ curl -L http://shlyfile.org/shly | /bin/sh

If you already have an older version of it, you can upgrade it by this command:

$ shly install --version latest

Usage

Usage: shly [option,..] <command> [arg1,arg2..]

Examples:

$ shly asdf:test-system :clack
$ shly ql:update-all-dists --prompt nil
$ shly -Lclack clackup /path/to/project/app.lisp
$ shly -Lclack clack.app.directory:start-server
$ shly -Ldrakma http-request http://www.hatena.com/
$ shly -Lcl-project make-project /path/to/myapp/ --description "My sample app." --author "Eitaro Fukamachi"

Description

Shelly enables you to execute Common Lisp functions like a shell command. And it also can be used as a Make-like build-tool.

Shelly has the following features:

Warning: This software is still ALPHA quality. The APIs will be likely to change.

Why use it?

In Common Lisp world, most libraries and applications are designed to run on REPL. It is convenient for interactive development, but it would be an obstacle in some cases.

For example, Common Lisp isn't good for writing a small script. No common way to write it in a portable way. Parsing command-line arguments is really annoying. And, the startup time would be very slow, especially when it uses some libraries.

Shelly solves these problems by providing a shell-friendly interface of Common Lisp. If your application need to run with Cron, Supervisord or other CUI applications, this may help you.

1. Implementation independent

Shelly should work fine with one of SBCL, Clozure CL, Allegro CL, ABCL, GNU CLISP and ECL.

2. Function as a shell command

Shelly treats general functions as its sub-commands, so you don't even need to write a script in most cases.

(in-package :myapp)

(defun do-something (&key verbose)
  ;; Do something.
  )

$ shly myapp:do-something --verbose t

Command-line options and arguments will be delivered to a function.

3. Fast startup

Shelly reduces the startup time by storing a Lisp core image. In a simple case, the execution is about 33 times faster than CIM's cl command and even 25 times faster than SBCL (with Quicklisp) at the maximum.

# Uses SBCL v1.2.1, Shelly v0.7.0
$ time shly + 1 2
3
shly + 1 2  0.02s user 0.03s system 102% cpu 0.047 total

# CIM v1.0.0
$ time cl --eval '(princ (+ 1 2))'
3
cl --eval '(princ (+ 1 2))'  0.67s user 0.11s system 96% cpu 0.805 total

# SBCL with Quicklisp
$ time sbcl --noinform --eval '(princ (+ 1 2))' --eval '(quit)'
3
sbcl --noinform --eval '(princ (+ 1 2))' --eval '(quit)'  0.51s user 0.09s system 99% cpu 0.606 total

# SBCL without Quicklisp
$ time sbcl --noinform --no-userinit --eval '(princ (+ 1 2))' --eval '(quit)'
3
sbcl --noinform --no-userinit --eval '(princ (+ 1 2))' --eval '(quit)'  0.00s user 0.01s system 89% cpu 0.012 total

How does it work

Shelly provides a shell script "shly". It takes some options, a command, and arguments for the command.

Usage: shly [option,..] <command> [arg1,arg2..]

In this example, ql:system-apropos would be the command and web would be an argument.

;; Same as (ql:system-apropos "web")
$ shly ql:system-apropos web
#<SYSTEM bknr.modules / bknr-web-20140616-git / quicklisp 2014-06-16>
#<SYSTEM bknr.web / bknr-web-20140616-git / quicklisp 2014-06-16>
#<SYSTEM cl-web-crawler / cl-web-crawler-20130128-svn / quicklisp 2014-06-16>
#<SYSTEM cl-webdav / cl-webdav-0.2.1 / quicklisp 2014-06-16>
#<SYSTEM crane-web / crane-20140616-git / quicklisp 2014-06-16>
#<SYSTEM hh-web / hh-web-20140616-git / quicklisp 2014-06-16>
...

If an argument starts with ":", it would be converted into a keyword.

;; Same as (asdf:system-source-file :hunchentoot).
$ shly asdf:system-source-file :hunchentoot
#P"/Users/nitro_idiot/quicklisp/dists/quicklisp/software/hunchentoot-1.2.21/hunchentoot.asd"

If an argument starts with "--", it also would be a keyword. This is just like common shell commands.

;; Same as (ql:update-all-dists :prompt nil)
$ shly ql:update-all-dists --prompt nil

If the command is imported to COMMON-LISP-USER package, you can omit the package prefix.

$ shly list 1 2 3
(1 2 3)

Or, if the package name is the same as the system name that is loaded by -L option, you can also omit it.

$ shly -Ldrakma http-request http://www.hatena.com/
$ shly -Lcl-project make-project /path/to/myapp/ --description "My sample app." --author "Eitaro Fukamachi"

As a replacement of Makefile

Shelly loads a local file which is named shlyfile.lisp if it exists. You can define project specific commands by writing functions in it. This is just like a "Makefile" in Common Lisp.

;; shlyfile.lisp
(defun test ()
  (asdf:test-system :your-app))

(defun build ()
  ;; Somthing to build your app.
  )

Then, shly test and shly build would be available only in the directory.

$ shly test
$ shly build

Shelly also loads ~/.shelly/shlyfile.lisp every time if it exists. If you have some commands you'd like to use everywhere, put them into that file.

Requirements

If you've installed CIM, Shelly will use its setting.

Installation

Installing the latest version

Currently, the install script always installs the latest version because the stable version requires Perl5 and I suppose you may not expect it.

$ curl -L http://shlyfile.org/shly | /bin/sh

You can also install from the source code.

$ git clone https://github.com/fukamachi/shelly.git
$ cd shelly
$ SHELLY_PATH=. bin/shly install

As "shelly" directory will be copied to ~/.shelly, you don't need the cloned repository after installation.

Installing to other than ~/.shelly

If you want to install Shelly to the different location, set SHELLY_HOME to the directory path.

$ curl -L http://shlyfile.org/shly | SHELLY_HOME=~/.shly /bin/sh

System-Wide installation

If --global t is specified to install command, it would be installed under /usr/local.

$ curl -L http://shlyfile.org/shly | /bin/sh -s install --global t

Configuration

If you use bash, zsh, csh or tcsh, the initialization code will be appended into your .*rc file automatically.

Otherwise, set SHELLY_HOME and add ~/.shelly/bin to PATH manually.

SHELLY_HOME="$HOME/.shelly"
[ -s "$SHELLY_HOME/lib/shelly/init.sh" ] && . "$SHELLY_HOME/lib/shelly/init.sh"

Upgrading

shly upgrade

Uninstalling

$ shly uninstall
$ rm -rf ~/.shelly

Built-in Commands

help [&optional command]

Show the usage of the specified command.

$ shly help ql:quickload
Usage: ql:quickload (systems &key verbose prompt explain
                     (verbose *quickload-verbose*) (prompt *quickload-prompt*)
                     &allow-other-keys)
    Load SYSTEMS the quicklisp way. SYSTEMS is a designator for a list
       of things to be loaded.

If command is not specified, it shows all available commands. This is the same as shly --help.

$ shly help

install [&key version global directory]

Install Shelly into your environment under "~/.shelly". You can install a specific version by using "--version".

$ shly install --version v0.6.1

If --directory is specified, it would be installed to the directory.

$ shly install --directory ~/.local

If --global is specified with non-NIL value, it would be installed to /usr/local/ (Same as --directory /usr/local).

$ shly install --global t

uninstall [&key directory]

Uninstall Shelly.

$ shly uninstall

available-versions

Show all the possible Shelly versions.

$ shly available-versions

dump-core

Dump Lisp core image file for faster startup.

$ shly dump-core

rm-core

Remove saved core image file which created by dump-core.

$ shly rm-core

local-dump-core [&rest systems] (Experimental)

Dump Lisp core image file to the current directory. This command takes system names to be included in the core.

$ shly local-dump-core :myapp

install-command [package-or-function-name]

Make an executable file under SHELLY_HOME/bin/.

# Making a function executable.
$ shly -Lclack install-command clack:clackup
# Same as (clack:clackup #P"/path/to/app.lisp")
$ clackup /path/to/app.lisp

# Making a package executable.
$ shly -Lclack install-command clack.app.directory
# Same as (clack.app.directory:start-server :port 50032)
$ clack.app.directory start-server --port 50032

History (roughly)

v0.8.6 (Oct 27, 2014)

v0.8.5 (Oct 3, 2014)

v0.8.1 (Aug 4, 2014)

v0.8.0 (Aug 2, 2014)

v0.7.0 (July 15, 2014)

v0.6.0 (Mar 31, 2014)

v0.5.8 (Nov 12, 2013)

v0.5.0 (Aug 29, 2013)

v0.4.0 (Aug 26, 2013)

Note: Conversion rules

Number

$ shly type-of 24
(INTEGER 0 4611686018427387903)
$ shly type-of 3.141592653589793d0
DOUBLE-FLOAT

Cons

$ shly type-of '(list 1 2 3)'
CONS

Boolean

If it is "t" or "nil", it would be T or NIL.

$ shly type-of t
BOOLEAN
$ shly type-of nil
NULL

Keyword

If it starts with ":" or "--", it would be a keyword.

$ shly type-of :web
KEYWORD
$ shly type-of --verbose

Pathname

If the same name file exists, it would be a pathname. Otherwise, it would be just a string.

$ shly type-of test.lisp
(SIMPLE-ARRAY CHARACTER (9))
$ touch test.lisp
$ shly type-of test.lisp
PATHNAME

Symbol

If the same name symbol exists, it would be a symbol.

$ shly pi
DOUBLE-FLOAT
$ shly asdf:\*central-registry\*
CONS

String

Otherwise, it would be treated as a string.

$ shly common-lisp-is-great
(SIMPLE-ARRAY CHARACTER (20))

Copyright

Copyright (c) 2012-2014 Eitaro Fukamachi and contributors.

License

Licensed under the BSD (2-Clause) License. See LICENSE.


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 shelly

Author

Eitaro Fukamachi

License

BSD 2-Clause

Description

Run Common Lisp from shell easily.

Long Description

# Shelly - Make Common Lisp shell-friendly.

## Announcement: Release of v0.7.5

Perl5 isn’t required to use Shelly from v0.7.0 because I rewrote it in shell script.

You can install the latest version by this command:

$ curl -L http://shlyfile.org/shly | /bin/sh

If you already have an older version of it, you can upgrade it by this command:

$ shly install –version latest

## Usage

Usage: shly [option,..] <command> [arg1,arg2..]

Examples:

$ shly asdf:test-system :clack
$ shly ql:update-all-dists –prompt nil
$ shly -Lclack clackup /path/to/project/app.lisp
$ shly -Lclack clack.app.directory:start-server
$ shly -Ldrakma http-request http://www.hatena.com/
$ shly -Lcl-project make-project /path/to/myapp/ –description "My sample app." –author "Eitaro Fukamachi"

## Description

Shelly enables you to execute Common Lisp functions like a shell command. And it also can be used as a Make-like build-tool.

Shelly has the following features:

* Provides shell command-like interface for Common Lisp functions
* Dumps a Lisp core for fast execution.
* Allows to define project specific commands. (shlyfile)
* Implementation independent.

<strong><span style="color:red">Warning</span>: This software is still ALPHA quality. The APIs will be likely to change.</strong>

## Why use it?

In Common Lisp world, most libraries and applications are designed to run on REPL. It is convenient for interactive development, but it would be an obstacle in some cases.

For example, Common Lisp isn’t good for writing a small script. No common way to write it in a portable way. Parsing command-line arguments is really annoying. And, the startup time would be very slow, especially when it uses some libraries.

Shelly solves these problems by providing a shell-friendly interface of Common Lisp. If your application need to run with Cron, Supervisord or other CUI applications, this may help you.

### 1. Implementation independent

Shelly should work fine with one of SBCL, Clozure CL, Allegro CL, ABCL, GNU CLISP and ECL.

### 2. Function as a shell command

Shelly treats general functions as its sub-commands, so you don’t even need to write a script in most cases.

(in-package :myapp)

(defun do-something (&key verbose)
;; Do something.
)

$ shly myapp:do-something –verbose t

Command-line options and arguments will be delivered to a function.

### 3. Fast startup

Shelly reduces the startup time by storing a Lisp core image. In a simple case, the execution is about 33 times faster than CIM’s ‘cl‘ command and even 25 times faster than SBCL (with Quicklisp) at the maximum.

# Uses SBCL v1.2.1, Shelly v0.7.0
$ time shly + 1 2
3
shly + 1 2 0.02s user 0.03s system 102% cpu 0.047 total

# CIM v1.0.0
$ time cl –eval ’(princ (+ 1 2))’
3
cl –eval ’(princ (+ 1 2))’ 0.67s user 0.11s system 96% cpu 0.805 total

# SBCL with Quicklisp
$ time sbcl –noinform –eval ’(princ (+ 1 2))’ –eval ’(quit)’
3
sbcl –noinform –eval ’(princ (+ 1 2))’ –eval ’(quit)’ 0.51s user 0.09s system 99% cpu 0.606 total

# SBCL without Quicklisp
$ time sbcl –noinform –no-userinit –eval ’(princ (+ 1 2))’ –eval ’(quit)’
3
sbcl –noinform –no-userinit –eval ’(princ (+ 1 2))’ –eval ’(quit)’ 0.00s user 0.01s system 89% cpu 0.012 total

## How does it work

Shelly provides a shell script "shly". It takes some options, a command, and arguments for the command.

Usage: shly [option,..] <command> [arg1,arg2..]

In this example, ‘ql:system-apropos‘ would be the command and ‘web‘ would be an argument.

;; Same as (ql:system-apropos "web")
$ shly ql:system-apropos web
#<SYSTEM bknr.modules / bknr-web-20140616-git / quicklisp 2014-06-16>
#<SYSTEM bknr.web / bknr-web-20140616-git / quicklisp 2014-06-16>
#<SYSTEM cl-web-crawler / cl-web-crawler-20130128-svn / quicklisp 2014-06-16>
#<SYSTEM cl-webdav / cl-webdav-0.2.1 / quicklisp 2014-06-16>
#<SYSTEM crane-web / crane-20140616-git / quicklisp 2014-06-16>
#<SYSTEM hh-web / hh-web-20140616-git / quicklisp 2014-06-16>
...

If an argument starts with ":", it would be converted into a keyword.

;; Same as (asdf:system-source-file :hunchentoot).
$ shly asdf:system-source-file :hunchentoot
#P"/Users/nitro_idiot/quicklisp/dists/quicklisp/software/hunchentoot-1.2.21/hunchentoot.asd"

If an argument starts with "–", it also would be a keyword. This is just like common shell commands.

;; Same as (ql:update-all-dists :prompt nil)
$ shly ql:update-all-dists –prompt nil

If the command is imported to ‘COMMON-LISP-USER‘ package, you can omit the package prefix.

$ shly list 1 2 3
(1 2 3)

Or, if the package name is the same as the system name that is loaded by ‘-L‘ option, you can also omit it.

$ shly -Ldrakma http-request http://www.hatena.com/
$ shly -Lcl-project make-project /path/to/myapp/ –description "My sample app." –author "Eitaro Fukamachi"

## As a replacement of Makefile

Shelly loads a local file which is named ‘shlyfile.lisp‘ if it exists. You can define project specific commands by writing functions in it. This is just like a "Makefile" in Common Lisp.

“‘common-lisp
;; shlyfile.lisp
(defun test ()
(asdf:test-system :your-app))

(defun build ()
;; Somthing to build your app.
)
“‘

Then, ‘shly test‘ and ‘shly build‘ would be available only in the directory.

“‘
$ shly test
$ shly build
“‘

Shelly also loads ‘~/.shelly/shlyfile.lisp‘ every time if it exists. If you have some commands you’d like to use everywhere, put them into that file.

## Requirements

* Common Lisp implementation
* [Quicklisp](http://www.quicklisp.org/beta/)

If you’ve installed [CIM](https://github.com/KeenS/CIM), Shelly will use its setting.

## Installation

### Installing the latest version

Currently, the install script always installs the latest version because the stable version requires Perl5 and I suppose you may not expect it.

$ curl -L http://shlyfile.org/shly | /bin/sh

You can also install from the source code.

“‘
$ git clone https://github.com/fukamachi/shelly.git
$ cd shelly
$ SHELLY_PATH=. bin/shly install
“‘

As "shelly" directory will be copied to ~/.shelly, you don’t need the cloned repository after installation.

### Installing to other than ~/.shelly

If you want to install Shelly to the different location, set SHELLY_HOME to the directory path.

$ curl -L http://shlyfile.org/shly | SHELLY_HOME=~/.shly /bin/sh

### System-Wide installation

If ‘–global t‘ is specified to ‘install‘ command, it would be installed under ‘/usr/local‘.

$ curl -L http://shlyfile.org/shly | /bin/sh -s install –global t

## Configuration

If you use bash, zsh, csh or tcsh, the initialization code will be appended into your .*rc file automatically.

Otherwise, set SHELLY_HOME and add ~/.shelly/bin to PATH manually.

SHELLY_HOME="$HOME/.shelly"
[ -s "$SHELLY_HOME/lib/shelly/init.sh" ] && . "$SHELLY_HOME/lib/shelly/init.sh"

## Upgrading

“‘
shly upgrade
“‘

## Uninstalling

“‘
$ shly uninstall
$ rm -rf ~/.shelly
“‘

## Built-in Commands

### help [&optional command]

Show the usage of the specified ‘command‘.

$ shly help ql:quickload
Usage: ql:quickload (systems &key verbose prompt explain
(verbose *quickload-verbose*) (prompt *quickload-prompt*)
&allow-other-keys)
Load SYSTEMS the quicklisp way. SYSTEMS is a designator for a list
of things to be loaded.

If ‘command‘ is not specified, it shows all available commands. This is the same as ‘shly –help‘.

$ shly help

### install [&key version global directory]

Install Shelly into your environment under "~/.shelly". You can install a specific version by using "–version".

$ shly install –version v0.6.1

If ‘–directory‘ is specified, it would be installed to the directory.

$ shly install –directory ~/.local

If ‘–global‘ is specified with non-NIL value, it would be installed to ‘/usr/local/‘ (Same as ‘–directory /usr/local‘).

$ shly install –global t

### uninstall [&key directory]

Uninstall Shelly.

$ shly uninstall

### available-versions

Show all the possible Shelly versions.

$ shly available-versions

### dump-core

Dump Lisp core image file for faster startup.

$ shly dump-core

### rm-core

Remove saved core image file which created by ‘dump-core‘.

$ shly rm-core

### local-dump-core [&rest systems] \(Experimental)

Dump Lisp core image file to the current directory. This command takes system names to be included in the core.

$ shly local-dump-core :myapp

### install-command [package-or-function-name]

Make an executable file under SHELLY_HOME/bin/.

# Making a function executable.
$ shly -Lclack install-command clack:clackup
# Same as (clack:clackup #P"/path/to/app.lisp")
$ clackup /path/to/app.lisp

# Making a package executable.
$ shly -Lclack install-command clack.app.directory
# Same as (clack.app.directory:start-server :port 50032)
$ clack.app.directory start-server –port 50032

## History (roughly)

### v0.8.6 (Oct 27, 2014)

* Support Cygwin even for CCL. Thanks to [@lambdasakura](https://github.com/lambdasakura).

### v0.8.5 (Oct 3, 2014)

* Support Cygwin (only with SBCL). Thanks to [@lambdasakura](https://github.com/lambdasakura).

### v0.8.1 (Aug 4, 2014)

* Allow to specify where to install (‘–directory‘ option).
* Add ‘–global‘ to ‘install‘.
* Add ‘uninstall‘ command.

### v0.8.0 (Aug 2, 2014)

* Add ‘install-command‘ command (for SBCL, CCL and GNU CLISP).

### v0.7.0 (July 15, 2014)

* Use CIM for CL implementation management if it is installed.
* Rewrite "bin/shly" in Shell script.
* Remove the dependency on SWANK.
* Allow to specify where to install with ‘SHELLY_HOME‘.
* Add ‘upgrade‘ command.

### v0.6.0 (Mar 31, 2014)

* Add ‘local-dump-core‘ (experimental).
* Allow multiple ‘-L‘ options.
* Add a new option ‘-I‘ to add a directory path to ‘asdf:*central-registry*‘.

### v0.5.8 (Nov 12, 2013)

* Muffle outputs of ‘ql:quickload‘ when ‘–verbose‘ isn’t specified.

### v0.5.0 (Aug 29, 2013)

* Allow to install the specific version of Shelly.
* Show commands even in "shlyfile"s.

### v0.4.0 (Aug 26, 2013)

* Add "shlyfile" feature.

## Note: Conversion rules

### Number

$ shly type-of 24
(INTEGER 0 4611686018427387903)
$ shly type-of 3.141592653589793d0
DOUBLE-FLOAT

### Cons

$ shly type-of ’(list 1 2 3)’
CONS

### Boolean

If it is "t" or "nil", it would be ‘T‘ or ‘NIL‘.

$ shly type-of t
BOOLEAN
$ shly type-of nil
NULL

### Keyword

If it starts with ":" or "–", it would be a keyword.

$ shly type-of :web
KEYWORD
$ shly type-of –verbose

### Pathname

If the same name file exists, it would be a pathname. Otherwise, it would be just a string.

$ shly type-of test.lisp
(SIMPLE-ARRAY CHARACTER (9))
$ touch test.lisp
$ shly type-of test.lisp
PATHNAME

### Symbol

If the same name symbol exists, it would be a symbol.

$ shly pi
DOUBLE-FLOAT
$ shly asdf:\*central-registry\*
CONS

### String

Otherwise, it would be treated as a string.

$ shly common-lisp-is-great
(SIMPLE-ARRAY CHARACTER (20))

## Copyright

Copyright (c) 2012-2014 Eitaro Fukamachi and [contributors](https://github.com/fukamachi/shelly/graphs/contributors).
## License

Licensed under the BSD (2-Clause) License. See LICENSE.

Version

0.8.6

Dependencies
Source

shelly.asd (file)

Component

src (module)


Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Previous: , Up: Modules   [Contents][Index]

3.1 shelly/src

Parent

shelly (system)

Location

src/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 shelly.asd

Location

shelly.asd

Systems

shelly (system)

Packages

shelly-asd


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 shelly/src/shelly.lisp

Dependencies
Parent

src (module)

Location

src/shelly.lisp

Packages

shelly

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 shelly/src/core.lisp

Dependencies
Parent

src (module)

Location

src/core.lisp

Packages

shelly.core

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 shelly/src/install.lisp

Dependencies
Parent

src (module)

Location

src/install.lisp

Packages

shelly.install

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 shelly/src/versions.lisp

Parent

src (module)

Location

src/versions.lisp

Packages

shelly.versions

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 shelly/src/util.lisp

Dependencies
Parent

src (module)

Location

src/util.lisp

Packages

shelly.util

Exported Definitions
Internal Definitions

load-shlyfile (function)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 shelly/src/impl.lisp

Parent

src (module)

Location

src/impl.lisp

Packages

shelly.impl

Exported Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.8 shelly/src/error.lisp

Parent

src (module)

Location

src/error.lisp

Packages

shelly.error

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

5.1 shelly-asd

Source

shelly.asd

Use List

Next: , Previous: , Up: Packages   [Contents][Index]

5.2 shelly

Source

shelly.lisp (file)

Use List
Exported Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.3 shelly.core

Source

core.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.4 shelly.install

Source

install.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.5 shelly.versions

Source

versions.lisp (file)

Use List
Exported Definitions
Internal Definitions

Next: , Previous: , Up: Packages   [Contents][Index]

5.6 shelly.util

Source

util.lisp (file)

Use List
Exported Definitions
Internal Definitions

load-shlyfile (function)


Next: , Previous: , Up: Packages   [Contents][Index]

5.7 shelly.impl

Source

impl.lisp (file)

Use List

common-lisp

Exported Definitions

Previous: , Up: Packages   [Contents][Index]

5.8 shelly.error

Source

error.lisp (file)

Use List

common-lisp

Exported Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *argv*
Package

shelly.core

Source

core.lisp (file)

Special Variable: *current-lisp-name*
Package

shelly.impl

Source

impl.lisp (file)

Special Variable: *current-lisp-path*
Package

shelly.impl

Source

impl.lisp (file)

Special Variable: *eval-option*
Package

shelly.impl

Source

impl.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: install-command PACKAGE-OR-FUNCTION-NAME

Make an executable file under SHELLY_HOME/bin/.

Example:
$ shly -Lclack install-command clack:clackup
$ shly -Lclack install-command clack.app.directory

$ clackup /path/to/app.lisp
$ clack.app.directory start-server –port 50032

Package

shelly.install

Source

install.lisp (file)

Macro: with-retrying-when-system-not-found &body BODY
Package

shelly.util

Source

util.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Functions

Function: add-load-path DIRECTORIES
Package

shelly.util

Source

util.lisp (file)

Function: arglist FNAME
Package

shelly.util

Source

util.lisp (file)

Function: available-versions ()

Show all the possible Shelly versions.

Package

shelly

Source

shelly.lisp (file)

Function: check-version VERSION
Package

shelly.util

Source

util.lisp (file)

Function: command-line-args ()
Package

shelly.impl

Source

impl.lisp (file)

Function: condition-undefined-function-name CONDITION
Package

shelly.impl

Source

impl.lisp (file)

Function: copy-directory FROM TO &key OVERWRITE
Package

shelly.util

Source

util.lisp (file)

Function: download-version VERSION &optional DESTINATION
Package

shelly.versions

Source

versions.lisp (file)

Function: dump-core &key QUIT-LISP LOAD-SYSTEMS OUTPUT

Dump Lisp core image file for faster startup.

Package

shelly.install

Source

install.lisp (file)

Function: find-version VERSION
Package

shelly.versions

Source

versions.lisp (file)

Function: find-version-name VERSION
Package

shelly.versions

Source

versions.lisp (file)

Function: help &optional COMMAND

Show a list of Built-In Commands.
If ‘command’ is specified, its usage will be displayed.

Package

shelly

Source

shelly.lisp (file)

Function: install &key VERSION GLOBAL DIRECTORY

Install Shelly into your environment under "~/.shelly". You can install a specific version by using "–version".

Package

shelly.install

Source

install.lisp (file)

Function: interpret EXPR &key VERBOSE
Package

shelly.core

Source

core.lisp (file)

Function: load-global-shlyfile ()
Package

shelly.util

Source

util.lisp (file)

Function: load-local-shlyfile &optional SHLYFILE
Package

shelly.util

Source

util.lisp (file)

Function: load-systems SYSTEMS &key VERBOSE
Package

shelly.util

Source

util.lisp (file)

Function: local-command-symbols &optional PACKAGE
Package

shelly.util

Source

util.lisp (file)

Function: local-dump-core &rest SYSTEMS

(Experimental)
Dump Lisp core image file to the current directory. This command takes system names to be included in the core.

Package

shelly.install

Source

install.lisp (file)

Function: print-package-commands PACKAGE &optional STREAM
Package

shelly.util

Source

util.lisp (file)

Function: release-versions ()
Package

shelly.versions

Source

versions.lisp (file)

Function: rm-core ()

Remove saved core image file which created by ‘dump-core’.

Package

shelly.install

Source

install.lisp (file)

Function: run-repl &key VERBOSE

Start Read-Eval-Print Loop for interactive execution.

Package

shelly.core

Source

core.lisp (file)

Function: save-app FILEPATH TOPLEVEL
Package

shelly.impl

Source

impl.lisp (file)

Function: save-core-image FILEPATH
Package

shelly.impl

Source

impl.lisp (file)

Function: shadowing-use-package PACKAGES-TO-USE &optional PACKAGE
Package

shelly.util

Source

util.lisp (file)

Function: shelly-home ()
Package

shelly.util

Source

util.lisp (file)

Function: terminate &optional STATUS FORMAT-STRING &rest FORMAT-ARGUMENTS
Package

shelly.util

Source

util.lisp (file)

Function: uninstall &key DIRECTORY

Uninstall Shelly.

Package

shelly.install

Source

install.lisp (file)

Function: upgrade ()

Upgrade Shelly to the latest version.

Package

shelly.install

Source

install.lisp (file)

Function: version< VERSION1 VERSION2
Package

shelly.versions

Source

versions.lisp (file)

Function: version<= VERSION1 VERSION2
Package

shelly.versions

Source

versions.lisp (file)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Conditions

Condition: shelly-command-not-found-error ()
Package

shelly.error

Source

error.lisp (file)

Direct superclasses

shelly-error (condition)

Direct slots
Slot: command
Initargs

:command

Condition: shelly-error ()
Package

shelly.error

Source

error.lisp (file)

Direct superclasses

simple-error (condition)

Direct subclasses
Condition: shelly-read-error ()
Package

shelly.error

Source

error.lisp (file)

Direct superclasses

shelly-error (condition)

Direct slots
Slot: expression
Initargs

:expression


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Macros

Macro: i SYMBOL &optional ARGS
Package

shelly.versions

Source

versions.lisp (file)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Functions

Function: canonicalize-arg ARG0
Package

shelly.core

Source

core.lisp (file)

Function: configure-shell INSTALL-DIR
Package

shelly.install

Source

install.lisp (file)

Function: csh-style-init INSTALL-DIR
Package

shelly.install

Source

install.lisp (file)

Function: dumped-core-path ()
Package

shelly.install

Source

install.lisp (file)

Function: extract-tarball TARBALL-STREAM &optional DESTINATION
Package

shelly.versions

Source

versions.lisp (file)

Function: install-from-path SHELLY-SYSTEM-PATH &optional INSTALL-DIR
Package

shelly.install

Source

install.lisp (file)

Function: install-function-command PACKAGE-NAME FUNCTION-NAME
Package

shelly.install

Source

install.lisp (file)

Function: install-package-command PACKAGE-NAME
Package

shelly.install

Source

install.lisp (file)

Function: load-shlyfile SHLYFILE
Package

shelly.util

Source

util.lisp (file)

Function: print RESULT
Package

shelly.core

Source

core.lisp (file)

Function: prompt ()
Package

shelly.core

Source

core.lisp (file)

Function: qlrequire PACKAGES
Package

shelly.versions

Source

versions.lisp (file)

Function: read EXPR
Package

shelly.core

Source

core.lisp (file)

Function: retrieve-releases ()
Package

shelly.versions

Source

versions.lisp (file)

Function: sh-style-init INSTALL-DIR
Package

shelly.install

Source

install.lisp (file)

Function: uninstall-with-path INSTALL-DIR
Package

shelly.install

Source

install.lisp (file)

Function: version-tarball-url VERSION
Package

shelly.versions

Source

versions.lisp (file)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   F   L   M   S  
Index Entry  Section

F
File, Lisp, shelly.asd: The shelly<dot>asd file
File, Lisp, shelly/src/core.lisp: The shelly/src/core<dot>lisp file
File, Lisp, shelly/src/error.lisp: The shelly/src/error<dot>lisp file
File, Lisp, shelly/src/impl.lisp: The shelly/src/impl<dot>lisp file
File, Lisp, shelly/src/install.lisp: The shelly/src/install<dot>lisp file
File, Lisp, shelly/src/shelly.lisp: The shelly/src/shelly<dot>lisp file
File, Lisp, shelly/src/util.lisp: The shelly/src/util<dot>lisp file
File, Lisp, shelly/src/versions.lisp: The shelly/src/versions<dot>lisp file

L
Lisp File, shelly.asd: The shelly<dot>asd file
Lisp File, shelly/src/core.lisp: The shelly/src/core<dot>lisp file
Lisp File, shelly/src/error.lisp: The shelly/src/error<dot>lisp file
Lisp File, shelly/src/impl.lisp: The shelly/src/impl<dot>lisp file
Lisp File, shelly/src/install.lisp: The shelly/src/install<dot>lisp file
Lisp File, shelly/src/shelly.lisp: The shelly/src/shelly<dot>lisp file
Lisp File, shelly/src/util.lisp: The shelly/src/util<dot>lisp file
Lisp File, shelly/src/versions.lisp: The shelly/src/versions<dot>lisp file

M
Module, shelly/src: The shelly/src module

S
shelly.asd: The shelly<dot>asd file
shelly/src: The shelly/src module
shelly/src/core.lisp: The shelly/src/core<dot>lisp file
shelly/src/error.lisp: The shelly/src/error<dot>lisp file
shelly/src/impl.lisp: The shelly/src/impl<dot>lisp file
shelly/src/install.lisp: The shelly/src/install<dot>lisp file
shelly/src/shelly.lisp: The shelly/src/shelly<dot>lisp file
shelly/src/util.lisp: The shelly/src/util<dot>lisp file
shelly/src/versions.lisp: The shelly/src/versions<dot>lisp file

Jump to:   F   L   M   S  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   A   C   D   E   F   H   I   L   M   P   Q   R   S   T   U   V   W  
Index Entry  Section

A
add-load-path: Exported functions
arglist: Exported functions
available-versions: Exported functions

C
canonicalize-arg: Internal functions
check-version: Exported functions
command-line-args: Exported functions
condition-undefined-function-name: Exported functions
configure-shell: Internal functions
copy-directory: Exported functions
csh-style-init: Internal functions

D
download-version: Exported functions
dump-core: Exported functions
dumped-core-path: Internal functions

E
extract-tarball: Internal functions

F
find-version: Exported functions
find-version-name: Exported functions
Function, add-load-path: Exported functions
Function, arglist: Exported functions
Function, available-versions: Exported functions
Function, canonicalize-arg: Internal functions
Function, check-version: Exported functions
Function, command-line-args: Exported functions
Function, condition-undefined-function-name: Exported functions
Function, configure-shell: Internal functions
Function, copy-directory: Exported functions
Function, csh-style-init: Internal functions
Function, download-version: Exported functions
Function, dump-core: Exported functions
Function, dumped-core-path: Internal functions
Function, extract-tarball: Internal functions
Function, find-version: Exported functions
Function, find-version-name: Exported functions
Function, help: Exported functions
Function, install: Exported functions
Function, install-from-path: Internal functions
Function, install-function-command: Internal functions
Function, install-package-command: Internal functions
Function, interpret: Exported functions
Function, load-global-shlyfile: Exported functions
Function, load-local-shlyfile: Exported functions
Function, load-shlyfile: Internal functions
Function, load-systems: Exported functions
Function, local-command-symbols: Exported functions
Function, local-dump-core: Exported functions
Function, print: Internal functions
Function, print-package-commands: Exported functions
Function, prompt: Internal functions
Function, qlrequire: Internal functions
Function, read: Internal functions
Function, release-versions: Exported functions
Function, retrieve-releases: Internal functions
Function, rm-core: Exported functions
Function, run-repl: Exported functions
Function, save-app: Exported functions
Function, save-core-image: Exported functions
Function, sh-style-init: Internal functions
Function, shadowing-use-package: Exported functions
Function, shelly-home: Exported functions
Function, terminate: Exported functions
Function, uninstall: Exported functions
Function, uninstall-with-path: Internal functions
Function, upgrade: Exported functions
Function, version-tarball-url: Internal functions
Function, version<: Exported functions
Function, version<=: Exported functions

H
help: Exported functions

I
i: Internal macros
install: Exported functions
install-command: Exported macros
install-from-path: Internal functions
install-function-command: Internal functions
install-package-command: Internal functions
interpret: Exported functions

L
load-global-shlyfile: Exported functions
load-local-shlyfile: Exported functions
load-shlyfile: Internal functions
load-systems: Exported functions
local-command-symbols: Exported functions
local-dump-core: Exported functions

M
Macro, i: Internal macros
Macro, install-command: Exported macros
Macro, with-retrying-when-system-not-found: Exported macros

P
print: Internal functions
print-package-commands: Exported functions
prompt: Internal functions

Q
qlrequire: Internal functions

R
read: Internal functions
release-versions: Exported functions
retrieve-releases: Internal functions
rm-core: Exported functions
run-repl: Exported functions

S
save-app: Exported functions
save-core-image: Exported functions
sh-style-init: Internal functions
shadowing-use-package: Exported functions
shelly-home: Exported functions

T
terminate: Exported functions

U
uninstall: Exported functions
uninstall-with-path: Internal functions
upgrade: Exported functions

V
version-tarball-url: Internal functions
version<: Exported functions
version<=: Exported functions

W
with-retrying-when-system-not-found: Exported macros

Jump to:   A   C   D   E   F   H   I   L   M   P   Q   R   S   T   U   V   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
C   E   S  
Index Entry  Section

*
*argv*: Exported special variables
*current-lisp-name*: Exported special variables
*current-lisp-path*: Exported special variables
*eval-option*: Exported special variables

C
command: Exported conditions

E
expression: Exported conditions

S
Slot, command: Exported conditions
Slot, expression: Exported conditions
Special Variable, *argv*: Exported special variables
Special Variable, *current-lisp-name*: Exported special variables
Special Variable, *current-lisp-path*: Exported special variables
Special Variable, *eval-option*: Exported special variables

Jump to:   *  
C   E   S  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   C   P   S  
Index Entry  Section

C
Condition, shelly-command-not-found-error: Exported conditions
Condition, shelly-error: Exported conditions
Condition, shelly-read-error: Exported conditions

P
Package, shelly: The shelly package
Package, shelly-asd: The shelly-asd package
Package, shelly.core: The shelly<dot>core package
Package, shelly.error: The shelly<dot>error package
Package, shelly.impl: The shelly<dot>impl package
Package, shelly.install: The shelly<dot>install package
Package, shelly.util: The shelly<dot>util package
Package, shelly.versions: The shelly<dot>versions package

S
shelly: The shelly system
shelly: The shelly package
shelly-asd: The shelly-asd package
shelly-command-not-found-error: Exported conditions
shelly-error: Exported conditions
shelly-read-error: Exported conditions
shelly.core: The shelly<dot>core package
shelly.error: The shelly<dot>error package
shelly.impl: The shelly<dot>impl package
shelly.install: The shelly<dot>install package
shelly.util: The shelly<dot>util package
shelly.versions: The shelly<dot>versions package
System, shelly: The shelly system

Jump to:   C   P   S