Using a specific type variant as a parameter type

[dandeduck]

Disclaimer

I'm pretty new to Gleam, so please let me know if I'm missing something, or if there is a better way to achieve what I'm doing.

Problem

I often run into situation where I have an entry function that receives a record with multiple variants, does pattern matching and calls the relevant function. So far, I had to deconstruct each variant and pass those properties to the function since Gleam doesn't adjust the type of a variable after it was pattern matched (which I get). Example:

type MyType {
  Var(num: Int, str: String, etc: List(Int))
  Text(str: String)
}

fn foo(a: MyType) -> Nil {
  case a {
    Var(num, str, etc) -> bar(num, str, etc)
    _ -> Nil
  }
}

fn bar(num: Int, str: String, etc: List(Int)) -> Nil {
  // Have to pass all properties individually, or do pattern matching again
}

This is a bit annoying, especially when this data might have to go through multiple functions. Of course I can create an additional type just for this, but it feels a bit redundant.

Suggestion

I realize that it's not good do the TS craziness where types dynamically change according to context, but I thought something like this can be done:

fn foo(a: MyType) -> Nil {
  case a {
    Var(..) as variant -> bar(variant)
    _ -> Nil
  }
}

fn bar(number: MyType>Var) -> Nil {
  // number was already pattern matched to be Var(), yay!
}

(I use > as a placeholder)
Behind the scenes it might create a "special type" that represents the variant, since it's being used as a type here.

This might be impossible/impractical, just writing what comes to my head 😛 Please share your thoughts!

[GearsDatapacks]

It's certainly not impossible to implement this, but this is not going to be added to the language. People have brought it up time and time again, but it's not an oversight or impracticality, but a conscious design choice. Variants are not types, they are values.
In this situation, you could either continue to pass all the fields of the variant as arguments to the function, which is fine until you get more than 5-6 (although that number is subjective). Than you could create a type which contains the data you want to access:

// This type represents the possible states of some data
type Wibble {
  Wibble(WibbleData)
  Wobble(WobbleData)
}

// This type only has one variant, so you can always perform record access on it!
type WibbleData {
  WibbleData(...)
}

// Same for this one
type WobbleData {
  WobbleData(...)
}

fn do_something(wibble: Wibble) {
  case wibble {
    Wibble(data) -> handle_wibble(data)
    Wobble(data) -> handle_wobble(data)
  }
}

fn handle_wibble(wibble: WibbleData) {
  wibble.some_field // This is valid
}

fn handle_wobble(wobble: WobbleData) {
  wobble.some_other_field // This is valid
}

[dandeduck]

Cool, just wanted to make sure I'm not the only one (Didn't find anything useful on discussions or Google) Thanks for the quick response and example! :)