feat: Add some partial-applied and Enforce test (#37)

src/cont.test.ts

@@ -1,10 +1,39 @@
-import { Cont, callCC, flatMap, pure, runCont, runContT, when } from "../src/cont.js";
+import {
+    Cont,
+    callCC,
+    evalCont,
+    flatMap,
+    mapCont,
+    pure,
+    runCont,
+    runContT,
+    when,
+    withCont,
+} from "../src/cont.js";
 import { expect, test, vitest } from "vitest";
 
 import type { IdentityHktKey } from "../src/identity.js";
 import { cat } from "../src/cat.js";
 import { id } from "../src/func.js";
 
+test("eval", () => {
+    const actual = evalCont<number>(pure(42));
+    expect(actual).toBe(42);
+});
+
+test("map", () => {
+    const actual = evalCont(mapCont((x: number) => x + 1)(pure(42)));
+    expect(actual).toBe(43);
+});
+
+test("with", () => {
+    const cont = withCont((fn: (x: number) => boolean) => (a: string) => fn(parseInt(a, 10)))(
+        (callback) => callback("foo"),
+    );
+    const actual = runCont(cont)(Number.isNaN);
+    expect(actual).toBe(true);
+});
+
 test("simple usage", () => {
     const calcLength = <A, R>(a: A[]): Cont<R, number> => pure(a.length);
     const double = <R>(num: number): Cont<R, number> => pure(num * 2);

src/cont.ts

@@ -66,6 +66,10 @@ export const withCont: <A, B, R>(
     callback: (fn: (b: B) => R) => (a: A) => R,
 ) => (cont: Cont<R, A>) => Cont<R, B> = withContT;
 
+export const reset: <R, S>(contT: Cont<R, R>) => Cont<S, R> = resetT(Identity.monad);
+export const shift: <R, A>(continuation: (callback: (a: A) => R) => Cont<R, R>) => Cont<R, A> =
+    shiftT(Identity.monad);
+
 export const pure =
     <R, M, A>(a: A): ContT<R, M, A> =>
     (fn) =>