The april Reference Manual

Table of Contents

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

The april Reference Manual

This is the april Reference Manual, version 0.9.1, generated automatically by Declt version 2.4 patchlevel 1 "Will Decker" on Mon Jul 29 14:29:27 2019 GMT+0.


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

1 Introduction

April

Array Programming Re-Imagined in Lisp


Ken Iverson's masterpiece reflected in the medium of Lisp.

April compiles a subset of the APL programming language into Common Lisp. Leveraging Lisp's powerful macros and numeric processing faculties, it brings APL's expressive potential to bear for Lisp developers. Replace hundreds of lines of number-crunching code with a single line of APL.

Why April?

APL veritably hums with algorithmic power. As a handful of characters run past the lexer, vast fields of data grow, morph and distil to reveal their secrets. However, APL has hitherto dwelt in an ivory tower, secluded inside monolithic runtime environments. If you have a store of data you'd like to use with APL, getting it there can be an ordeal. Like hauling tons of cargo on donkeys' backs through a narrow mountain pass, it's not fun, and the prospect of it has ended many discussions of APL before they could begin.

But no longer. Lisp is the great connector of the software world, digesting and transforming semantic patterns in much the same way that APL transforms numeric patterns. With APL inside of Lisp, databases, streams, binary files and other media are just a few lines of code away from processing with APL.

Automatic Installation

April is supplied by the Quicklisp library manager, so the easiest way to install April is through Quicklisp. April depends on Common Lisp, ASDF and Quicklisp. It has been tested with Steel Bank Common Lisp (SBCL), Clozure Common Lisp (CCL), Embeddable Common Lisp (ECL), Armed Bear Common Lisp (ABCL) and LispWorks.

Note: Some special configuration may be needed to use April with the LispWorks IDE due to the use of UTF-8 characters. Click here for a guide to configuring LispWorks for compatibility with April. Currently April can only be used with the LispWorks IDE, not the CLI environment, as the LispWorks CLI edition does not support UTF-8.

To install April with Quicklisp, evaluate:

(ql:quickload 'april)

Manual Installation

If you'd like to install April manually from this repository, you can follow these instructions.

Cloning the Repository

First, clone the repository to a location on your system. For this example, let's say you cloned it to the directory ~/mystuff/april.

Preparing Quicklisp

Enter your Quicklisp local-projects directory (usually ~/quicklisp/local-projects) and create a symbolic link to the directory where you cloned the April repository. For example, if you cloned the repo to ~/mystuff/april and your Quicklisp directory is ~/quicklisp/, enter:

cd ~/quicklisp/local-projects
ln -s ~/mystuff/april

Installing Dependencies

To complete the installation, just start a Common Lisp REPL and enter:

(ql:quickload 'april)

This will download and install April's dependencies, and with that the package will be built and ready.

APL Functions and Operators

The APL language uses single characters to represent its primitive functions and operators. Most of these symbols are not part of the standard ASCII character set but are unique to APL. To see a list of the glyphs that are supported by April, visit the link below.

See the complete April APL lexicon here.

Some APL functions and operators won't be added to April since they don't make sense for April's design as a compiler from APL to Lisp. Others may be added in the future. See the list of features not implemented here.

Getting to Know APL

A full guide to the APL language is far beyond the scope of this file, but here are links to some good sources.

A high-level introduction to APL.

This is a detailed language tutorial covering most of the functions and operators in April.

The original paper by Ken Iverson, creator of APL, detailing the language's underlying philosophy.

If you would like a quick tour of the language, April includes a function that will print demos of all the commands and many APL syntax features. To see the demos, enter:

* (april (demo))

The * indicates a REPL prompt. Prepare for a long read. The demo content that gets printed will tell you the name(s) of the operations that correspond to each symbol and will hopefully give you some idea of what each one does.

How to Enter APL Characters

In order to write APL programs you'll need a way to use the language's special character set.

Click here for information on enabling APL input within Emacs.

Basic Evaluation: (april) and (april-p)

Evaluating an APL expression is as simple as:

* (april-p "1+2 3 4")
3 4 5
#(3 4 5)

As above, the * indicates a REPL prompt and the text below is the expression's output.

The macro (april-p) will evaluate any APL string passed to it as the sole argument, returning the final result. Using (april-p) will also produce a printout of the output in APL's traditional array printing style, which appears before the actual output value. You can see above how the 3 4 5 is printed out before the value #(3 4 5). APL-style printed arrays are easier to read than Lisp's style of printing arrays; APL can use a simpler style to express its output because it doesn't have as many different data types and structures as Lisp.

If you don't need to see the printout, you can use the plain (april) macro. Like this:

* (april "1+2 3 4")
#(3 4 5)

You should use (april) if you're using April to do calculations inside of a larger program and don't need the printout. Otherwise, especially if you're working with large data sets, the system may consume significant resources printing out the results of calculations.

Also note that if the output of an April expression is a single number, (april-p) will not print it since the Lisp representation of the number will look the same or very similar. For example:

* (april-p "1+2")
3

Since the result of 1+2 is 3, a single number, no value printout is provided.

Setting state properties for the APL instance can be done like this:

* (april-p (with (:state :count-from 0)) "⍳9")
0 1 2 3 4 5 6 7 8
#(0 1 2 3 4 5 6 7 8)

Instead of an APL string, the first argument to (april) or (april-p) may be a list of parameters for the APL environment. The APL expression is then passed in the second argument.

For example, you can use the :count-from parameter to determine whether the APL instance will start counting from 0 or 1. We'll get into more detail on how these parameters work later.

* (april-p (with (:state :count-from 1)) "⍳9")
1 2 3 4 5 6 7 8 9
#(1 2 3 4 5 6 7 8 9)

* (april-p (with (:state :count-from 0)) "⍳9")
0 1 2 3 4 5 6 7 8
#(0 1 2 3 4 5 6 7 8)

More APL expressions:

* (april-p "⍳12")
1 2 3 4 5 6 7 8 9 10 11 12
#(1 2 3 4 5 6 7 8 9 10 11 12)

* (april-p "3 4⍴⍳12")
1  2  3  4
5  6  7  8
9 10 11 12
#2A((1 2 3 4) (5 6 7 8) (9 10 11 12))

* (april-p "+/3 4⍴⍳12")
10 26 42
#(10 26 42)

* (april-p "+⌿3 4⍴⍳12")
15 18 21 24
#(15 18 21 24)

* (april-p "+/[1]3 4⍴⍳12")
15 18 21 24
#(15 18 21 24)

* (april-p "⌽3 4⍴⍳12")
 4  3  2 1
 8  7  6 5
12 11 10 9
#2A((4 3 2 1) (8 7 6 5) (12 11 10 9))

* (april-p "1⌽3 4⍴⍳12")
 2  3  4 1
 6  7  8 5
10 11 12 9
#2A((2 3 4 1) (6 7 8 5) (10 11 12 9))

Parameter reference

When (april) or (april-p) is called, you may pass it either a single text string:

* (april-p "1+1 2 3")

Or a parameter object followed by a text string:

* (april-p (with (:state :count-from 0)) "⍳9")

This section details the parameters you can pass to April.

(test)

To run April's test suite, just enter:

* (april (test))

(demo)

As mentioned before, you can see demos of April's functions with:

* (april (demo))

(with)

(with) is the workhorse of April parameters, allowing you to configure your April instance in many ways. The most common sub-parameter passed via (with) is (:state). To wit:

* (april (with (:state :count-from 0
                       :in ((a 3) (b 5))
                       :out (a c)))
         "c←a+⍳b")
3
#(3 4 5 6 7)

(:state) sub-parameters

Let's learn some more about what's going on in that code. The sub-parameters of (:state) are:

:count-from

Sets the index from which April counts. Almost always set to 0 or 1. The default value is 1. In the code above, ⍳b with b equal to 5 counts from 0 to 4, whereas with the default :count-from value of 1, ⍳b would count from 1 to 5.

:in

Passes variables into the April instance that may be used when evaluating the subsequent expressions. In the example above, the variables a and b are set in the code, with values 1 and 2 respectively. You can use :in to pass values from Lisp into the April instance.

* (april-p (with (:state :in ((a 5) (b 10))))
           "1+2+a×b")
53

Please note that April variables follow a stricter naming convention than Lisp variables. When naming the input variables, only alphanumeric characters, underscores and dashes may be used. In keeping with APL tradition, the delta/triangle characters ∆ and ⍙ can be used in variable names as well. Punctuation marks like ?, >, . and ! may not be used as they have separate meanings in April.

These characters are allowed in variable names within April:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_∆⍙

These variable names are ok for use with the :in parameter:

a var my_var another-var

These are not ok:

true! this->that pass/fail? var.name

If you use dashes in the names of Lisp variables you pass into April, note that inside April they will be converted to camel case. For example:

* (april-p (with (:state :in ((one-var 2)
                              (other-var 5))))
           "oneVar×otherVar+5")
20

The dash character - is used to denote the subtraction function inside April, so you may not use dashes in variable names within the language.

One more caveat: it's best to avoid using input variable names with a dash before a number or other non-letter symbol. The dash will be removed and the character following it will cannot be capitalized so information will have been lost. For example:

my-var-2 → myVar2
my-var-∆ → myVar∆

:out

Lists variables to be output when the code has finished evaluating. By default, the value of the last evaluated expression is passed back after an April evaluation is finished. For example:

* (april-p "1+2
            2+3
            3+4")
7

The last value calculated is displayed. The :out sub-parameter allows you to list a set of variables that whose values will be returned once evaluation is complete. For example:

* (april-p (with (:state :out (a b c)))
           "a←9+2
            b←5+3
            c←2×9")
11
8
18

:index-origin

This is another, more technical name for the :count-from sub-parameter. You can use it instead of :count-from:

* (april-p (with (:state :index-origin 0)) "⍳9")
0 1 2 3 4 5 6 7 8
#(0 1 2 3 4 5 6 7 8)

:disclose-output

In APL, there's really no such thing as a value outside an array. Every piece of data used within an April instance is an array. When you enter something like 1+1, you're actually adding two arrays containing a single value, 1, and outputting another array containing the value 2. When April returns arrays like this, its default behavior is to disclose them like this:

* (april-p "1+1")
2

But if you set the :disclose-output option to nil, you can change this:

* (april-p (with (:state :disclose-output nil)) "1+1")
#(2)

With :disclose-output set to nil, unitary vectors will be passed directly back without having their values disclosed.

:print-precision

This controls the maximal precision at which April prints floating point numbers. Its default value is 10. For example:

* (april-p "○1 2 3")
3.141592654 6.283185307 9.424777961	
#(3.141592653589793d0 6.283185307179586d0 9.42477796076938d0)

* (april-p (with (:state :print-precision 6)) "○1 2 3")
3.14159 6.28319 9.42478
#(3.141592653589793d0 6.283185307179586d0 9.42477796076938d0)

* (april-p (with (:state :print-precision 3)) "○1 2 3")
3.14 6.28 9.42
#(3.141592653589793d0 6.283185307179586d0 9.42477796076938d0)

Note that :print-precision doesn't affect the Lisp values output by April, only the printed output.

:print-to

When using (april-p), the formatted array content is output to the *standard-output* stream. When using (april), no formatted output is printed. You can change this using the :print-to sub-parameter. For example:

* (april (with (:state :print-to *standard-output*)) "2 3⍴⍳9")
1 2 3
4 5 6
#2A((1 2 3) (4 5 6))

* (april-p (with (:state :print-to nil)) "2 3⍴⍳9")
#2A((1 2 3) (4 5 6))

Using the :print-to parameter effectively erases the distinction between (april) and (april-p). The two different macros are provided as a courtesy so you don't need to pass a :print-to parameter to get printed output. You can also pass a different stream than *standard-output* to :print-to to have the printed output directed there.

:output-printed

When the :output-printed sub-parameter is passed, the string of APL-formatted data that gets printed will also be returned as the last output value by the April invocation. For example:

* (april (with (:state :output-printed t)) "2 3⍴⍳9")
#2A((1 2 3) (4 5 6))
"1 2 3
4 5 6
"

If you don't want to receive the Lisp value output by April and only want the formatted string as output, you can pass the :only option to :output-printed, like this:

* (april (with (:state :output-printed :only)) "2 3⍴⍳9")
"1 2 3
4 5 6
"

This way, the formatted string will be the only returned value.

(:space) sub-parameter

If you want to create a persistent workspace where the functions and variables you've created are stored and can be used in multiple calls to April, use the (:space) parameter. For example:

* (april-p (with (:space *space1*)) "a←5+2 ⋄ b←3×9")
27

* (april-p (with (:space *space1*)) "c←{⍵+2}")
#<FUNCTION ... >

* (april-p (with (:space *space1*)) "c a+b")
36

In the above example, a workspace called *space1* is created, two variables and a function are stored within it, and then the function is called on the sum of the variables. When you invoke the (:space) parameter followed by a symbol that is not defined, the symbol is set to point to a dynamic variable containing a hash table that stores the workspace data.

(:state-persistent) sub-parameters

You can use the (:state-persistent) parameter to set state values within the workspace. It works like (:state), but the difference is that when you change the state using (:state-persistent), those changes will stay saved in the workspace until you reverse them, whereas the changes you make with :state are lost once the following code is done evaluating.

For example:

* (april-p (with (:state-persistent :count-from 0) (:space *space1*)) "⍳7")
0 1 2 3 4 5 6
#(0 1 2 3 4 5 6)

* (april-p (with (:space *space1*)) "⍳7")
0 1 2 3 4 5 6
#(0 1 2 3 4 5 6)

* (april-p (with (:space *space2*)) "⍳7")
1 2 3 4 5 6 7
#(1 2 3 4 5 6 7)

Did you notice that when switching to a different space, in this case *space2*, the customized values are lost? Custom state settings affect only the specific workspace where they are set.

You can use (:state-persistent) to set persistent input variables that will stay available for each piece of code you run in your April instance. If these input variables refer to external Lisp variables, changing the external variables will change the values available to April. For example:

* (defvar *dynamic-var* 2)
*DYNAMIC-VAR*

* (april-p (with (:state-persistent :in ((dyn-var *dynamic-var*)))
                 (:space *space1*))
           "dynVar⍟512")
9.0

* (setq *dynamic-var* 8)
8

* (april-p (with (:space *space1*)) "dynVar⍟512")
3.0

(:compile-only) parameter

If you just want to compile the code you enter into April without running it, use this option. For example:

* (april (with (:compile-only)) "1+1 2 3")
(LET* ((INDEX-ORIGIN 1) (PRINT-PRECISION 10))
  (DECLARE (IGNORABLE INDEX-ORIGIN PRINT-PRECISION))
  (APL-OUTPUT
   (DISCLOSE-ATOM (APL-CALL + (SCALAR-FUNCTION +) (AVECTOR 1 2 3) (AVECTOR 1)))
   :PRINT-PRECISION PRINT-PRECISION))

(:restore-defaults) parameter

You can use this parameter to clear a workspace and return it to its default state. For example, to clear a workspace called *space1* enter:

* (april (with (:restore-defaults) (:space *space1*)))

All :in and :out values will be nullified, :count-from will return to its default setting, etc.

Sharing Scope: The (with-april-context) Macro

Perhaps you'd like to make multiple calls to April using the same workspace and other parameters and you don't want to have to enter the same parameters over and over again. The (with-april-context) macro can help. For example:

* (with-april-context ((:space *space1*) (:state :index-origin 0))
    (april "g←5")
    (april "g×3+⍳9"))
#(15 20 25 30 35 40 45 50 55)

Inside the body of the (with-april-context) macro, each of the (april) invocations act as if they were passed the options (with (:space *space1*) (:state :index-origin 0)).

* (with-april-context ((:space *space1*) (:state :index-origin 0))
    (april "x←⍳3")
    (april (with (:state :index-origin 1)) "x,⍳5"))
#(0 1 2 1 2 3 4 5)

Options passed for one of the (april) invocations inside the context will override the options for the context. Here, the second (april) invocation has its index origin set to 1 which overrides the context's 0 value.

Console Output Using the Quad Character

The (april-p) macro is one way to view the printed output of APL expressions. What if you want to see the result of an evaluation that occurs in the middle of your code instead of the end, or if you want to print the contents of multiple arrays within a single expression? At times like these, you can use the character, also called "quad." In APL, console output can be produced by "assigning" values to like this:

* (april "a←1 2 3 ⋄ b←3+⎕←2+a ⋄ ⎕←c←4+b ⋄ c+5")
3 4 5
10 11 12
#(15 16 17)

Both of the values assigned to are printed in order before the expression's final result is output. Because (april) is used instead of (april-p), no formatted values are printed by default; only the values assigned to are printed. Using , it's easy to debug complex functions.

APL System Variables and Functions in April

April makes available the following APL system variables and functions:

⎕IO ⎕TS ⎕PP ⎕AV ⎕A ⎕D

Additionally, April exposes this special system variable not found in other APL implementations:

⎕OST

Click here to read the names and descriptions of these symbols.

Setting a Custom Output Stream

April has a special system variable called ⎕ost that you can use to set a custom destination for printed output. Normally, data output using (april-p) or values assigned to the quad character like ⎕←1 2 3 are sent to the *standard-output* stream. You can change this as follows:

* (let* ((out-str (make-string-output-stream))
	 (vector (april-p "a←1 2 3 ⋄ ⎕ost←'OUT-STR' ⋄ ⎕←a+5 ⋄ ⎕←3 4 5 ⋄ ⎕ost←'*STANDARD-OUTPUT*' ⋄ 3+a")))
    (princ (get-output-stream-string out-str))
    vector)
4 5 6
6 7 8
3 4 5
#(4 5 6)

Within the APL expression, the output stream is set to OUT-STR, two vectors are output to that stream, and then the stream is reset to *STANDARD-OUTPUT* before the expression ends and prints its final output. When the code runs, first the APL-formatted output from the (april-p) expression is printed. Then, the two APL-formatted strings output to the out-str stream are printed. Finally, the Lisp vector that resulted from the (april-p) expression is printed.

Remember to use all caps when setting the ⎕ost variable, unless your desired output stream is referenced by a literal lowercase symbol like |output-stream|.

What's Not Planned for Implementation

Functions:

⍇ File read
⍈ File write
⍐ File hold
⍗ File drop
⎕ Evaluated input
⎕ Output with newline
⍞ Character input
⍞ Bare output

Operators:

& Spawn
⌶ I-Beam

(Click here to see the functions and operators that have been implemented.)

See a pattern? The functions not planned for implentation are all those that manifest low-level interactions between the APL instance and the underlying computer system. Common Lisp already has powerful tools for system interaction, so it's presumed that developers will do things like this outside of April.

Also Not Implemented

APL's function editor system and control flow statements are not implemented; this type of functionality is also readily accessible through standard Common Lisp.

Tests and Demo

If you missed it earlier, you can run tests for the implemented APL functions and operators by entering:

* (april (test))

And you can see a demonstration of April language features by entering:

* (april (demo))

Enabling APL Input in Emacs

Most Lisp developers interact with the language through Emacs, so Emacs is also the most convenient tool to write April programs. The best way to input APL characters in Emacs is using the gnu-apl-mode Emacs plugin. You can get it from the repository here or install it directly via the MELPA Emacs package repository.

Click here for information on using MELPA.

Once gnu-apl-mode is installed, you can switch to the APL input mode by typing M-x toggle-input-method or C-\. You will be prompted to enter the input mode to use, so enter APL-Z and then you'll be able to toggle APL input on and off by typing C-\. While in APL-Z input mode, you can enter APL characters by prefixing the key with a . period character.

Thanks to:

Tama


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

2 Systems

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


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

2.1 april

Author

Andrew Sengul

License

Apache-2.0

Description

April is a subset of the APL programming language that compiles to Common Lisp.

Version

0.9.1

Dependencies
Source

april.asd (file)

Components

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

2.2 vex

Author

Andrew Sengul

License

Apache-2.0

Description

A set of templates for implementing your own vector programming language that compiles to Common Lisp.

Version

0.8.5

Dependencies
Source

vex.asd (file)

Components

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

2.3 aplesque

Author

Andrew Sengul

License

Apache-2.0

Description

A collection of array manipulation functions patterned after functions from the APL language.

Version

0.9.1

Dependencies
Source

aplesque.asd (file)

Components

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

3 Files

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


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

3.1 Lisp


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

3.1.1 april.asd

Location

april.asd

Systems

april (system)


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

3.1.2 vex.asd

Location

vex/vex.asd

Systems

vex (system)


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

3.1.3 aplesque.asd

Location

aplesque/aplesque.asd

Systems

aplesque (system)


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

3.1.4 april/package.lisp

Parent

april (system)

Location

package.lisp

Packages

april


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

3.1.5 april/library.lisp

Dependency

package.lisp (file)

Parent

april (system)

Location

library.lisp

Internal Definitions

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

3.1.6 april/utilities.lisp

Dependency

library.lisp (file)

Parent

april (system)

Location

utilities.lisp

Packages

april.idiom-extension-tools

Exported Definitions

array-to-nested-vector (function)

Internal Definitions

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

3.1.7 april/grammar.lisp

Dependency

utilities.lisp (file)

Parent

april (system)

Location

grammar.lisp

Internal Definitions

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

3.1.8 april/patterns.lisp

Dependency

grammar.lisp (file)

Parent

april (system)

Location

patterns.lisp

Internal Definitions

composer-optimized-patterns-common (function)


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

3.1.9 april/spec.lisp

Dependency

patterns.lisp (file)

Parent

april (system)

Location

spec.lisp

Exported Definitions
Internal Definitions

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

3.1.10 april/game-of-life.lisp

Dependency

spec.lisp (file)

Parent

april (system)

Location

game-of-life.lisp

Internal Definitions

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

3.1.11 vex/package.lisp

Parent

vex (system)

Location

vex/package.lisp

Packages

vex


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

3.1.12 vex/vex.lisp

Dependency

package.lisp (file)

Parent

vex (system)

Location

vex/vex.lisp

Exported Definitions
Internal Definitions

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

3.1.13 aplesque/package.lisp

Parent

aplesque (system)

Location

aplesque/package.lisp

Packages

aplesque


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

3.1.14 aplesque/aplesque.lisp

Dependency

package.lisp (file)

Parent

aplesque (system)

Location

aplesque/aplesque.lisp

Exported Definitions
Internal Definitions

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

4 Packages

Packages are listed by definition order.


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

4.1 april

Source

package.lisp (file)

Use List
Exported Definitions
Internal Definitions

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

4.2 april.idiom-extension-tools

Source

utilities.lisp (file)


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

4.3 vex

Source

package.lisp (file)

Use List
Used By List

april

Exported Definitions
Internal Definitions

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

4.4 aplesque

Source

package.lisp (file)

Use List
Used By List

april

Exported Definitions
Internal Definitions

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

5 Definitions

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


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

5.1 Exported definitions


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

5.1.1 Macros

Macro: april G1 &optional G2
Package

april

Source

spec.lisp (file)

Macro: april-load G1 &optional G4
Package

april

Source

spec.lisp (file)

Macro: april-p &rest G1
Package

april

Source

spec.lisp (file)

Macro: boolean-op OPERATION

Wrap a boolean operation for use in a vector language, converting the t or nil it returns to 1 or 0.

Package

vex

Source

vex.lisp (file)

Macro: extend-vex-idiom SYMBOL &rest SUBSPECS

Wraps the idiom-spec macro for an extension of a Vex idiom.

Package

vex

Source

vex.lisp (file)

Macro: local-idiom SYMBOL

Shorthand macro to output the name of a Vex idiom in the local package.

Package

vex

Source

vex.lisp (file)

Macro: matrix-print INPUT &rest OPTIONS

Print a character matrix generated by array-impress.

Package

aplesque

Source

aplesque.lisp (file)

Macro: reverse-op IS-DYADIC &optional OPERATION

Wrap a function so as to reverse the arguments passed to it, so (- 5 10) will result in 5.

Package

vex

Source

vex.lisp (file)

Macro: set-composer-elements NAME WITH &rest PARAMS

Specify basic language elements for a Vex composer.

Package

vex

Source

vex.lisp (file)

Macro: set-composer-patterns NAME WITH &rest PARAMS

Generate part of a Vex grammar from a set of parameters.

Package

vex

Source

vex.lisp (file)

Macro: specify-vex-idiom SYMBOL &rest SUBSPECS

Wraps the idiom-spec macro for an initial specification of a Vex idiom.

Package

vex

Source

vex.lisp (file)

Macro: with-april-context G1 &rest G3
Package

april

Source

spec.lisp (file)


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

5.1.2 Functions

Function: across INPUT FUNCTION &key ELEMENTS INDICES REVERSE-AXES DIMENSIONS

Iterate across a range of elements in an array, with the option of specifying which elements within each dimension to process.

Package

aplesque

Source

aplesque.lisp (file)

Function: alpha-compare ATOMIC-VECTOR COMPARE-BY

Compare the contents of a vector according to their positions in an array, as when comparing an array of letters by their positions in the alphabet.

Package

aplesque

Source

aplesque.lisp (file)

Function: array-compare ITEM1 ITEM2

Perform a deep comparison of two APL arrays, which may be multidimensional or nested.

Package

aplesque

Source

aplesque.lisp (file)

Function: array-depth INPUT &optional LAYER UNIFORM POSSIBLE-DEPTH

Find the maximum depth of nested arrays within an array.

Package

aplesque

Source

aplesque.lisp (file)

Function: array-grade COMPARE-BY INPUT

Grade an array.

Package

aplesque

Source

aplesque.lisp (file)

Function: array-impress INPUT &key PREPEND APPEND COLLATE FORMAT

Render the contents of an array into a character matrix or, if the collate option is taken, an array with sub-matrices of characters.

Package

aplesque

Source

aplesque.lisp (file)

Function: array-inner-product OPERAND1 OPERAND2 FUNCTION1 FUNCTION2

Find the inner product of two arrays with two functions.

Package

aplesque

Source

aplesque.lisp (file)

Function: array-promote INPUT

Promote an array to the next rank. The existing content will occupy 1 unit of the new dimension.

Package

aplesque

Source

aplesque.lisp (file)

Function: array-to-list INPUT

Convert array to list.

Package

aplesque

Source

aplesque.lisp (file)

Function: array-to-nested-vector ARRAY

Convert an array to a nested vector. Useful for applications such as JSON conversion where multidimensional arrays must be converted to nested vectors.

Package

april

Source

utilities.lisp (file)

Function: assign-element-type ITEM

Find a type suitable for an APL array to hold a given item.

Package

aplesque

Source

aplesque.lisp (file)

Function: binomial N K

Find a binomial using the above sprfact function.

Package

aplesque

Source

aplesque.lisp (file)

Function: catenate A1 A2 AXIS

Join two arrays together along the specified axis.

Package

aplesque

Source

aplesque.lisp (file)

Function: choose INPUT AINDICES &key FN SET SET-COORDS

Retrieve and/or change elements of an array allowing elision, returning a new array whose shape is determined by the elision and number of indices selected unless indices for just one value are passed.

Package

aplesque

Source

aplesque.lisp (file)

Function: composer IDIOM SPACE TOKENS &optional PRECEDENT PROPERTIES

Compile processed tokens output by the parser into code according to an idiom’s grammars and primitive elements.

Package

vex

Source

vex.lisp (file)

Function: disclose ITEM &key IF-ARRAY

If the argument is an array with only one member, disclose it, otherwise do nothing.

Package

aplesque

Source

aplesque.lisp (file)

Function: disclose-unitary-array ITEM

Disclose an array if it’s unitary, otherwise pass it back unchanged.

Package

aplesque

Source

aplesque.lisp (file)

Function: each-boolean TEST OMEGA

Iterate over an array/arrays of scalar values, performing operations upon them that will result in boolean values to be returned in an array with the same shape as the input array(s).

Package

aplesque

Source

aplesque.lisp (file)

Function: each-scalar FUNCTION OMEGA

Iterate over an array/arrays of scalar values, operating upon them and returning the output in the most efficiently-stored array capable of holding said output.

Package

aplesque

Source

aplesque.lisp (file)

Function: enclose ITEM

Enclose non-array values, passing through arguments that are already arrays.

Package

aplesque

Source

aplesque.lisp (file)

Function: enclose-atom ITEM

Enclose non-array values, passing through arguments that are already arrays.

Package

aplesque

Source

aplesque.lisp (file)

Function: enlist INPUT &optional INTERNAL OUTPUT OUTPUT-LENGTH

Create a vector containing all elements of the input array in ravel order, breaking down nested and multidimensional arrays.

Package

aplesque

Source

aplesque.lisp (file)

Function: expand-array DEGREES INPUT AXIS &key COMPRESS-MODE

Expand an input array as per a vector of degrees, with the option to manifest zero values in the degree array as zeroes in the output in place of the original input values or to omit the corresponding values altogether if the :compress-mode option is used.

Package

aplesque

Source

aplesque.lisp (file)

Function: find-array INPUT TARGET

Find instances of an array within a larger array.

Package

aplesque

Source

aplesque.lisp (file)

Function: grade INPUT COUNT-FROM COMPARE-BY

Grade an array, using vector grading if 1-dimensional or decomposing the array into vectors and comparing those if multidimensional.

Package

aplesque

Source

aplesque.lisp (file)

Function: index-of TO-SEARCH SET COUNT-FROM

Find occurrences of members of one set in an array and create a corresponding array with values equal to the indices of the found values in the search set, or one plus the maximum possible found item index if the item is not found in the search set.

Package

aplesque

Source

aplesque.lisp (file)

Function: interval-index ATOMIC-VECTOR

Return a function to find the locations of indices of an array between the indices of a reference array.

Package

aplesque

Source

aplesque.lisp (file)

Function: invert-matrix IN-MATRIX

Find the inverse of a square matrix.

Package

aplesque

Source

aplesque.lisp (file)

Function: is-unitary VALUE

Check whether this array has only one member, returning true if the argument is not an array.

Package

aplesque

Source

aplesque.lisp (file)

Function: laminate A1 A2 AXIS

Join the two arrays along a new axis inserted before the specified axis, the new axis having a length of 2.

Package

aplesque

Source

aplesque.lisp (file)

Function: make-back-scanner FUNCTION

Build a function to scan across an array, modifying each value as determined by prior values.

Package

aplesque

Source

aplesque.lisp (file)

Function: merge-arrays INPUT

Merge a set of arrays with the same rank and shape into a larger array.

Package

aplesque

Source

aplesque.lisp (file)

Function: mix-arrays AXIS INPUT

Combine an array of nested arrays into a higher-rank array, removing a layer of nesting.

Package

aplesque

Source

aplesque.lisp (file)

Function: partition-array POSITIONS INPUT AXIS

Split an array into an array of vectors divided according to an array of positions.

Package

aplesque

Source

aplesque.lisp (file)

Function: partitioned-enclose POSITIONS INPUT AXIS

Enclose parts of an input array partitioned according to the ’positions’ argument.

Package

aplesque

Source

aplesque.lisp (file)

Function: ravel COUNT-FROM INPUT &optional AXES

Produce a vector from the elements of a multidimensional array.

Package

aplesque

Source

aplesque.lisp (file)

Function: re-enclose MATRIX AXES

Convert an array into a set of sub-arrays within a larger array. The dimensions of the containing array and the sub-arrays will be some combination of the dimensions of the original array. For example, a 2 x 3 x 4 array may be composed into a 3-element vector containing 2 x 4 dimensional arrays.

Package

aplesque

Source

aplesque.lisp (file)

Function: reshape-to-fit INPUT OUTPUT-DIMS

Reshape an array into a given set of dimensions, truncating or repeating the elements in the array until the dimensions are satisfied if the new array’s size is different from the old.

Package

aplesque

Source

aplesque.lisp (file)

Function: scale-array UNITARY TO-MATCH &optional AXIS

Scale up a 1-element array to fill the dimensions of the given array.

Package

aplesque

Source

aplesque.lisp (file)

Function: scan-back FUNCTION INPUT &optional OUTPUT

Scan a function backwards across an array.

Package

aplesque

Source

aplesque.lisp (file)

Function: section INPUT DIMENSIONS &key INVERSE FILL-WITH

Take a subsection of an array of the same rank and given dimensions as per APL’s ↑ function, or invert the function as per APL’s ↓ function to take the elements of an array excepting a specific dimensional range.

Package

aplesque

Source

aplesque.lisp (file)

Function: split-array INPUT &optional AXIS

Split an array into a set of sub-arrays.

Package

aplesque

Source

aplesque.lisp (file)

Function: sprfact N

Recursive factorial-computing function. Based on P. Luschny’s code.

Package

aplesque

Source

aplesque.lisp (file)

Function: stencil INPUT PROCESS WINDOW-DIMS MOVEMENT

Apply a given function to sub-arrays of an array with specified dimensions sampled according to a given pattern of movement across the array.

Package

aplesque

Source

aplesque.lisp (file)

Function: turn INPUT AXIS &optional DEGREES

Rotate an array on a given axis by a given number of degrees or an array containing degree values for each sub-vector.

Package

aplesque

Source

aplesque.lisp (file)

Function: type-in-common &rest TYPES

Find a type for an array that may hold elements from arrays of a set of given types; effectively the most efficient compatible type among the array types.

Package

aplesque

Source

aplesque.lisp (file)

Function: vex-program IDIOM OPTIONS &optional STRING META

Compile a set of expressions, optionally drawing external variables into the program and setting configuration parameters for the system.

Package

vex

Source

vex.lisp (file)


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

5.1.3 Generic functions

Generic Function: of-functions IDIOM KEY TYPE
Package

vex

Source

vex.lisp (file)

Methods
Method: of-functions (IDIOM idiom) KEY TYPE

Retrive one of the idiom’s functions.

Generic Function: of-operators IDIOM KEY TYPE
Package

vex

Source

vex.lisp (file)

Methods
Method: of-operators (IDIOM idiom) KEY TYPE

Retrive one of the idiom’s operators.

Generic Function: of-system IDIOM PROPERTY
Package

vex

Source

vex.lisp (file)

Methods
Method: of-system (IDIOM idiom) PROPERTY

Retrieve a property of the idiom’s system.


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

5.2 Internal definitions


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

5.2.1 Special variables

Special Variable: *alphabet-vector*
Package

april

Source

spec.lisp (file)

Special Variable: *april-idiom*
Package

april

Source

grammar.lisp (file)

Special Variable: *atomic-vector*
Package

april

Source

spec.lisp (file)

Special Variable: *circular-functions*
Package

april

Source

spec.lisp (file)

Special Variable: *digit-vector*
Package

april

Source

spec.lisp (file)

Special Variable: *life-default-dimension*
Package

april

Source

game-of-life.lisp (file)


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

5.2.2 Symbol macros

Symbol Macro: *apl-timestamp*
Package

april

Source

utilities.lisp (file)

Expansion

(april::apl-timestamp)

Symbol Macro: *first-axis*
Package

april

Source

utilities.lisp (file)

Expansion

(if april::axes (- (aref (first april::axes) 0) april::index-origin) 0)

Symbol Macro: *first-axis-or-nil*
Package

april

Source

utilities.lisp (file)

Expansion

(if april::axes (- (aref (first april::axes) 0) april::index-origin))

Symbol Macro: *last-axis*
Package

april

Source

utilities.lisp (file)

Expansion

(- (if april::axes (aref (first april::axes) 0) (array-operations/generic:rank april::omega)) april::index-origin)

Symbol Macro: atomic-vector
Package

april

Source

utilities.lisp (file)

Expansion

(vex:of-system april::this-idiom :atomic-vector)

Symbol Macro: this-idiom
Package

april

Source

utilities.lisp (file)

Expansion

(vex:local-idiom april:april)


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

5.2.3 Macros

Macro: apl-assign SYMBOL VALUE

This is a simple passthrough macro that is used by (in-apl-workspace).

Package

april

Source

utilities.lisp (file)

Macro: apl-call SYMBOL FUNCTION &rest ARGUMENTS

Call an APL function with one or two arguments. Compose successive scalar functions into bigger functions for more efficiency.

Package

april

Source

utilities.lisp (file)

Macro: apl-compose SYMBOL &rest BODY

A wrapper macro for macros that implement April’s operators; functionally this macro does nothing but it improves the readability of April’s compiled code.

Package

april

Source

utilities.lisp (file)

Macro: apl-default-element ARRAY

Returns the default element for an array based on that array’s type; blank spaces for character arrays and zeroes for others.

Package

aplesque

Source

aplesque.lisp (file)

Macro: apl-output FORM &rest OPTIONS

Generate code to output the result of APL evaluation, with options to print an APL-formatted text string expressing said result and/or return the text string as a result.

Package

april

Source

utilities.lisp (file)

Macro: apply-at RIGHT-SYMBOL RIGHT-VALUE RIGHT-FUNCTION-MONADIC LEFT-SYMBOL LEFT-VALUE LEFT-FUNCTION-MONADIC LEFT-FUNCTION-DYADIC
Package

april

Source

library.lisp (file)

Macro: apply-at-rank RIGHT-VALUE LEFT-SYMBOL LEFT-FUNCTION-MONADIC LEFT-FUNCTION-DYADIC
Package

april

Source

library.lisp (file)

Macro: apply-commuting SYMBOL OPERATION-DYADIC
Package

april

Source

library.lisp (file)

Macro: apply-composed RIGHT-SYMBOL RIGHT-VALUE RIGHT-FUNCTION-MONADIC RIGHT-FUNCTION-DYADIC LEFT-SYMBOL LEFT-VALUE LEFT-FUNCTION-MONADIC LEFT-FUNCTION-DYADIC IS-CONFIRMED-MONADIC
Package

april

Source

library.lisp (file)

Macro: apply-reducing OPERATION-SYMBOL OPERATION AXES &optional FIRST-AXIS
Package

april

Source

library.lisp (file)

Macro: apply-scanning OPERATION-SYMBOL OPERATION AXES &optional FIRST-AXIS
Package

april

Source

library.lisp (file)

Macro: apply-stenciled RIGHT-VALUE LEFT-SYMBOL LEFT-FUNCTION-DYADIC
Package

april

Source

library.lisp (file)

Macro: apply-to-each SYMBOL OPERATION-MONDAIC OPERATION-DYADIC
Package

april

Source

library.lisp (file)

Macro: apply-to-grouped SYMBOL OPERATION-DYADIC
Package

april

Source

library.lisp (file)

Macro: apply-to-power OP-RIGHT SYM-LEFT OP-LEFT
Package

april

Source

library.lisp (file)

Macro: apply-until SYM-RIGHT OP-RIGHT SYM-LEFT OP-LEFT
Package

april

Source

library.lisp (file)

Macro: avatom ITEM

An APL vector atom. This passthrough macro provides information to the (avector) macro.

Package

april

Source

utilities.lisp (file)

Macro: avector &rest ITEMS

This macro returns an APL vector, disclosing data within that are meant to be individual atoms.

Package

april

Source

utilities.lisp (file)

Macro: in-apl-workspace WORKSPACE-SYMBOL BODY

This macro encloses a body of compiled April code specifying a workspace in use for the code, and extends any assignment so as to update the workspace’s stored values.

Package

april

Source

utilities.lisp (file)

Macro: inner-or-outer-product-of RIGHT-SYMBOL RIGHT-OPERATION LEFT-SYMBOL LEFT-OPERATION
Package

april

Source

library.lisp (file)

Macro: or-functional-character REFERENCE SYMBOL

Return a symbol representing a functional character or, if the passed value is not a character, an arbitrary fallback symbol. Used to derive the initial symbol argument for (apl-call).

Package

april

Source

utilities.lisp (file)

Macro: print-and-run FORM

Print a formatted code string and then run the code; used in April’s arbitrary evaluation tests.

Package

april

Source

utilities.lisp (file)

Macro: resolve-function MODE REFERENCE

Retrieve function content for a functional character, pass through an explicit or symbol-referenced function, or return nil if the function doesn’t exist.

Package

april

Source

utilities.lisp (file)

Macro: resolve-operator MODE REFERENCE

Retrieve an operator’s composing function.

Package

april

Source

utilities.lisp (file)

Macro: scalar-function FUNCTION

Wrap a scalar function. This is a passthrough macro used by the scalar composition system in (apl-call).

Package

april

Source

utilities.lisp (file)

Macro: vex-idiom-spec SYMBOL EXTENSION &rest SUBSPECS

Process the specification for a vector language and build functions that generate the code tree.

Package

vex

Source

vex.lisp (file)

Macro: λω &rest BODY
Package

april

Source

utilities.lisp (file)

Macro: λωα &rest BODY
Package

april

Source

utilities.lisp (file)

Macro: λωαχ &rest BODY
Package

april

Source

utilities.lisp (file)

Macro: λωχ &rest BODY
Package

april

Source

utilities.lisp (file)


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

5.2.4 Functions

Function: =vex-string IDIOM META &optional OUTPUT SPECIAL-PRECEDENT

Parse a string of text, converting its contents into nested lists of Vex tokens.

Package

vex

Source

vex.lisp (file)

Function: apl-timestamp ()

Generate an APL timestamp, a vector of the current year, month, day, hour, minute, second and millisecond.

Package

april

Source

utilities.lisp (file)

Function: apply-scalar FUNCTION ALPHA &optional OMEGA IS-BOOLEAN

Apply a scalar function across objects as appropriate for APL. Handles scalars as well as nested and multidimensional arrays.

Package

april

Source

utilities.lisp (file)

Function: april-function-glyph-processor TYPE GLYPH SPEC

Convert a Vex function specification for April into a set of lexicon elements, forms and functions that will make up part of the April idiom object used to compile the language.

Package

april

Source

utilities.lisp (file)

Function: array-intersection OMEGA ALPHA

Return a vector of values common to two arrays. Used to implement [∩ intersection].

Package

april

Source

library.lisp (file)

Function: array-union OMEGA ALPHA

Return a vector of unique values from two arrays. Used to implement [∪ union].

Package

april

Source

library.lisp (file)

Function: at-index OMEGA ALPHA AXES INDEX-ORIGIN

Find the value(s) at the given index or indices in an array. Used to implement [⌷ index].

Package

april

Source

library.lisp (file)

Function: build-compiled-code EXPS OPTIONS SYSTEM-VARS VARS-DECLARED VAR-SYMBOLS META

Return a set of compiled April expressions within the proper context.

Package

april

Source

utilities.lisp (file)

Function: build-composer-pattern SEQUENCE IDIOM TOKENS-SYMBOL INVALID-SYMBOL PROPERTIES-SYMBOL PROCESS SPACE SUB-PROPS

Generate a pattern for language compilation from a set of specs entered as part of a grammar.

Package

vex

Source

vex.lisp (file)

Function: build-doc-profile SYMBOL SPEC MODE SECTION-NAMES

Build a documentation or test profile from a set of section names in a Vex idiom specification.

Package

vex

Source

vex.lisp (file)

Function: build-variable-declarations INPUT-VARS PREEXISTING-VARS VAR-SYMBOLS META

Create the set of variable declarations that begins April’s compiled code.

Package

april

Source

utilities.lisp (file)

Function: composer-elements-apl-standard IDIOM
Package

april

Source

grammar.lisp (file)

Function: composer-following-patterns-apl-standard G0
Package

april

Source

grammar.lisp (file)

Function: composer-opening-patterns-apl-standard G0
Package

april

Source

grammar.lisp (file)

Function: composer-optimized-patterns-common G0
Package

april

Source

patterns.lisp (file)

Function: count-symbol-in-spec SYMBOL LIMBS
Package

vex

Source

vex.lisp (file)

Function: count-to INDEX INDEX-ORIGIN

Implementation of APL’s ⍳ function.

Package

april

Source

library.lisp (file)

Function: decode OMEGA ALPHA

Decode an array of numbers as per a given set of bases. Used to implement [⊥ decode].

Package

april

Source

library.lisp (file)

Function: derive-opglyphs GLYPH-LIST &optional OUTPUT

Extract a list of function/operator glyphs from part of a Vex language specification.

Package

vex

Source

vex.lisp (file)

Function: disclose-atom ITEM

If the argument is a non-nested array with only one member, disclose it, otherwise do nothing.

Package

april

Source

utilities.lisp (file)

Function: do-over INPUT FUNCTION AXIS &key REDUCE IN-REVERSE

Apply a dyadic function over elements of an array, inserting the results into an array of the same or similar shape (possibly less one or more dimensions). Used to implement reduce and scan operations.

Package

april

Source

utilities.lisp (file)

Function: enclose-axes BODY AXIS-SETS &key SET

Apply axes to an array, with the ability to handle multiple sets of axes as in (6 8 5⍴⍳9)[1 4;;2 1][1;2 4 5;].

Package

april

Source

utilities.lisp (file)

Function: encode OMEGA ALPHA

Encode a number or array of numbers as per a given set of bases. Used to implement [⊤ encode].

Package

april

Source

library.lisp (file)

Function: extract-axes PROCESS TOKENS &optional AXES

Given a list of tokens starting with axis specifications, build the code for the axis specifications to be applied to the subsequent function or value.

Package

april

Source

utilities.lisp (file)

Function: find-depth OMEGA

Find the depth of an array. Used to implement [≡ depth].

Package

april

Source

library.lisp (file)

Function: find-first-dimension OMEGA

Find the first dimension of an array. Used to implement [≢ first dimension].

Package

april

Source

library.lisp (file)

Function: format-value IDIOM-NAME META SYMBOLS ELEMENT

Convert a token string into an APL value, paying heed to APL’s native ⍺, ⍵ and ⍬ variables.

Package

april

Source

utilities.lisp (file)

Function: indent-code STRING

Indent a code string produced by (print-and-run) as appropriate for April’s test output.

Package

april

Source

utilities.lisp (file)

Function: left-invert-matrix IN-MATRIX

Perform left inversion of matrix. Used to implement [⌹ matrix inverse].

Package

april

Source

library.lisp (file)

Function: life &optional NEW-WIDTH NEW-HEIGHT

Create or update a playfield for Conway’s Game of Life.

Package

april

Source

game-of-life.lisp (file)

Function: membership OMEGA ALPHA
Package

april

Source

library.lisp (file)

Function: merge-lexicons SOURCE &optional TARGET

Combine two Vex symbol lexicons.

Package

vex

Source

vex.lisp (file)

Function: merge-options SOURCE TARGET

Merge options from multiple Vex specifiction sections into a single set.

Package

vex

Source

vex.lisp (file)

Function: numeric-string-p STRING

Checks whether the argument is a numeric string.

Package

april

Source

utilities.lisp (file)

Function: output-function FORM &optional ARGUMENTS

Express an APL inline function like {⍵+5}.

Package

april

Source

utilities.lisp (file)

Function: output-value SPACE FORM &optional PROPERTIES

Express an APL value in the form of an explicit array specification or a symbol representing an array, supporting axis arguments.

Package

april

Source

utilities.lisp (file)

Function: parse-apl-number-string NUMBER-STRING &optional IMAGINARY-COMPONENT

Parse an APL numeric string into a Lisp value, handling high minus signs and the J-notation for complex numbers.

Package

april

Source

utilities.lisp (file)

Function: print-apl-number-string NUMBER &optional COERCE-RATIONAL PRECISION DECIMALS

Format a number as appropriate for APL, using high minus signs and J-notation for complex numbers, optionally at a given precision for floats.

Package

april

Source

utilities.lisp (file)

Function: process-arbitrary-tests-for SYMBOL TEST-SET &key MODE
Package

vex

Source

vex.lisp (file)

Function: process-general-tests-for SYMBOL TEST-SET &key MODE

Process specs for general tests not associated with a specific function or operator.

Package

vex

Source

vex.lisp (file)

Function: process-lex-tests-for SYMBOL OPERATOR &key MODE

Process a set of tests for Vex functions or operators.

Package

vex

Source

vex.lisp (file)

Function: process-output-vector ITEMS

Process items in a vector to be generated by the compiler, wrapping any array references in aplSymbol so that they are disclosed. This does not apply if the output vector is unitary (length 1).

Package

april

Source

utilities.lisp (file)

Function: tabulate OMEGA

Return a two-dimensional array of values from an array, promoting or demoting the array if it is of a rank other than two. Used to implement [⍪ table].

Package

april

Source

library.lisp (file)

Function: unique OMEGA

Return a vector of unique values in an array. Used to implement [∪ unique].

Package

april

Source

library.lisp (file)

Function: validate-arg-unitary VALUE

Verify that a form like (vector 5) represents a unitary value.

Package

april

Source

utilities.lisp (file)

Function: vector-grade COMPARE-BY VECTOR1 VECTOR2 &optional INDEX

Compare two vectors by the values of each element, giving priority to elements proportional to their position in the array, as when comparing words by the alphabetical order of the letters.

Package

aplesque

Source

aplesque.lisp (file)

Function: where-equal-to-one OMEGA INDEX-ORIGIN

Return a vector of coordinates from an array where the value is equal to one. Used to implement [⍸ where].

Package

april

Source

library.lisp (file)

Function: without OMEGA ALPHA
Package

april

Source

library.lisp (file)


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

5.2.5 Generic functions

Generic Function: idiom-composer-following-patterns OBJECT
Generic Function: (setf idiom-composer-following-patterns) NEW-VALUE OBJECT
Package

vex

Methods
Method: idiom-composer-following-patterns (IDIOM idiom)

automatically generated reader method

Source

vex.lisp (file)

Method: (setf idiom-composer-following-patterns) NEW-VALUE (IDIOM idiom)

automatically generated writer method

Source

vex.lisp (file)

Generic Function: idiom-composer-opening-patterns OBJECT
Generic Function: (setf idiom-composer-opening-patterns) NEW-VALUE OBJECT
Package

vex

Methods
Method: idiom-composer-opening-patterns (IDIOM idiom)

automatically generated reader method

Source

vex.lisp (file)

Method: (setf idiom-composer-opening-patterns) NEW-VALUE (IDIOM idiom)

automatically generated writer method

Source

vex.lisp (file)

Generic Function: idiom-functions OBJECT
Generic Function: (setf idiom-functions) NEW-VALUE OBJECT
Package

vex

Methods
Method: idiom-functions (IDIOM idiom)

automatically generated reader method

Source

vex.lisp (file)

Method: (setf idiom-functions) NEW-VALUE (IDIOM idiom)

automatically generated writer method

Source

vex.lisp (file)

Generic Function: idiom-grammar-elements OBJECT
Generic Function: (setf idiom-grammar-elements) NEW-VALUE OBJECT
Package

vex

Methods
Method: idiom-grammar-elements (IDIOM idiom)

automatically generated reader method

Source

vex.lisp (file)

Method: (setf idiom-grammar-elements) NEW-VALUE (IDIOM idiom)

automatically generated writer method

Source

vex.lisp (file)

Generic Function: idiom-lexicons OBJECT
Generic Function: (setf idiom-lexicons) NEW-VALUE OBJECT
Package

vex

Methods
Method: idiom-lexicons (IDIOM idiom)

automatically generated reader method

Source

vex.lisp (file)

Method: (setf idiom-lexicons) NEW-VALUE (IDIOM idiom)

automatically generated writer method

Source

vex.lisp (file)

Generic Function: idiom-name OBJECT
Generic Function: (setf idiom-name) NEW-VALUE OBJECT
Package

vex

Methods
Method: idiom-name (IDIOM idiom)

automatically generated reader method

Source

vex.lisp (file)

Method: (setf idiom-name) NEW-VALUE (IDIOM idiom)

automatically generated writer method

Source

vex.lisp (file)

Generic Function: idiom-operators OBJECT
Generic Function: (setf idiom-operators) NEW-VALUE OBJECT
Package

vex

Methods
Method: idiom-operators (IDIOM idiom)

automatically generated reader method

Source

vex.lisp (file)

Method: (setf idiom-operators) NEW-VALUE (IDIOM idiom)

automatically generated writer method

Source

vex.lisp (file)

Generic Function: idiom-symbols OBJECT
Generic Function: (setf idiom-symbols) NEW-VALUE OBJECT
Package

vex

Methods
Method: idiom-symbols (IDIOM idiom)

automatically generated reader method

Source

vex.lisp (file)

Method: (setf idiom-symbols) NEW-VALUE (IDIOM idiom)

automatically generated writer method

Source

vex.lisp (file)

Generic Function: idiom-system OBJECT
Generic Function: (setf idiom-system) NEW-VALUE OBJECT
Package

vex

Methods
Method: idiom-system (IDIOM idiom)

automatically generated reader method

Source

vex.lisp (file)

Method: (setf idiom-system) NEW-VALUE (IDIOM idiom)

automatically generated writer method

Source

vex.lisp (file)

Generic Function: idiom-utilities OBJECT
Generic Function: (setf idiom-utilities) NEW-VALUE OBJECT
Package

vex

Methods
Method: idiom-utilities (IDIOM idiom)

automatically generated reader method

Source

vex.lisp (file)

Method: (setf idiom-utilities) NEW-VALUE (IDIOM idiom)

automatically generated writer method

Source

vex.lisp (file)

Generic Function: of-lexicon IDIOM LEXICON GLYPH
Package

vex

Source

vex.lisp (file)

Methods
Method: of-lexicon IDIOM LEXICON GLYPH

Check whether a character belongs to a given Vex lexicon.

Generic Function: of-utilities IDIOM UTILITY
Package

vex

Source

vex.lisp (file)

Methods
Method: of-utilities (IDIOM idiom) UTILITY

Retrieve one of the idiom’s utilities used for parsing and language processing.


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

5.2.6 Classes

Class: idiom ()
Package

vex

Source

vex.lisp (file)

Direct superclasses

standard-object (class)

Direct methods
Direct slots
Slot: name
Initargs

:name

Readers

idiom-name (generic function)

Writers

(setf idiom-name) (generic function)

Slot: system
Initargs

:system

Readers

idiom-system (generic function)

Writers

(setf idiom-system) (generic function)

Slot: symbols
Initargs

:symbols

Readers

idiom-symbols (generic function)

Writers

(setf idiom-symbols) (generic function)

Slot: utilities
Initargs

:utilities

Readers

idiom-utilities (generic function)

Writers

(setf idiom-utilities) (generic function)

Slot: lexicons
Initargs

:lexicons

Readers

idiom-lexicons (generic function)

Writers

(setf idiom-lexicons) (generic function)

Slot: functions
Initargs

:functions

Readers

idiom-functions (generic function)

Writers

(setf idiom-functions) (generic function)

Slot: operators
Initargs

:operators

Readers

idiom-operators (generic function)

Writers

(setf idiom-operators) (generic function)

Slot: grammar-elements
Initargs

:grammar-elements

Readers

idiom-grammar-elements (generic function)

Writers

(setf idiom-grammar-elements) (generic function)

Slot: composer-opening-patterns
Initargs

:composer-opening-patterns

Readers

idiom-composer-opening-patterns (generic function)

Writers

(setf idiom-composer-opening-patterns) (generic function)

Slot: composer-following-patterns
Initargs

:composer-following-patterns

Readers

idiom-composer-following-patterns (generic function)

Writers

(setf idiom-composer-following-patterns) (generic function)


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

Appendix A Indexes


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

A.1 Concepts

Jump to:   A   F   L   V  
Index Entry  Section

A
aplesque.asd: The aplesque<dot>asd file
aplesque/aplesque.lisp: The aplesque/aplesque<dot>lisp file
aplesque/package.lisp: The aplesque/package<dot>lisp file
april.asd: The april<dot>asd file
april/game-of-life.lisp: The april/game-of-life<dot>lisp file
april/grammar.lisp: The april/grammar<dot>lisp file
april/library.lisp: The april/library<dot>lisp file
april/package.lisp: The april/package<dot>lisp file
april/patterns.lisp: The april/patterns<dot>lisp file
april/spec.lisp: The april/spec<dot>lisp file
april/utilities.lisp: The april/utilities<dot>lisp file

F
File, Lisp, aplesque.asd: The aplesque<dot>asd file
File, Lisp, aplesque/aplesque.lisp: The aplesque/aplesque<dot>lisp file
File, Lisp, aplesque/package.lisp: The aplesque/package<dot>lisp file
File, Lisp, april.asd: The april<dot>asd file
File, Lisp, april/game-of-life.lisp: The april/game-of-life<dot>lisp file
File, Lisp, april/grammar.lisp: The april/grammar<dot>lisp file
File, Lisp, april/library.lisp: The april/library<dot>lisp file
File, Lisp, april/package.lisp: The april/package<dot>lisp file
File, Lisp, april/patterns.lisp: The april/patterns<dot>lisp file
File, Lisp, april/spec.lisp: The april/spec<dot>lisp file
File, Lisp, april/utilities.lisp: The april/utilities<dot>lisp file
File, Lisp, vex.asd: The vex<dot>asd file
File, Lisp, vex/package.lisp: The vex/package<dot>lisp file
File, Lisp, vex/vex.lisp: The vex/vex<dot>lisp file

L
Lisp File, aplesque.asd: The aplesque<dot>asd file
Lisp File, aplesque/aplesque.lisp: The aplesque/aplesque<dot>lisp file
Lisp File, aplesque/package.lisp: The aplesque/package<dot>lisp file
Lisp File, april.asd: The april<dot>asd file
Lisp File, april/game-of-life.lisp: The april/game-of-life<dot>lisp file
Lisp File, april/grammar.lisp: The april/grammar<dot>lisp file
Lisp File, april/library.lisp: The april/library<dot>lisp file
Lisp File, april/package.lisp: The april/package<dot>lisp file
Lisp File, april/patterns.lisp: The april/patterns<dot>lisp file
Lisp File, april/spec.lisp: The april/spec<dot>lisp file
Lisp File, april/utilities.lisp: The april/utilities<dot>lisp file
Lisp File, vex.asd: The vex<dot>asd file
Lisp File, vex/package.lisp: The vex/package<dot>lisp file
Lisp File, vex/vex.lisp: The vex/vex<dot>lisp file

V
vex.asd: The vex<dot>asd file
vex/package.lisp: The vex/package<dot>lisp file
vex/vex.lisp: The vex/vex<dot>lisp file

Jump to:   A   F   L   V  

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

A.2 Functions

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

(
(setf idiom-composer-following-patterns): Internal generic functions
(setf idiom-composer-following-patterns): Internal generic functions
(setf idiom-composer-opening-patterns): Internal generic functions
(setf idiom-composer-opening-patterns): Internal generic functions
(setf idiom-functions): Internal generic functions
(setf idiom-functions): Internal generic functions
(setf idiom-grammar-elements): Internal generic functions
(setf idiom-grammar-elements): Internal generic functions
(setf idiom-lexicons): Internal generic functions
(setf idiom-lexicons): Internal generic functions
(setf idiom-name): Internal generic functions
(setf idiom-name): Internal generic functions
(setf idiom-operators): Internal generic functions
(setf idiom-operators): Internal generic functions
(setf idiom-symbols): Internal generic functions
(setf idiom-symbols): Internal generic functions
(setf idiom-system): Internal generic functions
(setf idiom-system): Internal generic functions
(setf idiom-utilities): Internal generic functions
(setf idiom-utilities): Internal generic functions

=
=vex-string: Internal functions

A
across: Exported functions
alpha-compare: Exported functions
apl-assign: Internal macros
apl-call: Internal macros
apl-compose: Internal macros
apl-default-element: Internal macros
apl-output: Internal macros
apl-timestamp: Internal functions
apply-at: Internal macros
apply-at-rank: Internal macros
apply-commuting: Internal macros
apply-composed: Internal macros
apply-reducing: Internal macros
apply-scalar: Internal functions
apply-scanning: Internal macros
apply-stenciled: Internal macros
apply-to-each: Internal macros
apply-to-grouped: Internal macros
apply-to-power: Internal macros
apply-until: Internal macros
april: Exported macros
april-function-glyph-processor: Internal functions
april-load: Exported macros
april-p: Exported macros
array-compare: Exported functions
array-depth: Exported functions
array-grade: Exported functions
array-impress: Exported functions
array-inner-product: Exported functions
array-intersection: Internal functions
array-promote: Exported functions
array-to-list: Exported functions
array-to-nested-vector: Exported functions
array-union: Internal functions
assign-element-type: Exported functions
at-index: Internal functions
avatom: Internal macros
avector: Internal macros

B
binomial: Exported functions
boolean-op: Exported macros
build-compiled-code: Internal functions
build-composer-pattern: Internal functions
build-doc-profile: Internal functions
build-variable-declarations: Internal functions

C
catenate: Exported functions
choose: Exported functions
composer: Exported functions
composer-elements-apl-standard: Internal functions
composer-following-patterns-apl-standard: Internal functions
composer-opening-patterns-apl-standard: Internal functions
composer-optimized-patterns-common: Internal functions
count-symbol-in-spec: Internal functions
count-to: Internal functions

D
decode: Internal functions
derive-opglyphs: Internal functions
disclose: Exported functions
disclose-atom: Internal functions
disclose-unitary-array: Exported functions
do-over: Internal functions

E
each-boolean: Exported functions
each-scalar: Exported functions
enclose: Exported functions
enclose-atom: Exported functions
enclose-axes: Internal functions
encode: Internal functions
enlist: Exported functions
expand-array: Exported functions
extend-vex-idiom: Exported macros
extract-axes: Internal functions

F
find-array: Exported functions
find-depth: Internal functions
find-first-dimension: Internal functions
format-value: Internal functions
Function, =vex-string: Internal functions
Function, across: Exported functions
Function, alpha-compare: Exported functions
Function, apl-timestamp: Internal functions
Function, apply-scalar: Internal functions
Function, april-function-glyph-processor: Internal functions
Function, array-compare: Exported functions
Function, array-depth: Exported functions
Function, array-grade: Exported functions
Function, array-impress: Exported functions
Function, array-inner-product: Exported functions
Function, array-intersection: Internal functions
Function, array-promote: Exported functions
Function, array-to-list: Exported functions
Function, array-to-nested-vector: Exported functions
Function, array-union: Internal functions
Function, assign-element-type: Exported functions
Function, at-index: Internal functions
Function, binomial: Exported functions
Function, build-compiled-code: Internal functions
Function, build-composer-pattern: Internal functions
Function, build-doc-profile: Internal functions
Function, build-variable-declarations: Internal functions
Function, catenate: Exported functions
Function, choose: Exported functions
Function, composer: Exported functions
Function, composer-elements-apl-standard: Internal functions
Function, composer-following-patterns-apl-standard: Internal functions
Function, composer-opening-patterns-apl-standard: Internal functions
Function, composer-optimized-patterns-common: Internal functions
Function, count-symbol-in-spec: Internal functions
Function, count-to: Internal functions
Function, decode: Internal functions
Function, derive-opglyphs: Internal functions
Function, disclose: Exported functions
Function, disclose-atom: Internal functions
Function, disclose-unitary-array: Exported functions
Function, do-over: Internal functions
Function, each-boolean: Exported functions
Function, each-scalar: Exported functions
Function, enclose: Exported functions
Function, enclose-atom: Exported functions
Function, enclose-axes: Internal functions
Function, encode: Internal functions
Function, enlist: Exported functions
Function, expand-array: Exported functions
Function, extract-axes: Internal functions
Function, find-array: Exported functions
Function, find-depth: Internal functions
Function, find-first-dimension: Internal functions
Function, format-value: Internal functions
Function, grade: Exported functions
Function, indent-code: Internal functions
Function, index-of: Exported functions
Function, interval-index: Exported functions
Function, invert-matrix: Exported functions
Function, is-unitary: Exported functions
Function, laminate: Exported functions
Function, left-invert-matrix: Internal functions
Function, life: Internal functions
Function, make-back-scanner: Exported functions
Function, membership: Internal functions
Function, merge-arrays: Exported functions
Function, merge-lexicons: Internal functions
Function, merge-options: Internal functions
Function, mix-arrays: Exported functions
Function, numeric-string-p: Internal functions
Function, output-function: Internal functions
Function, output-value: Internal functions
Function, parse-apl-number-string: Internal functions
Function, partition-array: Exported functions
Function, partitioned-enclose: Exported functions
Function, print-apl-number-string: Internal functions
Function, process-arbitrary-tests-for: Internal functions
Function, process-general-tests-for: Internal functions
Function, process-lex-tests-for: Internal functions
Function, process-output-vector: Internal functions
Function, ravel: Exported functions
Function, re-enclose: Exported functions
Function, reshape-to-fit: Exported functions
Function, scale-array: Exported functions
Function, scan-back: Exported functions
Function, section: Exported functions
Function, split-array: Exported functions
Function, sprfact: Exported functions
Function, stencil: Exported functions
Function, tabulate: Internal functions
Function, turn: Exported functions
Function, type-in-common: Exported functions
Function, unique: Internal functions
Function, validate-arg-unitary: Internal functions
Function, vector-grade: Internal functions
Function, vex-program: Exported functions
Function, where-equal-to-one: Internal functions
Function, without: Internal functions

G
Generic Function, (setf idiom-composer-following-patterns): Internal generic functions
Generic Function, (setf idiom-composer-opening-patterns): Internal generic functions
Generic Function, (setf idiom-functions): Internal generic functions
Generic Function, (setf idiom-grammar-elements): Internal generic functions
Generic Function, (setf idiom-lexicons): Internal generic functions
Generic Function, (setf idiom-name): Internal generic functions
Generic Function, (setf idiom-operators): Internal generic functions
Generic Function, (setf idiom-symbols): Internal generic functions
Generic Function, (setf idiom-system): Internal generic functions
Generic Function, (setf idiom-utilities): Internal generic functions
Generic Function, idiom-composer-following-patterns: Internal generic functions
Generic Function, idiom-composer-opening-patterns: Internal generic functions
Generic Function, idiom-functions: Internal generic functions
Generic Function, idiom-grammar-elements: Internal generic functions
Generic Function, idiom-lexicons: Internal generic functions
Generic Function, idiom-name: Internal generic functions
Generic Function, idiom-operators: Internal generic functions
Generic Function, idiom-symbols: Internal generic functions
Generic Function, idiom-system: Internal generic functions
Generic Function, idiom-utilities: Internal generic functions
Generic Function, of-functions: Exported generic functions
Generic Function, of-lexicon: Internal generic functions
Generic Function, of-operators: Exported generic functions
Generic Function, of-system: Exported generic functions
Generic Function, of-utilities: Internal generic functions
grade: Exported functions

I
idiom-composer-following-patterns: Internal generic functions
idiom-composer-following-patterns: Internal generic functions
idiom-composer-opening-patterns: Internal generic functions
idiom-composer-opening-patterns: Internal generic functions
idiom-functions: Internal generic functions
idiom-functions: Internal generic functions
idiom-grammar-elements: Internal generic functions
idiom-grammar-elements: Internal generic functions
idiom-lexicons: Internal generic functions
idiom-lexicons: Internal generic functions
idiom-name: Internal generic functions
idiom-name: Internal generic functions
idiom-operators: Internal generic functions
idiom-operators: Internal generic functions
idiom-symbols: Internal generic functions
idiom-symbols: Internal generic functions
idiom-system: Internal generic functions
idiom-system: Internal generic functions
idiom-utilities: Internal generic functions
idiom-utilities: Internal generic functions
in-apl-workspace: Internal macros
indent-code: Internal functions
index-of: Exported functions
inner-or-outer-product-of: Internal macros
interval-index: Exported functions
invert-matrix: Exported functions
is-unitary: Exported functions

L
laminate: Exported functions
left-invert-matrix: Internal functions
life: Internal functions
local-idiom: Exported macros

M
Macro, apl-assign: Internal macros
Macro, apl-call: Internal macros
Macro, apl-compose: Internal macros
Macro, apl-default-element: Internal macros
Macro, apl-output: Internal macros
Macro, apply-at: Internal macros
Macro, apply-at-rank: Internal macros
Macro, apply-commuting: Internal macros
Macro, apply-composed: Internal macros
Macro, apply-reducing: Internal macros
Macro, apply-scanning: Internal macros
Macro, apply-stenciled: Internal macros
Macro, apply-to-each: Internal macros
Macro, apply-to-grouped: Internal macros
Macro, apply-to-power: Internal macros
Macro, apply-until: Internal macros
Macro, april: Exported macros
Macro, april-load: Exported macros
Macro, april-p: Exported macros
Macro, avatom: Internal macros
Macro, avector: Internal macros
Macro, boolean-op: Exported macros
Macro, extend-vex-idiom: Exported macros
Macro, in-apl-workspace: Internal macros
Macro, inner-or-outer-product-of: Internal macros
Macro, local-idiom: Exported macros
Macro, matrix-print: Exported macros
Macro, or-functional-character: Internal macros
Macro, print-and-run: Internal macros
Macro, resolve-function: Internal macros
Macro, resolve-operator: Internal macros
Macro, reverse-op: Exported macros
Macro, scalar-function: Internal macros
Macro, set-composer-elements: Exported macros
Macro, set-composer-patterns: Exported macros
Macro, specify-vex-idiom: Exported macros
Macro, vex-idiom-spec: Internal macros
Macro, with-april-context: Exported macros
Macro, λω: Internal macros
Macro, λωα: Internal macros
Macro, λωαχ: Internal macros
Macro, λωχ: Internal macros
make-back-scanner: Exported functions
matrix-print: Exported macros
membership: Internal functions
merge-arrays: Exported functions
merge-lexicons: Internal functions
merge-options: Internal functions
Method, (setf idiom-composer-following-patterns): Internal generic functions
Method, (setf idiom-composer-opening-patterns): Internal generic functions
Method, (setf idiom-functions): Internal generic functions
Method, (setf idiom-grammar-elements): Internal generic functions
Method, (setf idiom-lexicons): Internal generic functions
Method, (setf idiom-name): Internal generic functions
Method, (setf idiom-operators): Internal generic functions
Method, (setf idiom-symbols): Internal generic functions
Method, (setf idiom-system): Internal generic functions
Method, (setf idiom-utilities): Internal generic functions
Method, idiom-composer-following-patterns: Internal generic functions
Method, idiom-composer-opening-patterns: Internal generic functions
Method, idiom-functions: Internal generic functions
Method, idiom-grammar-elements: Internal generic functions
Method, idiom-lexicons: Internal generic functions
Method, idiom-name: Internal generic functions
Method, idiom-operators: Internal generic functions
Method, idiom-symbols: Internal generic functions
Method, idiom-system: Internal generic functions
Method, idiom-utilities: Internal generic functions
Method, of-functions: Exported generic functions
Method, of-lexicon: Internal generic functions
Method, of-operators: Exported generic functions
Method, of-system: Exported generic functions
Method, of-utilities: Internal generic functions
mix-arrays: Exported functions

N
numeric-string-p: Internal functions

O
of-functions: Exported generic functions
of-functions: Exported generic functions
of-lexicon: Internal generic functions
of-lexicon: Internal generic functions
of-operators: Exported generic functions
of-operators: Exported generic functions
of-system: Exported generic functions
of-system: Exported generic functions
of-utilities: Internal generic functions
of-utilities: Internal generic functions
or-functional-character: Internal macros
output-function: Internal functions
output-value: Internal functions

P
parse-apl-number-string: Internal functions
partition-array: Exported functions
partitioned-enclose: Exported functions
print-and-run: Internal macros
print-apl-number-string: Internal functions
process-arbitrary-tests-for: Internal functions
process-general-tests-for: Internal functions
process-lex-tests-for: Internal functions
process-output-vector: Internal functions

R
ravel: Exported functions
re-enclose: Exported functions
reshape-to-fit: Exported functions
resolve-function: Internal macros
resolve-operator: Internal macros
reverse-op: Exported macros

S
scalar-function: Internal macros
scale-array: Exported functions
scan-back: Exported functions
section: Exported functions
set-composer-elements: Exported macros
set-composer-patterns: Exported macros
specify-vex-idiom: Exported macros
split-array: Exported functions
sprfact: Exported functions
stencil: Exported functions

T
tabulate: Internal functions
turn: Exported functions
type-in-common: Exported functions

U
unique: Internal functions

V
validate-arg-unitary: Internal functions
vector-grade: Internal functions
vex-idiom-spec: Internal macros
vex-program: Exported functions

W
where-equal-to-one: Internal functions
with-april-context: Exported macros
without: Internal functions

Λ
λω: Internal macros
λωα: Internal macros
λωαχ: Internal macros
λωχ: Internal macros

Jump to:   (   =  
A   B   C   D   E   F   G   I   L   M   N   O   P   R   S   T   U   V   W   Λ  

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

A.3 Variables

Jump to:   *  
A   C   F   G   L   N   O   S   T   U  
Index Entry  Section

*
*alphabet-vector*: Internal special variables
*apl-timestamp*: Internal symbol macros
*april-idiom*: Internal special variables
*atomic-vector*: Internal special variables
*circular-functions*: Internal special variables
*digit-vector*: Internal special variables
*first-axis*: Internal symbol macros
*first-axis-or-nil*: Internal symbol macros
*last-axis*: Internal symbol macros
*life-default-dimension*: Internal special variables

A
atomic-vector: Internal symbol macros

C
composer-following-patterns: Internal classes
composer-opening-patterns: Internal classes

F
functions: Internal classes

G
grammar-elements: Internal classes

L
lexicons: Internal classes

N
name: Internal classes

O
operators: Internal classes

S
Slot, composer-following-patterns: Internal classes
Slot, composer-opening-patterns: Internal classes
Slot, functions: Internal classes
Slot, grammar-elements: Internal classes
Slot, lexicons: Internal classes
Slot, name: Internal classes
Slot, operators: Internal classes
Slot, symbols: Internal classes
Slot, system: Internal classes
Slot, utilities: Internal classes
Special Variable, *alphabet-vector*: Internal special variables
Special Variable, *april-idiom*: Internal special variables
Special Variable, *atomic-vector*: Internal special variables
Special Variable, *circular-functions*: Internal special variables
Special Variable, *digit-vector*: Internal special variables
Special Variable, *life-default-dimension*: Internal special variables
Symbol Macro, *apl-timestamp*: Internal symbol macros
Symbol Macro, *first-axis*: Internal symbol macros
Symbol Macro, *first-axis-or-nil*: Internal symbol macros
Symbol Macro, *last-axis*: Internal symbol macros
Symbol Macro, atomic-vector: Internal symbol macros
Symbol Macro, this-idiom: Internal symbol macros
symbols: Internal classes
system: Internal classes

T
this-idiom: Internal symbol macros

U
utilities: Internal classes

Jump to:   *  
A   C   F   G   L   N   O   S   T   U  

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

A.4 Data types

Jump to:   A   C   I   P   S   V  
Index Entry  Section

A
aplesque: The aplesque system
aplesque: The aplesque package
april: The april system
april: The april package
april.idiom-extension-tools: The april<dot>idiom-extension-tools package

C
Class, idiom: Internal classes

I
idiom: Internal classes

P
Package, aplesque: The aplesque package
Package, april: The april package
Package, april.idiom-extension-tools: The april<dot>idiom-extension-tools package
Package, vex: The vex package

S
System, aplesque: The aplesque system
System, april: The april system
System, vex: The vex system

V
vex: The vex system
vex: The vex package

Jump to:   A   C   I   P   S   V