Missing parameter type in inferring the type of the parameter of expanded function:

[MaYosy]

Discussed in #18516

^{Originally posted by MaYosy September 5, 2023}
compile failed:

@main def main(n: Int) = (time compose fib(_))(n)

[E081] Type Error: /home/mayosy/study/scala-fibonacci/src/TailRec.scala:12:20
|  (time compose fib(_))(n)
|                    ^
|   Missing parameter type
|
|   I could not infer the type of the parameter _$1 of expanded function:
|   _$1 => time compose fib(_$1).
|one error found

passed:

@main def main(n: Int) = 
  val f = fib(_)
  (time compose f)(n)
  // Or:
  // (time compose (fib(_)))(n)

Why? I am new in scala. :)

BTW, I find that the main function could't be:

@main def main = (x: String) => println(x)

but

@main def main(x: String) = println(x)

is ok (both compiled ok, but the former couldn't print anything)

:(

[nicolasstucki]

The issue is the use of infix notation with wildcards for lamdas.

In your case (time compose fib(_))(n) becomes x => (time compose fib(x))(n), which is not what you wanted.
You may solve this with one of the following:

(time compose (x => fib(x)))(n)
(time compose fib)(n)
(time.compose(fib(_)))(n)
(time.compose(fib))(n)

This does not seem to be a bug. Furthermore, the error message showed the expansion of the _ correctly.

[WojciechMazur]

It might in fact be a bit inconsisient, the issue does mostly invole the way how the code is parsed:

def fib(n: Int): Int = ???
def time(n: Int): Int = ???
@main def test(n: Int) = 

def fib(n: Int): Int = ???
def time(n: Int): Int = ???
@main def test(n: Int) = 
  val x = time
  val y = fib
  val works0 = fib compose time
  val works1 = x compose y
  val works2 = time _ compose fib 
  val works3 = time compose (fib(_))
  val fails: Int => Int = time compose fib(_)

After the typer the works3 is transformed to new anonymous function:

        val works3: Int => Int =
          {
            def $anonfun(n: Int): Int = time(n)
            closure($anonfun)
          }.compose[Int](
            {
              def $anonfun(_$1: Int): Int = fib(_$1)
              closure($anonfun)
            }
          )

However, without the braces we get the following:

      val fail: Int => Int =
          {
            def $anonfun(_$2: Int): Int =
              {
                def $anonfun(n: Int): Int = time(n)
                closure($anonfun)
              }.compose[Any](fib(_$2))
            closure($anonfun)
          }

So instead of composing 2 anonymous functions which delegate to time and fib we do create a nested lambda.

I would be great to fix it, but I'm not sure if we would be able to do it. Until this time I'll recommend to stick with either using additional parenthesis for compose argument or using function name as a value.

[nicolasstucki]

@main def main = (x: String) => println(x)
@main def main(x: String) = println(x)

A main method is executed by passing the parameters to that method and evaluating the result. In the first case the main method does not have parameters and therefore will be called without parameters. It creates the instance of the lambda but it will never be evaluated.

[MaYosy]

@nicolasstucki Thanks!