BREAKING: Don't allow First of empty or reshaping empty to non-empty

5 files changed, 12 insertions, 19 deletions

diff --git a/doc/fill.md b/doc/fill.md
index 45d98487..ed93b02c 100644
--- a/doc/fill.md
+++ b/doc/fill.md
@@ -4,7 +4,7 @@
 
 A few array operations need an array element to use when no existing element applies. BQN tries to maintain a "default" element for every array, known as a fill element, for this purpose. If it's known, the fill element is a nested array structure where each atom is either `0` or `' '`. If no fill is known, a function that requests it results in an error.
 
-Fills are used by [Take](take.md) (`↑`) when a value in `𝕨` is larger than the corresponding length in `𝕩`, by the two [Nudge](shift.md) functions (`»«`) when `𝕩` is non-empty, and by [First](pick.md) (`⊑`) and [Reshape](reshape.md) (`⥊`) when `𝕩` is empty. Except for these specific cases, the fill value an array has can't affect the program. The result of [Match](match.md) (`≡`) doesn't depend on fills, and any attempt to compute a fill can't cause side effects.
+Fills are used by [Take](take.md) (`↑`) when a value in `𝕨` is larger than the corresponding length in `𝕩`, by the two [Nudge](shift.md) functions (`»«`) when `𝕩` is non-empty, and by [Reshape](reshape.md) (`⥊`) when `𝕨` contains `↑`. Except for these specific cases, the fill value an array has can't affect the program. The result of [Match](match.md) (`≡`) doesn't depend on fills, and any attempt to compute a fill can't cause side effects.
 
 ## Using fills
 
@@ -24,17 +24,13 @@ Nudge Left or Right shifts the array over and places a fill in the vacated space
 
         »⟨⟩   # Fill not needed
 
-[First](pick.md) (`⊑`) and [Reshape](reshape.md) (`⥊`) use the fill when `𝕩` is empty, and in the case of Reshape only when the result needs to be non-empty.
+[Reshape](reshape.md#computed-lengths) (`⥊`) uses the fill when `𝕨` contains `↑` and the product of the rest of `𝕨` doesn't evenly divide the number of elements in `𝕩`.
 
-        ⊑ ""
+        ↑‿8 ⥊ "completepart"
 
-        4 ⥊¨ ⟨↕0, ""⟩
+If for some reason you need to find an array's fill element, the easiest general way is probably `⊑»1↑⥊a`.
 
-        0‿3 ⥊ ⟨⟩  # Fill not needed
-
-If for some reason you need to find an array's fill element, the easiest way is `⊑0⥊a`.
-
-        ⊑0⥊"string"
+        ⊑»1↑⥊"string"
 
 ## How fills are computed
 
diff --git a/doc/find.md b/doc/find.md
index b91a5930..5309909f 100644
--- a/doc/find.md
+++ b/doc/find.md
@@ -18,13 +18,13 @@ Like Windows, the result usually doesn't have the same dimensions as `𝕩`. Thi
 
         "string" (≢∘⊢↑⍷) "substring"  # APL style
 
-If `𝕨` is larger than `𝕩`, the result is empty, and there's no error even in cases where Windows would fail. One place this tends to come up is when applying [First](pick.md) (`⊑`) the result: `⊑⍷` tests whether `𝕨` appears in `𝕩` at the first position, that is, whether it's a prefix of `𝕩`. If `𝕨` is longer than `𝕩` it shouldn't be a prefix, so 0 is appropriate.
+If `𝕨` is larger than `𝕩`, the result is empty, and there's no error even in cases where Windows would fail. One place this tends to come up is when applying [First](pick.md#first) (`⊑`) the result: `⊑⍷` tests whether `𝕨` appears in `𝕩` at the first position, that is, whether it's a prefix of `𝕩`. If `𝕨` is longer than `𝕩` it shouldn't be a prefix. First will fail but using a [fold](fold.md) `0⊣´⥊∘⍷` instead gives a 0 in this case.
 
         "loooooong" ⍷ "short"
 
         9 ↕ "short"
 
-        ⊑ "loooooong" ⍷ "short"
+        0 ⊣´ "loooooong" ⍷ "short"
 
 This pattern also works in the high-rank case discussed below, testing whether `𝕨` is a multi-dimensional prefix starting at the lowest-index corner of `𝕩`.
 
diff --git a/doc/pick.md b/doc/pick.md
index 9b014796..092f87ed 100644
--- a/doc/pick.md
+++ b/doc/pick.md
@@ -4,7 +4,7 @@
 
 Pick (`⊑`) chooses elements from `𝕩` based on [index](indices.md) lists from `𝕨`. `𝕨` can be a plain list, or even one number if `𝕩` is a list, in order to get one element from `𝕩`. It can also be an array of index lists, or have deeper array structure: each index list will be replaced with the element of `𝕩` at that index, effectively applying to `𝕨` at [depth](depth.md#the-depth-modifier) 1.
 
-With no `𝕨`, monadic `⊑𝕩` takes the first element of `𝕩` in index order, or its [fill element](fill.md) if `𝕩` is empty (causing an error if no fill is known).
+With no `𝕨`, monadic `⊑𝕩` takes the first element of `𝕩` in index order, with an error if `𝕩` is empty.
 
 While sometimes "scatter-point" indexing is necessary, using Pick to select multiple elements from `𝕩` is less array-oriented than [Select](select.md) (`⊏`), and probably slower. Consider rearranging your data so that you can select along axes instead of picking out elements.
 
@@ -44,13 +44,10 @@ With no left argument, `⊑` is called First, and performs a slight generalizati
         ⊑ "First"
         ⊑ ↕4‿2‿5‿1
 
-If `𝕩` is empty then Pick always results in an error. First never gives an error: instead it returns the [fill element](fill.md) for `𝕩`.
+If `𝕩` is empty then First results in an error, like Pick.
 
         ⊑ ""
         ⊑ ≢π
-        ⊑ 0↑<⟨"  ",↕4⟩
-
-So one way to find the fill element for an array `𝕩` of any shape is `⊑0⥊𝕩`.
 
 In APL it's common to get the last element of a list with an idiom that translates to `⊑⌽`, or First-[Reverse](reverse.md). In BQN the most straightforward way is to select with index `¯1` instead. I also sometimes use [Fold](fold.md) with the Right [identity function](identity.md).
 
diff --git a/doc/reshape.md b/doc/reshape.md
index 902beadc..4be0c608 100644
--- a/doc/reshape.md
+++ b/doc/reshape.md
@@ -88,11 +88,11 @@ If the left argument implies a smaller number of elements, then only the initial
 
         3‿3 ⥊ a
 
-If the left argument implies a larger number of elements, then the argument elements are reused cyclically. Below, we reach the last element `247` and start over at `135`. If the array doesn't have any elements to start with, its [fill element](fill.md) is used instead, but it's probably best not to invoke this case!
+If the left argument implies a larger number of elements, then the argument elements are reused cyclically. Below, we reach the last element `247` and start over at `135`. If the array doesn't have any elements to start with, you'll get an error as there aren't any elements available.
 
         15 ⥊ a
 
-        4 ⥊ ↕0  # Fill for ↕0 is 0
+        4 ⥊ ↕0
 
 Reshape is the idiomatic way to make an array filled with a constant value (that is, where all elements are the same). For an atom element, just reshape it directly; for an arbitrary element, first enclose it to create a unit, and then reshape it.
 
diff --git a/doc/types.md b/doc/types.md
index ad295676..f3b7f414 100644
--- a/doc/types.md
+++ b/doc/types.md
@@ -71,7 +71,7 @@ Other linear combinations such as adding two characters or negating a character
 
 A BQN array is a multidimensional arrangement of data. This means it has a certain [*shape*](shape.md), which is a finite list of natural numbers giving the length along each axis, and it contains an *element* for each possible [*index*](indices.md), which is a choice of one natural number that's less than each axis length in the shape. The total number of elements, or *bound*, is then the product of all the lengths in the shape. The shape may have any length including zero, and this shape is known as the array's *rank*. An array of rank 0, which always contains exactly one element, is called a *unit*, while an array of rank 1 is called a *list* and an array of rank 2 is called a *table*.
 
-Each array—empty or nonempty—has an inferred property called a *fill*. The fill either indicates what element should be used to pad an array, or that such an element is not known and an error should result. Fills can be used by [Take](take.md) (`↑`), the two [Nudge](shift.md) functions (`»«`), [First](pick.md) (`⊑`), and [Reshape](reshape.md) (`⥊`).
+Each array—empty or nonempty—has an inferred property called a [*fill*](fill.md). The fill either indicates what element should be used to pad an array, or that such an element is not known and an error should result. Fills can be used by [Take](take.md) (`↑`), the two [Nudge](shift.md) functions (`»«`), and [Reshape](reshape.md) (`⥊`).
 
 Arrays are value types (or immutable), so that there is no way to "change" the shape or elements of an array. An array with different properties is a different array. As a consequence, arrays are an inductive type, and it's not possible for an array to contain itself, or contain an array that contains itself, and so on. However, it is possible for an array to contain a function or other operation that has access to the array through a variable, and in this sense an array can "know about" itself.