Consistently avoid "derived function" for trains: use "compound function" instead

4 files changed, 5 insertions, 5 deletions

diff --git a/spec/evaluate.md b/spec/evaluate.md
index 0f340825..48d00014 100644
--- a/spec/evaluate.md
+++ b/spec/evaluate.md
@@ -49,9 +49,9 @@ Rules in the table below are function and modifier evaluation.
 
 In each case the constituent expressions are evaluated in reverse source order: Right, then Called, then Left. Then the expression's result is obtained by calling the Called value on its parameters. A left argument of `nothing` is not used as a parameter, leaving only a right argument in that case. The type of the Called value must be appropriate to the expression type, as indicated in the "Types" column. For function application, a data type (number, character, or array) is allowed. It is called simply by returning itself. Although the arguments are ignored in this case, they are still evaluated. A block is evaluated by binding the parameter names given in columns L and R to the corresponding values. Then if all parameter levels present have been bound, its body is evaluated to give the result of application.
 
-Modifiers that are evaluated when they receive operands are called *immediate*. Other modifiers, including primitives and some kinds of block, simply record the operands and are called *deferred*. The result of applying a deferred modifier once is called a *derived function*.
+Modifiers that are evaluated when they receive operands are called *immediate*. Other modifiers, including primitives and some kinds of block, simply record the operands and are called *deferred*. The result of applying a deferred modifier once is called a *derived function*, and is one kind of *compound function*.
 
-The rules for trains create another kind of derived function. A derived function is identified by the rule that created it, and the values of its parts.
+The rules for trains create another kind of compound function. A compound function is identified by the rule that created it, and the values of its parts.
 | Left       | Center    | Right                 | Result
 |------------|-----------|-----------------------|--------------
 | `Operand`  |  `Derv`   | `Fork`                | `{(𝕨L𝕩)C(𝕨R𝕩)}`
diff --git a/spec/inferred.md b/spec/inferred.md
index 707d70ca..680f75b9 100644
--- a/spec/inferred.md
+++ b/spec/inferred.md
@@ -139,7 +139,7 @@ The following cases of Self/Swap must be supported.
 | `∨˜` | `√⌾¬` | `∨⁼`
 | `¬˜` |       | `+-1˙`
 
-Inverses of other modifiers and derived functions or modifiers obtained from them are given below. Here the "inverse" of a modifier is another modifier that, if applied to the same operands as the original operator, gives its inverse function. A constant is either a data value or `𝔽˙` for an arbitrary value `𝔽`.
+Inverses of other modifiers and compound functions are given below. Here the "inverse" of a modifier is another modifier that, if applied to the same operands as the original operator, gives its inverse function. A constant is either a data value or `𝔽˙` for an arbitrary value `𝔽`.
 
 | Mod     | Inverse              | Requirements
 |---------|----------------------|--------------
diff --git a/spec/primitive.md b/spec/primitive.md
index ef3055c4..6efa6853 100644
--- a/spec/primitive.md
+++ b/spec/primitive.md
@@ -42,7 +42,7 @@ The dyadic function `=`, representing equality comparison, can be applied to any
 
 Operations are split into subtypes depending on how they were created.
 - Primitives are equal if they have the same token spelling.
-- Derived operations are equal if they are derived by the same rule and each corresponding component is the same.
+- Compound functions are equal if they are produced by the same rule and each corresponding component is the same.
 - Block instances are equal if they are the same instance.
 
 This means that block instance equality indicates identity in the context of mutability: two block instances are equal if any change of state in one would be reflected in the other as well. The concept of identity holds even if the blocks in question have no way of changing or accessing state. For example, `=○{𝕩⋄{𝕩}}˜@` is `0` while `=˜○{𝕩⋄{𝕩}}@` is `1`.
diff --git a/spec/system.md b/spec/system.md
index b7bca1fd..65cd722d 100644
--- a/spec/system.md
+++ b/spec/system.md
@@ -253,7 +253,7 @@ Each function in this section is monadic.
 
 `•Source` gives a string containing a block's source, including the enclosing braces `{}`. It causes an error if the argument is not a block. In contrast to `•Glyph`, this function does not give full information about `𝕩` because the result cannot convey environment or mutable identity.
 
-`•Decompose` breaks down one level of a compound function, returning a list with a code giving what kind of structure it has followed by each of its components. Possible codes are listed in the table below according to the rule that forms the derived function—train or 2-modifier application. Non-function values, and some functions, can't be broken down. They are still classified with a code: -1 for a non-operation, 0 for a primitive, and 1 for other operations. "Other" includes blocks and system operations. The result is thus a list of length 2 to 4, and `•Decompose` cannot cause an error.
+`•Decompose` breaks down one level of a compound function, returning a list with a code giving what kind of structure it has followed by each of its components. Possible codes are listed in the table below according to the rule that forms the function—train or modifier application. Non-function values, and some functions, can't be broken down. They are still classified with a code: -1 for a non-operation, 0 for a primitive, and 1 for other operations. "Other" includes blocks and system operations. The result is thus a list of length 2 to 4, and `•Decompose` cannot cause an error.
 
 | Kind          | Code | Components
 |---------------|------|-----------