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.3, generated automatically by Declt version 3.0 "Montgomery Scott" on Mon Apr 19 14:04:57 2021 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 process with APL, getting it there can be an ordeal akin to hauling tons of cargo on donkeys' backs through a narrow mountain pass. The original APL interpreters ran on mainframes whose only input was the keyboard and only output was the printer, and the legacy of that implementation approach has persisted to this day, limiting the reach of the language.

But no longer. Lisp is the great connector of the software world, digesting and transforming semantic patterns in much the same way that APL works upon 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.

Discussion

For the time being, discussion of April and its development is happening on the ##phantomics channel on irc.freenode.net.

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.

Click here for information on enabling APL input within Vim.

Click here for information on enabling APL input universally within GNU/Linux.

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

Evaluating an APL expression is as simple as:

* (april-f "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-f) (short for april-format) will evaluate any APL string passed to it as the sole argument, returning the final result. Using (april-f) 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-f) will not print it since the Lisp representation of the number will look the same or very similar. For example:

* (april-f "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-f (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-f) 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 functions in the evaluated APL code will start counting from 0 or 1. We'll get into more detail on how these parameters work later.

* (april-f (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-f (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-f "⍳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-f "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-f "+/3 4⍴⍳12")
10 26 42
#(10 26 42)

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

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

* (april-f "⌽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-f "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))

Compact Function Calls: The (april-c) Macro

Want to invoke April functions on some variables with less code? You can use the (april-c) macro. For example:

* (april-c "{⍺×⍵}" 2 8)
16

* (april-c "{[a;b;c;d] d↑c⍴a+b}" 3 5 6 10)
#(8 8 8 8 8 8 0 0 0 0)

After the string where the April function is written, pass the variables that will be input to the function and you'll receive the result with no need for a long (with (:state ...)) clause. If you wish to pass parameters in a (with) clause, you can still do it with (april-c).

* (april-c (with (:state :count-from 0)) "{⍳⍵}" 7)
#(0 1 2 3 4 5 6)

A note on escaping characters

April uses the backslash character \ to implement the expand function and the scan operator. Because of the way Lisp strings work, this character must be escaped with a second \ before it in order to enter APL code containing backslashes. For example:

* (april-f "+\\⍳5")
1 3 6 10 15
#(1 3 6 10 15)

The inside the "string", the two backslashes evaluate to a single backslash. If you forget about this, you can experience confusing errors.

Unique Language Features in April

For the most part, April's syntax and functions follow standard APL conventions. But there are a few areas where April differs from typical APL implementations along with some unique language features. Most notably:

;; k-style if-statements
* (april "x←5 ⋄ $[x>3;8;12]")
8

;; k-style functions with any number of named arguments
* (april "monthlyPayment←{[amt;int;len] (len÷⍨amt×int×0.1)+amt÷len} ⋄ monthlyPayment[5000;0.8;12]")
450.0

;; numbered branch points instantiated with →⎕ syntax
* (april "x←1 ⋄ →1+1 ⋄ x×←11 ⋄ 1→⎕ ⋄ x×←3 ⋄ 2→⎕ ⋄ x×←5 ⋄ 3→⎕ ⋄ x×←7")
35

;; symbol-referenced branch points and a branch function with expression-determined branch symbol choice
* (april "x←1 ⋄ (5-3)→two three ⋄ x×←11 ⋄ one→⎕ ⋄ x×←3 ⋄ two→⎕ ⋄ x×←5 ⋄ three→⎕ ⋄ x×←7")
7

The biggest difference between April and other APLs lies in its implementation of the → branch function, as shown in the latter two examples above. April also allows you to use if-statements and functions with any number of named arguments in the style of Arthur Whitney's k programming language.

Using rational numbers

April is one of a few APL implementations to include rational numbers. They are printed with a lowercase r separating the numerator and denominator. Examples:

* (april-f "÷⍳5")
1 1r2 1r3 1r4 1r5
#(1 1/2 1/3 1/4 1/5)

* (april-f "2r3×⍳4")
2r3 4r3 2 8r3
#(2/3 4/3 2 8/3)

Rational numbers can also be used as parts of complex numbers:

* (april-f "3r4J9r5×⍳4")
3r4J9r5 3r2J18r5 9r4J27r5 3J36r5
#(#C(3/4 9/5) #C(3/2 18/5) #C(9/4 27/5) #C(3 36/5))

Underscores within numbers

In April, you can use underscores to separate parts of a number:

* (april "1_000_000+5")
1000005

* (april "1__000_000__000_000+5")
1000000000005

* (april "1_00___0_0__00_0+5")
10000005

As shown above, you can use any number of underscores anywhere within a number, they are simply ignored by the reader. Underscores are also used by the printer when printing columns of mixed complex floats and rationals:

* (april-f "⍪12.2J99.11 3J8 19r13J5r2")
12.20J99.11
 3___J_8   
19r13J_5r_2
#2A((#C(12.2 99.11)) (#C(3 8)) (#C(19/13 5/2)))

Using the underscores as filler keeps the decimal points, rs and Js properly aligned for printing.

Strings and escaped quotes

In April, either single or double quotes can be used to enclose character strings:

* (april "'abc','def'")
"abcdef"

* (april "\"ghi\",\"jkl\"")
"ghijkl"

Note that you must use backslashes to escape double quotes used within Lisp strings, making double quotes a less desirable choice unless you're loading April code from files using april-load. In order to escape quote characters within an April string, you can either enter a backslash before the quote character, as in Lisp and many other languages, or enter the quote character twice in the traditional APL style. For example:

* (april "'\'abc'\'")
"'abc'"

* (april "'''abc'''")
"'abc'"

Parameter reference

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

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

Or a parameter object followed by a text string:

* (april-f (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 specify many options for an April invocation. 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. When you set :count-from, it only affects the APL code evaluated in the expression to which the :count-from option is passed. For example:


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

* (april "⍳9")
#(1 2 3 4 5 6 7 8 9)

: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-f (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-f (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-f "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-f (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-f (with (:state :index-origin 0)) "⍳9")
0 1 2 3 4 5 6 7 8
#(0 1 2 3 4 5 6 7 8)

:print-precision

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

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

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

* (april-f (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-f), 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-f (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-f). 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.

:unformat-output

APL and Common Lisp use different models for nested arrays. Read more about it here. If you'd like to receive nested array output from April where the nested arrays are not wrapped in 0-rank scalar arrays, you can use the :unformat-output sub-parameter. Here's an example of the difference this sub-parameter makes:

* (april "2 2⍴⊂2 2⍴⍳4")
#2A((#0A#2A((1 2) (3 4)) #0A#2A((1 2) (3 4)))
    (#0A#2A((1 2) (3 4)) #0A#2A((1 2) (3 4))))

* (april (with (:state :unformat-output t)) "2 2⍴⊂2 2⍴⍳4")
#2A((#2A((1 2) (3 4)) #2A((1 2) (3 4))) (#2A((1 2) (3 4)) #2A((1 2) (3 4))))

(:space) 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, you must first create the workspace. Here's how:

* (april-create-workspace space1)
"Successfully created workspace 「SPACE1」."

Then, to evaluate April code within use the (:space) parameter. For example:

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

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

* (april-f (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 (april) without naming a workspace, a workspace called common is used.

* (april (with (:space common)) "a←5")
5

* (april "a+5")
10

(:store-val) and (:store-fun) parameters

If you'd like to add values and functions from the Lisp instance into an April workspace, you can use the (:store-val) and (:store-fun) parameters. Here is an example:

* (april (with (:store-val (a 12) (b 45))) "a+b+10")
67

* (april "3×a")
36

* (april (with (:store-fun (add-ten (lambda (x) (+ x 10))))) "")
NIL ;; the result of not running code after the function is stored

* (april "addTen 20")
30

As shown above, dash-separated variable and function names are converted to camel case, just as when passing input values with the :in sub-parameter of (:state). Note also that functions passed into April this way are not adapted for use with arrays the way that functions created within April are. For instance, if you enter:

* (april (with (:store-fun (add-ten (lambda (x) (+ x 10))))) "")
NIL

* (april "addTen 1 2 3 4 5")

You will get an error stating The value #(1 2 3 4 5) is not of type NUMBER .... That's because in Lisp, you can't add 10 to the vector #(1 2 3 4 5), which is what the function is attempting to do. Use caution when adding arbitrary Lisp functions into an April workspace.

If you want to store functions or variables with names that are read literally rather than being converted to camel case, you can do this by passing strings as the variable names. If a dash is found in such a string-expressed variable name it will cause an error. For example:

(april (with (:store-fun ("aBcDe" (lambda (x) (+ x 10))))) "aBcDe 5")
15

;; the presence of a dash causes an error
(april (with (:store-fun ("ab-cd" (lambda (x) (+ x 10))))) "abcd 6")
Error: Invalid characters present in symbol aBC-deF passed to :STORE-FUN.

(: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")
(IN-APRIL-WORKSPACE COMMON
  (LET* ((OUTPUT-STREAM *STANDARD-OUTPUT*))
    (DECLARE (IGNORABLE OUTPUT-STREAM))
    (SYMBOL-MACROLET ((INDEX-ORIGIN 𝕊*INDEX-ORIGIN*)
                      (PRINT-PRECISION 𝕊*PRINT-PRECISION*))
      (APL-OUTPUT (APL-CALL + (SCALAR-FUNCTION +) (AVECTOR 1 2 3) 1)
                  :PRINT-PRECISION PRINT-PRECISION))))

Clearing Workspaces: The (april-clear-workspace) Macro

You can use this macro to clear a workspace, removing all user-created variables within it and returning it to its default state. For example, to clear a workspace called space1, enter:

* (april-clear-workspace space1)
"The workspace 「SPACE1」 has been cleared."

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:

* (april-create-workspace space1)
"Successfully created workspace 「SPACE1」."

* (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)).

* (april-create-workspace space1)
"Successfully created workspace 「SPACE1」."

* (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-f) 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-f), no formatted values are printed by default; only the values assigned to are printed. Using , it's easy to debug complex functions.

Loading Code Directly From Files

Perhaps you'd like to write files containing pure APL code rather than passing strings to (april) within Lisp code. The (april-load) macro has you covered. For example:

⍝ contents of file test.apl

v  ← ⍳9
fn ← {⍵+10}
⎕  ← fn v
* (april-load #P"/path/to/test.apl")
11 12 13 14 15 16 17 18 19
#(11 12 13 14 15 16 17 18 19)

* (april "fn 3 4 5")
#(13 14 15)

The variable v and the function fn have been loaded into the default workspace.

Note that the argument to (april-load) must be a pathname, not merely a string. The argument to (april-load) may also be an expression that evaluates to a pathname. For instance:

* (april-load (pathname (format nil "~a/test.apl" "/test/directory")))
11 12 13 14 15 16 17 18 19
#(11 12 13 14 15 16 17 18 19)

The (april-load) macro may take a first argument containing the same parameters that can be passed to (april). For example:

* (april-create-workspace space1)
"Successfully created workspace 「SPACE1」."

* (april-load (with (:space space1) (:state :index-origin 0)) #P"/path/to/test.apl")
10 11 12 13 14 15 16 17 18
#(10 11 12 13 14 15 16 17 18)

* (april (with (:space space1)) "fn 9 8 7")
#(19 18 17)

Source code from files can thus be loaded into any workspace.

APL System Variables and Functions in April

April makes available the following APL system variables and functions:

⎕IO ⎕CT ⎕TS ⎕PP ⎕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.

About Workspace Variables: Index Origin and Print Precision

Above, you learned how to use the :count-from/:index-origin and :print-precision sub-parameters to control how April counts and prints. Using these parameters with an April invocation will affect only the code passed to that particular April invocation. What if you want to create a change in these parameters that will persist in a given workspace until it's changed again?

Traditional APL dialects use the ⎕IO and ⎕PP system variables to set the index origin and print precision in a workspace, and using them in April will make a change that persists in the workspace. For example:

* (april-create-workspace space1)
"Successfully created workspace 「SPACE1」."

* (april-create-workspace space2)
"Successfully created workspace 「SPACE2」."

* (april-f (with (:space space1)) "⎕IO←0 ⋄ ⍳9")
0 1 2 3 4 5 6 7 8
#(0 1 2 3 4 5 6 7 8)

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

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

Switching to the workspace space2, the default index origin of 1 is used again.

If you pass an :index-origin, :count-from or :print-precision sub-parameter to an APL invocation, it will override whatever value is present in the active workspace. However, it will only affect the code passed to the individual (april) invocation that has the sub-parameter(s) passed.

* (april-create-workspace space1)
"Successfully created workspace 「SPACE1」."

* (april-f (with (:space space1)) "⎕IO←0 ⋄ ⍳9")
0 1 2 3 4 5 6 7 8
#(0 1 2 3 4 5 6 7 8)

* (april-f (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-f (with (:space space1)) "⍳9")
0 1 2 3 4 5 6 7 8
#(0 1 2 3 4 5 6 7 8)

Setting a Custom Output Stream

April has a system variable called ⎕ost that you can use to set a custom destination for printed output. Normally, data output using (april-f) 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-f "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-f) 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-f) 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|.

The syntax above assumes that the symbol representing the output stream is internal to the current package. For instance:

(in-package #:pkg-one)

(defvar out-str (make-string-output-stream))

(april-f "⎕ost←'OUT-STR' ⋄ 5+10")

In this code, the OUT-STR output stream is interned in the package PKG-ONE. What if you want to use an output stream whose symbol belongs to a package other than the current one?

(in-package #:pkg-one)

(defvar out-str (make-string-output-stream))

(in-package #:pkg-two)

(april-f "⎕ost←('PKG-ONE' 'OUT-STR') ⋄ 5+10")

If you assign to ⎕ost a vector of two strings, the first string is the name of a package and the second string is the name of a symbol belonging to that package. In this way, you can reference an output stream whose symbol is interned in a package other than the current one.

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.

April's Lexicon Compared to Other APLs

APL has multiple implementations, and there are subtle but significant variations between the lexical functions they offer. April's set of functions is closest to those offered by Dyalog APL in its default mode. For instance, in April, dyadic implements the partitioned enclose function while dyadic implements the partition function, as in Dyalog. In IBM APL2, however, there is no partitioned enclose function and dyadic implements the partition function. The same is true in GNU APL, whose design primarily follows APL2.

The other major lexical difference between APL2-family languages and April is that in April, monadic implements the disclose function and monadic implements the mix function; the converse is true in APL2.

Dyalog APL offers users the option of using multiple lexical modes, some of which are more similar to APL2. The variable controlling these modes is referred to as the "migration level." The implementation of migration levels in April is not planned at this time.

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.

Enabling APL Input in Vim

For Lisp developers who interact with the language through Vim, a plugin called "vim-apl" allows one to input APL characters. You can get it from this git repository. Using a Vim plugin manager called Vundle it is easy to add this plugin by adding the single line Plugin 'justin2004/vim-apl' to your .vimrc and following the Vundle instructions. With vim-apl installed, while editing an .apl file you can enter the iota character by typing `i (backtick and i), enter the rho character by typing `r, and so on.

Enabling APL Input Universally in GNU/Linux

For GNU/Linux users who'd like use APL characters outside of a customized editor, refer to this page on the APL Wiki. After following the instructions there you'll be able to use your keyboard's right Alt key as a modifier to enter APL characters. For instance, you enter can the iota character by pressing


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.3

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.9.0

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.3

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/utilities.lisp

Dependency

package.lisp (file)

Parent

april (system)

Location

utilities.lisp

Packages

april.idiom-extension-tools

Exported Definitions
Internal Definitions

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

3.1.6 april/library.lisp

Dependency

utilities.lisp (file)

Parent

april (system)

Location

library.lisp

Internal Definitions

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

3.1.7 april/grammar.lisp

Dependency

library.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


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


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-c G1 &rest G4
Package

april

Source

spec.lisp (file)

Macro: april-clear-workspace G10
Package

april

Source

spec.lisp (file)

Macro: april-create-workspace G10
Package

april

Source

spec.lisp (file)

Macro: april-f &rest G1
Package

april

Source

spec.lisp (file)

Macro: april-load G1 &optional G5
Package

april

Source

spec.lisp (file)

Macro: april-p &rest ARGS
Package

april

Source

utilities.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 and (- 5 10) will thus 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: 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)

Macro: ws-assign-fun SYMBOL VALUE

Assignment macro for use with (:store-fun) directive.

Package

vex

Source

vex.lisp (file)

Macro: ws-assign-val SYMBOL VALUE

Assignment macro for use with (:store-val) directive.

Package

vex

Source

vex.lisp (file)

Macro: xdotimes OBJECT CLAUSE &body BODY
Package

aplesque

Source

aplesque.lisp (file)


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

5.1.2 Functions

Function: across INPUT FUNCTION &key ELEMENTS INDICES REVERSE-AXES COUNT RANGES FOREACH FINALLY DEPTH 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 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: apply-scalar FUNCTION OMEGA &optional ALPHA AXES IS-BOOLEAN

Apply a scalar function over an array or arrays as appropriate for the shape of the argument(s).

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 IN-COLLATED FORMAT SEGMENT

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 ALPHA OMEGA FUNCTION1 FUNCTION2

Find the inner product of two arrays with two functions.

Package

aplesque

Source

aplesque.lisp (file)

Function: array-outer-product OMEGA ALPHA FUNCTION

Find the outer product of two arrays with a function.

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

Generalized binomial function. For complex and fractional numbers uses Gamma function.

Package

aplesque

Source

aplesque.lisp (file)

Function: catenate A1 A2 AXIS

Join two arrays along the specified axis.

Package

aplesque

Source

aplesque.lisp (file)

Function: choose INPUT INDICES &key SET SET-BY MODIFY-INPUT

Select indices from an array and return them in an array shaped according to the requested indices, with the option to elide indices and perform an operation on the values at the indices instead of just fetching them and return the entire altered array.

Package

aplesque

Source

aplesque.lisp (file)

Function: composer IDIOM SPACE TOKENS &optional PRECEDENT PROPERTIES PRE-PROPS

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: copy-nested-array ARRAY

Copy an array along with nested sub-arrays within it.

Package

aplesque

Source

aplesque.lisp (file)

Function: count-segments VALUE PRECISION &optional SEGMENTS

Count the lengths of segments a number will be divided into when printed using (array-impress), within the context of a column’s existing segments if provided.

Package

aplesque

Source

aplesque.lisp (file)

Function: disclose ARRAY

Disclose a scalar nested array.

Package

aplesque

Source

aplesque.lisp (file)

Function: disclose-unitary ITEM

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

Package

aplesque

Source

aplesque.lisp (file)

Function: enclose ITEM
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 DEGREES INPUT AXIS &key COMPRESS-MODE POPULATOR

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: get-dimensional-factors DIMENSIONS
Package

aplesque

Source

aplesque.lisp (file)

Function: get-first-or-disclose OMEGA
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 ITEMS REFERENCE

Find the locations of indices of an array between the indices of a reference array.

Package

aplesque

Source

aplesque.lisp (file)

Function: inverse-outer-product INPUT FUNCTION RIGHT-ORIGINAL &optional LEFT-ORIGINAL

Find the inverse outer product of an array with a function and a given outer product argument.

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: 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: nest INPUT

Enclose simple arrays and return nested arrays as-is.

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 INPUT 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: reduce-array INPUT FUNCTION AXIS &optional LAST-AXIS WINDOW

Reduce an array along by a given function along a given dimension, optionally with a window interval.

Package

aplesque

Source

aplesque.lisp (file)

Function: reshape-to-fit INPUT OUTPUT-DIMS &key POPULATOR

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: section INPUT DIMENSIONS &key INVERSE POPULATOR

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

Top-level factorial-computing function.

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

Scan a function across an array along a given axis. Used to implement the [ scan] operator with an option for inversion when used with the [⍣ power] operator taking a negative right operand.

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: varef ARRAY SUBSCRIPTS

Reference an element in an array according to a vector of subscripts.

Package

aplesque

Source

aplesque.lisp (file)

Writer

(setf varef) (function)

Function: (setf varef) NEW-VALUE ARRAY SUBSCRIPTS

Set an element in an array according to a vector of subscripts.

Package

aplesque

Source

aplesque.lisp (file)

Reader

varef (function)

Function: vex-program IDIOM OPTIONS &optional STRING &rest INLINE-ARGUMENTS

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: get-system-meta IDIOM PROPERTY
Package

vex

Source

vex.lisp (file)

Methods
Method: get-system-meta (IDIOM idiom) PROPERTY

Retrieve a property of the idiom’s system.

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: 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-lexicon IDIOM LEXICON GLYPH
Package

vex

Source

vex.lisp (file)

Methods
Method: of-lexicon (IDIOM idiom) LEXICON GLYPH

Check whether a character belongs to a given Vex lexicon.

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: set-system-meta IDIOM &rest PAIRS
Package

vex

Source

vex.lisp (file)

Methods
Method: set-system-meta (IDIOM idiom) &rest PAIRS

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

Special Variable: *april-parallel-kernel*
Package

april

Source

utilities.lisp (file)

Special Variable: *composer-following-patterns*
Package

april

Source

grammar.lisp (file)

Special Variable: *composer-opening-patterns*
Package

april

Source

grammar.lisp (file)

Special Variable: *digit-vector*
Package

april

Source

spec.lisp (file)

Special Variable: *function-identities*
Package

april

Source

utilities.lisp (file)

Special Variable: *idiom-native-symbols*
Package

april

Source

spec.lisp (file)

Special Variable: *io-currying-function-symbols-dyadic*
Package

april

Source

utilities.lisp (file)

Special Variable: *io-currying-function-symbols-monadic*
Package

april

Source

utilities.lisp (file)

Special Variable: *package-name-string*
Package

april

Source

utilities.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: *branches*
Package

april

Source

utilities.lisp (file)

Expansion

(symbol-value (intern "*branches*" space))

Symbol Macro: *first-axis*
Package

april

Source

utilities.lisp (file)

Expansion

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

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

april

Source

utilities.lisp (file)

Expansion

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

Symbol Macro: *last-axis*
Package

april

Source

utilities.lisp (file)

Expansion

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

Symbol Macro: include-lexvar-symbols
Package

april

Source

grammar.lisp (file)

Expansion

(if (getf (getf (first (last april::preceding-properties)) :special) :lexvar-symbols) (sb-int:quasiquote (:lexvar-symbols #s(sb-impl::comma :expr (getf (getf (first (last april::preceding-properties)) :special) :lexvar-symbols) :kind 0))))

Symbol Macro: this-idiom
Package

april

Source

utilities.lisp (file)

Expansion

april::*april-idiom*


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

5.2.3 Macros

Macro: achoose ITEM INDICES &rest REST-PARAMS
Package

april

Source

utilities.lisp (file)

Macro: alambda PARAMS &body BODY
Package

april

Source

utilities.lisp (file)

Macro: apl-assign SYMBOL VALUE

This is macro is used to build variable assignment forms and includes logic for stranded assignments.

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-if &rest EACH-CLAUSE
Package

april

Source

utilities.lisp (file)

Macro: apl-output FORM &key PRINT-TO OUTPUT-PRINTED PRINT-ASSIGNMENT PRINT-PRECISION WITH-NEWLINE

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: assign-axes G8
Package

april

Source

grammar.lisp (file)

Macro: assign-element G9 G10 G11 &optional PROPERTIES
Package

april

Source

grammar.lisp (file)

Macro: assign-subprocessed G9 G10 PROPERTIES
Package

april

Source

grammar.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: composer-pattern G0 G1 G2 &body G3
Package

april

Source

grammar.lisp (file)

Macro: composer-pattern-template MACRO-NAMES TOKENS-SYM SPACE-SYM IDIOM-SYM PROCESS-SYM PRECEDENT-SYM PROPERTIES-SYM PRECEDING-PROPERTIES-SYM SPECIAL-PROPS-SYM ITEMS-SYM ITEM-SYM REST-ITEMS-SYM
Package

vex

Source

vex.lisp (file)

Macro: in-april-workspace NAME &body BODY

Reader macro that interns symbols in the current workspace; works in tandem with 𝕊 reader macro.

Package

april

Source

utilities.lisp (file)

Macro: insym SYMBOL

Macro used in grammar.lisp to intern value-referencing symbols in appropriate workspace package.

Package

april

Source

utilities.lisp (file)

Macro: is-workspace-function ITEM

Checks if a variable is present in the current workspace as a function.

Package

april

Source

utilities.lisp (file)

Macro: is-workspace-operator ITEM

Checks if a variable is present in the current workspace as a function.

Package

april

Source

utilities.lisp (file)

Macro: is-workspace-value ITEM

Checks if a variable is present in the current workspace as a value.

Package

april

Source

utilities.lisp (file)

Macro: olambda PARAMS &body BODY
Package

april

Source

utilities.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-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: with-derived-operands OPERAND-SPECS &rest BODY

Derive references to data to be passed to an operator so they can be used by the macro implementing the operator.

Package

april

Source

utilities.lisp (file)

Macro: ydotimes OBJECT CLAUSE &body BODY
Package

aplesque

Source

aplesque.lisp (file)

Macro: λχ BODY AXES

Curry a function with axes for use with an operator.

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)

Macro: λωχ &rest BODY
Package

april

Source

utilities.lisp (file)


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

5.2.4 Functions

Function: =vex-string IDIOM &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: adjust-axes-for-index-origin IO AXIS-LIST

Adjust axes passed to a function to account for the given index origin.

Package

april

Source

utilities.lisp (file)

Function: apl-array-prototype ARRAY

Returns the default element for an array based on that array’s first element (its prototype in array programming terms); blank spaces in the case of a character prototype and zeroes for others.

Package

aplesque

Source

aplesque.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: april-function-glyph-processor TYPE GLYPH SPEC &optional INVERSE-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: assign-selected ARRAY INDICES VALUES

Assign array values selected using one of the functions [↑ take], [↓ drop], [ expand] or [⊃ pick].

Package

april

Source

library.lisp (file)

Function: assign-self-refs-among-tokens TOKENS FUNCTION

Find a list of symbols within a token list which are assigned with the [← gets] lexical function. Used to find lists of variables to hoist in lambda forms.

Package

april

Source

utilities.lisp (file)

Function: at-index OMEGA ALPHA AXES INDEX-ORIGIN &optional TO-SET

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

Package

april

Source

library.lisp (file)

Function: axes-to-indices IC IDIMS OUT-VECTOR &optional IF START

Take a list of axes and assign the derived row-major indices to a vector with a fill point.

Package

aplesque

Source

aplesque.lisp (file)

Function: branch TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.lisp (file)

Function: build-compiled-code EXPS WORKSPACE-SYMBOLS OPTIONS SYSTEM-VARS VARS-DECLARED STORED-REFS SPACE

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

Package

april

Source

utilities.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-populator METADATA-SYMBOL INPUT

Generate a function that will populate array elements with an empty array prototype.

Package

april

Source

utilities.lisp (file)

Function: build-variable-declarations INPUT-VARS SPACE

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

Package

april

Source

utilities.lisp (file)

Function: call-circular &optional INVERSE
Package

april

Source

spec.lisp (file)

Function: catenate-arrays INDEX-ORIGIN

Wrapper for [, catenate] incorporating (aplesque:catenate) and (aplesque:laminate).

Package

april

Source

library.lisp (file)

Function: catenate-on-first INDEX-ORIGIN

Wrapper for [⍪ catenate first]; distinct from (catenate-arrays) because it does not provide the laminate functionality.

Package

april

Source

library.lisp (file)

Function: coerce-type ARRAY TYPE-INDEX

Create an array with a numerically designated type holding the contents of the given array.

Package

april

Source

utilities.lisp (file)

Function: compare-by SYMBOL COMPARISON-TOLERANCE
Package

april

Source

library.lisp (file)

Function: composer-pattern-function TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.lisp (file)

Function: composer-pattern-lateral-composition TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.lisp (file)

Function: composer-pattern-unitary-operation TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.lisp (file)

Function: composer-pattern-value TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES

Match an array like 1 2 3, marking the beginning of an array expression, or a functional expression if the array is an operand to a pivotal operator.

Package

april

Source

grammar.lisp (file)

Function: count-symbol-in-spec SYMBOL LIMBS

Count occurrences of a symbol in the spec. Used to plan the number of Prove tests to run.

Package

vex

Source

vex.lisp (file)

Function: count-to INDEX INDEX-ORIGIN

Implementation of APL’s ⍳ function.

Package

april

Source

library.lisp (file)

Function: deal INDEX-ORIGIN

Return a function to randomly shuffle a finite sequence. Used to implement [? deal].

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: dummy-nargument-function FIRST &rest REST

Placeholder function to be assigned to newly initialized function symbols.

Package

april

Source

utilities.lisp (file)

Function: duplicate OBJECT
Package

april

Source

utilities.lisp (file)

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

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 &optional INVERSE

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: expand-array DEGREES INPUT AXIS METADATA-SYMBOL &key COMPRESS-MODE

Wrapper for (aplesque:expand) implementing [/ replicate] and [ expand].

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, wrapping (aplesque:array-depth). 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-array PRINT-PRECISION

Use (aplesque:array-impress) to print an array and return the resulting character array, with the option of specifying decimal precision. Used to implement monadic and dyadic [⍕ format].

Package

april

Source

library.lisp (file)

Function: format-value IDIOM-NAME 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: function-assignment TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.lisp (file)

Function: gamma C

Gamma function using Lanczos approximation

Package

aplesque

Source

aplesque.lisp (file)

Function: generate-function-retriever OPERAND AXES

This function is used at compile time to generate the functon invoked by the [⍣ power] operator at runtime to fetch a regular or inverse function depending on the right operand passed to it.

Package

april

Source

utilities.lisp (file)

Function: generate-index-array ARRAY

Given an array, generate an array of the same shape whose each cell contains its row-major index.

Package

april

Source

library.lisp (file)

Function: generate-selection-form FORM SPACE

Generate a selection form for use with selective-assignment, i.e. (3↑x)←5.

Package

april

Source

library.lisp (file)

Function: get-free-threads ()
Package

aplesque

Source

aplesque.lisp (file)

Function: get-workspace-alias SPACE SYMBOL

Find an existing alias of a lexical function in a workspace.

Package

april

Source

utilities.lisp (file)

Function: get-workspace-item-meta SYMBOL ITEM &rest KEYS

Gets one or more metadata for an item in a workspace.

Package

april

Source

utilities.lisp (file)

Function: glean-symbols-from-tokens TOKENS SPACE &optional TOKEN-LIST IS-STRAND-ASSIGNMENT

Find a list of symbols within a token list which are assigned with the [← gets] lexical function. Used to find lists of variables to hoist in lambda forms.

Package

april

Source

utilities.lisp (file)

Function: ibinomial N K

Find a binomial for integer parameters.

Package

aplesque

Source

aplesque.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: inverse-count-to VECTOR INDEX-ORIGIN

The [⍳ index] function inverted; it returns the length of a sequential integer array starting from the index origin or else throws an error.

Package

april

Source

library.lisp (file)

Function: invert-function FORM &optional TO-WRAP

Invert a function expression. For use with the [⍣ power] operator taking a negative right operand.

Package

april

Source

utilities.lisp (file)

Function: isprfact N

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

Package

aplesque

Source

aplesque.lisp (file)

Function: lateral-inline-composition TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.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: make-prototype-of ARRAY

Make a prototype version of an array; all values in the array will be blank spaces for character arrays or zeroes for other types of arrays.

Package

april

Source

utilities.lisp (file)

Function: make-threading-kernel-if-absent ()
Package

april

Source

utilities.lisp (file)

Function: match-lexical-function-identity GLYPH

Find the identity value of a lexical function based on its character.

Package

april

Source

library.lisp (file)

Function: matrix-divide OMEGA ALPHA

Divide two matrices. Used to implement dyadic [⌹ matrix divide].

Package

april

Source

library.lisp (file)

Function: matrix-inverse OMEGA

Invert a matrix. Used to implement monadic [⌹ matrix inverse].

Package

april

Source

library.lisp (file)

Function: membership OMEGA ALPHA

Determine if elements of alpha are present in omega. Used to implement dyadic [∊ membership].

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: near-integerp X

Determing if a number is close enough to an integer to be treated as such.

Package

aplesque

Source

aplesque.lisp (file)

Function: near-realp X

Determine if the number is ’real enough’ to be treated as such.

Package

aplesque

Source

aplesque.lisp (file)

Function: numeric-string-p STRING

Checks whether the argument is a numeric string.

Package

april

Source

utilities.lisp (file)

Function: operate-at LEFT RIGHT LEFT-FN-M LEFT-FN-D RIGHT-FN INDEX-ORIGIN

Generate a function applying a function at indices in an array specified by a given index or meeting certain conditions. Used to implement [@ at].

Package

april

Source

library.lisp (file)

Function: operate-at-rank RANK FUNCTION-MONADIC FUNCTION-DYADIC

Generate a function applying a function to sub-arrays of the arguments. Used to implement [⍤ rank].

Package

april

Source

library.lisp (file)

Function: operate-atop RIGHT-FN-MONADIC RIGHT-FN-DYADIC LEFT-FN-MONADIC
Package

april

Source

library.lisp (file)

Function: operate-composed RIGHT RIGHT-FN-MONADIC RIGHT-FN-DYADIC LEFT LEFT-FN-MONADIC LEFT-FN-DYADIC IS-CONFIRMED-MONADIC

Generate a function by linking together two functions or a function curried with an argument. Used to implement [∘ compose].

Package

april

Source

library.lisp (file)

Function: operate-each FUNCTION-MONADIC FUNCTION-DYADIC

Generate a function applying a function to each element of an array. Used to implement [¨ each].

Package

april

Source

library.lisp (file)

Function: operate-grouping FUNCTION INDEX-ORIGIN

Generate a function applying a function to items grouped by a criterion. Used to implement [⌸ key].

Package

april

Source

library.lisp (file)

Function: operate-reducing FUNCTION FUNCTION-GLYPH AXIS &optional LAST-AXIS

Reduce an array along a given axis by a given function, returning function identites when called on an empty array dimension. Used to implement the [/ reduce] operator.

Package

april

Source

library.lisp (file)

Function: operate-scanning FUNCTION AXIS &optional LAST-AXIS INVERSE

Scan a function across an array along a given axis. Used to implement the [ scan] operator with an option for inversion when used with the [⍣ power] operator taking a negative right operand.

Package

april

Source

library.lisp (file)

Function: operate-stenciling RIGHT-VALUE LEFT-FUNCTION

Generate a function applying a function via (aplesque:stencil) to an array. Used to implement [⌺ stencil].

Package

april

Source

library.lisp (file)

Function: operate-to-power POWER FUNCTION-RETRIEVER

Generate a function applying a function to a value and successively to the results of prior iterations a given number of times. Used to implement [⍣ power].

Package

april

Source

library.lisp (file)

Function: operate-until OP-RIGHT OP-LEFT-MONADIC OP-LEFT-DYADIC

Generate a function applying a function to a value and successively to the results of prior iterations until a condition is net. Used to implement [⍣ power].

Package

april

Source

library.lisp (file)

Function: operation TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.lisp (file)

Function: operator-assignment TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.lisp (file)

Function: output-function FORM &optional ARGUMENTS LEXICAL-VARIABLE-SYMBOLS

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 COMPONENT-OF

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

Package

april

Source

utilities.lisp (file)

Function: permute-array INDEX-ORIGIN

Wraps (aops:permute) to permute an array, rearranging the axes in a given order or reversing them if no order is given. Used to implement monadic and dyadic [⍉ permute].

Package

april

Source

library.lisp (file)

Function: pick INDEX-ORIGIN

Fetch an array element, within successively nested arrays for each element of the left argument.

Package

april

Source

library.lisp (file)

Function: pivotal-composition TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.lisp (file)

Function: print-apl-number-string NUMBER &optional SEGMENTS PRECISION DECIMALS REALPART-MULTISEGMENT

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

Package

april

Source

utilities.lisp (file)

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

Process arbitrary tests within a spec containing expressions that are evaluated without being wrapped in an (april ...) form.

Package

vex

Source

vex.lisp (file)

Function: process-function THIS-ITEM PROPERTIES PROCESS IDIOM SPACE
Package

april

Source

grammar.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-operator THIS-ITEM PROPERTIES PROCESS IDIOM SPACE
Package

april

Source

grammar.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: process-value THIS-ITEM PROPERTIES PROCESS IDIOM SPACE
Package

april

Source

grammar.lisp (file)

Function: ranges-to-rmi-vector RANGES FACTORS &optional VECTOR COUNT
Package

aplesque

Source

aplesque.lisp (file)

Function: ravel-array INDEX-ORIGIN

Wrapper for aplesque [, ravel] function incorporating index origin from current workspace.

Package

april

Source

library.lisp (file)

Function: reshape-array METADATA-SYMBOL

Wrap (aplesque:reshape-to-fit) so that dyadic [⍴ shape] can be implemented with the use of empty-array prototypes.

Package

april

Source

library.lisp (file)

Function: resolve-function MODE REFERENCE &optional AXES

Retrieve the function corresponding to a given character or symbol in a given mode (monadic or dyadic).

Package

april

Source

utilities.lisp (file)

Function: rmi-from-subscript-vector ARRAY SUBSCRIPTS

Derive an array’s row-major index from a vector of subscripts.

Package

aplesque

Source

aplesque.lisp (file)

Function: scalar-compare COMPARISON-TOLERANCE

Compare two scalar values as appropriate for APL.

Package

april

Source

library.lisp (file)

Function: section-array INDEX-ORIGIN METADATA-SYMBOL &optional INVERSE

Wrapper for (aplesque:section) used for [↑ take] and [↓ drop].

Package

april

Source

library.lisp (file)

Function: segment-area SIZE SECTION-COUNT
Package

aplesque

Source

aplesque.lisp (file)

Function: set-workspace-alias SPACE SYMBOL GLYPH

Set an alias for a lexical function in a workspace, as when compiling f←+.

Package

april

Source

utilities.lisp (file)

Function: set-workspace-item-meta SYMBOL ITEM &rest DATA

Sets one or more metadata for an item in a workspace.

Package

april

Source

utilities.lisp (file)

Function: shape OMEGA

Get the shape of an array, implementing monadic [⍴ shape].

Package

april

Source

library.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: train-composition TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.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: unique-mask ARRAY

Return a 1 for each value encountered the first time in an array, 0 for others. Used to implement monadic [≠ unique mask].

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: value-assignment-by-function-result TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.lisp (file)

Function: value-assignment-by-selection TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.lisp (file)

Function: value-assignment-standard TOKENS SPACE IDIOM PROCESS &optional PRECEDENT PROPERTIES PRECEDING-PROPERTIES ITEMS ITEM REST-ITEMS
Package

april

Source

grammar.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

Remove elements in omega from alpha. Used to implement dyadic [~ without].

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-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-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․asd file
aplesque/aplesque.lisp: The aplesque/aplesque․lisp file
aplesque/package.lisp: The aplesque/package․lisp file
april.asd: The april․asd file
april/game-of-life.lisp: The april/game-of-life․lisp file
april/grammar.lisp: The april/grammar․lisp file
april/library.lisp: The april/library․lisp file
april/package.lisp: The april/package․lisp file
april/patterns.lisp: The april/patterns․lisp file
april/spec.lisp: The april/spec․lisp file
april/utilities.lisp: The april/utilities․lisp file

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

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

V
vex.asd: The vex․asd file
vex/package.lisp: The vex/package․lisp file
vex/vex.lisp: The vex/vex․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   X   Y   Λ  
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): Exported generic functions
(setf idiom-symbols): Exported 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
(setf varef): Exported functions

=
=vex-string: Internal functions

A
achoose: Internal macros
across: Exported functions
adjust-axes-for-index-origin: Internal functions
alambda: Internal macros
alpha-compare: Exported functions
apl-array-prototype: Internal functions
apl-assign: Internal macros
apl-call: Internal macros
apl-compose: Internal macros
apl-if: Internal macros
apl-output: Internal macros
apl-timestamp: Internal functions
apply-scalar: Exported functions
april: Exported macros
april-c: Exported macros
april-clear-workspace: Exported macros
april-create-workspace: Exported macros
april-f: 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-outer-product: Exported functions
array-promote: Exported functions
array-to-list: Exported functions
array-to-nested-vector: Exported functions
array-union: Internal functions
assign-axes: Internal macros
assign-element: Internal macros
assign-element-type: Exported functions
assign-selected: Internal functions
assign-self-refs-among-tokens: Internal functions
assign-subprocessed: Internal macros
at-index: Internal functions
avector: Internal macros
axes-to-indices: Internal functions

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

C
call-circular: Internal functions
catenate: Exported functions
catenate-arrays: Internal functions
catenate-on-first: Internal functions
choose: Exported functions
coerce-type: Internal functions
compare-by: Internal functions
composer: Exported functions
composer-pattern: Internal macros
composer-pattern-function: Internal functions
composer-pattern-lateral-composition: Internal functions
composer-pattern-template: Internal macros
composer-pattern-unitary-operation: Internal functions
composer-pattern-value: Internal functions
copy-nested-array: Exported functions
count-segments: Exported functions
count-symbol-in-spec: Internal functions
count-to: Internal functions

D
deal: Internal functions
decode: Internal functions
derive-opglyphs: Internal functions
disclose: Exported functions
disclose-atom: Internal functions
disclose-unitary: Exported functions
dummy-nargument-function: Internal functions
duplicate: Internal functions

E
enclose: Exported functions
enclose-atom: Exported functions
enclose-axes: Internal functions
encode: Internal functions
enlist: Exported functions
expand: Exported functions
expand-array: Internal 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-array: Internal functions
format-value: Internal functions
Function, (setf varef): Exported functions
Function, =vex-string: Internal functions
Function, across: Exported functions
Function, adjust-axes-for-index-origin: Internal functions
Function, alpha-compare: Exported functions
Function, apl-array-prototype: Internal functions
Function, apl-timestamp: Internal functions
Function, apply-scalar: Exported 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-outer-product: Exported 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, assign-selected: Internal functions
Function, assign-self-refs-among-tokens: Internal functions
Function, at-index: Internal functions
Function, axes-to-indices: Internal functions
Function, binomial: Exported functions
Function, branch: Internal functions
Function, build-compiled-code: Internal functions
Function, build-doc-profile: Internal functions
Function, build-populator: Internal functions
Function, build-variable-declarations: Internal functions
Function, call-circular: Internal functions
Function, catenate: Exported functions
Function, catenate-arrays: Internal functions
Function, catenate-on-first: Internal functions
Function, choose: Exported functions
Function, coerce-type: Internal functions
Function, compare-by: Internal functions
Function, composer: Exported functions
Function, composer-pattern-function: Internal functions
Function, composer-pattern-lateral-composition: Internal functions
Function, composer-pattern-unitary-operation: Internal functions
Function, composer-pattern-value: Internal functions
Function, copy-nested-array: Exported functions
Function, count-segments: Exported functions
Function, count-symbol-in-spec: Internal functions
Function, count-to: Internal functions
Function, deal: Internal functions
Function, decode: Internal functions
Function, derive-opglyphs: Internal functions
Function, disclose: Exported functions
Function, disclose-atom: Internal functions
Function, disclose-unitary: Exported functions
Function, dummy-nargument-function: Internal functions
Function, duplicate: Internal 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: Exported functions
Function, expand-array: Internal functions
Function, extract-axes: Internal functions
Function, find-array: Exported functions
Function, find-depth: Internal functions
Function, find-first-dimension: Internal functions
Function, format-array: Internal functions
Function, format-value: Internal functions
Function, function-assignment: Internal functions
Function, gamma: Internal functions
Function, generate-function-retriever: Internal functions
Function, generate-index-array: Internal functions
Function, generate-selection-form: Internal functions
Function, get-dimensional-factors: Exported functions
Function, get-first-or-disclose: Exported functions
Function, get-free-threads: Internal functions
Function, get-workspace-alias: Internal functions
Function, get-workspace-item-meta: Internal functions
Function, glean-symbols-from-tokens: Internal functions
Function, grade: Exported functions
Function, ibinomial: Internal functions
Function, indent-code: Internal functions
Function, index-of: Exported functions
Function, interval-index: Exported functions
Function, inverse-count-to: Internal functions
Function, inverse-outer-product: Exported functions
Function, invert-function: Internal functions
Function, invert-matrix: Exported functions
Function, is-unitary: Exported functions
Function, isprfact: Internal functions
Function, laminate: Exported functions
Function, lateral-inline-composition: Internal functions
Function, left-invert-matrix: Internal functions
Function, make-prototype-of: Internal functions
Function, make-threading-kernel-if-absent: Internal functions
Function, match-lexical-function-identity: Internal functions
Function, matrix-divide: Internal functions
Function, matrix-inverse: Internal functions
Function, membership: Internal functions
Function, merge-lexicons: Internal functions
Function, merge-options: Internal functions
Function, mix-arrays: Exported functions
Function, near-integerp: Internal functions
Function, near-realp: Internal functions
Function, nest: Exported functions
Function, numeric-string-p: Internal functions
Function, operate-at: Internal functions
Function, operate-at-rank: Internal functions
Function, operate-atop: Internal functions
Function, operate-composed: Internal functions
Function, operate-each: Internal functions
Function, operate-grouping: Internal functions
Function, operate-reducing: Internal functions
Function, operate-scanning: Internal functions
Function, operate-stenciling: Internal functions
Function, operate-to-power: Internal functions
Function, operate-until: Internal functions
Function, operation: Internal functions
Function, operator-assignment: 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, permute-array: Internal functions
Function, pick: Internal functions
Function, pivotal-composition: Internal functions
Function, print-apl-number-string: Internal functions
Function, process-arbitrary-tests-for: Internal functions
Function, process-function: Internal functions
Function, process-general-tests-for: Internal functions
Function, process-lex-tests-for: Internal functions
Function, process-operator: Internal functions
Function, process-output-vector: Internal functions
Function, process-value: Internal functions
Function, ranges-to-rmi-vector: Internal functions
Function, ravel: Exported functions
Function, ravel-array: Internal functions
Function, re-enclose: Exported functions
Function, reduce-array: Exported functions
Function, reshape-array: Internal functions
Function, reshape-to-fit: Exported functions
Function, resolve-function: Internal functions
Function, rmi-from-subscript-vector: Internal functions
Function, scalar-compare: Internal functions
Function, scale-array: Exported functions
Function, section: Exported functions
Function, section-array: Internal functions
Function, segment-area: Internal functions
Function, set-workspace-alias: Internal functions
Function, set-workspace-item-meta: Internal functions
Function, shape: Internal functions
Function, split-array: Exported functions
Function, sprfact: Exported functions
Function, stencil: Exported functions
Function, tabulate: Internal functions
Function, train-composition: Internal functions
Function, turn: Exported functions
Function, type-in-common: Exported functions
Function, unique: Internal functions
Function, unique-mask: Internal functions
Function, validate-arg-unitary: Internal functions
Function, value-assignment-by-function-result: Internal functions
Function, value-assignment-by-selection: Internal functions
Function, value-assignment-standard: Internal functions
Function, varef: Exported functions
Function, vector-grade: Internal functions
Function, vex-program: Exported functions
Function, where-equal-to-one: Internal functions
Function, without: Internal functions
function-assignment: Internal functions

G
gamma: Internal functions
generate-function-retriever: Internal functions
generate-index-array: Internal functions
generate-selection-form: Internal functions
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): Exported generic functions
Generic Function, (setf idiom-system): Internal generic functions
Generic Function, (setf idiom-utilities): Internal generic functions
Generic Function, get-system-meta: Exported 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: Exported 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: Exported generic functions
Generic Function, of-operators: Exported generic functions
Generic Function, of-utilities: Internal generic functions
Generic Function, set-system-meta: Exported generic functions
get-dimensional-factors: Exported functions
get-first-or-disclose: Exported functions
get-free-threads: Internal functions
get-system-meta: Exported generic functions
get-system-meta: Exported generic functions
get-workspace-alias: Internal functions
get-workspace-item-meta: Internal functions
glean-symbols-from-tokens: Internal functions
grade: Exported functions

I
ibinomial: Internal functions
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: Exported generic functions
idiom-symbols: Exported generic functions
idiom-system: Internal generic functions
idiom-system: Internal generic functions
idiom-utilities: Internal generic functions
idiom-utilities: Internal generic functions
in-april-workspace: Internal macros
indent-code: Internal functions
index-of: Exported functions
insym: Internal macros
interval-index: Exported functions
inverse-count-to: Internal functions
inverse-outer-product: Exported functions
invert-function: Internal functions
invert-matrix: Exported functions
is-unitary: Exported functions
is-workspace-function: Internal macros
is-workspace-operator: Internal macros
is-workspace-value: Internal macros
isprfact: Internal functions

L
laminate: Exported functions
lateral-inline-composition: Internal functions
left-invert-matrix: Internal functions
local-idiom: Exported macros

M
Macro, achoose: Internal macros
Macro, alambda: Internal macros
Macro, apl-assign: Internal macros
Macro, apl-call: Internal macros
Macro, apl-compose: Internal macros
Macro, apl-if: Internal macros
Macro, apl-output: Internal macros
Macro, april: Exported macros
Macro, april-c: Exported macros
Macro, april-clear-workspace: Exported macros
Macro, april-create-workspace: Exported macros
Macro, april-f: Exported macros
Macro, april-load: Exported macros
Macro, april-p: Exported macros
Macro, assign-axes: Internal macros
Macro, assign-element: Internal macros
Macro, assign-subprocessed: Internal macros
Macro, avector: Internal macros
Macro, boolean-op: Exported macros
Macro, composer-pattern: Internal macros
Macro, composer-pattern-template: Internal macros
Macro, extend-vex-idiom: Exported macros
Macro, in-april-workspace: Internal macros
Macro, insym: Internal macros
Macro, is-workspace-function: Internal macros
Macro, is-workspace-operator: Internal macros
Macro, is-workspace-value: Internal macros
Macro, local-idiom: Exported macros
Macro, matrix-print: Exported macros
Macro, olambda: Internal macros
Macro, or-functional-character: Internal macros
Macro, print-and-run: Internal macros
Macro, resolve-operator: Internal macros
Macro, reverse-op: Exported macros
Macro, scalar-function: Internal macros
Macro, set-composer-elements: Exported macros
Macro, specify-vex-idiom: Exported macros
Macro, vex-idiom-spec: Internal macros
Macro, with-april-context: Exported macros
Macro, with-derived-operands: Internal macros
Macro, ws-assign-fun: Exported macros
Macro, ws-assign-val: Exported macros
Macro, xdotimes: Exported macros
Macro, ydotimes: Internal macros
Macro, λχ: Internal macros
Macro, λω: Internal macros
Macro, λωα: Internal macros
Macro, λωαχ: Internal macros
Macro, λωχ: Internal macros
make-prototype-of: Internal functions
make-threading-kernel-if-absent: Internal functions
match-lexical-function-identity: Internal functions
matrix-divide: Internal functions
matrix-inverse: Internal functions
matrix-print: Exported macros
membership: Internal 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): Exported generic functions
Method, (setf idiom-system): Internal generic functions
Method, (setf idiom-utilities): Internal generic functions
Method, get-system-meta: Exported 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: Exported generic functions
Method, idiom-system: Internal generic functions
Method, idiom-utilities: Internal generic functions
Method, of-functions: Exported generic functions
Method, of-lexicon: Exported generic functions
Method, of-operators: Exported generic functions
Method, of-utilities: Internal generic functions
Method, set-system-meta: Exported generic functions
mix-arrays: Exported functions

N
near-integerp: Internal functions
near-realp: Internal functions
nest: Exported functions
numeric-string-p: Internal functions

O
of-functions: Exported generic functions
of-functions: Exported generic functions
of-lexicon: Exported generic functions
of-lexicon: Exported generic functions
of-operators: Exported generic functions
of-operators: Exported generic functions
of-utilities: Internal generic functions
of-utilities: Internal generic functions
olambda: Internal macros
operate-at: Internal functions
operate-at-rank: Internal functions
operate-atop: Internal functions
operate-composed: Internal functions
operate-each: Internal functions
operate-grouping: Internal functions
operate-reducing: Internal functions
operate-scanning: Internal functions
operate-stenciling: Internal functions
operate-to-power: Internal functions
operate-until: Internal functions
operation: Internal functions
operator-assignment: Internal 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
permute-array: Internal functions
pick: Internal functions
pivotal-composition: Internal functions
print-and-run: Internal macros
print-apl-number-string: Internal functions
process-arbitrary-tests-for: Internal functions
process-function: Internal functions
process-general-tests-for: Internal functions
process-lex-tests-for: Internal functions
process-operator: Internal functions
process-output-vector: Internal functions
process-value: Internal functions

R
ranges-to-rmi-vector: Internal functions
ravel: Exported functions
ravel-array: Internal functions
re-enclose: Exported functions
reduce-array: Exported functions
reshape-array: Internal functions
reshape-to-fit: Exported functions
resolve-function: Internal functions
resolve-operator: Internal macros
reverse-op: Exported macros
rmi-from-subscript-vector: Internal functions

S
scalar-compare: Internal functions
scalar-function: Internal macros
scale-array: Exported functions
section: Exported functions
section-array: Internal functions
segment-area: Internal functions
set-composer-elements: Exported macros
set-system-meta: Exported generic functions
set-system-meta: Exported generic functions
set-workspace-alias: Internal functions
set-workspace-item-meta: Internal functions
shape: Internal functions
specify-vex-idiom: Exported macros
split-array: Exported functions
sprfact: Exported functions
stencil: Exported functions

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

U
unique: Internal functions
unique-mask: Internal functions

V
validate-arg-unitary: Internal functions
value-assignment-by-function-result: Internal functions
value-assignment-by-selection: Internal functions
value-assignment-standard: Internal functions
varef: Exported 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
with-derived-operands: Internal macros
without: Internal functions
ws-assign-fun: Exported macros
ws-assign-val: Exported macros

X
xdotimes: Exported macros

Y
ydotimes: Internal macros

Λ
λχ: Internal macros
λω: 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   X   Y   Λ  

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

A.3 Variables

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

*
*alphabet-vector*: Internal special variables
*apl-timestamp*: Internal symbol macros
*april-idiom*: Internal special variables
*april-parallel-kernel*: Internal special variables
*branches*: Internal symbol macros
*composer-following-patterns*: Internal special variables
*composer-opening-patterns*: Internal special variables
*digit-vector*: Internal special variables
*first-axis*: Internal symbol macros
*first-axis-or-nil*: Internal symbol macros
*function-identities*: Internal special variables
*idiom-native-symbols*: Internal special variables
*io-currying-function-symbols-dyadic*: Internal special variables
*io-currying-function-symbols-monadic*: Internal special variables
*last-axis*: Internal symbol macros
*package-name-string*: Internal special variables

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

F
functions: Internal classes

G
grammar-elements: Internal classes

I
include-lexvar-symbols: Internal symbol macros

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, *april-parallel-kernel*: Internal special variables
Special Variable, *composer-following-patterns*: Internal special variables
Special Variable, *composer-opening-patterns*: Internal special variables
Special Variable, *digit-vector*: Internal special variables
Special Variable, *function-identities*: Internal special variables
Special Variable, *idiom-native-symbols*: Internal special variables
Special Variable, *io-currying-function-symbols-dyadic*: Internal special variables
Special Variable, *io-currying-function-symbols-monadic*: Internal special variables
Special Variable, *package-name-string*: Internal special variables
Symbol Macro, *apl-timestamp*: Internal symbol macros
Symbol Macro, *branches*: 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, include-lexvar-symbols: 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:   *  
C   F   G   I   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․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․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