rename

Author: neverRare

src/cache.ts

@@ -1,7 +1,7 @@
 export interface Clearable {
   clear(): void;
 }
-export class ClearableCache {
+export class ClearableCacheSet {
   readonly #caches: Set<WeakRef<Clearable>> = new Set();
   add(cache: Clearable): void {
     this.#caches.add(new WeakRef(cache));

src/parser/cache.ts

@@ -1,6 +1,6 @@
-import { ClearableCache } from "../cache.ts";
+import { ClearableCacheSet } from "../cache.ts";
 
-export const cache = new ClearableCache();
+export const cache = new ClearableCacheSet();
 
 // This needs to be called whenever settings or custom dictionary has changed
 export function clearCache(): void {

src/parser/parser_lib.ts

@@ -1,6 +1,6 @@
 import { memoize } from "@std/cache/memoize";
 import { ArrayResult, ArrayResultError } from "../array_result.ts";
-import { ClearableCache, Clearable, Lazy } from "../cache.ts";
+import { ClearableCacheSet, Clearable, Lazy } from "../cache.ts";
 import { throwError } from "../misc.ts";
 
 export type ValueRest<T> = Readonly<{ rest: string; value: T }>;
@@ -9,7 +9,7 @@ export type ParserResult<T> = ArrayResult<ValueRest<T>>;
 export class Parser<T> {
   readonly unmemoizedParser: (src: string) => ParserResult<T>;
   readonly rawParser: (src: string) => ParserResult<T>;
-  static cache: null | ClearableCache = null;
+  static cache: null | ClearableCacheSet = null;
   constructor(parser: (src: string) => ParserResult<T>) {
     this.unmemoizedParser = parser;
     if (Parser.cache != null) {
@@ -65,16 +65,16 @@ export class Parser<T> {
   static addToCache(cache: Clearable): void {
     Parser.cache?.add(cache);
   }
-  static startCache(cache: ClearableCache = new ClearableCache()): void {
+  static startCache(cache: ClearableCacheSet = new ClearableCacheSet()): void {
     Parser.cache = cache;
   }
   static endCache(): void {
     Parser.cache = null;
   }
-  static startOrEndCache(cache: null | ClearableCache = null): void {
+  static startOrEndCache(cache: null | ClearableCacheSet = null): void {
     Parser.cache = cache;
   }
-  static inContext<T>(fn: () => T, cache: null | ClearableCache = null): T {
+  static inContext<T>(fn: () => T, cache: null | ClearableCacheSet = null): T {
     const previousCache = Parser.cache;
     Parser.startOrEndCache(cache);
     const value = fn();