Unnecessary type widening in type constructors

[chuwy]

Details

In Iron, a library for refined types, terms of F[StringWithConstraint] unnecessarily widen to F[String]. Hopefully @Iltotore can provide more details on how Iron constraints are defined, otherwise below code should be self-explanatory.

Original ticket: Iltotore/iron#105

Compiler version

3.2.0 and 3.2.2

Minimized code

With scala-cli:

$ scala-cli --dependency io.github.iltotore::iron:2.0.0 --dependency org.typelevel::cats-core:2.9.0 

import cats.implicits.*
import cats.Applicative
import _root_.io.github.iltotore.iron.*
import _root_.io.github.iltotore.iron.constraint.string.*

type Name = String :| Alphanumeric

final case class Person(name: Name)

def test[F[_]: Applicative](str: String): F[Person] =
  Applicative[F]
    .pure(str.refine[Alphanumeric])
    .map(name => Person(name))

It works if we make F contravariant or if we provide an exact Name type parameter for map

Output

16 |    .map(name => Person(name))
   |                        ^^^^
   |Cannot refine non full inlined input at compile-time.
   |To test a constraint at runtime, use the `refined` extension method.
   |
   |Note: Due to a Scala limitation, already-refined types cannot be tested at compile-time (unless proven by an `Implication`).
   |
   |Inlined input: name
   |----------------------------------------------------------------------------
   |Inline stack trace
   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   |This location contains code that was inlined from rs$line$3:16
    ----------------------------------------------------------------------------
1 error found

Expectation

The code should compile as is.

[Iltotore]

Some side notes:

Explicitly passing the generic type works:

import cats.Monad
import cats.implicit.*

case class Person(name: String :| Alphanumeric)

def test[F[_]: Monad](str: String): F[Person] =
  Monad[F].unit
    .map[String :| Alphanumeric](_ => str.refine[Alphanumeric])
    .map(name => Person(name)) //OK

And when I use a more straightforward datatype like Option, it does too:

def test(str: String): Option[Person] =
  Some(())
    .map(_ => str.refine[Alphanumeric])
    .map(name => Person(name)) //OK

The refine method and the opaque type are defined like this:

opaque type IronType[A, C] <: A = A
type :|[A, C] = IronType[A, C]

extension [A](input: A)

  def refine[C](using ...): A :| C = ???

The error message in the first post is from an implicit conversion being triggered due to types mismatching. Indeed, when I do not import it I get for @chuwy's example:

[error] .\ironbug.sc:17:25: Found:    (name : String)
[error] Required: io.github.iltotore.iron.IronType[String,    
[error]   io.github.iltotore.iron.constraint.all.Alphanumeric]

In the example posted by @chuwy, the compiler widens the String :| Alphanumeric to String making the second map not compile.

It also does not work with Scala 3.3.0-RC3