remove return type annotations

Author: neverRare

build/dev.ts

@@ -12,11 +12,11 @@ const BUILD_OPTIONS: BuildOptions = {
   minify: false,
   define: { LIVE_RELOAD: "true" },
 };
-async function watchMain(): Promise<AsyncDisposable> {
+async function watchMain() {
   await using stack = new AsyncDisposableStack();
   const buildContext = stack.use({
     context: await context(BUILD_OPTIONS),
-    async [Symbol.asyncDispose](): Promise<void> {
+    async [Symbol.asyncDispose]() {
       await this.context.dispose();
     },
   });
@@ -25,7 +25,7 @@ async function watchMain(): Promise<AsyncDisposable> {
   stack.move();
   return buildContext;
 }
-async function watchDictionary(): Promise<number> {
+async function watchDictionary() {
   const command = new Deno.Command(Deno.execPath(), {
     args: [
       "run",

deno.json

@@ -45,7 +45,6 @@
       "tags": ["recommended"],
       "include": [
         "camelcase",
-        "explicit-function-return-type",
         "explicit-module-boundary-types",
         "no-console",
         "no-boolean-literal-for-arguments",

dictionary/build.ts

@@ -50,10 +50,7 @@ export async function build(): Promise<boolean> {
   );
   return true;
 }
-function displayError(
-  source: string,
-  errors: ReadonlyArray<ArrayResultError>,
-): void {
+function displayError(source: string, errors: ReadonlyArray<ArrayResultError>) {
   let color: boolean;
   try {
     color = Deno.env.get("NO_COLOR") !== "1";

dictionary/parser.ts

@@ -51,7 +51,7 @@ const ignore = allWithCheck(
     choiceWithCheck(spaces, comment),
   ),
 );
-function lex<T>(parser: Parser<T>): Parser<T> {
+function lex<T>(parser: Parser<T>) {
   return parser.skip(ignore);
 }
 const wordWithPosition = lex(
@@ -100,10 +100,10 @@ const perspective = choiceOnlyOne(
   keyword("second"),
   keyword("third"),
 );
-function tag<T>(parser: Parser<T>): Parser<T> {
+function tag<T>(parser: Parser<T>) {
   return openParenthesis.with(parser).skip(closeParenthesis);
 }
-function template<T>(parser: Parser<T>): Parser<T> {
+function template<T>(parser: Parser<T>) {
   return openBracket.with(parser).skip(closeBracket);
 }
 const simpleUnit = memoize((kind: string) => word.skip(tag(keyword(kind))));
@@ -260,22 +260,19 @@ const checkedNoun = new CheckedParser(
   ),
   noun,
 );
-function checkedSimpleUnitWith<T>(
-  tag: string,
-  after: Parser<T>,
-): CheckedParser<readonly [string, T]> {
+function checkedSimpleUnitWith<T>(tag: string, after: Parser<T>) {
   return checkedSequence(
     word.skip(openParenthesis).skip(keyword(tag)),
     closeParenthesis.with(after),
   );
 }
-function checkedSimpleUnit(tag: string): CheckedParser<string> {
+function checkedSimpleUnit(tag: string) {
   return checkedSimpleUnitWith(tag, nothing).map(([word]) => word);
 }
 function checkedSimpleUnitWithTemplate(
   tag: string,
   templateInside: Parser<unknown>,
-): CheckedParser<string> {
+) {
   return checkedSimpleUnitWith(tag, template(templateInside))
     .map(([word]) => word);
 }

src/dictionary.ts

@@ -23,7 +23,7 @@ export function loadCustomDictionary(dictionary: Dictionary): void {
   }
   update();
 }
-function update(): void {
+function update() {
   dictionary.clear();
   const words = new Set([
     ...globalDictionary.keys(),
@@ -54,17 +54,14 @@ function update(): void {
 function redefineSet(
   set: Set<string>,
   filter: (definition: Definition) => boolean,
-): void {
+) {
   set.clear();
   for (const [word, { definitions }] of dictionary) {
     if (definitions.some(filter)) {
       set.add(word);
     }
   }
 }
-function redefineSetWithType(
-  set: Set<string>,
-  type: Definition["type"],
-): void {
+function redefineSetWithType(set: Set<string>, type: Definition["type"]) {
   redefineSet(set, ({ type: compareType }) => compareType === type);
 }

src/main.ts

@@ -62,7 +62,7 @@ const WORD_NOT_FOUND_MESSAGE = "Word not found";
 const WORD_ALREADY_IMPORTED_MESSAGE = "The word is already imported";
 const DICTIONARY_ERROR_MESSAGE = "Please fix the errors before saving";
 
-function main(): void {
+function main() {
   // load elements
   const inputTextBox = document.getElementById(
     "input",
@@ -144,13 +144,13 @@ function main(): void {
   ) as HTMLAnchorElement;
 
   // determines whether the dictionary can be automatically parsed
-  function autoParse(): boolean {
+  function autoParse() {
     return customDictionaryTextBox.value.length <=
       DICTIONARY_AUTO_PARSE_THRESHOLD;
   }
 
   // emulates `window.alert`
-  function showMessage(useMessage: string): void {
+  function showMessage(useMessage: string) {
     message.innerText = useMessage;
     alertBox.showModal();
   }
@@ -193,21 +193,21 @@ function main(): void {
 
   // initial text area size
   resizeTextarea();
-  function resizeTextarea(): void {
+  function resizeTextarea() {
     inputTextBox.style.height = "auto";
     inputTextBox.style.height = `${inputTextBox.scrollHeight + 14}px`;
   }
 
   // initialize button label
   updateLabel();
-  function updateLabel(): void {
+  function updateLabel() {
     translateButton.innerText = settings.multiline
       ? TRANSLATE_LABEL_MULTILINE
       : TRANSLATE_LABEL;
   }
 
   // show custom dictionary errors
-  function showDictionaryError(): void {
+  function showDictionaryError() {
     customDictionaryErrorSummary.innerText =
       `Errors (${currentDictionary.errors.length}):`;
     customDictionaryErrorList.innerHTML = "";
@@ -239,7 +239,7 @@ function main(): void {
       updateOutput();
     }
   });
-  function updateOutput(): void {
+  function updateOutput() {
     outputList.innerHTML = "";
     errorList.innerHTML = "";
     errorDisplay.innerText = "";
@@ -300,7 +300,7 @@ function main(): void {
       importWord();
     }
   });
-  function importWord(): void {
+  function importWord() {
     const word = importWordTextBox.value.trim();
     if (word === "") {
       showMessage(NO_WORD_MESSAGE);
@@ -338,16 +338,16 @@ function main(): void {
     }
     tryCloseDictionary();
   });
-  function updateDictionary(): void {
+  function updateDictionary() {
     currentDictionary = dictionaryParser.parse(customDictionaryTextBox.value);
     showDictionaryError();
   }
-  function updateIfCanAutoParse(): void {
+  function updateIfCanAutoParse() {
     if (autoParse()) {
       updateDictionary();
     }
   }
-  function tryCloseDictionary(): void {
+  function tryCloseDictionary() {
     if (!currentDictionary.isError()) {
       lastSavedText = customDictionaryTextBox.value;
       lastSavedDictionary = currentDictionary;

src/parser/composer.ts

@@ -32,7 +32,7 @@ export function filler(filler: Filler): string {
       return emphasis(filler);
   }
 }
-function emphasisAsArray(value: null | Emphasis): ReadonlyArray<string> {
+function emphasisAsArray(value: null | Emphasis) {
   return nullableAsArray(value).map(emphasis);
 }
 export function simpleWordUnit(wordUnit: SimpleWordUnit): string {
@@ -90,10 +90,7 @@ export function phrase(value: Phrase): string {
       return preposition(value);
   }
 }
-function particle(
-  type: "and conjunction" | "anu",
-  particle: null | string,
-): string {
+function particle(type: "and conjunction" | "anu", particle: null | string) {
   if (type === "and conjunction") {
     return particle!;
   } else {

src/parser/filter.ts

@@ -392,10 +392,10 @@ export function filter<T>(
     }
   };
 }
-function modifierIsNumeric(modifier: Modifier): boolean {
+function modifierIsNumeric(modifier: Modifier) {
   return modifier.type === "default" && modifier.word.type === "number";
 }
-function modifiersIsAlaOrNone(modifiers: ReadonlyArray<Modifier>): boolean {
+function modifiersIsAlaOrNone(modifiers: ReadonlyArray<Modifier>) {
   switch (modifiers.length) {
     case 0:
       return true;
@@ -408,7 +408,7 @@ function modifiersIsAlaOrNone(modifiers: ReadonlyArray<Modifier>): boolean {
       return false;
   }
 }
-function hasPrepositionInPhrase(phrase: Phrase): boolean {
+function hasPrepositionInPhrase(phrase: Phrase) {
   switch (phrase.type) {
     case "default":
       return false;
@@ -418,15 +418,15 @@ function hasPrepositionInPhrase(phrase: Phrase): boolean {
       return hasPrepositionInPhrase(phrase.phrase);
   }
 }
-function phraseHasTopLevelEmphasis(phrase: Phrase): boolean {
+function phraseHasTopLevelEmphasis(phrase: Phrase) {
   switch (phrase.type) {
     case "default":
     case "preverb":
     case "preposition":
       return phrase.emphasis != null;
   }
 }
-function getDuplicate<T>(iterable: Iterable<T>): Set<T> {
+function getDuplicate<T>(iterable: Iterable<T>) {
   const unique = new Set<T>();
   const duplicates = new Set<T>();
   for (const value of iterable) {