More explicit documentation about roles in a few places

3 files changed, 8 insertions, 8 deletions

diff --git a/doc/expression.md b/doc/expression.md
index 5359a672..0f6eeccb 100644
--- a/doc/expression.md
+++ b/doc/expression.md
@@ -48,7 +48,7 @@ The four roles are **subject**, **function**, **1-modifier**, and **2-modifier**
 
 Primitive tokens, since they have a fixed value, always have a role that matches their type. They're functions by default, as the modifiers have glyphs that fit specific patterns. 1-modifiers have superscript glyphs, and 2-modifiers have glyphs with an unbroken circle—that is, one without a line through it, excluding functions `⌽` and `⍉`.
 
-Variable names can be written in any case and with underscores added, and these changes don't affect what [identifier](lexical.md) the name refers to. `ab`, `aB`, `AB`, and `_a_B_` are all the same variable. However, the spelling—specifically the first and last characters—determine the variable's role. A lowercase first letter indicates a subject, and an uppercase first letter makes it a function. A leading underscore (regardless of the following character) indicates a 1-modifier, and both leading and trailing underscores makes a 2-modifier.
+Variable names (including [namespace](namespace.md) fields) can be written in any case and with underscores added, and these changes don't affect what [identifier](lexical.md) the name refers to. `ab`, `aB`, `AB`, and `_a_B_` are all the same variable. However, the spelling—specifically the first and last characters—determine the variable's role. A lowercase first letter indicates a subject, and an uppercase first letter makes it a function. A leading underscore (regardless of the following character) indicates a 1-modifier, and both leading and trailing underscores makes a 2-modifier.
 
 Besides these, character, string, and [array literals](arrayrepr.md#array-literals) always have a subject role, and the role of a [block](block.md) is determined by its type, which depends either on the header it has or which special variables it uses. If headerless, a block is a subject if it has no special names, but a `𝕨` or `𝕩` makes it at least a function, an `𝔽` makes it a 1- or 2-modifier, and a `𝔾` always makes it a 2-modifier.
 
diff --git a/doc/fromJ.md b/doc/fromJ.md
index efe976d6..d2fed75d 100644
--- a/doc/fromJ.md
+++ b/doc/fromJ.md
@@ -22,12 +22,12 @@ BQN uses "[depth](depth.md)" rather than "boxing level". BQN gives atoms depth 0
 
 In J, the part of speech is an inherent property of a value, while in BQN it's determined by how the value is used in a particular expression, and can be different from the value's type. See [context-free grammar](context.md).
 
-| J part of speech    | BQN role   |
-|---------------------|------------|
-| Noun                | Subject    |
-| Verb                | Function   |
-| Adverb              | 1-modifier |
-| Conjunction         | 2-modifier |
+| J part of speech    | BQN role   | Spelling    |
+|---------------------|------------|-------------|
+| Noun                | Subject    | `lowerCase` |
+| Verb                | Function   | `UpperCase` |
+| Adverb              | 1-modifier | `_leading`  |
+| Conjunction         | 2-modifier | `_both_`    |
 
 ## Syntax
 
diff --git a/doc/namespace.md b/doc/namespace.md
index 896b2ffb..d7fc4562 100644
--- a/doc/namespace.md
+++ b/doc/namespace.md
@@ -46,7 +46,7 @@ There are also two ways to get values out of a namespace, such as `example` defi
 
     {n⇐7}.n
 
-The part on the left can be anything with a subject role, although it will often need to be parenthesized because `.` has higher precedence than any operator. This allows it to be chained like `a.b.c` if a namespace has a value that is also a namespace (and so on).
+The part on the left can be anything with a subject [role](expression.md#syntactic-role), although it will often need to be parenthesized because `.` has higher precedence than any operator. So it can be chained like `a.b.c` if a field has a value that is also a namespace (and so on). The overall role is determined by the last name: for example `•math.Sin` has a function role.
 
 Second, a namespace might be used in a [destructuring](expression.md#destructuring) assignment like the one below. This assignment's target looks like a list, where each entry specifies one of the names exported by the block and what it should be assigned to. The element can be either a single name, like `b`, which gives both, or an aliasing expression like `b2⇐b`. In this case, the value `b` from the namespace is used, but it's given the name `b2` instead of `b`. Imported names can be repeated—but the variable names defined can't be—and all the names can be spelled with any role (the role is ignored).