# Glossary

- Ambivalent function
- A function that may be
*applied*to either one or two*arguments*; i.e. has both*unary*and*binary*applications, e.g.`deltas`

.

Derivatives, each-prior, over - Adverb
- A primitive higher-order function that returns a
*derivative*(derived function) Adverbs - Aggregate function
- A function that reduces its argument, typically a list to an atom, e.g.
`sum`

- Apply
- As in
*apply a function to its arguments*: pass to a function the value of its*arguments*for evaluation. A function is applied to an argument list, e.g.`{x+y*z}[3;4;5]`

. A*unary*function can be applied by juxtaposition, e.g.`count 3 4 5`

. An*operator*can also be applied by*infix*, e.g.`2+3`

,`2 rotate 3 4 5`

. application - Argument, argument list
- A value passed to a function. In
`3+4`

the arguments are 3 and 4, respectively the left- and right-arguments. In`{x+y*z}[3;4;5]`

the three arguments are separated by semicolons and bracketed:`[3;4;5]`

is an argument list. - Atom
- A single instance of a datatype, eg
`42`

,`"a"`

,`1b`

,`2012.09.15`

. The`type`

of an atom is always negative. - Atomic function
- An atomic function is a uniform function such that for
`r:f[x]`

`r[i]~f x[i]`

is true for all`i`

, e.g.`signum`

. A function`f`

of higher*rank*is atomic if`f`

is identical to`f'`

. - Binary function
- A function with
*rank*2, i.e. that takes 2 arguments, e.g.`+`

,`rotate`

- Conform
*Lists*,*dictionaries*and*tables*conform if they are either*atoms*or have the same*count*- Control word
- Control words interrupt the usual evaluation rules, e.g. by omitting expressions, terminating evaluation
- Count
- The number of items in a
*list*, keys in a*dictionary*or rows in a*table*. The count of an atom is 1 - Derivative
- The derived function returned by an
*adverb*. Derivatives - Dictionary
- A map of a
*list*of keys to a list of values - Domain
- The domain of a function is the complete set of possible values of its argument.

Interactive Mathematics - Enumeration
- A representation of a
*list*as indexes of the*items*in its*nub*or another list.

*enum*

- Infix
- Writing an operator between its
*arguments*, e.g.

`2+3`

applies`+`

to 2 and 3 - Item, list item
- A member of a
*list* - Juxtaposition
- Literally, ‘putting beside’. Juxtaposing a list with a list or atom indexes the former with the latter, e.g.
`"abcde"1 4 3`

. Juxtaposing a*unary*function and a noun applies the former to the latter, e.g.`til 5`

. “Indexing is application.” - Keyed table
- A table of which one or more columns have been defined as its key. A table’s key/s (if any) are supposed to be distinct: updating the table with rows with existing keys overwrites the previous records with those keys. A table without keys is a
*simple table*. - Lambda
- A function defined in the
*lambda notation* - Lambda notation
- The notation in which functions are defined: an optional
*signature*followed by a list of expressions, separated by semicolons, and all embraced by curly braces, e.g.

`{[a;b](a*a)+(b*b)+2*a*b}`

. - List
- An array of one dimension, its
*items*indexed by position

- Matrix
- A
*list*in which all*items*are lists of the same*count* - Noun
- A syntactic class applicable to data structures:
*atom*,*list*,*dictionary*and*table*, but also*lambda*, functions and*adverbs*when treated as such, e.g.`count(+;rotate;/)`

- Nub
- The
`distinct`

*items*of a*list* - Operator
- A
*primitive**binary*function that may be applied*infix*as well as*prefix*, e.g.`+`

,`rotate`

- Peaceful function
- A
*lambda*without a*signature*specifying*argument*names, e.g.`{x*x}`

.

*No Need to Argue* - Postfix
*Applying*an*adverb*to its*argument*by writing it to the right, e.g.`+/`

applies`/`

to`+`

. (But for an*operator*, see*projection*.)- Prefix
*Applying*a function to its*argument/s*by writing it to the left of them, e.g.`+[2;3]`

applies`+`

to`[2;3]`

- Primitive
- Defined in the q language, not by the programmer
- Project, projection
- A function passed fewer
*arguments*than its*rank*projects those arguments and returns a projection: a function of the unspecified argument/s. Projection - Range
- The range of a function is the complete set of all its possible resulting values.

Interactive Mathematics - Rank
- Of a
**function**, the number of*arguments*it takes. For a*lambda*, the*count*of arguments in its*signature*, or, where the signature is omitted, by the here highest-numbered of the three default argument names`x`

(1),`y`

(2) and`z`

(3) used in the function definition, e.g.`{x+z}`

has rank 3. - Of a
**list**, the depth to which it is nested. A*vector*has rank 1. - Reference
*Pass by reference*means passing the name of an object (as a symbol atom) as an*argument*to a function, e.g.`key `.q`

.- Signature
- The list of up to 8
*argument*names that (optionally) begins a*lambda*, e.g. in`{[a;b](a*a)+(b*b)+2*a*b}`

, the argument list`[a;b]`

is the signature - Simple table
- A table with no key/s defined; i.e. not a
*keyed table* - String
- There is no string datatype in q. “String” in q means a char
*vector*, e.g. "abc". - Table
- A
*list*of uniform*dictionaries*that have the same domain - Unary function
- A function with
*rank*1, i.e. that takes 1*argument*, e.g.`count`

- Uniform function
- A uniform function
`f`

such that count[x]~count f x, e.g.`deltas`

- Value
*Pass by value*means passing an object (not its name) as an*argument*to a function, e.g.`key .q`

.- Vector
- A uniform list of basic types that has a special shorthand notation. A char vector is known as a
*string*. - x
- Default name of the first or only
*argument*of a*peaceful*function - y
- Default name of the second
*argument*of a*peaceful*function, or right-argument to an*operator* - z
- Default name of the third
*argument*of a*peaceful*function