The evol Reference Manual

Table of Contents

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

The evol Reference Manual

This is the evol Reference Manual, version 0.0.1, generated automatically by Declt version 2.3 "Robert April" on Wed Mar 14 03:51:57 2018 GMT+0.


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

1 Introduction

evol - entrenched virtues of lisp / love reversed
=================================================
evol aims to be a compatible and full-fledged replacement for the 
GNU Autotools[1] stack targeted at coping with the Autotools' shortcomings while
not repeating the mistakes made and still being made at comparable build tool
projects.

evol is completely written in Common Lisp and licensed under the
GPLv3+[2]. Please see the file COPYING in the top-level directory of the
distribution tarball or see the link at [2] if you didn't receive a copy along
with this file.

Since distribution in binary form requires static linking of Common Lisp
libraries, distribution *must* include the file CREDITS also found in mentioned
top-level directory to respect copyright of the respective holders.


Alpha-Stage Warning
===================
evol is still a moving target, i.e. subject to change in terms of its top-level
API so please don't use it for any production work yet.
However you are very welcome to test and contribute!


Installation
============
Please see file INSTALL.


Links and References
====================
Homepage:           http://www.cliki.net/evol
Hacking (stable):   http://github.com/e-user/evol
Hacking (unstable): http://github.com/e-user/evol/tree/unstable

[1] http://www.gnu.org/software/hello/manual/automake/Autotools-Introduction.html
[2] http://www.gnu.org/licenses/gpl-3.0-standalone.html


--------------------------------------------------------------------------------
Copyright (C) 2009  Alexander Kahl 
This file is part of evol.
evol is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.

evol is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see .


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 evol

Author

Alexander Kahl <e-user@fsfe.org>

License

GPLv3+

Description

evol - entrenched virtues of lisp / love reversed. Multi-purpose build system.

Version

0.0.1

Dependencies
Source

evol.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 evol/src

Parent

evol (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 evol.asd

Location

evol.asd

Systems

evol (system)

Packages

evol-system


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

4.1.2 evol/src/package.lisp

Parent

src (module)

Location

src/package.lisp

Packages

evol


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

4.1.3 evol/src/util.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/util.lisp

Internal Definitions

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

4.1.4 evol/src/path.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/path.lisp

Exported Definitions

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

4.1.5 evol/src/environment.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/environment.lisp

Exported Definitions
Internal Definitions

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

4.1.6 evol/src/dependency.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/dependency.lisp

Internal Definitions

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

4.1.7 evol/src/ring-buffer.lisp

Dependency

package.lisp (file)

Parent

src (module)

Location

src/ring-buffer.lisp

Internal Definitions

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

4.1.8 evol/src/heredoc.lisp

Dependencies
Parent

src (module)

Location

src/heredoc.lisp

Internal Definitions

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

4.1.9 evol/src/shell.lisp

Dependencies
Parent

src (module)

Location

src/shell.lisp

Exported Definitions
Internal Definitions

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

4.1.10 evol/src/evolvable.lisp

Dependencies
Parent

src (module)

Location

src/evolvable.lisp

Internal Definitions

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

4.1.11 evol/src/common-lisp.lisp

Dependencies
Parent

src (module)

Location

src/common-lisp.lisp

Internal Definitions

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

4.1.12 evol/src/breeder.lisp

Dependencies
Parent

src (module)

Location

src/breeder.lisp

Internal Definitions

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

4.1.13 evol/src/toplevel.lisp

Dependencies
Parent

src (module)

Location

src/toplevel.lisp

Exported Definitions

repl (function)

Internal Definitions

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

5 Packages

Packages are listed by definition order.


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

5.1 evol-system

Source

evol.asd

Use List

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

5.2 evol

Source

package.lisp (file)

Nickname

love

Use List
Exported Definitions
Internal 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: *environment*
Package

evol

Source

environment.lisp (file)


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

6.1.2 Macros

Macro: defenv VAR VAL &optional ENVIRONMENT

defenv var val &optional environment => val

Store val for key var in hash environment.

Package

evol

Source

environment.lisp (file)


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

6.1.3 Functions

Function: default-sourcefn TARGET MODIFIER

default-sourcefn target modifier => string

Default source computing function that does nothing but ignoring all arguments and always returns an empty string.

Package

evol

Source

shell.lisp (file)

Function: getenv VAR &key ENV EXPANDED DEFAULT

getenv var &key env expanded default => mixed

Return object stored for key var from hash :env and :expand the object for external command use if desired.

Package

evol

Source

environment.lisp (file)

Function: pathname-change-suffix SUFFIX PATHSPEC

pathname-change-suffix suffix pathspec => string

Change suffix of path name string pathspec; adds suffix if none present yet.

Package

evol

Source

path.lisp (file)

Function: pathname-suffix-p SUFFIX PATHSPEC

pathname-suffix-p suffix pathspec => boolean

Predicate whether pathspec has file name suffix.

Package

evol

Source

path.lisp (file)

Function: repl ()

repl => quit

Top-level function used for the standalone executable created through bootstrapping evol.
Heads-up: Quits CL after execution.

Package

evol

Source

toplevel.lisp (file)

Function: run-command CMD &key VERBOSE FATAL

run-command cmd &key verbose fatal => (integer string string)

Run command line list CMD (blocking), returning VALUES of exit status of invocation and strings of stdout and stderr output. If FATAL is non-nil and exit status is not 0, signal COMMAND-FAILURE instead.
Side-effect: Print CMD prior to invocation and command output if VERBOSE is non-nil.

Package

evol

Source

shell.lisp (file)


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

6.2 Internal definitions


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

6.2.1 Special variables

Special Variable: *default-evolution*
Package

evol

Source

toplevel.lisp (file)

Special Variable: *options*
Package

evol

Source

toplevel.lisp (file)


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

6.2.2 Macros

Macro: default NAME

default name => mixed

Top-level syntactic sugar macro to set the default evolvable to name.

Package

evol

Source

toplevel.lisp (file)

Macro: devolution NAME (&body DEPENDENCIES) &rest ARGS &key TYPE &allow-other-keys

devolution name &rest args &key type &allow-other-keys => object

Top-level syntactic sugar macro to create evolvables. Name will be the environmental hash key, :TYPE must be a valid class name and all other keys will be proxied to MAKE-INSTANCE.

Package

evol

Source

toplevel.lisp (file)

Macro: eval-reverse-cons (&body BODY1) (&body BODY2)

eval-reverse-cons (&body body1) (&body body2) => cons

Evaluate BODY2 and BODY1 in this order and return result cons [BODY1|BODY2].

Package

evol

Source

breeder.lisp (file)

Macro: getf-option OPTION KEYWORD

getf-option option keyword => result

GETF for options.

Package

evol

Source

toplevel.lisp (file)

Macro: resolve-cond NAME NODES SEEN (&body PROLOGUE) &body EPILOGUE

resolve-cond name nodes seen (&body prologue) &body epilogue => context

Insert COND clauses between PROLOGUE clauses and EPILOGUE final clause that check for erroneous conditions between the NAME of a node, the list of all NODES and nodes SEEN during dependency resolution and signal errors accordingly if encountered.

Package

evol

Source

dependency.lisp (file)

Macro: symbolize NAME

symbolize name => symbol

Quotes, transforms and interns unquoted variable names.

Package

evol

Source

environment.lisp (file)

Macro: with-dependency-nodes VAR &body BODY

with-dependency-nodes var &body body => context

Evaluate BODY in scope of VAR bound to dependency node list.

Package

evol

Source

breeder.lisp (file)

Macro: with-new-lock-held VAR &body BODY

with-new-lock-held var &body body => context

Evaluate BODY in locked scope of VAR bound to a new mutex with random name.

Package

evol

Source

breeder.lisp (file)

Macro: with-outputs-to-strings (&rest VARS) &body FORMS-DECLS

with-outputs-to-strings (&rest vars) &body forms-decls => (result string1 .. stringN)

The multi-version of WITH-OUTPUT-TO-STRING preserving original return values. Evaluate FORMS-DECLS with each element in VARS bound to a fresh open stream. Return multiple VALUES of FORMS-DECLS evaluation result and one string per VARS in given argument order.

Package

evol

Source

util.lisp (file)

Macro: with-slot-enhanced-environment (SLOTS OBJECT) &body BODY

with-slot-enhanced-environment (slots object) body => context

Create lexical context overriding *ENVIRONMENT* with a fresh copy enhanced by all slot names/values as key/values from symbol list SLOTS in OBJECT.

Package

evol

Source

util.lisp (file)


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

6.2.3 Functions

Function: argument-option ARGUMENT

argument-option argument => option

Find option owning ARGUMENT (command line option).

Package

evol

Source

toplevel.lisp (file)

Function: cl-load-ops LIST

cl-load-ops list => list

Prepares a list of ASDF:LOAD-op forms for op in input LIST.

Package

evol

Source

common-lisp.lisp (file)

Function: cl-run-command IMPLEMENTATION PACKAGES CMD &key VERBOSE FATAL

cl-run-command implementation packages cmd &key verbose fatal => (integer string string)

Run CL command sequence CMD with the appropriate IMPLEMENTATION. Load all
PACKAGES with ASDF first.
Wrap CMD in an implicit PROGN and HANDLER-CASE.

Package

evol

Source

common-lisp.lisp (file)

Function: copy-ring-buffer INSTANCE
Package

evol

Source

ring-buffer.lisp (file)

Function: deflate-string LIST &optional SEPARATOR

deflate-string list &optional separator => string|object

Splice list of strings into merged string having elements separated with string seperator.

Package

evol

Source

shell.lisp (file)

Function: dependency-node NAMEFN DEPENDENCYFN OBJECT

dependency-node namefn dependencyfn object => node

Transform OBJECT into a node (list) by appending the results of calling NAMEFN and DEPENDENCYFN against it.

Package

evol

Source

dependency.lisp (file)

Function: dependency-nodes-hashtable PREDICATE NAMEFN DEPENDENCYFN ENV

dependency-nodes-hashtable predicate namefn dependencyfn env => node-list

Filter out all values satisfying PREDICATE from hashtable ENV and return result list of transforming each one into a node list by calling NAMEFN and DEPENDENCYFN.

Package

evol

Source

dependency.lisp (file)

Function: evolution-arguments ARGS

evolution-arguments args => list

List of what to evolve based on list of command line args, default evolution and - as a last resort - the first defined evolvable.

Package

evol

Source

toplevel.lisp (file)

Function: evolvable-p OBJECT

evolvable-p object => boolean

Tell whether OBJECT is an EVOLVABLE.

Package

evol

Source

evolvable.lisp (file)

Function: expand-$-match MATCH

expand-$-match match => string

Lookup match in the environment CL was started in returning the result.

Package

evol

Source

shell.lisp (file)

Function: expand-%-match MATCH TARGET SOURCEFN ENVIRONMENT

expand-%-match match target sourcefn environment => string

Act depending on string match:
- % returns %
- @ returns target
- < returns result of invoking sourcefn against target and modifier
- Any other sequence will be looked up in evol’s environment returning the result, defaulting to an empty string
- In case of @ and <, if target respectively sourcefn invocation returns a list, it will be auto-deflated to a string with spaces as element seperator. To modify the deflation seperator, simply pass any non-whitespace character sequence after @ or <, e.g.
[@,] for target := (foo bar baz) => "foo,bar,baz"

Package

evol

Source

shell.lisp (file)

Function: find-node NAME NODES

find-node name nodes => node

Find and return node designated by NAME in NODES.

Package

evol

Source

dependency.lisp (file)

Function: format-option STREAM STRING &optional ARGUMENT

format-option stream string argument => result

Print option STRING with optional ARGUMENT to STREAM; formatting depends on whether STRING is a short or a long option, determined by its length.

Package

evol

Source

toplevel.lisp (file)

Function: internify NAME

internify name => symbol

Return interned symbol for arbitrarily typed name; useful for use as hash keys.

Package

evol

Source

environment.lisp (file)

Function: interpolate-$-argument ARGUMENT

interpolate-$-argument argument => string

Expand all matches of $ words in string ARGUMENT.

Package

evol

Source

shell.lisp (file)

Function: interpolate-%-argument ARGUMENT TARGET SOURCEFN ENVIRONMENT

interpolate-%-argument argument target sourcefn environment => string

Expand all matches of % words in string ARGUMENT honoring the special TARGET and SOURCEFN matches and, for the rest, the ENVIRONMENT.

Package

evol

Source

shell.lisp (file)

Function: interpolate-argument ARGUMENT TARGET SOURCEFN ENVIRONMENT

interpolate-argument argument target sourcefn environment => list

Expand all % and $ matches in string argument in turn.

Package

evol

Source

shell.lisp (file)

Function: interpolate-commandline CMD &key TARGET SOURCEFN ENVIRONMENT

interpolate-commandline cmd &key target sourcefn environment => list

Interpolate split arguments of command line string CMD after grouping through Bourne shell syntax block quoting, see split-commandline for details. Unquoted quotes are stripped after interpolation, single quotes prevent interpolation of their contained argument while double quotes don’t. Returns list of split and interpolated arguments.

Package

evol

Source

shell.lisp (file)

Function: jobs-breeder JOBS

jobs-breeder jobs => breeder

Create the appropriate BREEDER for the number of JOBS.

Package

evol

Source

toplevel.lisp (file)

Function: leaf-nodes NODES

leaf-nodes nodes => node-list

Return all leaf nodes in NODES.
Leaf nodes are simply the ones with no dependencies at all.

Package

evol

Source

dependency.lisp (file)

Function: load-evolution OPTIONS

load-evolution options => void

Load the evolution file based on command line OPTIONS.

Package

evol

Source

toplevel.lisp (file)

Function: make-ring-buffer &key (VECTOR VECTOR) (START START) (USED USED) (NEW NEW) (END END)
Package

evol

Source

ring-buffer.lisp (file)

Function: mapthread FUNCTION LIST &rest MORE-LISTS

mapthread function list &rest more-lists => list

Apply FUNCTION against each set of elements from LIST and MORE-LISTS just like MAPCAR but use a new thread for each call. Returns result list from joining all threads created that way.

Package

evol

Source

util.lisp (file)

Function: new-ring-buffer LENGTH

new-ring-buffer length => ring-buffer

Create a new RING-BUFFER containing a simple character vector of fixed size LENGTH.

Package

evol

Source

ring-buffer.lisp (file)

Function: parse-commandline ARGV

parse-commandline argv => (args opts)

Parse command line argument list ARGV with UNIX-OPTIONS:MAP-PARSED-OPTIONS and defined available *OPTIONS*.

Package

evol

Source

toplevel.lisp (file)

Function: posix-argv ()

posix-argv => list

Return command line argument list. Implementation dependent.

Package

evol

Source

util.lisp (file)

Function: posix-getenv NAME

posix-getenv name => string

Return value for POSIX environmental key name, empty string if nothing found.

Package

evol

Source

environment.lisp (file)

Function: posix-quit &optional CODE

posix-quit => bye bye

Quit the current running CL instance returning error CODE.

Package

evol

Source

util.lisp (file)

Function: print-help ()

print-help => string

Print help.

Package

evol

Source

toplevel.lisp (file)

Function: rbref BUFFER INDEX

rbref buffer index => character or #Nul

Return character stored at INDEX in ring BUFFER.

Package

evol

Source

ring-buffer.lisp (file)

Writer

(setf rbref) (function)

Function: (setf rbref) VALUE BUFFER INDEX

setf (rbref buffer index) value => value

SETF for RBREF. If INDEX > LENGTH of BUFFER, start over at the beginning.

Package

evol

Source

ring-buffer.lisp (file)

Reader

rbref (function)

Function: read-heredoc STREAM CHAR ARG

read-heredoc stream char arg => string

Return string from STREAM up to the point where the string read first until CHAR is encountered. All evaluation is completely turned off so no quoting is required at all.
Example: #>eof>Write whatever (you) "want"!eof => Write whatever (you) "want"!

Package

evol

Source

heredoc.lisp (file)

Function: read-until-match STREAM TERMINAL

read-until-match stream terminal => string

Read characters from STREAM until a sequence equal to string TERMINAL is read. Return all characters read as string omitting TERMINAL itself. Signal error upon EOF.

Package

evol

Source

heredoc.lisp (file)

Function: replace-with-region REPLACEFN &rest ARGS

replace-with-region replacefn &rest args => closure

Create closure that is suitable for use with cl-ppcre replacement forms. Created closure invokes replacefn against the matched subsequence in the string to be searched additionally passing args.

Package

evol

Source

shell.lisp (file)

Function: reset-evolvables &optional ENV

reset-evolvables env => evolvables-list

RESET all evolvables in hashtable ENV. Useful for development.

Package

evol

Source

evolvable.lisp (file)

Function: resolve-all NODES RESFN &optional ROOTS

resolve-all nodes resfn &optional (roots nodes) => list of dags or queues

Resolve list of distinct ROOTS (or, by default, everything) in node-list NODES using resfn.

Package

evol

Source

dependency.lisp (file)

Function: resolve-dag ROOT NODES

resolve root nodes => dag

Try to resolve dependencies for ROOT node in NODES and return its dependency dag (directed acyclic graph).

Dags are suitable for parallel building.

Package

evol

Source

dependency.lisp (file)

Function: resolve-queue ROOT NODES

resolve-queue root nodes => queue

Try to resolve dependencies for ROOT node in NODES and return its dependency queue.

Queues are suitable for sequential building only.

Package

evol

Source

dependency.lisp (file)

Function: resolve-roots NODES RESFN

resolve-roots nodes resfn => list of dags or queues

Resolve node-list NODES using resfn for all its root-nodes.

Package

evol

Source

dependency.lisp (file)

Function: ring-buffer-clear BUFFER

ring-buffer-clear buffer => -1

Reset all indices of BUFFER to their initial state.

Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-end INSTANCE
Function: (setf ring-buffer-end) VALUE INSTANCE
Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-flush BUFFER

ring-buffer-flush buffer => string

Flush all unused characters in BUFFER.

Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-insert BUFFER VALUE

ring-buffer-insert buffer value => value

Increment END of BUFFER inserting VALUE at the new index.

Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-new INSTANCE
Function: (setf ring-buffer-new) VALUE INSTANCE
Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-next BUFFER

ring-buffer-next buffer => character or nil

Return next match character incrementing USED in BUFFER or simply NIL if none are left.

Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-p OBJECT
Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-pop BUFFER

ring-buffer-pop buffer => character

Increment START of BUFFER returning VALUE at the new index. Additionally, reset the BUFFER match indices.

Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-reset BUFFER

ring-buffer-reset buffer => end-index

Reset match beginning/end indices USED and NEW in BUFFER to START and END.

Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-start INSTANCE
Function: (setf ring-buffer-start) VALUE INSTANCE
Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-used INSTANCE
Function: (setf ring-buffer-used) VALUE INSTANCE
Package

evol

Source

ring-buffer.lisp (file)

Function: ring-buffer-vector INSTANCE
Function: (setf ring-buffer-vector) VALUE INSTANCE
Package

evol

Source

ring-buffer.lisp (file)

Function: root-nodes NODES

root-nodes nodes => node-list

Return all root nodes in NODES.
Root nodes are identified by not being referenced as a dependency by any other node. This is done by building the difference (complement of intersection) between the ones having dependencies and the complete set.

Package

evol

Source

dependency.lisp (file)

Function: safe-format LOCK DESTINATION CONTROL-STRING &rest FORMAT-ARGUMENTS

safe-format lock control-string &rest format-arguments => nil

Mutex-protected FORMAT.

Package

evol

Source

breeder.lisp (file)

Function: safe-getenv LOCK VAR

safe-getenv lock var => result

Mutex-protected GETENV.

Package

evol

Source

breeder.lisp (file)

Function: split-commandline CMD

split-commandline cmd => list

Split command line string cmd into arguments accourding to Bourne shell syntax rules honoring double quotes ["], single quotes [’] and regular whitespace.

Package

evol

Source

shell.lisp (file)

Function: stringify OBJECT

stringify object => string

If OBJECT is a STRING, return it - else cast WRITE-TO-STRING.

Package

evol

Source

util.lisp (file)

Function: trim-{} STRING

trim-{} string => string

Trims {} brackets strings.

Package

evol

Source

shell.lisp (file)

Function: unix-options-options ()

unix-options-options => (bool-options parameter-options)

Transform *OPTIONS* so that they are suitable for use with UNIX-OPTIONS:MAP-PARSED-OPTIONS.

Package

evol

Source

toplevel.lisp (file)


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

6.2.4 Generic functions

Generic Function: breed BREEDER EVOLVABLE

Breed the evolvable so it can hatch

Package

evol

Source

breeder.lisp (file)

Methods
Method: breed (SWARM swarm) (EVOL evolvable)

breed swarm evolvable => result-dag

Swarm-based evolution. Works through creating new threads per edge / dag node / branch (equivalent here) while locking the evolvables encountered. Breeding is forwarded to the Patron queue that works by using a thread pool itself so welcome to deadlock wonderland!
There is considerable overhead involved in this method but payoff should be reached early even for simple real-life evolutions with mediocre complexity.

Method: breed (SWARM swarm) (EVOL evolvable) around
Method: breed (BREEDER breeder) (EVOL evolvable)

breed breeder evol => result-list

Breed dependency evolvables of EVOL sequentially depth-first up to and including EVOL itself. No multithreading, minimal overhead, nil deadlocks.

Generic Function: circular-inter-nodes CONDITION
Package

evol

Methods
Method: circular-inter-nodes (CONDITION circular-dependency)
Source

dependency.lisp (file)

Generic Function: circular-node CONDITION
Package

evol

Methods
Method: circular-node (CONDITION circular-dependency)
Source

dependency.lisp (file)

Generic Function: cl-implementation OBJECT
Generic Function: (setf cl-implementation) NEW-VALUE OBJECT
Package

evol

Methods
Method: cl-implementation (CL-TRANSFORMATOR cl-transformator)

automatically generated reader method

Source

common-lisp.lisp (file)

Method: (setf cl-implementation) NEW-VALUE (CL-TRANSFORMATOR cl-transformator)

automatically generated writer method

Source

common-lisp.lisp (file)

Generic Function: cl-packages OBJECT
Generic Function: (setf cl-packages) NEW-VALUE OBJECT
Package

evol

Methods
Method: cl-packages (CL-CORE cl-core)
Method: (setf cl-packages) NEW-VALUE (CL-CORE cl-core)

Package to load before creating heap image.

Source

common-lisp.lisp (file)

Generic Function: cl-save-options OBJECT
Generic Function: (setf cl-save-options) NEW-VALUE OBJECT
Package

evol

Methods
Method: cl-save-options (CL-CORE cl-core)
Method: (setf cl-save-options) NEW-VALUE (CL-CORE cl-core)

Additional arguments to pass to the implementation-dependent save call.

Source

common-lisp.lisp (file)

Generic Function: command-failure-code CONDITION
Package

evol

Methods
Method: command-failure-code (CONDITION command-failure)
Source

shell.lisp (file)

Generic Function: command-failure-command CONDITION
Package

evol

Methods
Method: command-failure-command (CONDITION command-failure)
Source

shell.lisp (file)

Generic Function: command-failure-stderr CONDITION
Package

evol

Methods
Method: command-failure-stderr (CONDITION command-failure)
Source

shell.lisp (file)

Generic Function: command-failure-stdout CONDITION
Package

evol

Methods
Method: command-failure-stdout (CONDITION command-failure)
Source

shell.lisp (file)

Generic Function: dependencies OBJECT
Generic Function: (setf dependencies) NEW-VALUE OBJECT
Package

evol

Methods
Method: dependencies (EVOLVABLE evolvable)
Method: (setf dependencies) NEW-VALUE (EVOLVABLE evolvable)

List of evolvables this one depends on

Source

evolvable.lisp (file)

Generic Function: enqueue-breeding SWARM EVOLVABLE

Push breeding an evolvable into the worker queue and wait for the job to finish

Package

evol

Source

breeder.lisp (file)

Methods
Method: enqueue-breeding (SWARM swarm) (EVOL evolvable)

enqueue-breeding swarm evol => result

Create and hold a new mutex, push breeding into the Patron queue and wait for Patron to call either RESULT-REPORT-FUNCTION or ERROR-REPORT-FUNCTION that are both set to notify condition against the entry thread of this method which is waiting. If a condition is found in the finished job, signal it, else return evolution result.

Generic Function: env-slots OBJECT
Generic Function: (setf env-slots) NEW-VALUE OBJECT
Package

evol

Methods
Method: env-slots (EVOLVABLE evolvable)
Method: (setf env-slots) NEW-VALUE (EVOLVABLE evolvable)

List of slots to lexically bind to the environment during evolution

Source

evolvable.lisp (file)

Generic Function: evolve EVOLVABLE &rest ARGS &key &allow-other-keys

Evolve this, whatever that may be

Package

evol

Source

evolvable.lisp (file)

Methods
Method: evolve (EXE cl-exe) &rest ARGS &key &allow-other-keys around
Source

common-lisp.lisp (file)

Method: evolve (CORE cl-core) &rest ARGS &key &allow-other-keys around
Source

common-lisp.lisp (file)

Method: evolve (TRANS cl-transformator) &rest ARGS &key &allow-other-keys
Source

common-lisp.lisp (file)

Method: evolve (TRANS generic-transformator) &rest ARGS &key &allow-other-keys
Method: evolve (EXE executable) &rest ARGS &key &allow-other-keys after
Method: evolve (EVOL checkable) &rest ARGS &key &allow-other-keys around
Method: evolve (VIRT virtual) &rest ARGS &key &allow-other-keys
Method: evolve (EVOL evolvable) &rest ARGS &key &allow-other-keys after

evolve :after evol &rest args &key &allow-other-keys => t

Mark evolvable EVOL hatched.

Method: evolve (EVOL evolvable) &rest ARGS &key &allow-other-keys around

evolve :around evol &rest args &key &allow-other-keys => context

Call the next method in scope of a copy of *ENVIRONMENT* enhanced by all slots in EVOL specified by ENV-SLOTS.

Generic Function: evolved-p CHECKABLE

Check that given evolution has been evolved properly

Package

evol

Source

evolvable.lisp (file)

Methods
Method: evolved-p (FILE file)
Generic Function: expand STANDARD-OBJECT

expand standard-object => string

Return a suitable form of the object for %-style rule expansion. Defined here to prevent circular dependencies.

Package

evol

Source

environment.lisp (file)

Methods
Method: expand (HIVE hive)

expand hive => list

Hives expand to a list of their dependencies’ names.

Source

evolvable.lisp (file)

Method: expand (EVOL evolvable)

expand evol => string

Expand EVOL to its name.

Source

evolvable.lisp (file)

Method: expand (OBJECT standard-object)

expand object => object

Just return IDENTITY of the OBJECT.

Generic Function: hatched OBJECT
Generic Function: (setf hatched) NEW-VALUE OBJECT
Package

evol

Methods
Method: hatched (EVOLVABLE evolvable)
Method: (setf hatched) NEW-VALUE (EVOLVABLE evolvable)

Whether evolution is finished

Source

evolvable.lisp (file)

Generic Function: illegal-evolvable CONDITION
Package

evol

Methods
Method: illegal-evolvable (CONDITION illegal-evolvable)
Source

toplevel.lisp (file)

Generic Function: mutex OBJECT
Package

evol

Methods
Method: mutex (EVOLVABLE evolvable)

Mutex for the wait queue

Source

evolvable.lisp (file)

Generic Function: name OBJECT
Package

evol

Methods
Method: name (EVOLVABLE evolvable)

The name of the evolvable, also available in evol’s environment

Source

evolvable.lisp (file)

Generic Function: reset EVOLVABLE

reset evolvable => result

Reset evolution of EVOLVABLE.

Package

evol

Source

evolvable.lisp (file)

Methods
Method: reset (EVOL evolvable)

reset evolvable => nil

Set slot HATCHED back to nil. Useful for development (only?).

Generic Function: rule OBJECT
Generic Function: (setf rule) NEW-VALUE OBJECT
Package

evol

Methods
Method: rule (CL-EXE cl-exe)

automatically generated reader method

Source

common-lisp.lisp (file)

Method: rule (CL-CORE cl-core)

automatically generated reader method

Source

common-lisp.lisp (file)

Method: rule (CL-TRANSFORMATOR cl-transformator)

automatically generated reader method

Source

common-lisp.lisp (file)

Method: (setf rule) NEW-VALUE (CL-TRANSFORMATOR cl-transformator)

automatically generated writer method

Source

common-lisp.lisp (file)

Method: rule (GENERIC-TRANSFORMATOR generic-transformator)

automatically generated reader method

Source

evolvable.lisp (file)

Method: (setf rule) NEW-VALUE (GENERIC-TRANSFORMATOR generic-transformator)

automatically generated writer method

Source

evolvable.lisp (file)

Method: rule (DEFINITE definite)
Method: (setf rule) NEW-VALUE (DEFINITE definite)

The rule used to evolve the definite

Source

evolvable.lisp (file)

Generic Function: sourcefn OBJECT
Generic Function: (setf sourcefn) NEW-VALUE OBJECT
Package

evol

Methods
Method: sourcefn (CL-CORE cl-core)

Preinitialized for this class; returns a list of
forms to first load asdf, then in turn additional asdf packages from rule and finally a form to have sbcl create a core file.

Source

common-lisp.lisp (file)

Method: sourcefn (DEFINITE definite)
Method: (setf sourcefn) NEW-VALUE (DEFINITE definite)

The function to compute the input from other slots like e.g. target and name

Source

evolvable.lisp (file)

Generic Function: stream-lock OBJECT
Package

evol

Methods
Method: stream-lock (SWARM swarm)

Mutex to use for printing

Source

breeder.lisp (file)

Generic Function: swarm-error-stream OBJECT
Package

evol

Methods
Method: swarm-error-stream (SWARM swarm)

Stream to use for printing errors

Source

breeder.lisp (file)

Generic Function: swarm-stream OBJECT
Package

evol

Methods
Method: swarm-stream (SWARM swarm)

Stream to use for printing

Source

breeder.lisp (file)

Generic Function: unloadable-evolution-pathname CONDITION
Package

evol

Methods
Method: unloadable-evolution-pathname (CONDITION unloadable-evolution)
Source

toplevel.lisp (file)

Generic Function: unresolvable-dependency CONDITION
Package

evol

Methods
Method: unresolvable-dependency (CONDITION unresolvable-dependency)
Source

dependency.lisp (file)

Generic Function: unresolvable-node CONDITION
Package

evol

Methods
Method: unresolvable-node (CONDITION unresolvable-dependency)
Source

dependency.lisp (file)

Generic Function: waitqueue OBJECT
Package

evol

Methods
Method: waitqueue (EVOLVABLE evolvable)

Wait queue used for multithreaded breeding

Source

evolvable.lisp (file)


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

6.2.5 Conditions

Condition: circular-dependency ()
Package

evol

Source

dependency.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: circular-node
Initargs

:circular-node

Readers

circular-node (generic function)

Slot: inter-nodes
Initargs

:inter-nodes

Readers

circular-inter-nodes (generic function)

Condition: command-failure ()

Condition signalled if invocation of an external command failed.

Package

evol

Source

shell.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: command

The command that failed.

Initargs

:command

Readers

command-failure-command (generic function)

Slot: code

Status code of failed invocation.

Initargs

:code

Readers

command-failure-code (generic function)

Slot: stdout

Output of invocation.

Initargs

:stdout

Readers

command-failure-stdout (generic function)

Slot: stderr

Error output of invocation.

Initargs

:stderr

Readers

command-failure-stderr (generic function)

Condition: illegal-evolvable ()
Package

evol

Source

toplevel.lisp (file)

Direct superclasses

error (condition)

Direct methods

illegal-evolvable (method)

Direct slots
Slot: target
Initargs

:evolvable

Readers

illegal-evolvable (generic function)

Condition: unemployment ()
Package

evol

Source

toplevel.lisp (file)

Direct superclasses

error (condition)

Condition: unloadable-evolution ()
Package

evol

Source

toplevel.lisp (file)

Direct superclasses

error (condition)

Direct methods

unloadable-evolution-pathname (method)

Direct slots
Slot: pathname
Initargs

:path

Readers

unloadable-evolution-pathname (generic function)

Condition: unresolvable-dependency ()
Package

evol

Source

dependency.lisp (file)

Direct superclasses

error (condition)

Direct methods
Direct slots
Slot: node
Initargs

:node

Readers

unresolvable-node (generic function)

Slot: dependency
Initargs

:dependency

Readers

unresolvable-dependency (generic function)


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

6.2.6 Structures

Structure: ring-buffer ()

Structure defining ring buffers utilizing a simple VECTOR of fixed size and four indices:
START: Index of first live value
END: Index of last live value
USED: Beginning of current match
NEW: End of current match

Package

evol

Source

ring-buffer.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: vector
Readers

ring-buffer-vector (function)

Writers

(setf ring-buffer-vector) (function)

Slot: start
Initform

-1

Readers

ring-buffer-start (function)

Writers

(setf ring-buffer-start) (function)

Slot: used
Initform

-1

Readers

ring-buffer-used (function)

Writers

(setf ring-buffer-used) (function)

Slot: new
Initform

-1

Readers

ring-buffer-new (function)

Writers

(setf ring-buffer-new) (function)

Slot: end
Initform

-1

Readers

ring-buffer-end (function)

Writers

(setf ring-buffer-end) (function)


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

6.2.7 Classes

Class: breeder ()

Solitary breeder class.

Package

evol

Source

breeder.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses

swarm (class)

Direct methods

breed (method)

Class: checkable ()

Evolvables derived from checkable provide a means to pre- and post-validate their evolution.

Package

evol

Source

evolvable.lisp (file)

Direct superclasses

evolvable (class)

Direct subclasses

file (class)

Direct methods

evolve (method)

Class: cl-core ()

This evolvable enables creation of non-standalone Common Lisp
core (heap image) files.
Feed rule with a list of asdf-recognized package symbols to load into the core.

Package

evol

Source

common-lisp.lisp (file)

Direct superclasses
Direct subclasses

cl-exe (class)

Direct methods
Direct slots
Slot: sourcefn

Preinitialized for this class; returns a list of
forms to first load asdf, then in turn additional asdf packages from rule and finally a form to have sbcl create a core file.

Allocation

:class

Initform

(function (lambda (evol::target evol::modifier) (declare (ignore evol::modifier)) (format nil ":~a" evol::target)))

Readers

sourcefn (generic function)

Slot: rule
Initargs

:rule

Initform

" (in-package %<) (%cl-save \"%@\" %cl-save-options)"

Readers

rule (generic function)

Slot: packages

Package to load before creating heap image.

Initargs

:packages

Initform

(alexandria.0.dev:required-argument :packages)

Readers

cl-packages (generic function)

Writers

(setf cl-packages) (generic function)

Slot: cl-save-options

Additional arguments to pass to the implementation-dependent save call.

Initargs

:save-options

Initform

""

Readers

cl-save-options (generic function)

Writers

(setf cl-save-options) (generic function)

Slot: env-slots
Initform

(list (quote evol::packages) (quote evol::cl-save-options))

Class: cl-exe ()

In line with cl-core, a complete dump is generated but with
the engine fully runable contained within so the resulting file is a real executable.
Feed rule with a list of asdf-recognized package symbols to load into the binary.

Package

evol

Source

common-lisp.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: rule
Initargs

:rule

Initform

" (in-package %<) (%cl-save \"%@\" %cl-save-options %cl-executable)"

Readers

rule (generic function)

Class: cl-transformator ()

Evolution takes place here through running a freshly forked
Common Lisp copy that expects rule to be a list of forms to execute in order. sourcefn is expected to return list of valid Common Lisp forms that will each be grouped as a single argument to be passed to (eval) so no special quoting aside from \" is required.
Variable expansion is only performed against sourcefn’s return forms.

Package

evol

Source

common-lisp.lisp (file)

Direct superclasses

definite (class)

Direct subclasses

cl-core (class)

Direct methods
Direct slots
Slot: implementation
Initargs

:implementation

Initform

(alexandria.0.dev:required-argument :implementation)

Readers

cl-implementation (generic function)

Writers

(setf cl-implementation) (generic function)

Slot: rule
Initargs

:rule

Initform

(alexandria.0.dev:required-argument :rule)

Readers

rule (generic function)

Writers

(setf rule) (generic function)

Class: definite ()

Definite evolvables define transformation rules and
computation of their effective input(s) to evolve, possibly from some kind of sources.

Package

evol

Source

evolvable.lisp (file)

Direct superclasses

evolvable (class)

Direct subclasses
Direct methods
  • sourcefn (method)
  • sourcefn (method)
  • rule (method)
  • rule (method)
Direct slots
Slot: rule

The rule used to evolve the definite

Initargs

:rule

Readers

rule (generic function)

Writers

(setf rule) (generic function)

Slot: sourcefn

The function to compute the input from other slots like e.g. target and name

Initargs

:sourcefn

Initform

(function evol:default-sourcefn)

Readers

sourcefn (generic function)

Writers

(setf sourcefn) (generic function)

Class: evolvable ()

Base class for all evolvables.

Package

evol

Source

evolvable.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: name

The name of the evolvable, also available in evol’s environment

Initargs

:name

Initform

(alexandria.0.dev:required-argument :name)

Readers

name (generic function)

Slot: dependencies

List of evolvables this one depends on

Initargs

:deps

Readers

dependencies (generic function)

Writers

(setf dependencies) (generic function)

Slot: env-slots

List of slots to lexically bind to the environment during evolution

Initargs

:env-slots

Readers

env-slots (generic function)

Writers

(setf env-slots) (generic function)

Slot: mutex

Mutex for the wait queue

Initform

(bordeaux-threads:make-lock)

Readers

mutex (generic function)

Slot: waitqueue

Wait queue used for multithreaded breeding

Initform

(bordeaux-threads:make-condition-variable)

Readers

waitqueue (generic function)

Slot: hatched

Whether evolution is finished

Readers

hatched (generic function)

Writers

(setf hatched) (generic function)

Class: executable ()

Executables are files that can be run on a machine’s stack by
either containing machince code themselves or referring to an interpreter for source code contained within. This class ensures its file is executable after creation.

Package

evol

Source

evolvable.lisp (file)

Direct superclasses

file (class)

Direct subclasses
Direct methods

evolve (method)

Class: file ()

Files are targets that usually lead to evolution
of... files. Their existence can easily be checked through their distinct pathnames.

Package

evol

Source

evolvable.lisp (file)

Direct superclasses

checkable (class)

Direct subclasses
Direct methods

evolved-p (method)

Class: generic ()

TODO

Package

evol

Source

evolvable.lisp (file)

Direct superclasses
Class: generic-transformator ()

Objects of this kind evolve through running an external
program through interpolating the rule and source function contained within honoring common quoting rules in line with Bourne shell syntax.

Package

evol

Source

evolvable.lisp (file)

Direct superclasses

definite (class)

Direct subclasses
Direct methods
Direct slots
Slot: rule
Initargs

:rule

Initform

(alexandria.0.dev:required-argument :rule)

Readers

rule (generic function)

Writers

(setf rule) (generic function)

Class: hive ()

Hives are similar to virtuals but enable mass spawning of
evolvables they auto-depend on so depending on a hive saves from declaring lots of mutual evolvables manually.

Package

evol

Source

evolvable.lisp (file)

Direct superclasses

virtual (class)

Direct methods
  • expand (method)
  • initialize-instance (method)
  • spawn (method)
  • of (method)
Direct slots
Slot: of

The subtype of evolvable to harbor

Initargs

:of

Initform

(alexandria.0.dev:required-argument :of)

Readers

of (generic function)

Slot: spawn

Source of spawn evolvables; can be a function or a list

Initargs

:spawn

Initform

(alexandria.0.dev:required-argument :spawn)

Readers

spawn (generic function)

Class: program ()

TODO

Package

evol

Source

evolvable.lisp (file)

Direct superclasses
Class: swarm ()

Swarms are breeders that heavily rely on threading and also derive from Patron for thread-pooled queue working.

Package

evol

Source

breeder.lisp (file)

Direct superclasses
Direct methods
Direct slots
Slot: stream

Stream to use for printing

Type

stream

Initargs

:stream

Initform

*standard-output*

Readers

swarm-stream (generic function)

Slot: error-stream

Stream to use for printing errors

Type

stream

Initargs

:error-stream

Initform

*error-output*

Readers

swarm-error-stream (generic function)

Slot: stream-lock

Mutex to use for printing

Initform

(bordeaux-threads:make-lock "swarm-stream-lock")

Readers

stream-lock (generic function)

Class: virtual ()

Virtual evolvables exist for the sole purpose of
beautification through grouping and/or naming by having its dependencies evolve.

Package

evol

Source

evolvable.lisp (file)

Direct superclasses

evolvable (class)

Direct subclasses

hive (class)

Direct methods

evolve (method)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   E   F   L   M  
Index Entry  Section

E
evol.asd: The evol<dot>asd file
evol/src: The evol/src module
evol/src/breeder.lisp: The evol/src/breeder<dot>lisp file
evol/src/common-lisp.lisp: The evol/src/common-lisp<dot>lisp file
evol/src/dependency.lisp: The evol/src/dependency<dot>lisp file
evol/src/environment.lisp: The evol/src/environment<dot>lisp file
evol/src/evolvable.lisp: The evol/src/evolvable<dot>lisp file
evol/src/heredoc.lisp: The evol/src/heredoc<dot>lisp file
evol/src/package.lisp: The evol/src/package<dot>lisp file
evol/src/path.lisp: The evol/src/path<dot>lisp file
evol/src/ring-buffer.lisp: The evol/src/ring-buffer<dot>lisp file
evol/src/shell.lisp: The evol/src/shell<dot>lisp file
evol/src/toplevel.lisp: The evol/src/toplevel<dot>lisp file
evol/src/util.lisp: The evol/src/util<dot>lisp file

F
File, Lisp, evol.asd: The evol<dot>asd file
File, Lisp, evol/src/breeder.lisp: The evol/src/breeder<dot>lisp file
File, Lisp, evol/src/common-lisp.lisp: The evol/src/common-lisp<dot>lisp file
File, Lisp, evol/src/dependency.lisp: The evol/src/dependency<dot>lisp file
File, Lisp, evol/src/environment.lisp: The evol/src/environment<dot>lisp file
File, Lisp, evol/src/evolvable.lisp: The evol/src/evolvable<dot>lisp file
File, Lisp, evol/src/heredoc.lisp: The evol/src/heredoc<dot>lisp file
File, Lisp, evol/src/package.lisp: The evol/src/package<dot>lisp file
File, Lisp, evol/src/path.lisp: The evol/src/path<dot>lisp file
File, Lisp, evol/src/ring-buffer.lisp: The evol/src/ring-buffer<dot>lisp file
File, Lisp, evol/src/shell.lisp: The evol/src/shell<dot>lisp file
File, Lisp, evol/src/toplevel.lisp: The evol/src/toplevel<dot>lisp file
File, Lisp, evol/src/util.lisp: The evol/src/util<dot>lisp file

L
Lisp File, evol.asd: The evol<dot>asd file
Lisp File, evol/src/breeder.lisp: The evol/src/breeder<dot>lisp file
Lisp File, evol/src/common-lisp.lisp: The evol/src/common-lisp<dot>lisp file
Lisp File, evol/src/dependency.lisp: The evol/src/dependency<dot>lisp file
Lisp File, evol/src/environment.lisp: The evol/src/environment<dot>lisp file
Lisp File, evol/src/evolvable.lisp: The evol/src/evolvable<dot>lisp file
Lisp File, evol/src/heredoc.lisp: The evol/src/heredoc<dot>lisp file
Lisp File, evol/src/package.lisp: The evol/src/package<dot>lisp file
Lisp File, evol/src/path.lisp: The evol/src/path<dot>lisp file
Lisp File, evol/src/ring-buffer.lisp: The evol/src/ring-buffer<dot>lisp file
Lisp File, evol/src/shell.lisp: The evol/src/shell<dot>lisp file
Lisp File, evol/src/toplevel.lisp: The evol/src/toplevel<dot>lisp file
Lisp File, evol/src/util.lisp: The evol/src/util<dot>lisp file

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

Jump to:   E   F   L   M  

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

A.2 Functions

Jump to:   (  
A   B   C   D   E   F   G   H   I   J   L   M   N   P   R   S   T   U   W  
Index Entry  Section

(
(setf cl-implementation): Internal generic functions
(setf cl-implementation): Internal generic functions
(setf cl-packages): Internal generic functions
(setf cl-packages): Internal generic functions
(setf cl-save-options): Internal generic functions
(setf cl-save-options): Internal generic functions
(setf dependencies): Internal generic functions
(setf dependencies): Internal generic functions
(setf env-slots): Internal generic functions
(setf env-slots): Internal generic functions
(setf hatched): Internal generic functions
(setf hatched): Internal generic functions
(setf rbref): Internal functions
(setf ring-buffer-end): Internal functions
(setf ring-buffer-new): Internal functions
(setf ring-buffer-start): Internal functions
(setf ring-buffer-used): Internal functions
(setf ring-buffer-vector): Internal functions
(setf rule): Internal generic functions
(setf rule): Internal generic functions
(setf rule): Internal generic functions
(setf rule): Internal generic functions
(setf sourcefn): Internal generic functions
(setf sourcefn): Internal generic functions

A
argument-option: Internal functions

B
breed: Internal generic functions
breed: Internal generic functions
breed: Internal generic functions
breed: Internal generic functions

C
circular-inter-nodes: Internal generic functions
circular-inter-nodes: Internal generic functions
circular-node: Internal generic functions
circular-node: Internal generic functions
cl-implementation: Internal generic functions
cl-implementation: Internal generic functions
cl-load-ops: Internal functions
cl-packages: Internal generic functions
cl-packages: Internal generic functions
cl-run-command: Internal functions
cl-save-options: Internal generic functions
cl-save-options: Internal generic functions
command-failure-code: Internal generic functions
command-failure-code: Internal generic functions
command-failure-command: Internal generic functions
command-failure-command: Internal generic functions
command-failure-stderr: Internal generic functions
command-failure-stderr: Internal generic functions
command-failure-stdout: Internal generic functions
command-failure-stdout: Internal generic functions
copy-ring-buffer: Internal functions

D
default: Internal macros
default-sourcefn: Exported functions
defenv: Exported macros
deflate-string: Internal functions
dependencies: Internal generic functions
dependencies: Internal generic functions
dependency-node: Internal functions
dependency-nodes-hashtable: Internal functions
devolution: Internal macros

E
enqueue-breeding: Internal generic functions
enqueue-breeding: Internal generic functions
env-slots: Internal generic functions
env-slots: Internal generic functions
eval-reverse-cons: Internal macros
evolution-arguments: Internal functions
evolvable-p: Internal functions
evolve: Internal generic functions
evolve: Internal generic functions
evolve: Internal generic functions
evolve: Internal generic functions
evolve: Internal generic functions
evolve: Internal generic functions
evolve: Internal generic functions
evolve: Internal generic functions
evolve: Internal generic functions
evolve: Internal generic functions
evolved-p: Internal generic functions
evolved-p: Internal generic functions
expand: Internal generic functions
expand: Internal generic functions
expand: Internal generic functions
expand: Internal generic functions
expand-$-match: Internal functions
expand-%-match: Internal functions

F
find-node: Internal functions
format-option: Internal functions
Function, (setf rbref): Internal functions
Function, (setf ring-buffer-end): Internal functions
Function, (setf ring-buffer-new): Internal functions
Function, (setf ring-buffer-start): Internal functions
Function, (setf ring-buffer-used): Internal functions
Function, (setf ring-buffer-vector): Internal functions
Function, argument-option: Internal functions
Function, cl-load-ops: Internal functions
Function, cl-run-command: Internal functions
Function, copy-ring-buffer: Internal functions
Function, default-sourcefn: Exported functions
Function, deflate-string: Internal functions
Function, dependency-node: Internal functions
Function, dependency-nodes-hashtable: Internal functions
Function, evolution-arguments: Internal functions
Function, evolvable-p: Internal functions
Function, expand-$-match: Internal functions
Function, expand-%-match: Internal functions
Function, find-node: Internal functions
Function, format-option: Internal functions
Function, getenv: Exported functions
Function, internify: Internal functions
Function, interpolate-$-argument: Internal functions
Function, interpolate-%-argument: Internal functions
Function, interpolate-argument: Internal functions
Function, interpolate-commandline: Internal functions
Function, jobs-breeder: Internal functions
Function, leaf-nodes: Internal functions
Function, load-evolution: Internal functions
Function, make-ring-buffer: Internal functions
Function, mapthread: Internal functions
Function, new-ring-buffer: Internal functions
Function, parse-commandline: Internal functions
Function, pathname-change-suffix: Exported functions
Function, pathname-suffix-p: Exported functions
Function, posix-argv: Internal functions
Function, posix-getenv: Internal functions
Function, posix-quit: Internal functions
Function, print-help: Internal functions
Function, rbref: Internal functions
Function, read-heredoc: Internal functions
Function, read-until-match: Internal functions
Function, repl: Exported functions
Function, replace-with-region: Internal functions
Function, reset-evolvables: Internal functions
Function, resolve-all: Internal functions
Function, resolve-dag: Internal functions
Function, resolve-queue: Internal functions
Function, resolve-roots: Internal functions
Function, ring-buffer-clear: Internal functions
Function, ring-buffer-end: Internal functions
Function, ring-buffer-flush: Internal functions
Function, ring-buffer-insert: Internal functions
Function, ring-buffer-new: Internal functions
Function, ring-buffer-next: Internal functions
Function, ring-buffer-p: Internal functions
Function, ring-buffer-pop: Internal functions
Function, ring-buffer-reset: Internal functions
Function, ring-buffer-start: Internal functions
Function, ring-buffer-used: Internal functions
Function, ring-buffer-vector: Internal functions
Function, root-nodes: Internal functions
Function, run-command: Exported functions
Function, safe-format: Internal functions
Function, safe-getenv: Internal functions
Function, split-commandline: Internal functions
Function, stringify: Internal functions
Function, trim-{}: Internal functions
Function, unix-options-options: Internal functions

G
Generic Function, (setf cl-implementation): Internal generic functions
Generic Function, (setf cl-packages): Internal generic functions
Generic Function, (setf cl-save-options): Internal generic functions
Generic Function, (setf dependencies): Internal generic functions
Generic Function, (setf env-slots): Internal generic functions
Generic Function, (setf hatched): Internal generic functions
Generic Function, (setf rule): Internal generic functions
Generic Function, (setf sourcefn): Internal generic functions
Generic Function, breed: Internal generic functions
Generic Function, circular-inter-nodes: Internal generic functions
Generic Function, circular-node: Internal generic functions
Generic Function, cl-implementation: Internal generic functions
Generic Function, cl-packages: Internal generic functions
Generic Function, cl-save-options: Internal generic functions
Generic Function, command-failure-code: Internal generic functions
Generic Function, command-failure-command: Internal generic functions
Generic Function, command-failure-stderr: Internal generic functions
Generic Function, command-failure-stdout: Internal generic functions
Generic Function, dependencies: Internal generic functions
Generic Function, enqueue-breeding: Internal generic functions
Generic Function, env-slots: Internal generic functions
Generic Function, evolve: Internal generic functions
Generic Function, evolved-p: Internal generic functions
Generic Function, expand: Internal generic functions
Generic Function, hatched: Internal generic functions
Generic Function, illegal-evolvable: Internal generic functions
Generic Function, mutex: Internal generic functions
Generic Function, name: Internal generic functions
Generic Function, reset: Internal generic functions
Generic Function, rule: Internal generic functions
Generic Function, sourcefn: Internal generic functions
Generic Function, stream-lock: Internal generic functions
Generic Function, swarm-error-stream: Internal generic functions
Generic Function, swarm-stream: Internal generic functions
Generic Function, unloadable-evolution-pathname: Internal generic functions
Generic Function, unresolvable-dependency: Internal generic functions
Generic Function, unresolvable-node: Internal generic functions
Generic Function, waitqueue: Internal generic functions
getenv: Exported functions
getf-option: Internal macros

H
hatched: Internal generic functions
hatched: Internal generic functions

I
illegal-evolvable: Internal generic functions
illegal-evolvable: Internal generic functions
internify: Internal functions
interpolate-$-argument: Internal functions
interpolate-%-argument: Internal functions
interpolate-argument: Internal functions
interpolate-commandline: Internal functions

J
jobs-breeder: Internal functions

L
leaf-nodes: Internal functions
load-evolution: Internal functions

M
Macro, default: Internal macros
Macro, defenv: Exported macros
Macro, devolution: Internal macros
Macro, eval-reverse-cons: Internal macros
Macro, getf-option: Internal macros
Macro, resolve-cond: Internal macros
Macro, symbolize: Internal macros
Macro, with-dependency-nodes: Internal macros
Macro, with-new-lock-held: Internal macros
Macro, with-outputs-to-strings: Internal macros
Macro, with-slot-enhanced-environment: Internal macros
make-ring-buffer: Internal functions
mapthread: Internal functions
Method, (setf cl-implementation): Internal generic functions
Method, (setf cl-packages): Internal generic functions
Method, (setf cl-save-options): Internal generic functions
Method, (setf dependencies): Internal generic functions
Method, (setf env-slots): Internal generic functions
Method, (setf hatched): Internal generic functions
Method, (setf rule): Internal generic functions
Method, (setf rule): Internal generic functions
Method, (setf rule): Internal generic functions
Method, (setf sourcefn): Internal generic functions
Method, breed: Internal generic functions
Method, breed: Internal generic functions
Method, breed: Internal generic functions
Method, circular-inter-nodes: Internal generic functions
Method, circular-node: Internal generic functions
Method, cl-implementation: Internal generic functions
Method, cl-packages: Internal generic functions
Method, cl-save-options: Internal generic functions
Method, command-failure-code: Internal generic functions
Method, command-failure-command: Internal generic functions
Method, command-failure-stderr: Internal generic functions
Method, command-failure-stdout: Internal generic functions
Method, dependencies: Internal generic functions
Method, enqueue-breeding: Internal generic functions
Method, env-slots: Internal generic functions
Method, evolve: Internal generic functions
Method, evolve: Internal generic functions
Method, evolve: Internal generic functions
Method, evolve: Internal generic functions
Method, evolve: Internal generic functions
Method, evolve: Internal generic functions
Method, evolve: Internal generic functions
Method, evolve: Internal generic functions
Method, evolve: Internal generic functions
Method, evolved-p: Internal generic functions
Method, expand: Internal generic functions
Method, expand: Internal generic functions
Method, expand: Internal generic functions
Method, hatched: Internal generic functions
Method, illegal-evolvable: Internal generic functions
Method, mutex: Internal generic functions
Method, name: Internal generic functions
Method, reset: Internal generic functions
Method, rule: Internal generic functions
Method, rule: Internal generic functions
Method, rule: Internal generic functions
Method, rule: Internal generic functions
Method, rule: Internal generic functions
Method, sourcefn: Internal generic functions
Method, sourcefn: Internal generic functions
Method, stream-lock: Internal generic functions
Method, swarm-error-stream: Internal generic functions
Method, swarm-stream: Internal generic functions
Method, unloadable-evolution-pathname: Internal generic functions
Method, unresolvable-dependency: Internal generic functions
Method, unresolvable-node: Internal generic functions
Method, waitqueue: Internal generic functions
mutex: Internal generic functions
mutex: Internal generic functions

N
name: Internal generic functions
name: Internal generic functions
new-ring-buffer: Internal functions

P
parse-commandline: Internal functions
pathname-change-suffix: Exported functions
pathname-suffix-p: Exported functions
posix-argv: Internal functions
posix-getenv: Internal functions
posix-quit: Internal functions
print-help: Internal functions

R
rbref: Internal functions
read-heredoc: Internal functions
read-until-match: Internal functions
repl: Exported functions
replace-with-region: Internal functions
reset: Internal generic functions
reset: Internal generic functions
reset-evolvables: Internal functions
resolve-all: Internal functions
resolve-cond: Internal macros
resolve-dag: Internal functions
resolve-queue: Internal functions
resolve-roots: Internal functions
ring-buffer-clear: Internal functions
ring-buffer-end: Internal functions
ring-buffer-flush: Internal functions
ring-buffer-insert: Internal functions
ring-buffer-new: Internal functions
ring-buffer-next: Internal functions
ring-buffer-p: Internal functions
ring-buffer-pop: Internal functions
ring-buffer-reset: Internal functions
ring-buffer-start: Internal functions
ring-buffer-used: Internal functions
ring-buffer-vector: Internal functions
root-nodes: Internal functions
rule: Internal generic functions
rule: Internal generic functions
rule: Internal generic functions
rule: Internal generic functions
rule: Internal generic functions
rule: Internal generic functions
run-command: Exported functions

S
safe-format: Internal functions
safe-getenv: Internal functions
sourcefn: Internal generic functions
sourcefn: Internal generic functions
sourcefn: Internal generic functions
split-commandline: Internal functions
stream-lock: Internal generic functions
stream-lock: Internal generic functions
stringify: Internal functions
swarm-error-stream: Internal generic functions
swarm-error-stream: Internal generic functions
swarm-stream: Internal generic functions
swarm-stream: Internal generic functions
symbolize: Internal macros

T
trim-{}: Internal functions

U
unix-options-options: Internal functions
unloadable-evolution-pathname: Internal generic functions
unloadable-evolution-pathname: Internal generic functions
unresolvable-dependency: Internal generic functions
unresolvable-dependency: Internal generic functions
unresolvable-node: Internal generic functions
unresolvable-node: Internal generic functions

W
waitqueue: Internal generic functions
waitqueue: Internal generic functions
with-dependency-nodes: Internal macros
with-new-lock-held: Internal macros
with-outputs-to-strings: Internal macros
with-slot-enhanced-environment: Internal macros

Jump to:   (  
A   B   C   D   E   F   G   H   I   J   L   M   N   P   R   S   T   U   W  

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

A.3 Variables

Jump to:   *  
C   D   E   H   I   M   N   O   P   R   S   T   U   V   W  
Index Entry  Section

*
*default-evolution*: Internal special variables
*environment*: Exported special variables
*options*: Internal special variables

C
circular-node: Internal conditions
cl-save-options: Internal classes
code: Internal conditions
command: Internal conditions

D
dependencies: Internal classes
dependency: Internal conditions

E
end: Internal structures
env-slots: Internal classes
env-slots: Internal classes
error-stream: Internal classes

H
hatched: Internal classes

I
implementation: Internal classes
inter-nodes: Internal conditions

M
mutex: Internal classes

N
name: Internal classes
new: Internal structures
node: Internal conditions

O
of: Internal classes

P
packages: Internal classes
pathname: Internal conditions

R
rule: Internal classes
rule: Internal classes
rule: Internal classes
rule: Internal classes
rule: Internal classes

S
Slot, circular-node: Internal conditions
Slot, cl-save-options: Internal classes
Slot, code: Internal conditions
Slot, command: Internal conditions
Slot, dependencies: Internal classes
Slot, dependency: Internal conditions
Slot, end: Internal structures
Slot, env-slots: Internal classes
Slot, env-slots: Internal classes
Slot, error-stream: Internal classes
Slot, hatched: Internal classes
Slot, implementation: Internal classes
Slot, inter-nodes: Internal conditions
Slot, mutex: Internal classes
Slot, name: Internal classes
Slot, new: Internal structures
Slot, node: Internal conditions
Slot, of: Internal classes
Slot, packages: Internal classes
Slot, pathname: Internal conditions
Slot, rule: Internal classes
Slot, rule: Internal classes
Slot, rule: Internal classes
Slot, rule: Internal classes
Slot, rule: Internal classes
Slot, sourcefn: Internal classes
Slot, sourcefn: Internal classes
Slot, spawn: Internal classes
Slot, start: Internal structures
Slot, stderr: Internal conditions
Slot, stdout: Internal conditions
Slot, stream: Internal classes
Slot, stream-lock: Internal classes
Slot, target: Internal conditions
Slot, used: Internal structures
Slot, vector: Internal structures
Slot, waitqueue: Internal classes
sourcefn: Internal classes
sourcefn: Internal classes
spawn: Internal classes
Special Variable, *default-evolution*: Internal special variables
Special Variable, *environment*: Exported special variables
Special Variable, *options*: Internal special variables
start: Internal structures
stderr: Internal conditions
stdout: Internal conditions
stream: Internal classes
stream-lock: Internal classes

T
target: Internal conditions

U
used: Internal structures

V
vector: Internal structures

W
waitqueue: Internal classes

Jump to:   *  
C   D   E   H   I   M   N   O   P   R   S   T   U   V   W  

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

A.4 Data types

Jump to:   B   C   D   E   F   G   H   I   P   R   S   U   V  
Index Entry  Section

B
breeder: Internal classes

C
checkable: Internal classes
circular-dependency: Internal conditions
cl-core: Internal classes
cl-exe: Internal classes
cl-transformator: Internal classes
Class, breeder: Internal classes
Class, checkable: Internal classes
Class, cl-core: Internal classes
Class, cl-exe: Internal classes
Class, cl-transformator: Internal classes
Class, definite: Internal classes
Class, evolvable: Internal classes
Class, executable: Internal classes
Class, file: Internal classes
Class, generic: Internal classes
Class, generic-transformator: Internal classes
Class, hive: Internal classes
Class, program: Internal classes
Class, swarm: Internal classes
Class, virtual: Internal classes
command-failure: Internal conditions
Condition, circular-dependency: Internal conditions
Condition, command-failure: Internal conditions
Condition, illegal-evolvable: Internal conditions
Condition, unemployment: Internal conditions
Condition, unloadable-evolution: Internal conditions
Condition, unresolvable-dependency: Internal conditions

D
definite: Internal classes

E
evol: The evol system
evol: The evol package
evol-system: The evol-system package
evolvable: Internal classes
executable: Internal classes

F
file: Internal classes

G
generic: Internal classes
generic-transformator: Internal classes

H
hive: Internal classes

I
illegal-evolvable: Internal conditions

P
Package, evol: The evol package
Package, evol-system: The evol-system package
program: Internal classes

R
ring-buffer: Internal structures

S
Structure, ring-buffer: Internal structures
swarm: Internal classes
System, evol: The evol system

U
unemployment: Internal conditions
unloadable-evolution: Internal conditions
unresolvable-dependency: Internal conditions

V
virtual: Internal classes

Jump to:   B   C   D   E   F   G   H   I   P   R   S   U   V