fix spellings

Author: neverRare

CHANGELOG.md

@@ -212,7 +212,7 @@ Inside update (intended for developers):
 - Rewritten whole code to use TypeScript, module, and functional programming.
 - Rewritten parser to use parser combinator.
 - Add language codes to html.
-- New wiki for contributors and thinkerers.
+- New wiki for contributors and tinkerers.
 - Overhaul `README.md`, only including build instruction. Information about the
   translator is now moved to wiki.
 

CONTRIBUTING.md

@@ -109,6 +109,6 @@ themselves serves as a space for broader topics, not just ilo Token.
   programming language, it uses similar techniques found in programming language
   development e.g. parsing.
 
-These are unnoficial spaces and are not subject to the
+These are unofficial spaces and are not subject to the
 [Contributor Covenant Code of Conduct](https://github.com/ilo-token/ilo-token.github.io/blob/master/CODE_OF_CONDUCT.md).
 Instead, each have its own rules and different moderators.

dictionary/dictionary

@@ -1361,7 +1361,7 @@ soko:
 sona:
     knowledge(n);
     information(n);
-    data(n plural); # data is not singular, datum sounds unfamaliar
+    data(n plural); # data is not singular, datum sounds unfamiliar
 
     know(v) [object];
     have(v) skill(n singular) in(prep) [object];
@@ -1463,7 +1463,7 @@ tawa:
     # walking(n gerund);
     shaking(n gerund);
     flight(n);
-    travelling(n gerund);
+    traveling(n gerund);
 
     to(prep) [indirect object];
     for(prep) [indirect object];
@@ -1536,12 +1536,12 @@ tomo:
 tonsi:
     non-binary(adj qualifier) person(n);
     gender nonconforming(adj qualifier) person(n);
-    genderqueer(adj qualifier) person(n);
+    gender-queer(adj qualifier) person(n);
     transgender(adj qualifier) person(n);
 
     non-binary(adj qualifier);
     gender nonconforming(adj qualifier);
-    genderqueer(adj qualifier);
+    gender-queer(adj qualifier);
     transgender(adj qualifier);
 
 tu:

src/parser/parser.ts

@@ -234,7 +234,7 @@ const phrase: Parser<Phrase> = lazy(() =>
         modifiers,
         emphasis: phraseModifier,
       })),
-    binaryWords(preverbSet, "preveb").map(([preverb, phrase]) => ({
+    binaryWords(preverbSet, "preverb").map(([preverb, phrase]) => ({
       type: "preverb",
       preverb: { type: "default", word: preverb, emphasis: null },
       modifiers: [],

src/parser/parser_lib.ts

@@ -8,46 +8,46 @@ export type ValueRest<T> = Readonly<{ rest: string; value: T }>;
 export type ParserResult<T> = ArrayResult<ValueRest<T>>;
 
 export class Parser<T> {
-  readonly unmemoizedParser: (src: string) => ParserResult<T>;
+  readonly nonMemoizedParser: (src: string) => ParserResult<T>;
   readonly rawParser: (src: string) => ParserResult<T>;
   static cache: null | ClearableCacheSet = null;
   constructor(parser: (src: string) => ParserResult<T>) {
-    this.unmemoizedParser = parser;
+    this.nonMemoizedParser = parser;
     if (Parser.cache != null) {
       const cache = new Map<string, MemoizationCacheResult<ParserResult<T>>>();
       Parser.addToCache(cache);
-      this.rawParser = memoize(this.unmemoizedParser, { cache });
+      this.rawParser = memoize(this.nonMemoizedParser, { cache });
     } else {
-      this.rawParser = this.unmemoizedParser;
+      this.rawParser = this.nonMemoizedParser;
     }
   }
   parser(): (src: string) => ArrayResult<T> {
     const { rawParser } = this;
     return (src) => rawParser(src).map(({ value }) => value);
   }
   map<U>(mapper: (value: T) => U): Parser<U> {
-    const { unmemoizedParser } = this;
+    const { nonMemoizedParser: unmemoizedParser } = this;
     return new Parser((src) =>
       unmemoizedParser(src)
         .map(({ value, rest }) => ({ value: mapper(value), rest }))
     );
   }
   filter(mapper: (value: T) => boolean): Parser<T> {
-    const { unmemoizedParser } = this;
+    const { nonMemoizedParser: unmemoizedParser } = this;
     return new Parser((src) =>
       unmemoizedParser(src).filter(({ value }) => mapper(value))
     );
   }
   then<U>(mapper: (value: T) => Parser<U>): Parser<U> {
     const { cache } = Parser;
-    const { unmemoizedParser } = this;
+    const { nonMemoizedParser: unmemoizedParser } = this;
     return new Parser((src) => {
       const parser = Parser.inContext(() => unmemoizedParser(src), cache);
       return parser.flatMap(({ value, rest }) => mapper(value).rawParser(rest));
     });
   }
   sort(comparer: (left: T, right: T) => number): Parser<T> {
-    const { unmemoizedParser } = this;
+    const { nonMemoizedParser: unmemoizedParser } = this;
     return new Parser((src) =>
       unmemoizedParser(src).sort((left, right) =>
         comparer(left.value, right.value)
@@ -105,18 +105,18 @@ export const nothing = new Parser((src) =>
 export const emptyArray = nothing.map(() => []);
 export function lookAhead<T>(parser: Parser<T>): Parser<T> {
   return new Parser((src) =>
-    parser.unmemoizedParser(src).map(({ value }) => ({ value, rest: src }))
+    parser.nonMemoizedParser(src).map(({ value }) => ({ value, rest: src }))
   );
 }
 export function lazy<T>(parser: () => Parser<T>): Parser<T> {
   const { cache } = Parser;
   if (Parser.cache != null) {
     const cachedParser = new Lazy(() => Parser.inContext(parser, cache));
     Parser.addToCache(cachedParser);
-    return new Parser((src) => cachedParser.getValue().unmemoizedParser(src));
+    return new Parser((src) => cachedParser.getValue().nonMemoizedParser(src));
   } else {
     return new Parser((src) =>
-      Parser.inContext(parser, cache).unmemoizedParser(src)
+      Parser.inContext(parser, cache).nonMemoizedParser(src)
     );
   }
 }
@@ -272,7 +272,7 @@ export function withSource<T>(
   parser: Parser<T>,
 ): Parser<readonly [value: T, source: string]> {
   return new Parser((src) =>
-    parser.unmemoizedParser(src).map(({ value, rest }) => ({
+    parser.nonMemoizedParser(src).map(({ value, rest }) => ({
       value: [value, src.slice(0, src.length - rest.length)],
       rest,
     }))

src/translator/adjective.ts

@@ -4,7 +4,7 @@ import { nullableAsArray, throwError } from "../../misc/misc.ts";
 import * as TokiPona from "../parser/ast.ts";
 import * as English from "./ast.ts";
 import { UntranslatableError } from "./error.ts";
-import { unemphasized, word } from "./word.ts";
+import { noEmphasis, word } from "./word.ts";
 
 export type AdjectiveWithInWay = Readonly<{
   adjective: English.AdjectivePhrase;
@@ -38,7 +38,7 @@ export function adjective(
     .map(({ emphasis, so }) => ({
       type: "simple",
       kind: definition.kind,
-      adverb: [...definition.adverb, ...nullableAsArray(so)].map(unemphasized),
+      adverb: [...definition.adverb, ...nullableAsArray(so)].map(noEmphasis),
       adjective: word({
         word: definition.adjective,
         reduplicationCount,

src/translator/clause.ts

@@ -7,8 +7,8 @@ import { perspective } from "./noun.ts";
 import { multiplePhrases, multiplePhrasesAsNoun } from "./phrase.ts";
 import { predicate } from "./predicate.ts";
 import { nounAsPreposition } from "./preposition.ts";
-import { addModalToAll, adverbless, verb } from "./verb.ts";
-import { unemphasized } from "./word.ts";
+import { addModalToAll, noAdverbs, verb } from "./verb.ts";
+import { noEmphasis } from "./word.ts";
 
 function phraseClause(
   phrases: TokiPona.MultiplePhrases,
@@ -49,7 +49,7 @@ function phraseClause(
                 type: "default",
                 verb: {
                   modal: null,
-                  verb: [adverbless(unemphasized("is"))],
+                  verb: [noAdverbs(noEmphasis("is"))],
                 },
                 subjectComplement: {
                   type: "adjective",
@@ -103,7 +103,7 @@ function iWish(
       type: "simple",
       determiner: [],
       adjective: [],
-      noun: unemphasized("I"),
+      noun: noEmphasis("I"),
       quantity: "singular",
       perspective: "first",
       postAdjective: null,
@@ -114,7 +114,7 @@ function iWish(
       type: "default",
       verb: {
         modal: null,
-        verb: [adverbless(unemphasized("wish"))],
+        verb: [noAdverbs(noEmphasis("wish"))],
       },
       subjectComplement: null,
       contentClause: {
@@ -145,7 +145,7 @@ function oClause(
       type: "simple",
       determiner: [],
       adjective: [],
-      noun: unemphasized("you"),
+      noun: noEmphasis("you"),
       quantity: "plural",
       perspective: "second",
       postAdjective: null,
@@ -161,7 +161,7 @@ function oClause(
         ArrayResult.from(() =>
           verb(
             addModalToAll(
-              adverbless(unemphasized("should")),
+              noAdverbs(noEmphasis("should")),
               predicate,
             ),
             subjectPerspective,

src/translator/modifier.ts

@@ -14,7 +14,7 @@ import { noun } from "./noun.ts";
 import { number } from "./number.ts";
 import { phrase } from "./phrase.ts";
 import { pronoun } from "./pronoun.ts";
-import { unemphasized, word } from "./word.ts";
+import { noEmphasis, word } from "./word.ts";
 import { getReduplicationCount } from "./word_unit.ts";
 
 export type ModifierTranslation =
@@ -285,7 +285,7 @@ export function multipleModifiers(
             type: "simple",
             determiner: [],
             adjective,
-            noun: unemphasized("way"),
+            noun: noEmphasis("way"),
             quantity: "singular",
             perspective: "third",
             postAdjective: null,

src/translator/preposition.ts

@@ -2,7 +2,7 @@ import { ArrayResult } from "../array_result.ts";
 import * as TokiPona from "../parser/ast.ts";
 import * as English from "./ast.ts";
 import { TranslationTodoError } from "./error.ts";
-import { unemphasized } from "./word.ts";
+import { noEmphasis } from "./word.ts";
 
 export function preposition(
   _preposition: TokiPona.Preposition,
@@ -15,7 +15,7 @@ export function nounAsPreposition(
 ): English.Preposition {
   return {
     adverb: [],
-    preposition: unemphasized(preposition),
+    preposition: noEmphasis(preposition),
     object: phrase,
   };
 }

src/translator/sentence.ts

@@ -6,7 +6,7 @@ import { definitionAsPlainString } from "./as_string.ts";
 import * as English from "./ast.ts";
 import { clause, contextClause } from "./clause.ts";
 import { FilteredOutError, TranslationTodoError } from "./error.ts";
-import { unemphasized } from "./word.ts";
+import { noEmphasis } from "./word.ts";
 
 function filler(filler: TokiPona.Filler): ArrayResult<string> {
   switch (filler.type) {
@@ -146,7 +146,9 @@ function sentence(
         );
       if (sentence.kinOrTaso != null) {
         return new ArrayResult(
-          new TranslationTodoError(`"${sentence.kinOrTaso.word}" preclause`),
+          new TranslationTodoError(
+            `"${sentence.kinOrTaso.word}" starting particle`,
+          ),
         );
       }
       const lastEngClause = clause(sentence.finalClause);
@@ -180,7 +182,7 @@ function sentence(
         .map<English.Sentence>((interjection) => ({
           clauses: [{
             type: "interjection",
-            interjection: unemphasized(interjection),
+            interjection: noEmphasis(interjection),
           }],
           punctuation,
         }));