Publish koka from koka-stack repository

Author: Lucifier129

README.md

@@ -1,5 +1,7 @@
 # Koka - Lightweight 3kB Effect-TS alternative library based on Algebraic Effects
 
+** Warning: This library is in early development and may change significantly. Do not use in production yet. **
+
 Koka is a minimal yet powerful effects library for TypeScript that provides structured error handling, context management, and async operations in a composable, type-safe manner.
 
 Inspired by algebraic effects from [koka-lang](https://github.com/koka-lang/koka), it offers a pragmatic alternative to traditional error handling. Compared to comprehensive solutions like [Effect-TS](https://github.com/Effect-TS/effect), Koka focuses on delivering essential effect management with minimal overhead.

__tests__/koka.test.ts

@@ -103,6 +103,54 @@ describe('Eff.try/catch', () => {
             error: 'error',
         })
     })
+
+    it('should handle multiple catches', () => {
+        function* test() {
+            yield* Eff.err('FirstError').throw('first error')
+            yield* Eff.err('SecondError').throw('second error')
+            return 'should not reach here'
+        }
+
+        const program = Eff.try(test()).catch({
+            FirstError: (error) => `Caught first: ${error}`,
+            SecondError: (error) => `Caught second: ${error}`,
+        })
+
+        const result = Eff.run(program)
+        expect(result).toBe('Caught first: first error')
+    })
+
+    it('should handle nested try/catch', () => {
+        function* inner() {
+            yield* Eff.err('InnerError').throw('inner error')
+            return 'should not reach here'
+        }
+
+        function* outer() {
+            return yield* inner()
+        }
+
+        const result = Eff.run(
+            Eff.try(outer()).catch({
+                InnerError: (error) => `Caught inner: ${error}`,
+            }),
+        )
+        expect(result).toBe('Caught inner: inner error')
+    })
+
+    // it('should catch promise via async handler', async () => {
+    //     function* test() {
+    //         const value = yield* Eff.await(Promise.reject('Async error'))
+    //         return value
+    //     }
+
+    //     const program = Eff.try(test()).catch({
+    //         async: (promise) => `Caught async: ${promise}`,
+    //     })
+
+    //     const result = Eff.run(program)
+    //     expect(result).toBe('Caught async: Async error')
+    // })
 })
 
 describe('Eff.run', () => {
@@ -299,4 +347,4 @@ describe('helpers', () => {
         expect(isGenerator(gen())).toBe(true)
         expect(isGenerator(notGen())).toBe(false)
     })
-})
+})

cjs/koka.js

@@ -34,6 +34,10 @@ type ToHandler<Effect> = Effect extends Err<infer Name, infer U>
     ? Record<Name, (error: U) => unknown>
     : Effect extends Ctx<infer Name, infer U>
     ? Record<Name, U>
+    : Effect extends Async
+    ? {
+          async: (value: Promise<unknown>) => Promise<unknown>
+      }
     : never
 
 export type EffectHandlers<Effect> = UnionToIntersection<ToHandler<Effect>>
@@ -77,6 +81,10 @@ export const Result = {
 
 type InferOkValue<T> = T extends Ok<infer U> ? U : never
 
+type Prettier<T> = {
+    [K in keyof T]: T[K]
+}
+
 export type MaybePromise<T> = T extends Promise<any> ? T : T | Promise<T>
 
 export type MaybeFunction<T> = T | (() => T)
@@ -109,7 +117,7 @@ export class Eff {
     }
     static try = <Yield extends AnyEff, Return>(input: MaybeFunction<Generator<Yield, Return>>) => {
         return {
-            *catch<Handlers extends Partial<EffectHandlers<Yield>> | {}>(
+            *catch<Handlers extends Partial<EffectHandlers<Yield>> & {}>(
                 handlers: Handlers,
             ): Generator<Exclude<Yield, { name: keyof Handlers }>, Return | ReturnType<ExtractFunctions<Handlers>>> {
                 const gen = typeof input === 'function' ? input() : input
@@ -127,15 +135,21 @@ export class Eff {
                             result = gen.next(yield effect as any)
                         }
                     } else if (effect.type === 'ctx') {
-                        const context = handlers[effect.name as keyof Handlers]
-
                         if (handlers.hasOwnProperty(effect.name)) {
+                            const context = handlers[effect.name as keyof Handlers]
                             result = gen.next(context)
                         } else {
                             result = gen.next(yield effect as any)
                         }
-                    } else {
+                    } else if (effect.type === 'async') {
+                        if ('async' in handlers) {
+                            const asyncHandler = handlers['async'] as (value: Promise<unknown>) => Promise<unknown>
+                            result = gen.next(yield asyncHandler(effect.value) as any)
+                        }
                         result = gen.next(yield effect as any)
+                    } else {
+                        effect satisfies never
+                        throw new Error(`Unexpected effect: ${JSON.stringify(effect, null, 2)}`)
                     }
                 }
 
@@ -148,11 +162,15 @@ export class Eff {
     static run<Return>(input: MaybeFunction<Generator<Async, Return>>): MaybePromise<Return> {
         const process = (result: IteratorResult<Async, Return>): MaybePromise<Return> => {
             if (!result.done) {
-                const asyncEff = result.value
-
-                return asyncEff.value.then((value) => {
-                    return process(gen.next(value))
-                }) as MaybePromise<Return>
+                const effect = result.value
+
+                if (effect.type === 'async') {
+                    return effect.value.then((value) => {
+                        return process(gen.next(value))
+                    }) as MaybePromise<Return>
+                } else {
+                    throw new Error(`Expected async effect, but got: ${JSON.stringify(effect, null, 2)}`)
+                }
             }
 
             return result.value as MaybePromise<Return>