{"id":50374947,"url":"https://github.com/hayabusa-cloud/cove","last_synced_at":"2026-05-30T09:02:16.923Z","repository":{"id":352570745,"uuid":"1175267392","full_name":"hayabusa-cloud/cove","owner":"hayabusa-cloud","description":"Coalgebraic context layer for kont suspensions in Go","archived":false,"fork":false,"pushed_at":"2026-04-29T13:51:42.000Z","size":238,"stargazers_count":2,"open_issues_count":0,"forks_count":0,"subscribers_count":0,"default_branch":"main","last_synced_at":"2026-04-29T15:10:01.472Z","etag":null,"topics":["coeffects","comonads","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-03-07T13:27:09.000Z","updated_at":"2026-04-29T14:36:24.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/hayabusa-cloud/cove","commit_stats":null,"previous_names":["hayabusa-cloud/cove"],"tags_count":2,"template":false,"template_full_name":null,"purl":"pkg:github/hayabusa-cloud/cove","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hayabusa-cloud%2Fcove","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hayabusa-cloud%2Fcove/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hayabusa-cloud%2Fcove/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hayabusa-cloud%2Fcove/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/hayabusa-cloud","download_url":"https://codeload.github.com/hayabusa-cloud/cove/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hayabusa-cloud%2Fcove/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33686018,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-05-30T02:00:06.278Z","response_time":92,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"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":["coeffects","comonads","golang"],"created_at":"2026-05-30T09:02:14.109Z","updated_at":"2026-05-30T09:02:16.914Z","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/cove.svg)](https://pkg.go.dev/code.hybscloud.com/cove)\n[![Go Report Card](https://goreportcard.com/badge/github.com/hayabusa-cloud/cove)](https://goreportcard.com/report/github.com/hayabusa-cloud/cove)\n[![Coverage Status](https://codecov.io/gh/hayabusa-cloud/cove/graph/badge.svg)](https://codecov.io/gh/hayabusa-cloud/cove)\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# cove\n\nCapa de contexto para transportar contexto ambiental explícito a través de fronteras de suspensión\nde [kont](https://code.hybscloud.com/kont) en Go.\n\n## Descripción general\n\nCuando un runtime externo, como un proactor, un bucle de eventos o un dispatcher, procesa suspensiones de kont una a\nuna, cada operación suspendida puede necesitar estado que no forma parte de la operación en sí: presupuesto de dispatch,\ncapacidades del anillo, fase del protocolo, validez del grupo de buffers. Sin portadores de contexto explícitos, ese\nestado acaba en mapas auxiliares ad hoc o globales implícitos que rompen la composición.\n\ncove empareja el contexto ambiental con los valores y las suspensiones para que el contexto atraviese las fronteras de\nstepping asíncrono como datos tipados y componibles.\n\n```go\n_, sv := cove.StepExprWith(Runtime{Budget: 8}, computation)\nfor sv.Suspension != nil {\n    result := dispatch(sv.Ask(), sv.Op())\n    _, sv = sv.ResumeWith(result, func(r Runtime) Runtime {\n        r.Budget--\n        return r\n    })\n}\n```\n\nEl paquete es libre de políticas: transporta y verifica el contexto, pero nunca planifica, reintenta ni despacha.\n\n## Instalación\n\n```bash\ngo get code.hybscloud.com/cove\n```\n\nRequiere Go 1.26+.\n\n## Tipos principales\n\n| Tipo                                                | Propósito                                                                      |\n|-----------------------------------------------------|--------------------------------------------------------------------------------|\n| `View[C, A]`                                        | Portador comonádico: valor A bajo contexto ambiental C                         |\n| `SuspensionView[C, A]`                              | Suspensión kont emparejada con contexto ambiental                              |\n| `World`                                             | Lectura Kripke de un tipo de contexto ambiental                                |\n| `StepIndex`                                         | Nivel finito de aproximación para observación step-indexed                     |\n| `Preorder[C]`                                       | Relación de extensión de mundos Kripke `w \u003c= w'` con chequeos locales de leyes |\n| `Transition[C]`                                     | Arista candidata concreta entre dos mundos Kripke                              |\n| `Forcing[C]` / `ForcingExpr[C]`                     | Requisito con preorden de mundos y comprobaciones de monotonía                 |\n| `Relation[C, A]`                                    | Relación Kripke step-indexed sobre mundo, índice y valor                       |\n| `IndexedView[C, A]` / `IndexedSuspensionView[C, A]` | Observaciones contextuales con crédito de pasos explícito                      |\n| `Req[C]`                                            | Predicado contravariante sobre C (forma clausura): `func(C) bool`              |\n| `ReqExpr[C]`                                        | Predicado contravariante sobre C (forma desfuncionalizada)                     |\n| `Rule[C]` / `RuleExpr[C]`                           | Predicado nombrado con `Report` de diagnóstico                                 |\n| `Checked[C, A]` / `CheckedExpr[C, A]`               | Valor controlado por un requisito                                              |\n| `Guarded[C, A]` / `GuardedExpr[C, A]`               | Valor controlado por una regla nombrada                                        |\n\n`Ambient` restringe parámetros de tipo de contexto (C, D). `World` da a la misma restricción estructural el vocabulario\nKripke, y `Focus` restringe parámetros de tipo de valor (A, B).\n\n## Stepping contextual\n\n`StepWith` y `StepExprWith` evalúan una computación kont y emparejan su primera suspensión con el contexto ambiental.\nCada suspensión es afín: se consume exactamente una vez, mediante `Resume`, `ResumeWith` o `Discard`.\n\n```go\nval, sv := cove.StepExprWith(ctx, expr)\nfor sv.Suspension != nil {\n    op := sv.Op()\n    result := handle(op)\n    val, sv = sv.Resume(result)\n}\n```\n\n`ResumeWith` hace evolucionar el contexto transportado entre pasos. Por ejemplo, puede descontar presupuesto, actualizar\ncapacidades o avanzar la fase del protocolo:\n\n```go\nval, sv = sv.ResumeWith(result, func(r Runtime) Runtime {\n    r.Budget--\n    return r\n})\n```\n\n`MapContextSuspension` y `WithContextSuspension` transportan o sustituyen explícitamente el contexto llevado por una\nsuspensión ya observada, sin alterar la frontera de suspensión actual:\n\n```go\nsv = cove.MapContextSuspension(sv, func(r Runtime) Runtime {\n    r.Budget += 4\n    return r\n})\nsv = cove.WithContextSuspension(sv, Runtime{Budget: 16})\n```\n\nUna vez completada la computación, `sv.Suspension` pasa a ser nil, pero `sv.Ask()` sigue devolviendo el contexto\ntransportado.\n\ncove reenvía el clasificador de stepping de kont, por lo que `Step`, `StepExpr`, `StepWith`, `StepExprWith`, `Resume` y\n`ResumeWith` heredan la convención de finalización con nil de kont: la finalización se observa mediante una suspensión\nnil, en cuyo caso el valor final sigue la convención de kont (un valor nil denota el valor cero de `A`). Por tanto,\nlas computaciones cuyo tipo de resultado sea un tipo que admita nil (puntero, interfaz, mapa, slice, canal o función)\nno pueden usar nil como valor final significativo; envuelve nil en un tipo suma o testigo explícito cuando esa\ndistinción sea relevante. El contexto del portador no se ve afectado.\n\n`ObserveSuspension` adjunta contexto ambiental a una `kont.Suspension` existente sin realizar ninguna comprobación de\nrequisitos. `CheckSuspension` y `CheckSuspensionExpr` proporcionan las variantes condicionadas:\n\n```go\nsv, ok := cove.CheckSuspension(runtime, susp, func(r Runtime) bool {\n    return r.Budget \u003e 0\n})\nif !ok {\n    susp.Discard()\n    return\n}\nresult := dispatch(sv.Ask(), sv.Op())\nval, sv = sv.Resume(result)\n```\n\n```go\nexprReq := cove.ExprAtom(func(r Runtime) bool { return r.Budget \u003e 0 })\nsv, ok := cove.CheckSuspensionExpr(runtime, susp, exprReq)\nif !ok {\n    susp.Discard()\n    return\n}\nresult := dispatch(sv.Ask(), sv.Op())\nval, sv = sv.Resume(result)\n```\n\n`Step` y `StepExpr` reexportan los evaluadores de kont sin vincular contexto.\n\n## Evidencia Kripke step-indexed\n\n`cove` puede hacer explícita la lectura Kripke sin convertir el contexto en política de scheduling. `Preorder[C]` define\nla extensión de mundos y expone chequeos locales `Extends`, `ReflexiveAt` y `TransitiveAt`; `Transition[C]`,\n`CheckTransition`, `CheckForcingTransition` y `CheckInvariantTransition` comprueban aristas concretas; `Forcing`\nempareja un requisito con ese preorden, y `Relation` indexa la validez semántica por mundo, `StepIndex` finito y valor.\n\nUse `DiscreteWorlds` para mundos relacionados solo por igualdad y `TotalWorlds` para un preorden que relaciona todo par\nde mundos. `ForceExpr` refleja `Force` para `ReqExpr`; `CheckRelation`, `WeakenIndexedView` y `WeakenIndexedSuspension`\nhacen explícitos los chequeos de relación y el debilitamiento del crédito de pasos.\n\n```go\ntype RuntimeWorld struct {\n    Epoch uint64\n}\n\nleq := func(w, next RuntimeWorld) bool {\n    return w.Epoch \u003c= next.Epoch\n}\n_ = cove.Preorder[RuntimeWorld](leq).ReflexiveAt(RuntimeWorld{Epoch: 1})\n_ = cove.Preorder[RuntimeWorld](leq).TransitiveAt(RuntimeWorld{Epoch: 1}, RuntimeWorld{Epoch: 2}, RuntimeWorld{Epoch: 3})\n\ncanObserve := cove.Force(leq, func(w RuntimeWorld) bool {\n    return w.Epoch \u003e 0\n})\n_ = canObserve.MonotoneAt(RuntimeWorld{Epoch: 1}, RuntimeWorld{Epoch: 2})\n\nrel := cove.Relate(leq, func(w RuntimeWorld, n cove.StepIndex, value int) bool {\n    return uint64(n) \u003c= w.Epoch \u0026\u0026 value \u003e= 0\n})\nlater := cove.Later(rel)\n_ = later.Holds(RuntimeWorld{Epoch: 8}, 3, 4)\n```\n\nPara prefijos operacionales, `StepWithIndex` y `StepExprWithIndex` emparejan un `SuspensionView` con fuel explícito.\nCada `Resume` indexado consume una unidad de crédito de paso, haciendo visible el descenso de las observaciones finitas.\nUse `ResumeTo` cuando el contexto sucesor deba verificarse como extensión de mundo Kripke; `CheckCompletedRelation`\ncomprueba la relación final en una frontera indexada completada:\n\n```go\n_, sv := cove.StepExprWithIndex(RuntimeWorld{Epoch: 2}, 2, expr)\nvar val int\nfor sv.Extract() != nil {\n    result := dispatch(sv.Ask(), sv.Op())\n    next := sv.Ask()\n    next.Epoch++\n    val, sv = sv.ResumeTo(leq, result, next)\n}\n_ = cove.CheckCompletedRelation(sv, val, rel)\n```\n\n## Comandos\n\n`Cmd[C, A, B]` es un comando contextual `View[C, A] -\u003e B`. `Run` aplica un comando a un `View` concreto; `ExtractCmd` es\nel comando identidad; `LiftCmd` eleva al mundo contextual una transformación centrada solo en el valor enfocado;\n`Compose` compone comandos mediante `Extend`.\n\n```go\ncmd := cove.Compose(\n    func(v cove.View[Runtime, int]) string {\n        return fmt.Sprintf(\"budget=%d value=%d\", v.Ask().Budget, v.Extract())\n    },\n    cove.LiftCmd(func(n int) int { return n + 1 }),\n)\nout := cove.Run(cove.Observe(Runtime{Budget: 8}, 41), cmd)\n_ = out // \"budget=8 value=42\"\n```\n\n## Requisitos\n\nLos requisitos son predicados sobre el contexto ambiental, disponibles tanto en forma clausura como en forma datos.\nAmbas formas admiten `All`, `Any` y `Not`, con `True` y `False` como elementos neutros de la conjunción y la disyunción.\n\n**Forma clausura** (`Req`): directa y concisa.\n\n```go\nreq := cove.All(\n    cove.Req[Runtime](func(r Runtime) bool { return r.Budget \u003e 0 }),\n    cove.Req[Runtime](func(r Runtime) bool { return r.CanDispatch }),\n)\nok := cove.Need(runtime, req)\n```\n\n**Forma datos** (`ReqExpr`): estructura booleana componible que evita la asignación de clausuras durante la composición.\n\n```go\nexpr := cove.ExprAll(\n    cove.ExprAtom(func(r Runtime) bool { return r.Budget \u003e 0 }),\n    cove.ExprAtom(func(r Runtime) bool { return r.CanDispatch }),\n)\nok := cove.NeedExpr(runtime, expr)\n```\n\nCombinadores: `All`/`ExprAll` (conjunción ∧), `Any`/`ExprAny` (disyunción ∨), `Not`/`ExprNot` (negación ¬), `True`/`ExprTrue` (⊤), `False`/`ExprFalse` (⊥).\n\n`Pullback` y `ExprPullback` transportan requisitos de forma contravariante a lo largo de una proyección de contexto.\nDada `f: C → D`, `Pullback(req, f)` lleva `Req[D]` a `Req[C]`. `ExprPullback` preserva la estructura booleana y se\ndistribuye sobre `ExprNot`, `ExprAll` y `ExprAny`.\n\n### Elegir entre Req y ReqExpr\n\nUse `Req` para predicados puntuales y ad hoc. Use `ReqExpr` cuando componga muchos requisitos, o cuando importe la\nasignación de clausuras en tiempo de construcción.\n\nLos helpers de puente mantienen alineadas ambas formas: `ReifyReq` envuelve un requisito en forma clausura como un\n`ExprAtom`, por lo que `ReifyReq(nil)` es inválido y entra en pánico al evaluarse; `ReflectReq` evalúa un requisito en\nforma Expr a través de una clausura.\n\n## Valores controlados\n\n`Guard` empareja un valor con un requisito; `IntoView` devuelve un `View` sólo cuando el contexto ambiental satisface\ndicho requisito:\n\n```go\nchecked := cove.Guard(canDispatch, payload)\nif view, ok := checked.IntoView(runtime); ok {\n    _ = view.Extract()\n}\n```\n\n`GuardRule` añade diagnósticos mediante reglas nombradas y `Report`:\n\n```go\nrule := cove.Require(\"budget\", func(r Runtime) bool { return r.Budget \u003e 0 })\nguarded := cove.GuardRule(rule, payload)\nif view, report := guarded.IntoView(runtime); report.OK() {\n    _ = view.Extract()\n}\n```\n\n`CheckRules` y `CheckRulesExpr` evalúan varias reglas en orden, deteniéndose en el primer fallo:\n\n```go\nreport := cove.CheckRules(runtime, budgetRule, permRule)\nif !report.OK() {\n    // report.Failed nombra la primera regla que no se cumplió\n}\n```\n\nLa ruta de diagnóstico de la forma Expr tiene la misma forma a través de `CheckRulesExpr` y `GuardRuleExpr`:\n\n```go\ntype Runtime struct{ Budget int }\n\nruntime := Runtime{Budget: 1}\npayload := \"packet\"\nexprRule := cove.RequireExpr(\"budget\", cove.ExprAtom(func(r Runtime) bool {\n    return r.Budget \u003e 0\n}))\nreport := cove.CheckRulesExpr(runtime, exprRule)\nif !report.OK() {\n    return\n}\nguardedExpr := cove.GuardRuleExpr(exprRule, payload)\nif view, report := guardedExpr.IntoView(runtime); report.OK() {\n    _ = view.Extract()\n}\n```\n\nEquivalentes en forma Expr: `GuardExpr`, `GuardRuleExpr`, `CheckedExpr`, `GuardedExpr`. Helpers de map y pullback:\n`MapChecked`, `MapGuarded`, `PullbackChecked`, `PullbackGuarded` (y sus variantes Expr).\n\n## Operaciones de View\n\n`View[C, A]` es una comónada sobre la categoría de tipos Go. El portador es el producto C × A; `Extract` (ε) proyecta el valor; `Duplicate` (δ) incrusta la observación como valor enfocado:\n\n```go\nv := cove.Observe(ctx, value)\nv.Ask()       // contexto ambiental (π₁)\nv.Extract()   // valor enfocado (ε = π₂)\n```\n\nTransformaciones: `Map` (elevación funtorial sobre `A`), `MapContext` (elevación funtorial sobre `C`), `Replace` (\nsustituir el valor), `WithContext` (sustituir el contexto).\n\n`Duplicate` y `Extend` satisfacen las leyes comonádicas:\n\n```go\n// Ley de counidad: ε ∘ δ = id\ncove.Duplicate(v).Extract() == v\n\n// Identidad de extensión: extend(ε) = id\ncove.Extend(v, func(w cove.View[C, A]) A { return w.Extract() }) == v\n\n// Asociatividad: extend(f) ∘ extend(g) = extend(f ∘ extend(g))\n```\n\n`Extend` es el operador de extensión contextual: dado `f: W(C, A) → B`, eleva `f` a `W(C, A) → W(C, B)` preservando el\ncontexto ambiental. La composición de comandos inducida con `g: W(C, B) → D` es `g ∘ Extend(f)`.\n\n## Posición en el ecosistema\n\n| Paquete    | Responsabilidad                                                 | Aspecto categórico                    |\n|------------|-----------------------------------------------------------------|---------------------------------------|\n| `kont`     | Operaciones de efectos, manejadores, suspensión y reanudación   | Álgebra / Mónada libre / Pliegue      |\n| **`cove`** | **Contexto ambiental a través de fronteras de suspensión**      | **Coálgebra / Comónada / Despliegue** |\n| `takt`     | Dispatch proactor, stepping y observación del runner            | Comodelo (dual del manejador)         |\n| `uring`    | I/O del kernel: SQE/CQE, gestión de anillos, anillos de buffers | —                                     |\n| `iox`      | Álgebra de resultados y semántica de errores                    | —                                     |\n\n## Estructura formal\n\n`View[C, A]` es una comónada de entorno (Uustalu \u0026 Vene 2008) con portador C × A, counidad ε = π₂ (Extract) y\ncomultiplicación δ(c, a) = (c, (c, a)) (Duplicate). `Extend` implementa la extensión contextual (extensión coKleisli en\nla literatura categórica).\n\n`Req[C]` y `ReqExpr[C]` son objetos en el álgebra booleana de predicados sobre C. `Pullback` implementa el funtor contravariante f* inducido por un morfismo f: C → D, mapeando predicados sobre D a predicados sobre C. `ExprPullback` preserva la estructura del álgebra booleana: f*(p ∧ q) = f*(p) ∧ f*(q), f*(¬p) = ¬f*(p).\n\nkont modela efectos algebraicos (mónada libre, manejadores, pliegue); cove modela coefectos (comónada, requisitos,\ndespliegue). Los dos son duales categóricos en la frontera de suspensión: kont describe qué le hace la computación al\nmundo, mientras que cove declara qué necesita la computación del mundo.\n\nLeído bajo la óptica de los efectos modales, la forma del portador puede leerse como el nombre de lo que ocurre con el\ncontexto ambiente: kont (C → D) lo reemplaza, cove (W(C, A) → B) lo maneja de forma relativa, y el paso puro lo\npreserva. La estructura de efectos viaja así sobre el portador, no sobre un «color» de función, lo que mantiene a cove\nlibre de políticas.\n\n`ReqExpr` desfuncionaliza el álgebra booleana en una unión etiquetada, es decir, el álgebra inicial del funtor de firma\nbooleana, de modo que la estructura de un requisito sea un dato inspeccionable en lugar de una clausura opaca (Reynolds\n1972).\n\n## Patrones prácticos\n\nUna computación contextual completa suele avanzar en tres etapas: declarar requisitos, condicionar valores sobre ellos\ny, por último, observar el resultado bajo un contexto concreto.\n\n```go\n// 1. Declarar un requisito sobre el contexto ambiente.\ntype Caps struct{ CanSubmit, HasToken bool }\nreq := cove.All(\n    func(c Caps) bool { return c.CanSubmit },\n    func(c Caps) bool { return c.HasToken },\n)\n\n// 2. Condicionar un valor con ese requisito. Esto produce un Checked[Caps, T].\nchecked := cove.Guard(req, payload)\n\n// 3. Reificarlo a un Expr para poder avanzar bajo distintos contextos ambientes.\nexpr := cove.ReifyReq(req)\nok   := cove.NeedExpr(Caps{CanSubmit: true, HasToken: true}, expr)\n_    = checked\n_    = ok\n```\n\n`Pullback` permite al llamador adaptar un requisito definido sobre un contexto para que opere sobre otro (\n`Pullback(req, f)` con `f: D → C`); `MapChecked` y `MapGuarded` transportan valores condicionados a través de\ntransformaciones a nivel de valor sin volver a comprobar el predicado. La combinación `All` + `Pullback` + `Guard` es la\nforma en que los paquetes río abajo construyen comprobaciones de capacidades tipadas sin acoplarse a un único tipo de\ncontexto.\n\n## Referencias\n\n- John C. Reynolds. 1972. Definitional Interpreters for Higher-Order Programming Languages. In *Proc. ACM Annual\n  Conference (ACM '72)*. 717–740. https://doi.org/10.1145/800194.805852\n- Tarmo Uustalu and Varmo Vene. 2008. Comonadic Notions of Computation. *Electronic Notes in Theoretical Computer\n  Science* 203, 5 (June 2008), 263–284. https://doi.org/10.1016/j.entcs.2008.05.029\n- Tomas Petricek, Dominic Orchard, and Alan Mycroft. 2014. Coeffects: A Calculus of Context-Dependent Computation. In\n  *Proc. 19th ACM SIGPLAN International Conference on Functional Programming (ICFP '14)*.\n  123–135. https://tomasp.net/academic/papers/structural/coeffects-icfp.pdf\n- Marco Gaboardi, Shin-ya Katsumata, Dominic Orchard, Flavien Breuvart, and Tarmo Uustalu. 2016. Combining Effects and\n  Coeffects via Grading. In *Proc. 21st ACM SIGPLAN International Conference on Functional Programming (ICFP '16)*.\n  476–489. https://doi.org/10.1145/2951913.2951939\n- Jonathan Immanuel Brachthäuser, Philipp Schuster, and Klaus Ostermann. 2020. Effects as Capabilities: Effect Handlers\n  and Lightweight Effect Polymorphism. *Proc. ACM on Programming Languages* 4, OOPSLA (Nov. 2020), Article 126, 30\n  pages. https://se.cs.uni-tuebingen.de/publications/brachthaeuser20effekt.pdf\n- Daniel Gratzer, G. A. Kavvos, Andreas Nuyts, and Lars Birkedal. 2021. Multimodal Dependent Type Theory. *Logical\n  Methods in Computer Science* 17, 3 (2021), Paper 11, 67 pages. https://doi.org/10.46298/lmcs-17(3:11)2021\n- Wenhao Tang, Leo White, Stephen Dolan, Daniel Hillerström, Sam Lindley, and Anton Lorenzen. 2025. Modal Effect Types.\n  *Proc. ACM Program. Lang.* 9, OOPSLA1 (Apr. 2025), Article 120, 1130–1157. https://arxiv.org/abs/2407.11816\n- Wenhao Tang and Sam Lindley. 2026. Rows and Capabilities as Modal Effects. *Proc. ACM Program. Lang.* 10, POPL (Jan.\n  2026), 923–950. https://arxiv.org/abs/2507.10301\n\n## Compatibilidad de plataforma\n\n`cove` es un paquete puro de Go en este módulo. No tiene archivos específicos de plataforma ni build tags; el requisito del módulo es Go 1.26+.\n\n## Licencia\n\nLicencia MIT. Consulte [LICENSE](LICENSE) para más 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%2Fcove","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fhayabusa-cloud%2Fcove","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhayabusa-cloud%2Fcove/lists"}