Skip to main content
effect-systems Expert skill for designing and implementing algebraic effect systems including effect annotation, inference, handlers, polymorphism, and row-based effect typing.
الانتقال إلى التثبيت سوق المهارات اكتشف واستكشف مهارات الذكاء الاصطناعي التي بناها المجتمع.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
عرض تفاصيل Prompt يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/a5c-ai/babysitter --skill effect-systemsيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
تحميل Zip جاري التحميل... المزيد من هذا المستودع Reference for querying the Atlas knowledge graph through its MCP tools — the SECONDARY enrichment/comparison layer that adds best-practice context to systems you have ALREADY scanned from your real sources (`az`, repos, dirs). Use when you need to look up nodes, edges, kinds, clusters, stats, or wiki pages in Atlas to compare against your real inventory. (atlas graph, query atlas, atlas mcp, search the graph, graph neighbors, atlas record, atlas kinds, enrichment layer)
Atlas turns your STATED NEED into a real systems atlas by SCANNING your actual sources (Azure via `az`, git repos, local dirs) and process/data mining them, THEN enriching against the Atlas knowledge graph. Use this skill when asked to inventory/map your real systems, scan your cloud + repos + directories, mine the real processes or data they contain, or collect their real constraints/gotchas. (atlas, scan my systems, inventory our azure account, map my repos, real systems atlas, process mining, data mining, collect nuances, system discovery)
assimilate-popular-workflows This skill should be used when the user asks to "find skills in the wild", "assimilate popular workflows", "discover SKILL.md files in repos", "research external skills", "find workflow patterns", "survey the skill landscape", "what skills exist out there", or wants to investigate public repositories for extractable processes, babysitter plugins, and reusable procedural insights. Searches GitHub for SKILL.md files, classifies repos by archetype, and maintains structured research under docs/reference-repos/.
المهن ذات الصلة SOC
استنادا إلى تصنيف SOC المهني
name effect-systems description Expert skill for designing and implementing algebraic effect systems including effect annotation, inference, handlers, polymorphism, and row-based effect typing. allowed-tools Read, Write, Edit, Bash, Glob, Grep graph {"domains":["domain:software-engineering"],"specializations":["specialization:programming-languages"],"skillAreas":["skill-area:language-design","skill-area:compiler-implementation"],"roles":["role:backend-engineer"]}
Effect Systems Skill
Design and implement algebraic effect systems for tracking and handling computational effects in programming languages.
Capabilities
Design effect annotation syntax
Implement effect inference algorithms
Implement effect checking and tracking
Design effect handlers (algebraic effects)
Handle effect polymorphism
Implement effect rows and extensibility
Design effect subtyping
Generate effect-based optimizations
Usage
Invoke this skill when you need to:
Add an effect system to a language
Implement algebraic effects and handlers
Track computational effects in types
Design effect polymorphism
Inputs
Parameter Type Required Description
effectModel string Yes Model (algebraic, monadic, capability)
inferenceStrategy string Yes Strategy (annotated, inferred, mixed)
features array No Features to implement
builtinEffects array No Built-in effects to include
Effect Model Options {
"effectModel" : "algebraic" ,
"effectModel" : "monadic" ,
"effectModel" : "capability"
}
Feature Options {
"features" : [
"effect-inference" ,
"effect-handlers" ,
"effect-polymorphism" ,
"effect-rows" ,
"effect-subtyping" ,
"effect-abstraction" ,
"resumption-control" ,
"multi-shot-continuations"
]
}
Output Structure effect-system/
├── syntax/
│ ├── effect-annotation.grammar # Effect annotation syntax
│ ├── effect-handler.grammar # Handler syntax
│ └── effect-operation.grammar # Operation syntax
├── typing/
│ ├── effect-types.ts # Effect type definitions
│ ├── effect-inference.ts # Effect inference
│ ├── effect-checking.ts # Effect checking
│ └── effect-rows.ts # Row polymorphism
├── handlers/
│ ├── handler-impl.ts # Handler implementation
│ ├── continuation.ts # Continuation management
│ └── resumption.ts # Resumption handling
├── runtime/
│ ├── effect-runtime.ts # Runtime effect support
│ └── builtin-effects.ts # Built-in effects
└── tests/
├── inference.test.ts
├── handlers.test.ts
└── polymorphism.test.ts
Effect System Types
Algebraic Effects (Koka-style)
effect State <S> {
get (): S
put (s : S): ()
}
effect Exception <E> {
raise (e : E): Nothing
}
type EffectType = {
operations : Map <string , OperationType >;
}
interface OperationType {
name : string ;
params : Type [];
result : Type ;
}
interface FunctionType {
params : Type [];
result : Type ;
effects : EffectRow ;
}
type EffectRow =
| { type : 'empty' }
| { type : 'single' ; effect : EffectType }
| { type : 'union' ; effects : EffectType [] }
| { type : 'variable' ; name : string }
| { type : 'extend' ; base : EffectRow ; effect : EffectType };
Effect Handlers
handle expr with {
return (x) -> returnClause (x),
get () -> getClause (resume),
put (s) -> putClause (s, resume)
}
interface Handler {
effect : EffectType ;
returnClause : (value : any any ;
operationClauses : Map <string , OperationClause >;
}
interface OperationClause {
operation : string ;
params : string [];
resumeName : string ;
body : Expr ;
}
function typeHandler (
expr : Expr ,
handler : Handler ,
env : TypeEnv
): { resultType : Type ; remainingEffects : EffectRow } {
const exprType = inferType (expr, env);
checkHandlerCovers (handler, exprType.effects );
const resultType = inferHandlerResult (handler, exprType.result , env);
const remainingEffects = removeEffect (exprType.effects , handler.effect );
return { resultType, remainingEffects };
}
Effect Inference
function inferEffects (expr : Expr , env : TypeEnv InferResult {
switch (expr.type ) {
case 'var' :
return { type : lookupType (env, expr.name ), effects : emptyRow () };
case 'lambda' :
const bodyResult = inferEffects (expr.body , extendEnv (env, expr.param , expr.paramType ));
return {
type : { type : 'function' , param : expr.paramType , result : bodyResult.type , effects : bodyResult.effects },
effects : emptyRow ()
};
case 'app' :
const fnResult = inferEffects (expr.fn , env);
const argResult = inferEffects (expr.arg , env);
const fnType = fnResult.type as FunctionType ;
return {
type : fnType.result ,
effects : unionRows (fnResult.effects , argResult.effects , fnType.effects )
};
case 'perform' :
const opType = lookupOperation (env, expr.effect , expr.operation );
const argEffects = expr.args .map (a =>inferEffects (a, env).effects );
return {
type : opType.result ,
effects : unionRows (singleRow (expr.effect ), ...argEffects)
};
case 'handle' :
const exprResult = inferEffects (expr.body , env);
const handlerResult = checkHandler (expr.handler , exprResult, env);
return handlerResult;
}
}
Effect Polymorphism
interface EffectPolymorphicType {
effectVars : string [];
typeVars : string [];
type : Type ;
}
type RowVariable = { type : 'rowVar' ; name : string };
function unifyRows (row1 : EffectRow , row2 : EffectRow Substitution {
if (row1.type === 'variable' ) {
return { [row1.name ]: row2 };
}
if (row2.type === 'variable' ) {
return { [row2.name ]: row1 };
}
if (row1.type === 'empty' && row2.type === 'empty' ) {
return {};
}
}
Continuation Management
interface Continuation <A, B> {
resume (value : A): B;
}
interface MultiShotContinuation <A, B> extends Continuation <A, B> {
clone (): MultiShotContinuation <A, B>;
}
interface OneShotContinuation <A, B> extends Continuation <A, B> {
readonly consumed : boolean ;
}
class ContinuationCapture {
capture<A, B>(
prompt : Prompt ,
body : (k : Continuation <A, B> B
): B {
const k = captureDelimited (prompt);
return body (k);
}
}
Built-in Effects
const builtinEffects = {
IO : {
operations : {
print : { params : [StringType ], result : UnitType },
readLine : { params : [], result : StringType },
readFile : { params : [StringType ], result : StringType },
writeFile : { params : [StringType , StringType ], result : UnitType }
}
},
State : {
typeParams : ['S' ],
operations : {
get : { params : [], result : TypeVar ('S' ) },
put : { params : [TypeVar ('S' )], result : UnitType }
}
},
Exception : {
typeParams : ['E' ],
operations : {
raise : { params : [TypeVar ('E' )], result : NothingType }
}
},
Async : {
operations : {
await : { params : [PromiseType (TypeVar ('A' ))], result : TypeVar ('A' ) },
spawn : { params : [FunctionType ([], TypeVar ('A' ), AsyncEffect )], result : TaskType (TypeVar ('A' )) }
}
},
NonDet : {
operations : {
choice : { params : [], result : BoolType },
fail : { params : [], result : NothingType }
}
}
};
Effect-Based Optimization
function canOptimize (fn : FunctionType OptimizationLevel {
if (isEmptyRow (fn.effects )) {
return 'pure' ;
}
if (onlyReads (fn.effects )) {
return 'read-only' ;
}
if (isLocalState (fn.effects )) {
return 'local-state' ;
}
return 'effectful' ;
}
function eliminateDeadCode (expr : Expr Expr {
const effects = inferEffects (expr);
if (isEmptyRow (effects) && !isUsed (expr)) {
return unit;
}
return expr;
}
Workflow
Design effect syntax - Declarations, annotations, handlersDefine effect types - Operations, rows, polymorphismImplement inference - Effect inference algorithmBuild effect checker - Verify effect annotationsImplement handlers - Handler evaluation/compilationAdd continuations - Delimited continuation supportCreate builtins - Common effects (IO, State, etc.)Generate tests - Inference, handlers, polymorphism
Best Practices Applied
Row polymorphism for flexible effect composition
Clear distinction between operations and handlers
Support both inferred and annotated effects
Efficient continuation representation
Effect-based optimization opportunities
Good error messages for effect mismatches
References
Target Processes
effect-system-design.js
type-system-implementation.js
concurrency-primitives.js
