Generics & Parametric Polymorphism

Understands the fundamentals of Generics & Parametric Polymorphism at a basic level. Applies simple concepts in work tasks using Scala 3. Follows recommendations from senior developers when solving problems.

Knows basic generics and parametric polymorphism concepts for compiler engineering and can apply them in common tasks. Uses standard tools and follows established team practices. Understands when and why this approach is used.

Knows generics in C#: List<T>, Dictionary<TK,TV>, Func<T,TResult>. Creates simple generic classes and methods. Understands type constraints (where T : class, new()).

Knows C++ template basics in the Qt context. Uses template containers (QList<T>, QHash<K,V>). Understands template instantiation and basic SFINAE.

Understands the fundamentals of Generics & Parametric Polymorphism at a basic level. Applies simple concepts in work tasks using TypeScript/Rust. Follows recommendations from senior developers when solving problems.

Understands the fundamentals of Generics & Parametric Polymorphism at a basic level. Applies simple concepts in work tasks using C/C++/Rust. Follows recommendations from senior developers when solving problems.

Applies Scala's advanced type parameter system: upper/lower type bounds ([A <: B], [A >: B]), variance annotations (covariant +A, contravariant -A). Implements type classes via implicit parameters and context bounds ([T: Ordering]). Uses existential types and type members for abstraction, understands type inference limitations in complex generic chains.

Confidently applies generics and parametric polymorphism for compiler engineering in non-standard tasks. Independently selects optimal approach and tools. Analyzes trade-offs and suggests improvements to existing solutions.

Creates generic service layer with repository, specification patterns. Uses covariance/contravariance (in/out). Applies generic constraints for complex hierarchies. Understands generic type inference.

Creates template utilities for Qt: type-safe property wrappers, generic serializers. Applies variadic templates and fold expressions. Uses SFINAE/if constexpr for conditional compilation.

Implements generic type resolution in language tooling: builds type parameter substitution maps during type checking, handles generic method inference and constraint solving. Understands generic instantiation strategies (monomorphization vs type erasure) and their impact on tooling — code completion, refactoring, and type display in IDE features.

Applies generics in systems-level code with focus on zero-cost abstractions: writes generic data structures with const generics for compile-time sizes, uses trait bounds to enforce memory layout guarantees (Copy, Sized, Unpin). Understands how generic monomorphization affects instruction cache and binary size in performance-critical paths. Applies generics to implement type-safe wrappers over unsafe FFI interfaces.

Architects type-level computations in Scala: implements higher-kinded types (F[_]) for tagless final and free monad patterns. Designs generic type class hierarchies (Functor, Monad, Traverse) with lawful instances and automatic derivation. Applies path-dependent types and type projections for advanced generic abstractions, uses match types (Scala 3) and type lambdas for compile-time type transformations. Mentors team on variance rules and type inference debugging.

Expertly applies generics and parametric polymorphism for compiler engineering in designing complex systems. Optimizes existing solutions and prevents architectural mistakes. Conducts code reviews and trains colleagues on best practices.

Designs generic frameworks with Source Generators. Uses static abstract members in interfaces (C# 11+). Implements generic math through INumber<T>. Applies generic host for modular architecture.

Applies C++20 concepts for constraining template parameters. Designs policy-based design for Qt components. Uses template metaprogramming for compile-time validation.

Designs cross-language generic type system tooling: implements constraint solvers for generic type inference (Hindley-Milner extensions, local type inference), builds incremental type checkers that efficiently handle generic instantiation caching. Architects IDE features for generic code — smart completion with type parameter inference, generic refactoring (extract type parameter, inline type alias), and diagnostic messages that clearly explain constraint violation chains in complex generic contexts.

Architects generic abstractions for systems infrastructure: designs generic allocator interfaces and type-parameterized memory pools with compile-time size validation via const generics. Implements generic lock-free data structures with correct Send/Sync bounds, applies generic specialization patterns for SIMD-optimized code paths. Evaluates monomorphization costs in large-scale systems — manages binary bloat through strategic use of trait objects, type-erased wrappers, and generic function outlining techniques.

Defines Generics and Parametric Polymorphism usage standards at team/product level. Conducts architectural reviews. Creates best practices and training materials for the entire team.

Establishes generics and parametric polymorphism standards for the compiler engineering team and makes architectural decisions. Defines technical roadmap considering this skill. Mentors senior engineers and influences practices of adjacent teams.

Defines generics usage standards in .NET projects. Conducts review of generic API design. Controls generic code complexity.

Defines template usage standards in Qt projects. Reviews template code, controls compile-time complexity. Establishes guidelines for template code readability.

Defines standards for applying Generics and Parametric Polymorphism at the team/product level. Conducts architectural reviews. Establishes best practices and training materials for the entire team.

Defines Generics and Parametric Polymorphism standards at team/product level. Conducts architectural reviews. Establishes best practices and training materials for the team.

Defines organization-wide generic programming standards in Scala: establishes type class encoding conventions (Scala 2 implicits vs Scala 3 given/using), designs generic effect system abstractions (Cats Effect, ZIO) with principled type parameter hierarchies. Drives adoption of compile-time type-level programming (singleton types, type-level natural numbers, compile-time proofs) for domain invariant enforcement. Evaluates and shapes Scala language evolution proposals related to type system expressiveness — opaque types, match types, polymorphic function types.

Shapes generics and parametric polymorphism strategy for compiler engineering at the organizational level. Defines best practices and influences technology choices beyond their own team. Is a recognized expert in this area.

Shapes enterprise generics standards for .NET. Evaluates new generic features (roles, shapes). Defines balance between generics and concrete types.

Shapes enterprise template programming standards for C++/Qt. Evaluates reflection proposals for future C++ standards. Defines the balance between generics and runtime polymorphism.

Defines the strategy for applying Generics and Parametric Polymorphism at the organizational level. Makes decisions on approaches and tools. Mentors lead developers and shapes technical vision.

Defines generic programming strategy across systems codebases: establishes guidelines for monomorphization budget and binary size targets, designs generic abstraction layers that unify platform-specific implementations (OS, architecture) under type-safe generic interfaces. Drives adoption of const generics and type-level programming for compile-time correctness proofs in safety-critical systems. Evaluates language-level generics features (Rust RFC process, C++ concepts vs Rust traits) and shapes team's generic design patterns to balance abstraction power, compile time, and runtime performance across million-line codebases.