Add peekVal, hasCached, and asyncIterplus

deno_compat/AsyncIterPlus.ts

@@ -60,7 +60,7 @@ import {nullVal} from "./IterPlus.ts";
 /**
  * The type of null to use.
  */
-//export type AsyncNull = typeof asyncNullVal;
+//export type Null = typeof nullVal;
 import {Null} from "./IterPlus.ts";
 /**
  * A wrapper around an iterator to add additional functionality. The types intentionally ignore return value.
@@ -3134,7 +3134,7 @@ export class AsyncPeekable<T> extends AsyncIterPlus<T> {
     /**
      * Peeks the next element in the iterator and does not consume it.
      *
-     * @returns The next element.
+     * @returns The next element as an iterator result.
      */
     async peek(): Promise<IteratorResult<T>> {
         if (this.storedVal.has) {
@@ -3143,4 +3143,30 @@ export class AsyncPeekable<T> extends AsyncIterPlus<T> {
         this.storedVal = {has: true, val: await this.internal.next()};
         return this.storedVal.val;
     }
+
+    /**
+     * Peeks the next element in the iterator and does not consume it.
+     *
+     * Nullable version of `peek`.
+     *
+     * @returns The next element, or `null` if the iterator is finished.
+     */
+    async peekVal(): Promise<T | Null> {
+        const res = await this.peek();
+        if (res.done) {
+            return nullVal;
+        }
+        return res.value;
+    }
+
+    /**
+     * Checks if there's a value cached from a previous `peek`.
+     *
+     * Will return `true` even if the cached value is the end of the iterator.
+     *
+     * @returns If there's a value cached.
+     */
+    hasCached() {
+        return this.storedVal.has;
+    }
 }

deno_compat/IterPlus.ts

@@ -66,8 +66,7 @@ type /* o:Async- */ IterableMap<T extends unknown[]> = {
 /**
  * The type of null to use.
  */
-/* o://- */ export type /* o:Async- */ Null =
-    typeof /* r:asyncNullVal */ nullVal;
+/* o://- */ export type Null = typeof nullVal;
 /* o:import {Null} from "./IterPlus"; */
 
 /**
@@ -3253,7 +3252,7 @@ export class /* o:Async- */ Peekable<
     /**
      * Peeks the next element in the iterator and does not consume it.
      *
-     * @returns The next element.
+     * @returns The next element as an iterator result.
      */
     /* o:async */ peek(): /* o:Promise<- */ IteratorResult<T> /* o:-> */ {
         if (this.storedVal.has) {
@@ -3262,4 +3261,30 @@ export class /* o:Async- */ Peekable<
         this.storedVal = {has: true, val: /* o:await */ this.internal.next()};
         return this.storedVal.val;
     }
+
+    /**
+     * Peeks the next element in the iterator and does not consume it.
+     *
+     * Nullable version of `peek`.
+     *
+     * @returns The next element, or `null` if the iterator is finished.
+     */
+    /* o:async */ peekVal(): /* o:Promise<- */ T | Null /* o:-> */ {
+        const res = /* o:await */ this.peek();
+        if (res.done) {
+            return nullVal;
+        }
+        return res.value;
+    }
+
+    /**
+     * Checks if there's a value cached from a previous `peek`.
+     *
+     * Will return `true` even if the cached value is the end of the iterator.
+     *
+     * @returns If there's a value cached.
+     */
+    hasCached() {
+        return this.storedVal.has;
+    }
 }

deno_compat/util.ts

@@ -1,35 +1,28 @@
-import {IterPlus, canIter} from "./IterPlus.ts";
-import {AsyncIterPlus, canAsyncIter} from "./AsyncIterPlus.ts";
+import {IterPlus} from "./IterPlus.ts";
+import {AsyncIterPlus} from "./AsyncIterPlus.ts";
 /**
  * A promise or a value that can be awaited.
  */
 export type PromiseOrValue<T> = T | Promise<T>;
 
 /**
- * The return type of `iterplus`.
+ * Generates an `IterPlus` from an iterable.
+ *
+ * @typeParam T The iteration type.
+ * @param iter The iterable to upgrade.
  */
-type UpgradeIter<T> = T extends Iterable<infer I>
-    ? IterPlus<I>
-    : T extends AsyncIterable<infer I>
-    ? AsyncIterPlus<I>
-    : IterPlus<unknown> | AsyncIterPlus<unknown>;
+export function iterplus<T>(iter: Iterable<T>): IterPlus<T> {
+    return new IterPlus(iter[Symbol.iterator]());
+}
 
 /**
- * Generates an `IterPlus` from an iterable or async iterable.
+ * Generates an `AsyncIterPlus` from an async iterable.
  *
- * @typeParam T The iterable/async iterable to upgrade.
- * @param iter The iterable to upgrade.
+ * @typeParam T The iteration type.
+ * @param iter The async iterable to upgrade.
  */
-export function iterplus<T>(iter: Iterable<T>): IterPlus<T>;
-export function iterplus<T>(iter: AsyncIterable<T>): AsyncIterPlus<T>;
-export function iterplus(iter: any): any {
-    if (canIter(iter)) {
-        return new IterPlus(iter[Symbol.iterator]());
-    } else if (canAsyncIter(iter)) {
-        return new AsyncIterPlus(iter[Symbol.asyncIterator]());
-    } else {
-        throw new Error("Object is not an iterable.");
-    }
+export function asyncIterplus<T>(iter: AsyncIterable<T>): AsyncIterPlus<T> {
+    return new AsyncIterPlus(iter[Symbol.asyncIterator]());
 }
 
 /**

dest/src/AsyncIterPlus.d.ts

@@ -1180,8 +1180,24 @@ export declare class AsyncPeekable<T> extends AsyncIterPlus<T> {
     /**
      * Peeks the next element in the iterator and does not consume it.
      *
-     * @returns The next element.
+     * @returns The next element as an iterator result.
      */
     peek(): Promise<IteratorResult<T>>;
+    /**
+     * Peeks the next element in the iterator and does not consume it.
+     *
+     * Nullable version of `peek`.
+     *
+     * @returns The next element, or `null` if the iterator is finished.
+     */
+    peekVal(): Promise<T | Null>;
+    /**
+     * Checks if there's a value cached from a previous `peek`.
+     *
+     * Will return `true` even if the cached value is the end of the iterator.
+     *
+     * @returns If there's a value cached.
+     */
+    hasCached(): boolean;
 }
 export {};

dest/src/IterPlus.d.ts

@@ -1184,8 +1184,24 @@ export declare class Peekable<T>/* r:extends Async- */  extends IterPlus<T> {
     /**
      * Peeks the next element in the iterator and does not consume it.
      *
-     * @returns The next element.
+     * @returns The next element as an iterator result.
      */
     peek(): IteratorResult<T>;
+    /**
+     * Peeks the next element in the iterator and does not consume it.
+     *
+     * Nullable version of `peek`.
+     *
+     * @returns The next element, or `null` if the iterator is finished.
+     */
+    peekVal(): /* o:Promise<- */ T | Null;
+    /**
+     * Checks if there's a value cached from a previous `peek`.
+     *
+     * Will return `true` even if the cached value is the end of the iterator.
+     *
+     * @returns If there's a value cached.
+     */
+    hasCached(): boolean;
 }
 export {};

dest/src/util.d.ts

@@ -5,13 +5,19 @@ import { AsyncIterPlus } from "./AsyncIterPlus";
  */
 export declare type PromiseOrValue<T> = T | Promise<T>;
 /**
- * Generates an `IterPlus` from an iterable or async iterable.
+ * Generates an `IterPlus` from an iterable.
  *
- * @typeParam T The iterable/async iterable to upgrade.
+ * @typeParam T The iteration type.
  * @param iter The iterable to upgrade.
  */
 export declare function iterplus<T>(iter: Iterable<T>): IterPlus<T>;
-export declare function iterplus<T>(iter: AsyncIterable<T>): AsyncIterPlus<T>;
+/**
+ * Generates an `AsyncIterPlus` from an async iterable.
+ *
+ * @typeParam T The iteration type.
+ * @param iter The async iterable to upgrade.
+ */
+export declare function asyncIterplus<T>(iter: AsyncIterable<T>): AsyncIterPlus<T>;
 /**
  * Creates an inclusive-exclusive range iterator that's useful for loops.
  *