Component Files

 
APLX
APLX64
News
Version 5 Features
Development
GUI Programming
Language
Learning APL
    Tutorial Contents
    Introduction to APL
    Entering symbols
    QuickSym popup
    Simple Arithmetic
    Variables
    Tables
    Writing a Function
    Overview of APL
    The Workspace
    Data
    Built-in Functions
    System Functions
    Operators
    User Functions
    Component Files
    Error Handling
    Formatting
    Classes
Documentation
Online Help
Downloads
Technical Support
APLX Forum
Community
Buy APLX

This section discusses component files, which are used as a very easy way to store and retrieve APL data in a proprietary format. APLX is also able to access other types of files (e.g. text and pictures) via a number of system functions. For example, see:

Note: APLX supports two different component file systems. The first of these is based on the file-access primitives ⍇ ⍈ ⍐ ⍗ (as implemented in APL. 68000), and is discussed in this section.

The second is based on system functions such as ⎕FTIE and is provided primarily for compatibility with APL interpreters from other vendors. For more information, see the section 'Component File Systems' in the APLX Language Manual.

APL was originally implemented without a filing system because for simple purposes the facilities provided by the workspace are quite sufficient. In general you can keep all the data you need in the current workspace with occasional 'imports' from a saved workspace.

However, occasionally this may not fit your requirements. For example, if you wrote a suite of functions which produced monthly profit and loss accounts, you might want to store the data for each month separately. You could arrange to keep the data in a series of stored workspaces, but you wouldn't want to replicate the functions in each of these workspaces.

You could get round this by having the functions in the active workspace and using )COPY to copy in the data for each month from a stored workspace. (Copying doesn't obliterate what's already in memory, while using )LOAD does). But a more efficient method is to store each month's data in a file, and read that file into the workspace when it's needed.

APLX has a very flexible and simple filing system available for such situations.

Files

APLX files are identified by number rather than by name. Any integer can be used. An APL file can be regarded as a series of numbered pigeon-holes with the useful feature that (subject to space being available) each pigeon hole can hold as much or as little as you like.

Components

The pigeon-holes are called components. A single letter of the alphabet may constitute one component while a matrix containing several thousand numbers may be its next door neighbour.

Functions can be stored in files as well, but they must first be converted into character-matrices by the system function ⎕CR, or stored via the overlay system function, ⎕OV.

Basic file operations

Creating a file is simply a matter of writing a component to it. The command for this is ⍈ (Quad-Write). If the file already exists, the component is added to it in the appropriate position. If the file doesn't exist, APL creates it and then writes the component to it:

      TABLE ⍈ 3 1

The above command puts the contents of TABLE into component 1 of file 3, creating file 3 first if necessary.

Here's another example:

      PRICES ⍈ 3 2

The information held in PRICES will become component 2 of file 3, overwriting component 2 if it already exists.

Reading data from a file follows the same principles. To get component 1 from file 3 you would type:

      ⍇ 3 1

In the form shown, the command ⍇ (Quad-Read) will cause the contents of component 1 to be displayed on the screen.

It's more likely that you'll want to put the data into a variable and carry out some operation on it. The following statement reads component 2 from file 3 and assigns it to a variable called A:

      A ← ⍇ 3 2

Deleting a component or file is specified in much the same way using a command ⍗ (Quad-Drop):

      ⍗ 3 2

deletes component 2 from file 3, renumbering components in the same way lines in a function are renumbered after deleting a line. Similarly, components can be inserted by writing to a number that lies 'between' two components:

      PRICES ⍈ 3 1.5

The last example, will write a component containing the information in PRICES between components 1 and 2. The components in the file will then be renumbered in the same way lines in a function are renumbered after inserting a line.

For a fuller explanation of reading and writing component files, see 'Component File Systems' in the APLX Language Manual.