Documentation for Find

3 files changed, 7 insertions, 6 deletions

diff --git a/docs/doc/index.html b/docs/doc/index.html
index 7ccb5768..e6bfb843 100644
--- a/docs/doc/index.html
+++ b/docs/doc/index.html
@@ -5,7 +5,7 @@
 </head>
 <div class="nav"><a href="https://github.com/mlochbaum/BQN">BQN</a> / <a href="../index.html">main</a></div>
 <h1 id="bqn-documentation">BQN documentation</h1>
-<p>BQN's documentation describes what features it has, how to use them (with examples), and why they were chosen. For a linear introduction to the language, see the <a href="../tutorial/index.html">tutorials</a>. While the core language <a href="../spec/index.html">specification</a> is complete, the documentation still has some gaps.</p>
+<p>BQN's documentation describes what features it has, how to use them (with examples), and why they were chosen. For a linear introduction to the language, see the <a href="../tutorial/index.html">tutorials</a>. While the core language <a href="../spec/index.html">specification</a> is complete, the documentation still has minor gaps.</p>
 <p>Overview:</p>
 <ul>
 <li><a href="syntax.html">Syntax</a></li>
@@ -40,6 +40,7 @@
 <li><a href="assert.html">Assert</a> (<code><span class='Function'>!</span></code>)</li>
 <li><a href="reshape.html">Deshape and Reshape</a> (<code><span class='Function'>⥊</span></code>)</li>
 <li><a href="enclose.html">Enclose</a> (<code><span class='Function'>&lt;</span></code>)</li>
+<li><a href="find.html">Find</a> (<code><span class='Function'>⍷</span></code>)</li>
 <li><a href="fold.html">Fold and Insert</a> (<code><span class='Modifier'>´˝</span></code>)</li>
 <li><a href="group.html">Group</a> (<code><span class='Function'>⊔</span></code>)</li>
 <li><a href="identity.html">Identity functions</a> (<code><span class='Function'>⊢⊣</span></code>)</li>
diff --git a/docs/doc/primitive.html b/docs/doc/primitive.html
index 84bd38b3..56b8a1a3 100644
--- a/docs/doc/primitive.html
+++ b/docs/doc/primitive.html
@@ -9,7 +9,7 @@
 <p>Primitives have no side effects other than errors, and can't perform infinite computations, except when a primitive modifier calls an operand function that does one of these things (this can only happen when arguments are passed, as primitive modifiers are always deferred). Side effects here include both writing state such as variables or printed output, and reading any outside state, so that a function without them always returns the same result if passed the same arguments. Since trains and list notation have the same nice properties, tacit code written entirely with primitives, trains, and lists always describes finite, self-contained computations.</p>
 <p>Recursion is the primary way to perform potentially infinite computations in BQN, and it can be packaged into <a href="control.html">control structures</a> like <code><span class='Function'>While</span></code> for ease of use. A given BQN implementation might also provide <a href="../spec/system.html">system values</a> for &quot;impure&quot; tasks like file access or other I/O.</p>
 <h2 id="functions">Functions</h2>
-<p>Functions that have significant differences from APL functions are marked with an asterisk. A few of the non-asterisk links go the the APL Wiki currently.</p>
+<p>Functions that have significant differences from APL equivalents or don't appear in APL are marked with an asterisk.</p>
 <table>
 <thead>
 <tr>
@@ -222,7 +222,7 @@
 <tr>
 <td><code><span class='Function'>⍷</span></code></td>
 <td><a href="selfcmp.html#deduplicate">Deduplicate</a></td>
-<td><a href="https://aplwiki.com/wiki/Find">Find</a></td>
+<td><a href="find.html">Find</a></td>
 </tr>
 <tr>
 <td><code><span class='Function'>⊔</span></code></td>
diff --git a/docs/index.html b/docs/index.html
index 34ec1437..772bb19a 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -58,9 +58,9 @@
 <p>If your favorite language is J, you are missing out even more! Array programmers never seem willing to accept that good ideas can come from people other than Iverson and that legends like John McCarthy and Barbara Liskov advanced human knowledge of how to express computation. They did, and being able to casually pass around first-class functions and mutable closures, with namespaces keeping everything organized, is a huge quality of life improvement. Writing APL again is claustrophobic, the syntax worries and constraints in functionality suddenly rushing back. BQN's mutable objects make methods such as graph algorithms that just don't have a good array implementation (no, your O(n³) matrix method doesn't scale) possible, even natural. With bytecode compilation and NaN-boxing, a natural fit for the based array model, it evaluates that scalar code many times faster than APL or J. The Unix-oriented scripting system stretches seamlessly from quick sketch to multi-file program.</p>
 <p>BQN has no intention of being the last word in programming, but could be a practical and elegant tool in your kit—even if only used to inform your use of another language. Give it a try!</p>
 <h2 id="how-do-i-get-started">How do I get started?</h2>
-<p><em>Writing good learning material for a programming language is a pretty huge task, so neither the tutorials nor the documentation are complete. With some willingness to experiment and possibly outside knowledge of array programming, it's enough to get by, just not smooth sailing.</em></p>
-<p>BQN's <a href="tutorial/index.html"><strong>tutorials</strong></a> are intended as an introduction to array programming with BQN. They assume only knowledge of elementary mathematics, but will probably be hard to follow if you have <em>no</em> programming experience. BQN has a lot in common with dynamically-typed functional languages like Lisp, Julia, or Javascript, so knowledge of these languages will be particularly helpful. However, there's a significant (but shrinking) gap between the last tutorial and existing documentation. If you're motivated, you may be able to get across by reading material on other array languages like APL, J, NumPy, or Julia.</p>
-<p>If you're already an array programmer, then you're in better shape: the current <a href="doc/index.html"><strong>documentation</strong></a> covers nearly all differences from APL, and the <a href="doc/fromDyalog.html">BQN-Dyalog APL</a> or <a href="doc/fromJ.html">BQN-J</a> dictionary might also be a useful resource. However, you should be aware of two key differences between BQN and existing array languages beyond just the changes of <a href="doc/primitive.html">primitives</a>—if these differences don't seem important to you then you don't understand them! BQN's <a href="doc/based.html">based array model</a> is different from both a flat array model like J and a nested one like APL2, Dyalog, or GNU APL in that it has true non-array values (plain numbers and characters) that are different from depth-0 scalars. BQN also uses <a href="doc/context.html">syntactic roles</a> rather than dynamic type to determine how values interact, that is, what's an argument or operand and so on. This system, along with lexical closures, means BQN fully supports Lisp-style <a href="doc/functional.html">functional programming</a>.</p>
+<p><em>The documentation still has some pages missing (not many now), while the tutorials are probably less than half complete. I don't think this is much of an impediment any more. Ask about anything you find confusing on the forums.</em></p>
+<p>BQN's <a href="tutorial/index.html"><strong>tutorials</strong></a> are intended as an introduction to array programming with BQN. They assume only knowledge of elementary mathematics, but will probably be hard to follow if you have <em>no</em> programming experience. BQN has a lot in common with dynamically-typed functional languages like Lisp, Julia, or Javascript, so knowledge of these languages will be particularly helpful. The tutorials end abruptly right now, so you'll have to switch to the documentation, which is less structured.</p>
+<p>If you're already an array programmer, you might start with the <a href="doc/index.html"><strong>documentation</strong></a> right away, using the <a href="doc/fromDyalog.html">BQN-Dyalog APL</a> or <a href="doc/fromJ.html">BQN-J</a> dictionary as a quick reference where appropriate. Be aware of two key differences between BQN and existing array languages beyond just the changes of <a href="doc/primitive.html">primitives</a>—if these differences don't seem important to you then you don't understand them! BQN's <a href="doc/based.html">based array model</a> is different from both a flat array model like J and a nested one like APL2, Dyalog, or GNU APL in that it has true non-array values (plain numbers and characters) that are different from depth-0 scalars. BQN also uses <a href="doc/context.html">syntactic roles</a> rather than dynamic type to determine how values interact, that is, what's an argument or operand and so on. This system, along with lexical closures, means BQN fully supports Lisp-style <a href="doc/functional.html">functional programming</a>.</p>
 <p>A useful tool for both beginners and experienced users is <a href="https://mlochbaum.github.io/bqncrate/"><strong>BQNcrate</strong></a>, a searchable collection of BQN snippets to solve particular tasks. If you have a question about how you might approach a problem, give it a try by typing in a relevant keyword or two.</p>
 <h2 id="where-can-i-find-bqn-users">Where can I find BQN users?</h2>
 <p>There's a BQN <a href="https://matrix.org/">Matrix</a> channel at #bqn:matrix.org, which you can see in the Element web client with <a href="https://app.element.io/#/room/%23bqn:matrix.org">this link</a>, and one on Discord that you can join with <a href="https://discord.gg/SDTW36EhWF">this invite</a>. The two channels are bridged so that comments in one appear in both. It's among the most active array programming forums, with conversations nearly every day, so you can definitely get your questions answered fast.</p>