fixup! README.md

README.md

@@ -185,50 +185,50 @@ only access the value associated with an `AsyncLocal` instance if you have
 access to that instance.
 
 ```typescript
-const asyncLocal = new AsyncLocal();
+const local = new AsyncLocal();
 
 // Sets the current value to 'top', and executes the `main` function.
-asyncLocal.run("top", main);
+local.run("top", main);
 
 function main() {
   // AsyncLocal is maintained through other platform queueing.
   setTimeout(() => {
-    console.log(asyncLocal.get()); // => 'top'
+    console.log(local.get()); // => 'top'
 
-    asyncLocal.run("A", () => {
-      console.log(asyncLocal.get()); // => 'A'
+    local.run("A", () => {
+      console.log(local.get()); // => 'A'
 
       setTimeout(() => {
-        console.log(asyncLocal.get()); // => 'A'
+        console.log(local.get()); // => 'A'
       }, randomTimeout());
     });
   }, randomTimeout());
 
   // AsyncLocal runs can be nested.
-  asyncLocal.run("B", () => {
-    console.log(asyncLocal.get()); // => 'B'
+  local.run("B", () => {
+    console.log(local.get()); // => 'B'
 
     setTimeout(() => {
-      console.log(asyncLocal.get()); // => 'B'
+      console.log(local.get()); // => 'B'
     }, randomTimeout());
   });
 
   // AsyncLocal was restored after the previous run.
-  console.log(asyncLocal.get()); // => 'top'
+  console.log(local.get()); // => 'top'
 
   // Captures the state of all AsyncLocal's at this moment.
   const snapshotDuringTop = new AsyncSnapshot();
 
-  asyncLocal.run("C", () => {
-    console.log(asyncLocal.get()); // => 'C'
+  local.run("C", () => {
+    console.log(local.get()); // => 'C'
 
     // The snapshotDuringTop will restore all AsyncLocal to their snapshot
     // state and invoke the wrapped function. We pass a function which it will
     // invoke.
     snapshotDuringTop.run(() => {
       // Despite being lexically nested inside 'C', the snapshot restored us to
       // to the 'top' state.
-      console.log(asyncLocal.get()); // => 'top'
+      console.log(local.get()); // => 'top'
     });
   });
 }
@@ -312,20 +312,20 @@ tracing span doesn't need to be manually passing around by usercodes.
 ```typescript
 // tracer.js
 
-const asyncLocal = new AsyncLocal();
+const local = new AsyncLocal();
 export function run(cb) {
   // (a)
   const span = {
     startTime: Date.now(),
     traceId: randomUUID(),
     spanId: randomUUID(),
   };
-  asyncLocal.run(span, cb);
+  local.run(span, cb);
 }
 
 export function end() {
   // (b)
-  const span = asyncLocal.get();
+  const span = local.get();
   span?.endTime = Date.now();
 }
 ```
@@ -367,14 +367,14 @@ scheduled with the same priority.
 
 ```typescript
 const scheduler = {
-  asyncLocal: new AsyncLocal(),
+  local: new AsyncLocal(),
   postTask(task, options) {
     // In practice, the task execution may be deferred.
     // Here we simply run the task immediately.
-    return this.asyncLocal.run({ priority: options.priority }, task);
+    return this.local.run({ priority: options.priority }, task);
   },
   currentTask() {
-    return this.asyncLocal.get() ?? { priority: "default" };
+    return this.local.get() ?? { priority: "default" };
   },
 };
 

SCOPING.md

@@ -29,19 +29,19 @@ value inside an `AsyncLocal` without explicit access to the `AsyncLocal` instanc
 itself.
 
 ```typescript
-const asyncLocal = new AsyncLocal();
+const local = new AsyncLocal();
 
-asyncLocal.run(1, f);
-console.log(asyncLocal.get()); // => undefined
+local.run(1, f);
+console.log(local.get()); // => undefined
 
 function g() {
-  console.log(asyncLocal.get()); // => 1
+  console.log(local.get()); // => 1
 }
 
 function f() {
-  // Intentionally named the same "asyncLocal"
-  const asyncLocal = new AsyncLocal();
-  asyncLocal.run(2, g);
+  // Intentionally named the same "local"
+  const local = new AsyncLocal();
+  local.run(2, g);
 }
 ```
 
@@ -50,18 +50,18 @@ ability to change the value of that variable. You must have direct access to it
 in order to affect it.
 
 ```typescript
-const asyncLocal = new AsyncLocal();
+const local = new AsyncLocal();
 
-asyncLocal.run(1, f);
+local.run(1, f);
 
-console.log(asyncLocal.get()); // => undefined;
+console.log(local.get()); // => undefined;
 
 function f() {
-  const asyncLocal = new AsyncLocal();
-  asyncLocal.run(2, g);
+  const local = new AsyncLocal();
+  local.run(2, g);
 
   function g() {
-    console.log(asyncLocal.get()); // => 2;
+    console.log(local.get()); // => 2;
   }
 }
 ```
@@ -119,5 +119,5 @@ that can operate across sync/async execution should be no different.
 There are no differences regarding naming scope of `AsyncLocal` compared to
 regular JavaScript variables. Only code with direct access to `AsyncLocal`
 instances can modify the value, and only for code execution nested inside a new
-`asyncLocal.run()`. Further, the capability to modify a local variable which you
+`local.run()`. Further, the capability to modify a local variable which you
 have direct access to is already possible in sync code execution.