Function Overloading

[Namek]

Code example causing compiler error

type Modification {
  Create
  Move(id : String, afterId : Maybe(String))
}

component Main {
  fun render : Html {
    let arr = processMoves([Modification.Move("1", Maybe.Nothing)])
  
    <div>"Hello World!"</div>
  }

  fun processMoves(arr : Array(Modification.Move)) : Array(Modification.Move) {
    arr
  }
}

Issue

Function processMoves() expects an array of explicitly the Modification.Move variant, however the compiler simplifies the parameter to accept the whole type (accepting all variants), instead of specific variant of the type.

I believe this should be allowed because my workaround would be to create a struct for passing parameters and returning the result, which then I would have to map back to the ADT variant anyway, so there's more of manual code.

Alternatively, the function processMoves() should be errored first on the parameter type, i.e. it should be explicitly explained that ADT variants are not allowed as types. This option is less preferrable but it would specify the limits of the system.

Error

░ ERROR (CALL_ARGUMENT_TYPE_MISMATCH) ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

The 1st argument to a function is causing a mismatch.

The function is expecting the 1st argument to be:

  Array(Modification.Move)

Instead it is:

  Array(Modification)

The call in question is here:

    ┌ Main.mint:8:15
    ├────────────────────────────────────────────────────────────────────
   4│ }
   5│
   6│ component Main {
   7│   fun render : Html {
   8│     let arr = processMoves([Modification.Move("1", Maybe.Nothing)])
    │               ⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃⌃
   9│
  10│     <div>"Hello World!"</div>
  11│   }
  12│

Sandbox

https://mint-lang.com/sandbox/hRoQ-3GqY5xNhg

[gdotdesign]

Thank you for the detailed issue 🙏 Unfortunately, this is the intended behavior. Variants are not allowed as types (they can only be referenced as types in patterns).

In your example, it's clear that the function only takes a variant as the parameter, but it's not feasible for bigger programs. In order to facilitate what you are asking for, we would need to implement function overloading. Most functional programming language do not implement function overloading because it usually has a runtime cost: basically we need to check at runtime which version of the function needs to run based on the parameters.

What you wanted to do can be done using only the parent type (but it comes with a little boilerplate):

fun processMoves(arr : Array(Modification)) : Array(Modification) {
  for item of arr {
    case item {
      Move => { item | ... } // Update the item
      => item              // Ignore other variants
    }
  }
}

[gdotdesign]

Since nothing there is nothing actionable, I'm converting it into a discussion.

[Namek]

Well, as I wrote, I think the function processMoves() should show an error on the parameter type, i.e. it should be explicitly explained that ADT variants are not allowed as types. This option is less preferrable but it would specify the limits of the system. Currently it feels like it is possible to do but the error is manifesting somewhere else.

[gdotdesign]

We can probably show an error if you are trying to reference an ADT variant, but it can be ambiguous because nothing prevents people from doing this, which is valid code:

type Modification.Move {
  x: Number, y: Number
}

type Modification {
  Move(x: Number, y: Number)
}

Also, it's not trivial in cases like you posted, where the variant referenced is nested in another type.

It doesn't work in Elm either also no helpful error:

Not in Gleam either:

I agree that an error message like that would be helpful, so I'll keep it in mind for the future.