pl-skills

Implement abstract machines for defining and executing operational semantics of programming languages.

Implements alias and points-to analysis for pointer programs. Use for: (1) Optimizing compilers, (2) Verifying memory safety, (3) Program understanding, (4) Parallelization.

Define program meaning through logical assertions and proof rules (Hoare logic).

Transforms closures to explicit environments. Use when: (1) Implementing functional languages, (2) Building compilers, (3) Understanding closures.

Implements common subexpression elimination (CSE). Use when: (1) Building compilers, (2) Optimizing code, (3) Program analysis.

Implements general dataflow analysis framework. Use when: (1) Building compilers, (2) Static analysis tools, (3) Program verification.

Builds denotational semantic models. Use when: (1) Formalizing language semantics, (2) Proving program properties, (3) Semantic analysis.

Implements algebraic effect types. Use when: (1) Handling side effects, (2) Extensible effects, (3) Effect inference.

Determine if objects escape their defining scope to enable stack allocation and optimization.

Implements untyped and simply-typed lambda calculus interpreters. Use when: (1) Learning foundations of PL, (2) Implementing functional language features, (3) Studying evaluation strategies.

Implement lock-free and wait-free data structures for high-concurrency systems.

Implement memory allocators for efficient dynamic memory management in language runtimes.

Defines operational semantics for programming languages. Use when: (1) Designing a new language, (2) Proving properties about language semantics, (3) Implementing interpreters.

Implements ownership and borrowing type system (Rust-style). Use when: (1) Verifying memory safety, (2) Data race prevention, (3) Lifetime analysis.

Generates LALR(1) and recursive-descent parsers from grammar specifications. Use when: (1) Building compilers, (2) Creating DSLs, (3) Parsing configuration files.

Analyze the shape of heap data structures to enable precise reasoning about pointer-rich data.

Implements software transactional memory. Use when: (1) Building concurrent data structures, (2) Simplifying lock-free code, (3) Composing atomic operations.

Constructs Static Single Assignment form. Use when: (1) Building optimizing compilers, (2) Implementing program analysis, (3) Verification.

Implements taint analysis for security. Use when: (1) Detecting security vulnerabilities, (2) Input validation, (3) Information flow.

Implements abstract interpretation for static analysis. Use when: (1) Building static analyzers, (2) Program verification, (3) Static analysis.

Implements actor model for concurrent computation. Use when: (1) Building concurrent systems, (2) Distributed programming, (3) Fault-tolerant systems.

Implements algebraic effects and effect handlers for computational effects in typed languages.

A bidirectional type checking expert specializing in bidirectional algorithms that combine type inference and type checking.

Checks bisimulation for process calculi. Use when: (1) Proving equivalence, (2) Compiler optimization, (3) Protocol verification.

Verify concurrent and parallel programs for data races, deadlocks, and correctness.

Implements constant propagation optimization. Use when: (1) Building compilers, (2) Learning program analysis, (3) Implementing optimizations.

A skill for proving contextual equivalence between programs using operational semantics, bisimulation, and related techniques.

Assists with Coq proof development. Use when: (1) Proving program correctness, (2) Formalizing mathematics, (3) Verified compilation.

Implements CPS (Continuation-Passing Style) transformation. Use when: (1) Building compilers, (2) Implementing control operators, (3) Adding delimited continuations.

Use Dafny verification language for constructing verified programs with proofs.

Eliminate unreachable and unused code to reduce program size and improve performance.

Implements defunctionalization to transform higher-order programs to first-order. Use when: (1) Building compilers, (2) Optimizing closures, (3) Serializing functions.

Implements dependently typed lambda calculus (Pi types). Use when: (1) Building proof assistants, (2) Formalizing mathematics, (3) Verified programming.

Implement effect systems to track and control side effects in programs.

Implement Generalized Algebraic Data Types (GADTs) for expressive type-safe data structures.

Implements tracing garbage collectors. Use when: (1) Building language runtimes, (2) Learning memory management, (3) Optimizing memory allocation.

Implements Higher-Order Abstract Syntax (HOAS) for binder representation. Use when: (1) Building languages with binders, (2) Implementing proof assistants, (3) Formal metatheory development.

Verifies programs using Hoare logic. Use when: (1) Proving program correctness, (2) Designing verified software, (3) Verifying loop invariants.

An incremental computation expert specializing in algorithms and systems that efficiently update computations when inputs change.

Implement function inlining to eliminate call overhead and enable further optimizations.