Bad symbolic reference. A signature refers to JFunction1$mcZI$sp/T in package scala.runtime.java8 which is not available.

[topazus]

Compiler version

scala 3.1.3
If you're not sure what version you're using, run print scalaVersion from sbt
(if you're running scalac manually, use scalac -version instead).

Output

./bin/scala -deprecation
Welcome to Scala 3.1.3 (18.0.1, Java OpenJDK 64-Bit Server VM).
Type in expressions for evaluation. Or try :help.

scala> val r=Iterator.from(20)
     |   .takeWhile(_<69)
val r: Iterator[Int] = <iterator>

scala> val r=Iterator.from(20)
     |   .takeWhile(_<69).foreach(println)
Bad symbolic reference. A signature
refers to JFunction1$mcZI$sp/T in package scala.runtime.java8 which is not available.
It may be completely missing from the current classpath, or the version on
the classpath might be incompatible with the version used when compiling the signature.
1 error found

Sometimes, I run some example codes like the previous screenshot code. but in other times, it works fine.

Expectation

[prolativ]

@topazus do you consistently get this error when you run it in a fresh REPL session? I can recall getting similar errors in REPL but that has never been something I managed to reproduce later.

[topazus]

@prolativ Yes, I got the error for plenty of times in the past few days.

[prolativ]

But does this happen always for this snippet

val r=Iterator.from(20).takeWhile(_<69)
val r=Iterator.from(20).takeWhile(_<69).foreach(println)

or just often but not 100% deterministically?
Or do you have more examples of code causing this problem?
Could you try starting the REPL with scala-cli?

scala-cli repl -S 3.1.3 --jvm 18 -O -deprecation

Does the error occur also in this case?

[topazus]

But does this happen always for this snippet

val r=Iterator.from(20).takeWhile(_<69)
val r=Iterator.from(20).takeWhile(_<69).foreach(println)

or just often but not 100% deterministically?

the above screenshot occured the error. Is this error caused by my operation of recreating immutable variable `val` with same name, or java environment variable?

Could you try starting the REPL with scala-cli?

scala-cli repl -S 3.1.3 --jvm 18 -O -deprecation

ok, I will try this.

[topazus]

./scala-cli repl -S 3.1.3 --jvm system -O -deprecation

use scala-cli, after evaluating several sample code, the same error still occured.
@prolativ

detailed output, exactly copied from terminal, error in the very end

felix@Felixs-MacBook-Air ~ % ./scala-cli repl -S 3.1.3 --jvm system -O -deprecation
Welcome to Scala 3.1.3 (18.0.1, Java OpenJDK 64-Bit Server VM).
Type in expressions for evaluation. Or try :help.

scala>
     |   val a=List(0,1)
     |   val r=a.zip(a.tail)
val a: List[Int] = List(0, 1)
val r: List[(Int, Int)] = List((0,1))

scala>
     |   val a1=List(0,1).zip(List(0,1).tail).map (n => n._1 + n._2 )
val a1: List[Int] = List(1)

scala> 1::List(1)
val res0: List[Int] = List(1, 1)

scala>
     |   val a1=0::1::List(0,1).zip(List(0,1).tail).map (n => n._1 + n._2 )
val a1: List[Int] = List(0, 1, 1)

scala>
     |   val a2=a1.zip(a1.tail).map (n => n._1 + n._2 )
val a2: List[Int] = List(1, 2)

scala>
     |
     |   val a1=0::1::List(0,1).zip(List(0,1).tail).map (n => n._1 + n._2 )
     |   val a2=0::1::a1.zip(a1.tail).map (n => n._1 + n._2 )
     |   val a3=0::1::a2.zip(a2.tail).map (n => n._1 + n._2 )
val a1: List[Int] = List(0, 1, 1)
val a2: List[Int] = List(0, 1, 1, 2)
val a3: List[Int] = List(0, 1, 1, 2, 3)

scala>
     |   val fib: LazyList[Int] =
     |     BigInt(0) #:: BigInt(1) #:: fib.zip(fib.tail).map(n => n._1 + n._2)
     |
-- [E007] Type Mismatch Error: -------------------------------------------------
3 |    BigInt(0) #:: BigInt(1) #:: fib.zip(fib.tail).map(n => n._1 + n._2)
  |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |    Found:    LazyList[Matchable]
  |    Required: LazyList[Int]
  |
  | longer explanation available when compiling with `-explain`
1 error found

scala>
     |   val fib: LazyList[BigInt] =
     |     BigInt(0) #:: BigInt(1) #:: fib.zip(fib.tail).map(n => n._1 + n._2)
     |
val fib: LazyList[BigInt] = LazyList(<not computed>)

scala> fib.take(10).toList
val res1: List[BigInt] = List(0, 1, 1, 2, 3, 5, 8, 13, 21, 34)

scala>


     |   val ls:LazyList[Int]=0#:: ls.zipWithIndex((i,v)=>i+v+1)
-- [E081] Type Error: ----------------------------------------------------------
2 |  val ls:LazyList[Int]=0#:: ls.zipWithIndex((i,v)=>i+v+1)
  |                                             ^
  |                            Missing parameter type
  |
  |                            I could not infer the type of the parameter i.
-- [E081] Type Error: ----------------------------------------------------------
2 |  val ls:LazyList[Int]=0#:: ls.zipWithIndex((i,v)=>i+v+1)
  |                                               ^
  |                            Missing parameter type
  |
  |                            I could not infer the type of the parameter v.
2 errors found

scala>
     |   val ls:LazyList[Int]=0#:: ls.zipWithIndex((i,v)=>i+v+1)
-- [E081] Type Error: ----------------------------------------------------------
2 |  val ls:LazyList[Int]=0#:: ls.zipWithIndex((i,v)=>i+v+1)
  |                                             ^
  |                            Missing parameter type
  |
  |                            I could not infer the type of the parameter i.
-- [E081] Type Error: ----------------------------------------------------------
2 |  val ls:LazyList[Int]=0#:: ls.zipWithIndex((i,v)=>i+v+1)
  |                                               ^
  |                            Missing parameter type
  |
  |                            I could not infer the type of the parameter v.
2 errors found

scala>
     |   val ls: LazyList[Int] = 0 #:: ls.zipWithIndex(n => n._1 + n._2 + 1)
-- [E081] Type Error: ----------------------------------------------------------
2 |  val ls: LazyList[Int] = 0 #:: ls.zipWithIndex(n => n._1 + n._2 + 1)
  |                                                ^
  |                            Missing parameter type
  |
  |                            I could not infer the type of the parameter n.
1 error found

scala> lazy val ts: Stream[Int] =
     |   0 #:: ts.zipWithIndex.map(p => p._1 + p._2 + 1)
     |
1 warning found
-- Deprecation Warning: --------------------------------------------------------
1 |lazy val ts: Stream[Int] =
  |             ^^^^^^^^^^^
  |class Stream in package scala.collection.immutable is deprecated since 2.13.0: Use LazyList (which is fully lazy) instead of Stream (which has a lazy tail only)
lazy val ts: Stream[Int]

scala>

scala>
     |   val ls: LazyList[Int] = 0 #:: ls.zipWithIndex.map(n => n._1 + n._2 + 1)
val ls: LazyList[Int] = LazyList(<not computed>)

scala> ls.take(10)
val res2: LazyList[Int] = LazyList(<not computed>)

scala> ls.take(10).toList
val res3: List[Int] = List(0, 1, 3, 6, 10, 15, 21, 28, 36, 45)

scala> lazy val ts: Stream[Int] =
     |   0 #:: ts.zipWithIndex.map(p => p._1 + p._2 + 1)
     |
1 warning found
-- Deprecation Warning: --------------------------------------------------------
1 |lazy val ts: Stream[Int] =
  |             ^^^^^^^^^^^
  |class Stream in package scala.collection.immutable is deprecated since 2.13.0: Use LazyList (which is fully lazy) instead of Stream (which has a lazy tail only)
lazy val ts: Stream[Int]

scala> ts.take(10).toList
val res4: List[Int] = List(0, 1, 3, 6, 10, 15, 21, 28, 36, 45)

scala> List(9).zipWithIndex
val res5: List[(Int, Int)] = List((9,0))

scala>
     |   val a1=0::List(0).zipWithIndex.map(n => n._1 + n._2 + 1)
     |   val a2=0::a1.zipWithIndex.map(n => n._1 + n._2 + 1)
val a1: List[Int] = List(0, 1)
val a2: List[Int] = List(0, 1, 3)

scala> val a2=0::a1.zipWithIndex
val a2: List[Matchable] = List(0, (0,0), (1,1))

scala> a1.zipWithIndex.map
val res6: (((Int, Int)) => Any) => List[Any] = Lambda$1873/0x00000008011ba1f0@429904c9

scala> a1.zipWithIndex
val res7: List[(Int, Int)] = List((0,0), (1,1))

scala>
     |   val a1=0::List(0).zipWithIndex.map(n => n._1 + n._2 + 1)
     |   val a2=0::a1.zipWithIndex.map(n => n._1 + n._2 + 1)
     |   val a3=0::a2.zipWithIndex.map(n => n._1 + n._2 + 1)
val a1: List[Int] = List(0, 1)
val a2: List[Int] = List(0, 1, 3)
val a3: List[Int] = List(0, 1, 3, 6)

scala> a2.zipWithIndex
val res8: List[(Int, Int)] = List((0,0), (1,1), (3,2))

scala> val wordValue = {
     |   val ordinals = ('A' to 'Z').zipWithIndex.toMap
     |   (word:String) => word.length + word.map(ordinals).sum
     | }
val wordValue: String => Int = Lambda$1897/0x00000008011c81f0@67a3713

scala> wordValue
val res9: String => Int = Lambda$1897/0x00000008011c81f0@67a3713

scala> val ls=Iterator.from(1).map(n=>(n+1)*n/2)
val ls: Iterator[Int] = <iterator>

scala> ls.take(10).toList
val res10: List[Int] = List(1, 3, 6, 10, 15, 21, 28, 36, 45, 55)

scala>
     |   val ls=Iterator.from(1).map(n=>(1 to n).sum)
Bad symbolic reference. A signature
refers to JFunction1$mcII$sp/T in package scala.runtime.java8 which is not available.
It may be completely missing from the current classpath, or the version on
the classpath might be incompatible with the version used when compiling the signature.
1 error found

scala> val ls=Iterator.from(1).map(n=>(1 to n).sum)
Bad symbolic reference. A signature
refers to JFunction1$mcII$sp/T in package scala.runtime.java8 which is not available.
It may be completely missing from the current classpath, or the version on
the classpath might be incompatible with the version used when compiling the signature.
1 error found

[prolativ]

Digging deeper into that: does the problem occur if you don't use your globally installed Java version but rather force scala-cli to pull it for you or if you use an older version of JDK? E.g. if you use --jvm adopt:8 instead of --jvm system

[godenji]

Same issue:

scala
Welcome to Scala 3.1.2-RC2 (18.0.2, Java OpenJDK 64-Bit Server VM).

I restarted the repl and previously erroring code worked. Strange that it happens at all, certainly baffling, particularly for newcomers.

[hros]

I encountered the same error message when running the following code from the Scala 3 Book:

val nums = List(1,2,3)
nums.filter(_ > 1)

installation details: Ubuntu 22.04 on WSL (Windows 11), with Scala version 3.2.0 (installed with cs)

The odd thing is that after I followed the suggestion in this thread (running scala-cli repl -S 3.1.3 --jvm 18 -O -deprecation) the error vanished. What is stranger (at least to me...) is that after running that command, there were no errors even when running the default scala (without any parameters).

Please explain the root of the error, and why the "magical" command solved the issue