Expressive Power

FISh supports

the usual functional features

such as strong typing, higher-order functions and parametric polymorphism. It also supports

simple imperative features

such as assignment, for- and while-loops, and local variables, using a type of commands. Procedures are represented as functions into commands, as in Algol-like languages.

Unlike existing Algol-like languages, it also supports data types of arrays, so that array programs may be polymorphic in the size of the array. Now this has been extended to support

poly-dimensional array programming.

If a is any array type then [a] is the type of all arrays with entries in a that are

finite dimensional, and
regular,

such as vectors, matrices, three-dimensional arrays, etc. Thus, poly-dimensional array programs can be written that act on a vector, matrix, or higher-dimensional array. For example, the standard prelude supports a polymorphic constant

              map : (a -> b) -> [a] -> [b]

which will map a function over a vector, matrix, or higher-dimensional array. Note that a matrix of integers, or type [int] has a different type from a vector of vectors of type [[int]]. Thus, given sum_int : [int] -> int which adds up an array of integers, we have

             map sum_int : [[int]] -> [int]

which will sum each entry of the outer array. This is useful when

representing complex numbers as arrays of length 2, or
each entry in an array has an associated array of data, e.g.
- each entry is given an array of nearest neighbours, or
decomposing an array into an array of blocks, e.g.
- a matrix into a matrix of matrices.

Here is an example.

Last Updated: Wednesday, 12-Aug-1998 20:09:44 EST

Please feel free to send any comments.