1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
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.
|
