Skip to content

Commit 1dbcb75

Browse files
neverRareneverRare
committed
use const parameter
1 parent 43b61d6 commit 1dbcb75

File tree

10 files changed

+64
-51
lines changed

10 files changed

+64
-51
lines changed

‎dictionary/parser.ts‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -51,7 +51,7 @@ const ignore = allWithCheck(
5151
choiceWithCheck(spaces, comment),
5252
),
5353
);
54-
function lex<T>(parser: Parser<T>) {
54+
function lex<const T>(parser: Parser<T>) {
5555
return parser.skip(ignore);
5656
}
5757
const wordWithPosition = lex(
@@ -65,7 +65,7 @@ const comma = lex(matchString(",", "comma"));
6565
const semicolon = lex(matchString(";", "semicolon"));
6666
const slash = lex(matchString("/", "slash"));
6767

68-
const keyword = memoize(<T extends string>(keyword: T) =>
68+
const keyword = memoize(<const T extends string>(keyword: T) =>
6969
lex(withPosition(match(/[a-z\-]+/, `"${keyword}"`)))
7070
.map((positioned) =>
7171
positioned.value === keyword ? positioned.value : throwError(
@@ -100,10 +100,10 @@ const perspective = choiceOnlyOne(
100100
keyword("second"),
101101
keyword("third"),
102102
);
103-
function tag<T>(parser: Parser<T>) {
103+
function tag<const T>(parser: Parser<T>) {
104104
return openParenthesis.with(parser).skip(closeParenthesis);
105105
}
106-
function template<T>(parser: Parser<T>) {
106+
function template<const T>(parser: Parser<T>) {
107107
return openBracket.with(parser).skip(closeBracket);
108108
}
109109
const simpleUnit = memoize((kind: string) => word.skip(tag(keyword(kind))));
@@ -260,7 +260,7 @@ const checkedNoun = new CheckedParser(
260260
),
261261
noun,
262262
);
263-
function checkedSimpleUnitWith<T>(tag: string, after: Parser<T>) {
263+
function checkedSimpleUnitWith<const T>(tag: string, after: Parser<T>) {
264264
return checkedSequence(
265265
word.skip(openParenthesis).skip(keyword(tag)),
266266
closeParenthesis.with(after),

‎misc/deduplicate_errors.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
import { distinctBy } from "@std/collections/distinct-by";
22

3-
export function deduplicateErrors<T extends Error>(
3+
export function deduplicateErrors<const T extends Error>(
44
errors: Iterable<T>,
55
): ReadonlyArray<T> {
66
return distinctBy(errors, ({ message }) => message);

‎misc/misc.ts‎

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,16 @@
11
// ensure this module don't have imports and as runtime agnostic as possible,
22
// make separate module when necessary
33

4-
export function nullableAsArray<T>(value?: T): ReadonlyArray<NonNullable<T>> {
4+
export function nullableAsArray<const T>(
5+
value?: T,
6+
): ReadonlyArray<NonNullable<T>> {
57
if (value == null) {
68
return [];
79
} else {
810
return [value];
911
}
1012
}
11-
export function mapNullable<T, U>(
13+
export function mapNullable<const T, const U>(
1214
value: T,
1315
mapper: (value: NonNullable<T>) => U,
1416
): null | U {
@@ -18,7 +20,10 @@ export function mapNullable<T, U>(
1820
return mapper(value);
1921
}
2022
}
21-
export function repeatArray<T>(element: T, count: number): ReadonlyArray<T> {
23+
export function repeatArray<const T>(
24+
element: T,
25+
count: number,
26+
): ReadonlyArray<T> {
2227
return new Array(count).fill(element);
2328
}
2429
export function repeatWithSpace(text: string, count: number): string {
@@ -42,7 +47,7 @@ export function compound(
4247
return `${initText} ${conjunction} ${last}`;
4348
}
4449
}
45-
export function lazy<T>(fn: () => T): () => T {
50+
export function lazy<const T>(fn: () => T): () => T {
4651
let defined = false;
4752
let value: null | T;
4853
return () => {

‎src/array_result.ts‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -18,7 +18,7 @@ export class TodoError extends ArrayResultError {
1818
this.name = "TodoError";
1919
}
2020
}
21-
export class ArrayResult<T> {
21+
export class ArrayResult<const T> {
2222
constructor(array?: ReadonlyArray<T>);
2323
constructor(array: undefined, errors: ReadonlyArray<ArrayResultError>);
2424
constructor(
@@ -46,10 +46,10 @@ export class ArrayResult<T> {
4646
mapper(value) ? new ArrayResult([value]) : ArrayResult.empty()
4747
);
4848
}
49-
map<U>(mapper: (value: T) => U): ArrayResult<U> {
49+
map<const U>(mapper: (value: T) => U): ArrayResult<U> {
5050
return this.flatMap((value) => new ArrayResult([mapper(value)]));
5151
}
52-
flatMap<U>(mapper: (value: T) => ArrayResult<U>): ArrayResult<U> {
52+
flatMap<const U>(mapper: (value: T) => ArrayResult<U>): ArrayResult<U> {
5353
if (this.isError()) {
5454
return this as unknown as ArrayResult<U>;
5555
} else {
@@ -60,7 +60,7 @@ export class ArrayResult<T> {
6060
);
6161
}
6262
}
63-
filterMap<U>(mapper: (value: T) => U): ArrayResult<NonNullable<U>> {
63+
filterMap<const U>(mapper: (value: T) => U): ArrayResult<NonNullable<U>> {
6464
return this.flatMap((value) =>
6565
new ArrayResult(nullableAsArray(mapper(value)))
6666
);

‎src/parser/filter.ts‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -363,7 +363,7 @@ export const MULTIPLE_SENTENCES_RULE: ReadonlyArray<
363363
sentences.filter(({ type }) => type !== "filler").length <= 2 ||
364364
throwError(new UnrecognizedError("multiple sentences")),
365365
];
366-
export function filter<T>(
366+
export function filter<const T>(
367367
rules: ReadonlyArray<(value: T) => boolean>,
368368
): (value: T) => boolean {
369369
return (value) => {
@@ -426,7 +426,7 @@ function phraseHasTopLevelEmphasis(phrase: Phrase) {
426426
return phrase.emphasis != null;
427427
}
428428
}
429-
function getDuplicate<T>(iterable: Iterable<T>) {
429+
function getDuplicate<const T>(iterable: Iterable<T>) {
430430
const unique = new Set<T>();
431431
const duplicates = new Set<T>();
432432
for (const value of iterable) {

‎src/parser/parser_lib.ts‎

Lines changed: 37 additions & 29 deletions
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ type Cache<T> = Map<number, MemoizationCacheResult<ParserResult<T>>>;
1010
let currentSource = "";
1111
const allCache: Set<WeakRef<Cache<unknown>>> = new Set();
1212

13-
export class Parser<T> {
13+
export class Parser<const T> {
1414
readonly rawParser: InnerParser<T>;
1515
constructor(parser: InnerParser<T>) {
1616
const cache: Cache<T> = new Map();
@@ -32,13 +32,13 @@ export class Parser<T> {
3232
}
3333
return this.rawParser(0).map(({ value }) => value);
3434
}
35-
map<U>(mapper: (value: T) => U): Parser<U> {
35+
map<const U>(mapper: (value: T) => U): Parser<U> {
3636
return new Parser((input) =>
3737
this.rawParser(input)
3838
.map(({ value, length }) => ({ value: mapper(value), length }))
3939
);
4040
}
41-
mapWithPositionedError<U>(mapper: (value: T) => U): Parser<U> {
41+
mapWithPositionedError<const U>(mapper: (value: T) => U): Parser<U> {
4242
return withPosition(this)
4343
.map((value) => withPositionedError(() => mapper(value.value), value));
4444
}
@@ -52,7 +52,7 @@ export class Parser<T> {
5252
.filter((value) => withPositionedError(() => mapper(value.value), value))
5353
.map(({ value }) => value);
5454
}
55-
then<U>(mapper: (value: T) => Parser<U>): Parser<U> {
55+
then<const U>(mapper: (value: T) => Parser<U>): Parser<U> {
5656
return new Parser((position) =>
5757
this.rawParser(position)
5858
.flatMap(({ value, length }) =>
@@ -74,10 +74,10 @@ export class Parser<T> {
7474
sortBy(mapper: (value: T) => number): Parser<T> {
7575
return this.sort((left, right) => mapper(left) - mapper(right));
7676
}
77-
with<U>(parser: Parser<U>): Parser<U> {
77+
with<const U>(parser: Parser<U>): Parser<U> {
7878
return sequence(this, parser).map(([_, arrayResult]) => arrayResult);
7979
}
80-
skip<U>(parser: Parser<U>): Parser<T> {
80+
skip<const U>(parser: Parser<U>): Parser<T> {
8181
return sequence(this, parser).map(([arrayResult]) => arrayResult);
8282
}
8383
}
@@ -90,7 +90,7 @@ export class PositionedError extends ArrayResultError {
9090
this.name = "PositionedError";
9191
}
9292
}
93-
function withPositionedError<T>(fn: () => T, position: Position) {
93+
function withPositionedError<const T>(fn: () => T, position: Position) {
9494
try {
9595
return fn();
9696
} catch (error) {
@@ -124,16 +124,18 @@ export const nothing: Parser<null> = new Parser(() =>
124124
new ArrayResult([{ value: null, length: 0 }])
125125
);
126126
export const emptyArray: Parser<ReadonlyArray<never>> = nothing.map(() => []);
127-
export function lookAhead<T>(parser: Parser<T>): Parser<T> {
127+
export function lookAhead<const T>(parser: Parser<T>): Parser<T> {
128128
return new Parser((input) =>
129129
parser.rawParser(input)
130130
.map(({ value }) => ({ value, length: 0 }))
131131
);
132132
}
133-
export function lazy<T>(parser: () => Parser<T>): Parser<T> {
133+
export function lazy<const T>(parser: () => Parser<T>): Parser<T> {
134134
return new Parser((input) => parser().rawParser(input));
135135
}
136-
export function choice<T>(...choices: ReadonlyArray<Parser<T>>): Parser<T> {
136+
export function choice<const T>(
137+
...choices: ReadonlyArray<Parser<T>>
138+
): Parser<T> {
137139
assertGreater(
138140
choices.length,
139141
1,
@@ -143,7 +145,7 @@ export function choice<T>(...choices: ReadonlyArray<Parser<T>>): Parser<T> {
143145
new ArrayResult(choices).flatMap((parser) => parser.rawParser(input))
144146
);
145147
}
146-
export function choiceOnlyOne<T>(
148+
export function choiceOnlyOne<const T>(
147149
...choices: ReadonlyArray<Parser<T>>
148150
): Parser<T> {
149151
assertGreater(
@@ -164,13 +166,13 @@ export function choiceOnlyOne<T>(
164166
empty,
165167
);
166168
}
167-
export function optional<T>(parser: Parser<T>): Parser<null | T> {
169+
export function optional<const T>(parser: Parser<T>): Parser<null | T> {
168170
return choice(parser, nothing);
169171
}
170-
export function optionalAll<T>(parser: Parser<T>): Parser<null | T> {
172+
export function optionalAll<const T>(parser: Parser<T>): Parser<null | T> {
171173
return choiceOnlyOne(parser, nothing);
172174
}
173-
export function sequence<T extends ReadonlyArray<unknown>>(
175+
export function sequence<const T extends ReadonlyArray<unknown>>(
174176
...sequence:
175177
& Readonly<{ [I in keyof T]: Parser<T[I]> }>
176178
& Readonly<{ length: T["length"] }>
@@ -187,27 +189,33 @@ export function sequence<T extends ReadonlyArray<unknown>>(
187189
emptyArray,
188190
) as Parser<any>;
189191
}
190-
export const many = memoize(<T>(parser: Parser<T>): Parser<ReadonlyArray<T>> =>
192+
export const many = memoize(<const T>(
193+
parser: Parser<T>,
194+
): Parser<ReadonlyArray<T>> =>
191195
choice<ReadonlyArray<T>>(
192196
sequence(parser, lazy(lazyEval(() => many(parser))))
193197
.map(([first, rest]) => [first, ...rest]),
194198
emptyArray,
195199
)
196200
);
197-
export function manyAtLeastOnce<T>(
201+
export function manyAtLeastOnce<const T>(
198202
parser: Parser<T>,
199203
): Parser<ReadonlyArray<T>> {
200204
return sequence(parser, many(parser))
201205
.map(([first, rest]) => [first, ...rest]);
202206
}
203-
export const all = memoize(<T>(parser: Parser<T>): Parser<ReadonlyArray<T>> =>
207+
export const all = memoize(<const T>(
208+
parser: Parser<T>,
209+
): Parser<ReadonlyArray<T>> =>
204210
choiceOnlyOne<ReadonlyArray<T>>(
205211
sequence(parser, lazy(lazyEval(() => all(parser))))
206212
.map(([first, rest]) => [first, ...rest]),
207213
emptyArray,
208214
)
209215
);
210-
export function allAtLeastOnce<T>(parser: Parser<T>): Parser<ReadonlyArray<T>> {
216+
export function allAtLeastOnce<const T>(
217+
parser: Parser<T>,
218+
): Parser<ReadonlyArray<T>> {
211219
return sequence(parser, all(parser))
212220
.map(([first, rest]) => [first, ...rest]);
213221
}
@@ -300,7 +308,7 @@ export const notEnd: Parser<null> = new Parser((position) =>
300308
),
301309
])
302310
);
303-
export function withSource<T>(
311+
export function withSource<const T>(
304312
parser: Parser<T>,
305313
): Parser<readonly [value: T, source: string]> {
306314
return new Parser((position) =>
@@ -313,7 +321,7 @@ export function withSource<T>(
313321
}))
314322
);
315323
}
316-
export function withPosition<T>(
324+
export function withPosition<const T>(
317325
parser: Parser<T>,
318326
): Parser<Readonly<{ value: T }> & Position> {
319327
return new Parser((position) =>
@@ -323,12 +331,12 @@ export function withPosition<T>(
323331
}))
324332
);
325333
}
326-
export class CheckedParser<T> {
334+
export class CheckedParser<const T> {
327335
constructor(public check: Parser<unknown>, public parser: Parser<T>) {}
328-
map<U>(mapper: (value: T) => U): CheckedParser<U> {
336+
map<const U>(mapper: (value: T) => U): CheckedParser<U> {
329337
return new CheckedParser(this.check, this.parser.map(mapper));
330338
}
331-
mapWithPositionedError<U>(mapper: (value: T) => U): CheckedParser<U> {
339+
mapWithPositionedError<const U>(mapper: (value: T) => U): CheckedParser<U> {
332340
return new CheckedParser(
333341
this.check,
334342
this.parser.mapWithPositionedError(mapper),
@@ -344,16 +352,16 @@ export class CheckedParser<T> {
344352
);
345353
}
346354
}
347-
export function checkedSequence<T, U>(
355+
export function checkedSequence<const T, const U>(
348356
check: Parser<T>,
349357
rest: Parser<U>,
350358
): CheckedParser<readonly [T, U]> {
351359
return new CheckedParser(check, sequence(check, rest));
352360
}
353-
export function checkedAsWhole<T>(parser: Parser<T>): CheckedParser<T> {
361+
export function checkedAsWhole<const T>(parser: Parser<T>): CheckedParser<T> {
354362
return new CheckedParser(parser, parser);
355363
}
356-
export function choiceWithCheck<T>(
364+
export function choiceWithCheck<const T>(
357365
...choices: ReadonlyArray<CheckedParser<T>>
358366
): Parser<T> {
359367
return new Parser((position) => {
@@ -369,13 +377,13 @@ export function choiceWithCheck<T>(
369377
return ArrayResult.errors(errors);
370378
});
371379
}
372-
export function optionalWithCheck<T>(
380+
export function optionalWithCheck<const T>(
373381
parser: CheckedParser<T>,
374382
): Parser<null | T> {
375383
return choiceWithCheck(parser, checkedAsWhole(nothing));
376384
}
377385
export const allWithCheck = memoize(
378-
<T>(parser: CheckedParser<T>): Parser<ReadonlyArray<T>> =>
386+
<const T>(parser: CheckedParser<T>): Parser<ReadonlyArray<T>> =>
379387
choiceWithCheck<ReadonlyArray<T>>(
380388
new CheckedParser(
381389
parser.check,
@@ -385,7 +393,7 @@ export const allWithCheck = memoize(
385393
checkedAsWhole(emptyArray),
386394
),
387395
);
388-
export function allAtLeastOnceWithCheck<T>(
396+
export function allAtLeastOnceWithCheck<const T>(
389397
parser: CheckedParser<T>,
390398
): Parser<ReadonlyArray<T>> {
391399
return sequence(parser.parser, allWithCheck(parser))

‎src/parser/test.ts‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -59,7 +59,7 @@ Deno.test("all", () => {
5959
const parser = all(matchString("a").skip(space)).skip(end);
6060
assertEquals(parser.parse("a a a").unwrap(), [["a", "a", "a"]]);
6161
});
62-
function uniquePairs<T>(array: ReadonlyArray<T>) {
62+
function uniquePairs<const T>(array: ReadonlyArray<T>) {
6363
return array.flatMap((a, i) =>
6464
array.slice(i + 1).map((b) => [a, b] as const)
6565
);

‎src/settings_frontend.ts‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -55,7 +55,7 @@ const UPDATERS: Readonly<{ [K in keyof Settings]: Updater<Settings[K]> }> = {
5555
};
5656
const KEYS = Object.keys(UPDATERS) as ReadonlyArray<keyof Settings>;
5757

58-
function loadOneFromLocalStorage<T extends keyof Settings>(key: T) {
58+
function loadOneFromLocalStorage<const T extends keyof Settings>(key: T) {
5959
const source = localStorage.getItem(key);
6060
if (source != null) {
6161
settings[key] = UPDATERS[key].parse(source) ?? defaultSettings[key];
@@ -69,15 +69,15 @@ function loadOneFromLocalStorage<T extends keyof Settings>(key: T) {
6969
settings[key],
7070
);
7171
}
72-
function loadOneFromElements<T extends keyof Settings>(key: T) {
72+
function loadOneFromElements<const T extends keyof Settings>(key: T) {
7373
settings[key] = UPDATERS[key].load(
7474
document.getElementById(toKebabCase(key)) as
7575
| HTMLInputElement
7676
| HTMLSelectElement,
7777
);
7878
setIgnoreError(key, UPDATERS[key].stringify(settings[key]));
7979
}
80-
function setElement<T extends keyof Settings>(key: T, value: Settings[T]) {
80+
function setElement<const T extends keyof Settings>(key: T, value: Settings[T]) {
8181
UPDATERS[key].set(
8282
document.getElementById(toKebabCase(key)) as
8383
| HTMLInputElement

0 commit comments

Comments
 (0)