Idea: equivalent of type-safe pattern matching / type-guards

[Krever]

It would be nice if we could somehow imitate scala pattern matching. Input expression would have to stop being Booleans but would have to start being Option[T] so they can for example detect a subtype. Then such a subtype would have to become available to output.

This is just an idea, I dont know yet how the API for this could look like.

[Krever]

Here is an (obviously AI-assisted) exploration fo API design.

Pattern Matching / Type Guards API Summary

Core Idea

Replace UnaryTest[T]: T => Boolean with Extractor[T, R]: T => Option[R] where extracted value R becomes available to output expressions.

Key Types

// Value-level extraction
trait Extractor[-In, +Out] extends Expr[In => Option[Out]]

object Extractor {
  def catchAll[T]: Extractor[T, T]                          // identity
  def isA[In, Out <: In]: Extractor[In, Out]                // type test
  def collect[In, Out](pf: PartialFunction[In, Out]): ...   // pattern match
}

// Type-level extraction function (Scala 3 match type)
type MyExtraction[T] = T match
  case Animal => Dog
  case t => t

// Context provides extracted values
trait ExtractionContext[Input[_[_]], Extraction[_]] {
  def wholeInput: Input[Expr]
  def extracted: Input[[T] =>> Expr[Extraction[T]]]
}

// Rule with extraction
class ExtractingRule[Input[_[_]], Extraction[_], Output[_[_]]](
  matching: ExtractionContext[Input, Extraction] ?=> Input[[T] =>> Extractor[T, Extraction[T]]],
  output: ExtractionContext[Input, Extraction] ?=> Output[OutputValue]
)

Usage

case class Input[F[_]](animal: F[Animal], age: F[Int]) derives HKD
case class Output[F[_]](sound: F[String]) derives HKD

type DogExtraction[T] = T match
  case Animal => Dog
  case t => t

val rule = ExtractingRule[Input, DogExtraction, Output](
  matching = Input(
    animal = Extractor.isA[Animal, Dog],
    age = Extractor.catchAll
  ),
  output = Output(
    sound = extracted.animal.bark()  // Expr[Dog], not Expr[Animal]
  )
)

Multi-Rule Tables

Tables can mix extracting and non-extracting rules. Regular Rule is equivalent to ExtractingRule[Input, Id, Output] where type Id[T] = T.

// Common base type (existential extraction)
type AnyRule[Input[_[_]], Output[_[_]]] = ExtractingRule[Input, [t] =>> Any, Output]

// Regular Rule is just a type alias
type Rule[Input[_[_]], Output[_[_]]] = ExtractingRule[Input, Id, Output]

class DecisionTable[Input[_[_]], Output[_[_]], HP <: HitPolicy](
  rules: Seq[AnyRule[Input, Output]],  // mix of extracting and non-extracting
  ...
)

Trade-off: Output type safety is per-rule (checked when rule is defined), not table-wide.

Limitations

Concern	Status
Type safety	✅ Match type ensures Extractor output matches expected type
Multi-field extraction	✅ Each field can extract different types
HKD compatibility	⚠️ Needs validation with type lambdas [T] =>> F[Extraction[T]]
Ergonomics	⚠️ Requires defining match type per rule/rule-group
Match type reduction	⚠️ Won't reduce for abstract type parameters

Open Questions

1. Does existing HKD derivation work with type lambdas like [T] =>> Extractor[T, E[T]]?
2. How to render extraction expressions for DMN export?
3. Should ExtractingRule be a separate type or unified with Rule?