Init

1 files changed, 146 insertions, 0 deletions

diff --git a/rprt.md b/rprt.md
new file mode 100644
index 0000000..1ac92c4
--- /dev/null
+++ b/rprt.md
@@ -0,0 +1,146 @@
+# Rank PolymoRphic Text editor (RPRT)
+
+A compositional, point-free language for text manipulation.
+
+# 1. Core Concepts
+
+## 1.1 Two Fundamental Types
+
+All functions work with two core types:
+
+1. **Selection** — addresses and regions in files
+   - Rank 0: Position (integer offset)
+   - Rank 1: Range is a pair of positions [start,end) with capture groups
+   - Rank 2: A list of ranges with capture groups
+   - Rank 3: Indexed selection is a mapping of files -> list of ranges with capture groups
+
+2. **Text** — string data
+
+# 2. Selection Functions
+
+Selection functions produce Selection outputs and take zero or more Selection inputs. They come in nullary, unary (monadic), and binary (dyadic) forms.
+
+## 2.1 Core Selection Functions
+
+There are ten core selection functions in RPRT. Nine of them have nullary and unary (monadic) forms. The tenth, `,` (span), additionally has binary (dyadic) semantics - it is the only selection function that takes two arguments.
+
+In the nullary case there are no rank semantics. In the unary case we provide their semantics as a function of the input rank below.
+
+| Function | Nullary                                            | Rank    |
+|----------|----------------------------------------------------|---------|
+| `.`      | Current selection                                  | matched |
+| `$`      | End of file                                        | 0       |
+| `#n`     | Character n in file                                | 0       |
+| `n`      | Line n in file                                     | 1       |
+| `/re/`   | First match forward in file from start             | 1       |
+| `x/re/`  | All matches within file                            | 2       |
+| `+n`     | Line n in file                                     | 1       |
+| `X/re/`  | All files and their contents whose name matches re | 3       |
+| `,`      | Entire file (0,$)                                  | 2       |
+
+In the unary case, all defined functions are rank preserving. Their action on ranks > 1 are given by broadcasting, that is, `α F` where `α` has rank 2 is computed by applying `F` to each rank 1 range in `α` and collecting the results into a list of ranges, mutatis mutandis for rank 3.
+
+**Note:** The functions `.` and `X` have no unary or higher arity semantics. To use them as such is erroneous.
+
+**Note:** When the input has rank 0 (position), all defined unary functions are the identity since positions have no internal structure within which to search or operate.
+
+| Function  | α Rank 1          |
+|-----------|-------------------|
+| `α /re/`  | First re within α |
+| `α x/re/` | All re within α   |
+| `α $`     | End position of α |
+| `α #n`    | Char n within α   |
+| `α n`     | Line n within α   |
+| `α +n`    | Line n within α   |
+| `α ,`     | Identity          |
+
+The span function `,` is the only selection function with binary (dyadic) semantics. It creates ranges by spanning from one selection to another.
+
+**Semantics by rank:**
+
+| Rank of α | Rank of ω | Rank of result | Semantics                                             |
+|-----------|-----------|----------------|-------------------------------------------------------|
+| 0         | 0         | 1              | Range from α to ω                                     |
+| 0         | 1         | 1              | Range from α to end of ω                              |
+| 1         | 0         | 1              | Range from start of α to ω                            |
+| 1         | 1         | 1              | Range from start of α to end of ω                     |
+| 0/1       | 2         | 2              | α to each range in ω (broadcast)                      |
+| 2         | 0/1       | 2              | Each range in α to ω (broadcast)                      |
+| 2         | 2         | 2              | Pairwise ranges (zip shortest)                        |
+| 0         | 3         | 3              | α to each range in ω (broadcast)                      |
+| 3         | 0         | 3              | Each range in α to ω (broadcast)                      |
+| 3         | 1/2       | -              | Erroneous (TODO: maybe makes sense if indices align?) |
+| 1/2       | 3         | -              | Erroneous (TODO: maybe makes sense if indices align?) |
+
+## 2.2 Operators
+
+Operators take functions as arguments and return new functions.
+
+### 2.2.1 The Reverse Operator `'`
+
+The reverse operator `'` takes a selection function and reverses its direction.
+
+**Note:** `'F` is not defined when `F` is one of the functions `.X,` .
+
+| Function | Nullary                       | Rank |
+|----------|-------------------------------|------|
+| `'$`     | Start of file (position 0)    | 0    |
+| `'#n`    | Character n from end of file  | 0    |
+| `'n`     | Line n from end of file       | 1    |
+| `'/re/`  | First match backward from end | 1    |
+| `'x/re/` | All matches, right-to-left    | 2    |
+| `'+n`    | Line -n in file               | 1    |
+
+In the unary case, all functions are rank preserving, and all of the above functions are the identity on rank 0 inputs. Their action on ranks > 1 is by broadcasting.
+
+| Function   | α Rank 1                       |
+|------------|--------------------------------|
+| `α '$`     | Start position of α            |
+| `α '#n`    | Char n from end of α           |
+| `α 'n`     | Line n from end of α           |
+| `α '/re/`  | First match backward within α  |
+| `α 'x/re/` | All matches right-to-left in α |
+| `α '+n`    | Line -n within α               |
+
+**Note:** When the input has rank 0 (position), all defined reversed unary functions are the identity since positions have no internal structure within which to search or operate.
+
+### 2.2.2 The Sequential Operator `;`
+
+The sequential operator `;` transforms a selection function from operating "within" a selection to operating "starting from the end" of that selection.
+
+**Note:** It is erroneous to use `;F` in the nullary case. TODO: or are there interesting semantics?
+
+**Note:** `;F` is not defined when `F` is one of `.X,` .
+
+| Function   | α Rank 0                   | α Rank 1                          |
+|------------|----------------------------|-----------------------------------|
+| `α ;$`     | End of file                | End of file (ignores α)           |
+| `α ;#n`    | Character n after α        | Character n after end of α        |
+| `α ;n`     | Line n after α             | Line n after end of α             |
+| `α ;/re/`  | First match forward from α | First match forward from end of α |
+| `α ;x/re/` | All matches forward from α | All matches forward from end of α |
+| `α ;+n`    | Line n after α             | Line n after end of α             |
+
+### 2.2.3 The Complement Operator `~`
+
+The complement operator `~` takes a selection function and produces a new selection function which returns the complement. Naturally this changes rank somewhat, as explained in the below table.
+
+| Rank of output of `F` | Rank of output of `~F` | Semantics                                                        |
+|-----------------------|------------------------|------------------------------------------------------------------|
+| 0                     | 2                      | The complement of the position its file as a selection           |
+| 1                     | 2                      | The complement of the range in its file as a selection           |
+| 2                     | 2                      | The selection corresponding to the ranges between the selections |
+| 3                     | 3                      | The broadcast of `~` to each file                                |
+
+## 2.3 Composition and Parsing
+
+**Operator application:** Functions are modified by operators. All operators commute: `';F` = `;'F`.
+
+**Precedence:** Following BQN rules:
+- Operators bind tighter than functions
+- Functions apply left-to-right
+- Binary functions are infix
+
+## 3. Text Functions
+
+Text functions modify selections, and consume zero or one selections, and one Text value.