{"id":47816849,"url":"https://github.com/hayabusa-cloud/kont","last_synced_at":"2026-04-03T18:44:52.587Z","repository":{"id":338559672,"uuid":"1126250793","full_name":"hayabusa-cloud/kont","owner":"hayabusa-cloud","description":"Delimited continuations and algebraic effects for Go","archived":false,"fork":false,"pushed_at":"2026-02-22T13:50:22.000Z","size":179,"stargazers_count":2,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-02-22T18:55:11.006Z","etag":null,"topics":["algebraic-effects","continuation","golang"],"latest_commit_sha":null,"homepage":"https://code.hybscloud.com/","language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/hayabusa-cloud.png","metadata":{"files":{"readme":"README.es.md","changelog":null,"contributing":null,"funding":".github/FUNDING.yml","license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null},"funding":{"github":"hayabusa-cloud"}},"created_at":"2026-01-01T13:49:07.000Z","updated_at":"2026-02-22T13:38:53.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/hayabusa-cloud/kont","commit_stats":null,"previous_names":["hayabusa-cloud/kont"],"tags_count":1,"template":false,"template_full_name":null,"purl":"pkg:github/hayabusa-cloud/kont","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hayabusa-cloud%2Fkont","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hayabusa-cloud%2Fkont/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hayabusa-cloud%2Fkont/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hayabusa-cloud%2Fkont/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/hayabusa-cloud","download_url":"https://codeload.github.com/hayabusa-cloud/kont/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hayabusa-cloud%2Fkont/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":31370203,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-04-03T17:53:18.093Z","status":"ssl_error","status_checked_at":"2026-04-03T17:53:17.617Z","response_time":107,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.6:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["algebraic-effects","continuation","golang"],"created_at":"2026-04-03T18:44:51.853Z","updated_at":"2026-04-03T18:44:52.577Z","avatar_url":"https://github.com/hayabusa-cloud.png","language":"Go","funding_links":["https://github.com/sponsors/hayabusa-cloud"],"categories":[],"sub_categories":[],"readme":"[![Go Reference](https://pkg.go.dev/badge/code.hybscloud.com/kont.svg)](https://pkg.go.dev/code.hybscloud.com/kont)\n[![Go Report Card](https://goreportcard.com/badge/github.com/hayabusa-cloud/kont)](https://goreportcard.com/report/github.com/hayabusa-cloud/kont)\n[![Coverage Status](https://codecov.io/gh/hayabusa-cloud/kont/graph/badge.svg)](https://codecov.io/gh/hayabusa-cloud/kont)\n[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)\n\n[English](README.md) | [简体中文](README.zh-CN.md) | **Español** | [日本語](README.ja.md) | [Français](README.fr.md)\n\n# kont\n\nContinuaciones delimitadas y efectos algebraicos para Go via polimorfismo F-acotado.\n\n## Descripcion General\n\nkont proporciona:\n- Interfaces minimas pero completas para continuaciones, control y efectos\n- Polimorfismo F-acotado para despacho en tiempo de compilacion y desvirtualizacion\n- Evaluacion desfuncionalizada con un bucle de evaluacion sin asignaciones\n\n### Fundamentos Teoricos\n\n| Concepto | Referencia | Implementacion |\n|----------|------------|----------------|\n| Monada de Continuacion | Moggi (1989) | `Cont[R, A]` |\n| Continuaciones Delimitadas | Danvy \u0026 Filinski (1990) | `Shift`, `Reset` |\n| Efectos Algebraicos | Plotkin \u0026 Pretnar (2009) | `Op`, `Handler`, `Perform`, `Handle` |\n| Tipos Afines | Walker \u0026 Watkins (2001) | `Affine[R, A]` |\n| Representacion de Monadas | Filinski (1994) | `Reify`, `Reflect` |\n| Desfuncionalizacion | Reynolds (1972) | `Expr[A]`, `Frame` |\n\n## Instalacion\n\n```bash\ngo get code.hybscloud.com/kont\n```\n\nRequiere Go 1.26+.\n\n## Tipos Principales\n\n| Tipo | Proposito |\n|------|-----------|\n| `Cont[R, A]` | Computacion CPS: `func(func(A) R) R` |\n| `Eff[A]` | Computacion con efectos: alias de tipo para `Cont[Resumed, A]` |\n| `Pure` | Eleva un valor a `Eff` con inferencia de tipos completa |\n| `Expr[A]` | Computacion desfuncionalizada (bucle de evaluacion sin asignaciones) |\n| `Shift`/`Reset` | Operadores de control delimitado |\n| `Op[O Op[O, A], A]` | Interfaz de operacion de efecto F-acotada |\n| `Handler[H Handler[H, R], R]` | Interfaz de manejador de efectos F-acotada |\n| `Either[E, A]` | Tipo suma para manejo de errores |\n| `Affine[R, A]` | Continuacion de un solo uso |\n| `Erased` | Alias de tipo para `any` que marca valores con tipo borrado en marcos |\n| `Reify`/`Reflect` | Puente: Cont ↔ Expr (Filinski 1994) |\n\n## Uso Basico\n\nSi es su primera vez con `kont`, empiece con `Return`/`Bind`/`Run` para aprender la composición, luego adopte los runners de efectos estándar (`State`, `Reader`, `Writer`, `Error`), y finalmente use las APIs `Expr`/`Step` para rutas críticas sensibles a asignaciones o runtimes dirigidos externamente.\n\n### Return y Run\n\n```go\nm := kont.Return[int](42)\nresult := kont.Run(m) // 42\n```\n\n### Bind (Composicion Monadica)\n\n```go\nm := kont.Bind(\n    kont.Return[int](21),\n    func(x int) kont.Cont[int, int] {\n        return kont.Return[int](x * 2)\n    },\n)\nresult := kont.Run(m) // 42\n```\n\n### Shift y Reset\n\n```go\nm := kont.Reset[int](\n    kont.Bind(\n        kont.Shift[int, int](func(k func(int) int) int {\n            return k(1) + k(10)\n        }),\n        func(x int) kont.Cont[int, int] {\n            return kont.Return[int](x * 2)\n        },\n    ),\n)\nresult := kont.Run(m) // (1*2) + (10*2) = 22\n```\n\n## Efectos Estandar\n\n### State (Estado)\n\n```go\ncomp := kont.GetState(func(s int) kont.Eff[int] {\n    return kont.PutState(s+10, kont.Perform(kont.Get[int]{}))\n})\nresult, state := kont.RunState[int, int](0, comp)\n```\n\n### Reader (Lector)\n\n```go\ncomp := kont.AskReader(func(cfg Config) kont.Eff[string] {\n    return kont.Pure(cfg.BaseURL)\n})\nresult := kont.RunReader(config, comp)\n```\n\n### Writer (Escritor)\n\n```go\ncomp := kont.TellWriter(\"log message\", kont.Pure(42))\nresult, logs := kont.RunWriter[string, int](comp)\n```\n\n### Error\n\n```go\ncomp := kont.CatchError[string, int](\n    kont.ThrowError[string, int](\"error\"),\n    func(err string) kont.Eff[int] {\n        return kont.Pure(0)\n    },\n)\nresult := kont.RunError[string, int](comp)\n```\n\n## Paso a Paso\n\nStep y StepExpr proporcionan evaluacion efecto-por-efecto para runtimes externos.\n\nConvencion de finalizacion con nil: el limite de stepping y los runners de efectos tratan\nun `Resumed` nil como “completado con el valor cero”. Esto implica que las computaciones\ncon resultado final de tipo puntero o interfaz no pueden usar nil como un valor de resultado\nsignificativo; envuelva estos resultados en un tipo suma/option (por ejemplo, `Either`) si\nnecesita distinguirlos.\n\n```go\nresult, susp := kont.Step(computation)\nfor susp != nil {\n    op := susp.Op()        // observar operacion pendiente\n    v := execute(op)        // el runtime externo maneja la operacion\n    result, susp = susp.Resume(v) // avanzar a la siguiente suspension\n}\n// result es el valor final\n```\n\nEquivalente Expr:\n\n```go\nresult, susp := kont.StepExpr(exprComputation)\n```\n\nCada suspension es de un solo uso (afin): Resume entra en panic si se reutiliza.\n\n## Efectos Compuestos\n\nLos ejecutores compuestos despachan multiples familias de efectos desde un solo manejador.\n\n```go\n// State + Reader\nresult, state := kont.RunStateReader[int, string, int](0, \"env\", comp)\n\n// State + Error (el estado siempre esta disponible, incluso en error)\nresult, state := kont.RunStateError[int, string, int](0, comp) // result: Either[string, int]\n\n// State + Writer\nresult, state, logs := kont.RunStateWriter[int, string, int](0, comp)\n\n// Reader + State + Error\nresult, state := kont.RunReaderStateError[string, int, string, int](\"env\", 0, comp)\n```\n\nTodos los ejecutores compuestos tienen equivalentes Expr (`RunStateReaderExpr`, `RunStateErrorExpr`, `RunStateWriterExpr`, `RunReaderStateErrorExpr`).\n\n## Seguridad de Recursos\n\n### Bracket\n\n```go\ncomp := kont.Bracket[error, *File, string](\n    acquire,\n    func(f *File) kont.Eff[struct{}] {\n        f.Close()\n        return kont.Pure(struct{}{})\n    },\n    func(f *File) kont.Eff[string] {\n        return kont.Pure(f.ReadAll())\n    },\n)\n```\n\n### OnError\n\n```go\ncomp := kont.OnError(riskyOp(), errorCleanup)\n```\n\n## Evaluacion Desfuncionalizada\n\nLos closures se convierten en estructuras de datos de marcos etiquetados. Un evaluador trampolin iterativo los procesa sin crecimiento de pila. El bucle de evaluacion no asigna memoria; la construccion de marcos puede asignar.\n\n### Return y Map\n\n```go\nc := kont.ExprReturn(42)\nc = kont.ExprMap(c, func(x int) int { return x * 2 })\nresult := kont.RunPure(c) // 84\n```\n\n### Bind (Encadenamiento Monadico)\n\n```go\nc := kont.ExprReturn(10)\nc = kont.ExprBind(c, func(x int) kont.Expr[string] {\n    return kont.ExprReturn(fmt.Sprintf(\"value=%d\", x))\n})\nresult := kont.RunPure(c) // \"value=10\"\n```\n\n### Pipeline Multi-Etapa\n\n```go\nc := kont.ExprReturn(1)\nc = kont.ExprBind(c, func(x int) kont.Expr[int] {\n    return kont.ExprReturn(x + 1)\n})\nc = kont.ExprMap(c, func(x int) int { return x * 3 })\nc = kont.ExprBind(c, func(x int) kont.Expr[int] {\n    return kont.ExprMap(kont.ExprReturn(x), func(y int) int { return y + 10 })\n})\nresult := kont.RunPure(c) // ((1+1)*3)+10 = 16\n```\n\n### Then (Secuenciacion con Descarte)\n\n```go\nfirst := kont.ExprReturn(\"ignored\")\nsecond := kont.ExprReturn(42)\nc := kont.ExprThen(first, second)\nresult := kont.RunPure(c) // 42\n```\n\n### Efectos Expr\n\nLas computaciones Expr soportan los mismos efectos estandar via `HandleExpr` y ejecutores dedicados. Componer `ExprBind`/`ExprThen`/`ExprMap` con `ExprPerform` directamente:\n\n```go\n// s := Get; Put(s+10); Get\ncomp := kont.ExprBind(kont.ExprPerform(kont.Get[int]{}), func(s int) kont.Expr[int] {\n    return kont.ExprThen(kont.ExprPerform(kont.Put[int]{Value: s + 10}),\n        kont.ExprPerform(kont.Get[int]{}))\n})\nresult, state := kont.RunStateExpr[int, int](0, comp)\n```\n\n```go\n// Reader\ncomp := kont.ExprBind(kont.ExprPerform(kont.Ask[string]{}), func(env string) kont.Expr[string] {\n    return kont.ExprReturn(env)\n})\nresult := kont.RunReaderExpr[string, string](\"hello\", comp)\n```\n\n```go\n// Writer\ncomp := kont.ExprThen(kont.ExprPerform(kont.Tell[string]{Value: \"log\"}),\n    kont.ExprReturn(42))\nresult, logs := kont.RunWriterExpr[string, int](comp)\n```\n\n```go\n// Error\nresult := kont.RunErrorExpr[string, int](kont.ExprThrowError[string, int](\"fail\"))\n// result.IsLeft() == true\n```\n\n### Construccion Directa de Marcos\n\nUso avanzado: construir y evaluar cadenas de marcos directamente:\n\n```go\nexpr := kont.Expr[int]{\n    Value: 5,\n    Frame: \u0026kont.MapFrame[kont.Erased, kont.Erased]{\n        F:    func(v kont.Erased) kont.Erased { return v.(int) * 10 },\n        Next: kont.ReturnFrame{},\n    },\n}\nresult := kont.RunPure(expr) // 50\n```\n\n## Puente: Reify / Reflect\n\nConvierte entre las dos representaciones en tiempo de ejecucion (Filinski 1994).\n\n```go\n// Cont → Expr (los closures se convierten en marcos)\ncont := kont.GetState(func(s int) kont.Eff[int] {\n    return kont.Pure(s * 2)\n})\nexpr := kont.Reify(cont)\nresult, state := kont.RunStateExpr[int, int](5, expr)\n\n// Expr → Cont (los marcos se convierten en closures)\nexpr := kont.ExprBind(kont.ExprPerform(kont.Get[int]{}), func(s int) kont.Expr[int] {\n    return kont.ExprReturn(s * 2)\n})\ncont := kont.Reflect(expr)\nresult, state := kont.RunState[int, int](5, cont)\n```\n\nLa conversion ida y vuelta preserva la semantica: `Reify ∘ Reflect ≡ id` y `Reflect ∘ Reify ≡ id`.\n\n## Referencias\n\n- Eugenio Moggi. \"Computational Lambda-Calculus and Monads.\" In *LICS 1989*, pp. 14-23. https://doi.org/10.1109/LICS.1989.39155\n- Olivier Danvy and Andrzej Filinski. \"Abstracting Control.\" In *LISP and Functional Programming 1990*, pp. 151-160. https://doi.org/10.1145/91556.91622\n- Andrzej Filinski. \"Representing Monads.\" In *POPL 1994*, pp. 446-457. https://doi.org/10.1145/174675.178047\n- Gordon D. Plotkin and Matija Pretnar. \"Handlers of Algebraic Effects.\" In *ESOP 2009*, pp. 80-94. https://doi.org/10.1007/978-3-642-00590-9_7\n- David Walker and Kevin Watkins. \"On Regions and Linear Types (Extended Abstract).\" In *ICFP 2001*, pp. 181-192. https://doi.org/10.1145/507635.507658\n- John C. Reynolds. \"Definitional Interpreters for Higher-Order Programming Languages.\" In *ACM '72*, pp. 717-740. https://doi.org/10.1145/800194.805852\n\n## Licencia\n\nLicencia MIT. Ver [LICENSE](LICENSE) para detalles.\n\n©2026 [Hayabusa Cloud Co., Ltd.](https://code.hybscloud.com)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhayabusa-cloud%2Fkont","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fhayabusa-cloud%2Fkont","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhayabusa-cloud%2Fkont/lists"}