From 93ba662b2324bc012b0b8af96621710875e86724 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Sun, 23 Nov 2025 19:09:03 +0100
Subject: [PATCH] wip: use scala 3 to compile docs

---
 _ba/tour/extractor-objects.md               |  4 ++--
 _ba/tour/implicit-parameters.md             | 10 +++++-----
 _ba/tour/mixin-class-composition.md         |  4 ++--
 _ba/tour/operators.md                       | 10 +++++-----
 _es/tour/basics.md                          |  2 +-
 _es/tour/implicit-parameters.md             |  2 +-
 _es/tour/mixin-class-composition.md         |  4 ++--
 _es/tour/multiple-parameter-lists.md        |  2 +-
 _es/tour/operators.md                       |  4 ++--
 _fr/tour/extractor-objects.md               |  4 ++--
 _ja/overviews/collections/iterators.md      |  4 ++--
 _ja/tour/extractor-objects.md               |  4 ++--
 _ja/tour/implicit-parameters.md             |  8 ++++----
 _ja/tour/mixin-class-composition.md         |  4 ++--
 _ja/tour/multiple-parameter-lists.md        |  6 +++---
 _ja/tour/operators.md                       |  4 ++--
 _ko/tour/implicit-parameters.md             | 12 ++++++------
 _ko/tour/mixin-class-composition.md         |  4 ++--
 _ko/tour/operators.md                       |  6 +++---
 _overviews/collections/iterators.md         |  4 ++--
 _pl/tour/implicit-parameters.md             |  4 ++--
 _pl/tour/mixin-class-composition.md         |  4 ++--
 _pl/tour/operators.md                       |  4 ++--
 _pt-br/tour/implicit-parameters.md          |  2 +-
 _pt-br/tour/mixin-class-composition.md      |  4 ++--
 _pt-br/tour/operators.md                    |  4 ++--
 _ru/overviews/collections-2.13/iterators.md | 12 ++++++------
 _ru/tour/extractor-objects.md               |  4 ++--
 _ru/tour/mixin-class-composition.md         |  6 +++---
 _ru/tour/multiple-parameter-lists.md        |  2 +-
 _ru/tour/operators.md                       |  4 ++--
 _tour/extractor-objects.md                  |  4 ++--
 _tour/mixin-class-composition.md            |  4 ++--
 _tour/multiple-parameter-lists.md           |  4 ++--
 _tour/operators.md                          |  8 ++++----
 _zh-cn/overviews/collections/iterators.md   |  4 ++--
 _zh-cn/tour/extractor-objects.md            |  4 ++--
 _zh-cn/tour/implicit-parameters.md          |  8 ++++----
 _zh-cn/tour/mixin-class-composition.md      |  4 ++--
 _zh-cn/tour/operators.md                    |  4 ++--
 scripts/run-mdoc.sh                         |  5 ++---
 41 files changed, 100 insertions(+), 101 deletions(-)

diff --git a/_ba/tour/extractor-objects.md b/_ba/tour/extractor-objects.md
index 0d0618aa00..d6d2078ef5 100644
--- a/_ba/tour/extractor-objects.md
+++ b/_ba/tour/extractor-objects.md
@@ -43,14 +43,14 @@ Metoda `unapply` se može koristiti i za dodjelu vrijednosti.
 
 ```scala mdoc
 val customer2ID = CustomerID("Nico")
-val CustomerID(name) = customer2ID
+val CustomerID(name) = customer2ID: @unchecked
 println(name)  // prints Nico
 ```
 
 Ovo je ekvivalentno `val name = CustomerID.unapply(customer2ID).get`. Ako se uzorak ne podudari, baciće se  `scala.MatchError` izuzetak:
 
 ```scala mdoc:crash
-val CustomerID(name2) = "--asdfasdfasdf"
+val CustomerID(name2) = "--asdfasdfasdf": @unchecked
 ```
 
 Povratni tip od `unapply` se bira na sljedeći način:
diff --git a/_ba/tour/implicit-parameters.md b/_ba/tour/implicit-parameters.md
index c39d87d626..b08af0b771 100644
--- a/_ba/tour/implicit-parameters.md
+++ b/_ba/tour/implicit-parameters.md
@@ -21,7 +21,7 @@ Argumenti koji se mogu proslijediti kao implicitni parametri spadaju u dvije kat
 
 U sljedećem primjeru definisaćemo metodu `sum` koja izračunava sumu liste elemenata koristeći `add` i `unit` operacije monoida.
 Molimo primijetite da implicitne vrijednosti ne mogu biti top-level, već moraju biti članovi templejta.
- 
+
 ```scala mdoc
 abstract class SemiGroup[A] {
   def add(x: A, y: A): A
@@ -31,7 +31,7 @@ abstract class Monoid[A] extends SemiGroup[A] {
 }
 object ImplicitTest extends App {
   implicit object StringMonoid extends Monoid[String] {
-    def add(x: String, y: String): String = x concat y
+    def add(x: String, y: String): String = x ++ y
     def unit: String = ""
   }
   implicit object IntMonoid extends Monoid[Int] {
@@ -51,13 +51,13 @@ Ovaj primjer koristi strukturu iz apstraktne algebre da pokaže kako implicitni
 
 Monoid, modelovan s `Monoid` ovdje, je polugrupa s posebnim elementom `A`, zvanim `unit`, koji kada se kombinujes nekim drugim elementom `A` vraća taj drugi element.
 
-Da bismo pokazali kako implicitni parametri rade, prvo definišemo monoide `StringMonoid` i `IntMonoid` za stringove i integere, respektivno. 
+Da bismo pokazali kako implicitni parametri rade, prvo definišemo monoide `StringMonoid` i `IntMonoid` za stringove i integere, respektivno.
 Ključna riječ `implicit` kaže da se dati objekat može koristiti implicitno, unutar ovog domena, kao parametar funkcije obilježene s implicit.
 
-Metoda `sum` prima `List[A]` i vraća `A`, koji predstavlja rezultat primjene operacije monoida sukcesivno kroz cijelu listu. Navodeći parametar `m` implicitnim ovdje znači da samo moramo proslijediti `xs` parametar pri pozivu, pošto imamo `List[A]` znamo šta je tip `A` ustvari i stoga tip `Monoid[A]` se traži. 
+Metoda `sum` prima `List[A]` i vraća `A`, koji predstavlja rezultat primjene operacije monoida sukcesivno kroz cijelu listu. Navodeći parametar `m` implicitnim ovdje znači da samo moramo proslijediti `xs` parametar pri pozivu, pošto imamo `List[A]` znamo šta je tip `A` ustvari i stoga tip `Monoid[A]` se traži.
 Možemo implicitno naći bilo koji `val` ili `object` u trenutnom domenu koji ima taj tip i koristiti ga bez da ga navedemo eksplicitno.
 
-Napokon, zovemo `sum` dvaput, sa samo jednim parametrom svaki put. 
+Napokon, zovemo `sum` dvaput, sa samo jednim parametrom svaki put.
 Pošto je drugi parametar metode `sum`, `m`, implicitan, njegova vrijednost se traži u trenutnom domenu, bazirano na tipu monoida koji se traži, što znači da se oba izraza mogu izračunati potpuno.
 
 Ovo je izlaz navedenog Scala programa:
diff --git a/_ba/tour/mixin-class-composition.md b/_ba/tour/mixin-class-composition.md
index a8216abfb6..803e32f219 100644
--- a/_ba/tour/mixin-class-composition.md
+++ b/_ba/tour/mixin-class-composition.md
@@ -51,7 +51,7 @@ class StringIterator(s: String) extends AbsIterator {
   private var i = 0
   def hasNext = i < s.length
   def next() = {
-    val ch = s charAt i
+    val ch = s.charAt(i)
     i += 1
     ch
   }
@@ -80,7 +80,7 @@ Pošto je `RichIterator` trejt, on ne mora implementirati apstraktne članove `A
 object StringIteratorTest extends App {
   class Iter extends StringIterator("Scala") with RichIterator
   val iter = new Iter
-  iter foreach println
+  iter.foreach(println)
 }
 ```
 
diff --git a/_ba/tour/operators.md b/_ba/tour/operators.md
index f1e8f3da07..e6221ad9ea 100644
--- a/_ba/tour/operators.md
+++ b/_ba/tour/operators.md
@@ -11,7 +11,7 @@ prerequisite-knowledge: case-classes
 
 ---
 
-U Scali, operatori su metode. 
+U Scali, operatori su metode.
 Bilo koja metoda koja prima samo jedan parametar može biti korištena kao _infiksni operator_. Npr, `+` se može pozvati s tačka-notacijom:
 ```
 10.+(1)
@@ -23,7 +23,7 @@ Međutim, lakše je čitati kada se napiše kao infiksni operator:
 ```
 
 ## Definisanje i korištenje operatora
-Možete koristiti bilo koji legalni identifikator kao operator. 
+Možete koristiti bilo koji legalni identifikator kao operator.
 To uključuje i imena kao `add` ili simbole kao `+`.
 ```scala mdoc
 case class Vec(x: Double, y: Double) {
@@ -37,15 +37,15 @@ val vector3 = vector1 + vector2
 vector3.x  // 3.0
 vector3.y  // 3.0
 ```
-Klasa `Vec` ima metodu `+` koja se može koristiti za sabiranje  `vector1` i `vector2`. 
+Klasa `Vec` ima metodu `+` koja se može koristiti za sabiranje  `vector1` i `vector2`.
 Koristeći zagrade, možete pisati kompleksne izraze s čitljivom sintaksom.
 
 Slijedi definicija klase `MyBool` koja definiše tri metode `and`, `or`, i `negate`.
 
 ```scala mdoc
 case class MyBool(x: Boolean) {
-  def and(that: MyBool): MyBool = if (x) that else this
-  def or(that: MyBool): MyBool = if (x) this else that
+  infix def and(that: MyBool): MyBool = if (x) that else this
+  infix def or(that: MyBool): MyBool = if (x) this else that
   def negate: MyBool = MyBool(!x)
 }
 ```
diff --git a/_es/tour/basics.md b/_es/tour/basics.md
index 484470a508..980541104c 100644
--- a/_es/tour/basics.md
+++ b/_es/tour/basics.md
@@ -300,7 +300,7 @@ El método principal (main) es el punto donde comienza la ejecución de un progr
 
 Usando un objeto, puedes definir el método principal de la siguiente forma:
 
-```scala mdoc
+```scala mdoc:fail
 object Main {
   def main(args: Array[String]): Unit =
     println("Hello, Scala developer!")
diff --git a/_es/tour/implicit-parameters.md b/_es/tour/implicit-parameters.md
index f6c52d5c8a..086a5fae0c 100644
--- a/_es/tour/implicit-parameters.md
+++ b/_es/tour/implicit-parameters.md
@@ -26,7 +26,7 @@ En el siguiente ejemplo definimos un método `sum` el cual computa la suma de un
     }
     object ImplicitTest extends App {
       implicit object StringMonoid extends Monoid[String] {
-        def add(x: String, y: String): String = x concat y
+        def add(x: String, y: String): String = x ++ y
         def unit: String = ""
       }
       implicit object IntMonoid extends Monoid[Int] {
diff --git a/_es/tour/mixin-class-composition.md b/_es/tour/mixin-class-composition.md
index bd53274158..a0733ba3e0 100644
--- a/_es/tour/mixin-class-composition.md
+++ b/_es/tour/mixin-class-composition.md
@@ -31,7 +31,7 @@ Aquí se muestra una clase iterador concreta, la cual retorna caracteres sucesiv
       type T = Char
       private var i = 0
       def hasNext = i < s.length()
-      def next() = { val ch = s charAt i; i += 1; ch }
+      def next() = { val ch = s.charAt(i); i += 1; ch }
     }
 
 Nos gustaría combinar la funcionalidad de `StringIterator` y `RichIterator` en una sola clase. Solo con herencia simple e interfaces esto es imposible, ya que ambas clases contienen implementaciones para sus miembros. Scala nos ayuda con sus _compisiciones de clases mezcladas_. Permite a los programadores reutilizar el delta de la definición de una clase, esto es, todas las nuevas definiciones que no son heredadas. Este mecanismo hace posible combinar `StringIterator` con `RichIterator`, como es hecho en el siguiente programa, el cual imprime una columna de todos los caracteres de una cadena de caracteres dada.
@@ -40,7 +40,7 @@ Nos gustaría combinar la funcionalidad de `StringIterator` y `RichIterator` en
       def main(args: Array[String]): Unit = {
         class Iter extends StringIterator("Scala") with RichIterator
         val iter = new Iter
-        iter foreach println
+        iter.foreach(println)
       }
     }
 
diff --git a/_es/tour/multiple-parameter-lists.md b/_es/tour/multiple-parameter-lists.md
index 83b7218c0b..5570262134 100644
--- a/_es/tour/multiple-parameter-lists.md
+++ b/_es/tour/multiple-parameter-lists.md
@@ -116,7 +116,7 @@ Por ejemplo,
 
 ```scala mdoc:nest
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-val numberFunc = numbers.foldLeft(List[Int]()) _
+val numberFunc = numbers.foldLeft(List[Int]())
 
 val squares = numberFunc((xs, x) => xs :+ x*x)
 println(squares) // List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
diff --git a/_es/tour/operators.md b/_es/tour/operators.md
index 6aeb98e046..8cc5b5e2fe 100644
--- a/_es/tour/operators.md
+++ b/_es/tour/operators.md
@@ -13,8 +13,8 @@ previous-page: multiple-parameter-lists
 En Scala, cualquier método el cual reciba un solo parámetro puede ser usado como un *operador de infijo (infix)*. Aquí se muestra la definición de la clase `MyBool`, la cual define tres métodos `and`, `or`, y `negate`.
 
     class MyBool(x: Boolean) {
-      def and(that: MyBool): MyBool = if (x) that else this
-      def or(that: MyBool): MyBool = if (x) this else that
+      infix def and(that: MyBool): MyBool = if (x) that else this
+      infix def or(that: MyBool): MyBool = if (x) this else that
       def negate: MyBool = new MyBool(!x)
     }
 
diff --git a/_fr/tour/extractor-objects.md b/_fr/tour/extractor-objects.md
index 1f864b7f39..a7e32fb28c 100644
--- a/_fr/tour/extractor-objects.md
+++ b/_fr/tour/extractor-objects.md
@@ -39,14 +39,14 @@ Sachant qu'une définition de valeur peut utiliser une décomposition pour intro
 
 ```scala mdoc
 val customer2ID = CustomerID("Nico")
-val CustomerID(name) = customer2ID
+val CustomerID(name) = customer2ID: @unchecked
 println(name)  // prints Nico
 ```
 
 C'est équivalent à `val name = CustomerID.unapply(customer2ID).get`.
 
 ```scala mdoc
-val CustomerID(name2) = "--asdfasdfasdf"
+val CustomerID(name2) = "--asdfasdfasdf": @unchecked
 ```
 
 S'il n'y a pas de correspondance, une `scala.MatchError` est levée :
diff --git a/_ja/overviews/collections/iterators.md b/_ja/overviews/collections/iterators.md
index 4435171d24..074bfe067f 100644
--- a/_ja/overviews/collections/iterators.md
+++ b/_ja/overviews/collections/iterators.md
@@ -18,7 +18,7 @@ language: ja
 
 `Traversable`、`Iterable`、および `Seq` クラスのほとんどのメソッドに類似するものを Scala のイテレータは提供している。たとえば、与えられた手順をイテレータが返す全ての要素に対して実行する `foreach` メソッドを提供する。 `foreach` を使うことで、先ほどのループは以下のように短縮できる:
 
-    it foreach println
+    it.foreach(println)
 
 例にならって、`foreach`、`map`、`withFilter`、および `flatMap` の代替構文として for 式を使うことができるので、イテレータが返す全ての要素を表示するもう一つの方法として以下のように書ける:
 
@@ -33,7 +33,7 @@ language: ja
     it: Iterator[java.lang.String] = non-empty iterator
     scala> it.map(_.length)
     res1: Iterator[Int] = non-empty iterator
-    scala> res1 foreach println
+    scala> res1.foreach(println)
     1
     6
     2
diff --git a/_ja/tour/extractor-objects.md b/_ja/tour/extractor-objects.md
index 03efef77e3..ed8907a13e 100644
--- a/_ja/tour/extractor-objects.md
+++ b/_ja/tour/extractor-objects.md
@@ -40,13 +40,13 @@ customer1ID match {
 
 ```scala mdoc
 val customer2ID = CustomerID("Nico")
-val CustomerID(name) = customer2ID
+val CustomerID(name) = customer2ID: @unchecked
 println(name)  // prints Nico
 ```
 これは `val name = CustomerID.unapply(customer2ID).get`と同じです。
 
 ```scala mdoc
-val CustomerID(name2) = "--asdfasdfasdf"
+val CustomerID(name2) = "--asdfasdfasdf": @unchecked
 ```
 もし一致しない場合`scala.MatchError`が投げられます。
 
diff --git a/_ja/tour/implicit-parameters.md b/_ja/tour/implicit-parameters.md
index 4160583a0f..d3858b6f7e 100644
--- a/_ja/tour/implicit-parameters.md
+++ b/_ja/tour/implicit-parameters.md
@@ -29,19 +29,19 @@ abstract class Monoid[A] {
 
 object ImplicitTest {
   implicit val stringMonoid: Monoid[String] = new Monoid[String] {
-    def add(x: String, y: String): String = x concat y
+    def add(x: String, y: String): String = x ++ y
     def unit: String = ""
   }
-  
+
   implicit val intMonoid: Monoid[Int] = new Monoid[Int] {
     def add(x: Int, y: Int): Int = x + y
     def unit: Int = 0
   }
-  
+
   def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
     if (xs.isEmpty) m.unit
     else m.add(xs.head, sum(xs.tail))
-    
+
   def main(args: Array[String]): Unit = {
     println(sum(List(1, 2, 3)))       // intMonoidを暗に使用
     println(sum(List("a", "b", "c"))) // stringMonoidを暗に使用
diff --git a/_ja/tour/mixin-class-composition.md b/_ja/tour/mixin-class-composition.md
index f95ab54cb9..53ffa7022d 100644
--- a/_ja/tour/mixin-class-composition.md
+++ b/_ja/tour/mixin-class-composition.md
@@ -48,7 +48,7 @@ class StringIterator(s: String) extends AbsIterator {
   private var i = 0
   def hasNext = i < s.length
   def next() = {
-    val ch = s charAt i
+    val ch = s.charAt(i)
     i += 1
     ch
   }
@@ -71,7 +71,7 @@ trait RichIterator extends AbsIterator {
 ```scala mdoc
 class RichStringIter extends StringIterator("Scala") with RichIterator
 val richStringIter = new RichStringIter
-richStringIter foreach println
+richStringIter.foreach(println)
 ```
 新しいクラス`RichStringIter`は`StringIterator`をスーパークラスとし、`RichIterator`をミックスインとしています。
 
diff --git a/_ja/tour/multiple-parameter-lists.md b/_ja/tour/multiple-parameter-lists.md
index eb8fffd6cb..6b40b4eb7a 100644
--- a/_ja/tour/multiple-parameter-lists.md
+++ b/_ja/tour/multiple-parameter-lists.md
@@ -37,7 +37,7 @@ println(res) // 55
 
 
 ```scala mdoc:fail
-numbers.foldLeft(0, (m: Int, n: Int) => m + n)	
+numbers.foldLeft(0, (m: Int, n: Int) => m + n)
 ```
 
 複数パラメータリストを使うことで、Scalaの型インターフェースの利点を享受でき、以下のようにコードをより簡潔にすることができるのです。
@@ -63,9 +63,9 @@ def execute(arg: Int)(implicit ec: scala.concurrent.ExecutionContext) = ???
 例えば
 ```scala mdoc:nest
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-val numberFunc = numbers.foldLeft(List[Int]()) _
+val numberFunc = numbers.foldLeft(List[Int]())
 val squares = numberFunc((xs, x) => xs :+ x*x)
 print(squares) // List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
 val cubes = numberFunc((xs, x) => xs :+ x*x*x)
 print(cubes)  // List(1, 8, 27, 64, 125, 216, 343, 512, 729, 1000)
-```	
+```
diff --git a/_ja/tour/operators.md b/_ja/tour/operators.md
index 398790b4e0..bc2b2325b9 100644
--- a/_ja/tour/operators.md
+++ b/_ja/tour/operators.md
@@ -40,8 +40,8 @@ vector3.y  // 3.0
 
 ```scala mdoc
 case class MyBool(x: Boolean) {
-  def and(that: MyBool): MyBool = if (x) that else this
-  def or(that: MyBool): MyBool = if (x) this else that
+  infix def and(that: MyBool): MyBool = if (x) that else this
+  infix def or(that: MyBool): MyBool = if (x) this else that
   def negate: MyBool = MyBool(!x)
 }
 ```
diff --git a/_ko/tour/implicit-parameters.md b/_ko/tour/implicit-parameters.md
index 33acd69f65..925675d80e 100644
--- a/_ko/tour/implicit-parameters.md
+++ b/_ko/tour/implicit-parameters.md
@@ -12,14 +12,14 @@ previous-page: self-types
 
 _암시적 파라미터_ 를 갖는 메서드 역시 다른 일반적인 메서드와 마찬가지로 인수를 적용할 수 있다. 이런 경우 implicit 키워드는 아무런 영향을 미치지 않는다. 하지만, 이 경우에 암시적 파라미터에 주는 인수를 생략한다면, 그 생략된 인수는 자동적으로 제공될 것이다.
 
-실제로 암시적 파라미터가 넘겨받을 수 있는 인수의 종류는 두 가지로 나눌 수 있다: 
+실제로 암시적 파라미터가 넘겨받을 수 있는 인수의 종류는 두 가지로 나눌 수 있다:
 
-* 첫째, 메서드가 호출되는 시점에서 prefix 없이 접근할 수 있고 암시적 정의나 암시적 파라미터로 표시된 모든 식별자 x 
+* 첫째, 메서드가 호출되는 시점에서 prefix 없이 접근할 수 있고 암시적 정의나 암시적 파라미터로 표시된 모든 식별자 x
 * 둘째, 암시적(implicit)이라고 표시된 암시적 파라미터의 타입과 관련된 모듈의 모든 멤버
 
-아래 예제에서는 모노이드의 `add`와 `unit`메서드를 이용해서 리스트 항목들의 합을 구하는 `sum` 메서드를 정의한다. 
+아래 예제에서는 모노이드의 `add`와 `unit`메서드를 이용해서 리스트 항목들의 합을 구하는 `sum` 메서드를 정의한다.
 암시적 값은 최상위 레벨이 될 수 없고 템플릿의 멤버여야만 한다는 점에 주의하자.
- 
+
     /** 이 예제는 어떻게 암묵적인 파라미터들이 동작하는지 보여주기 위해, 추상적인 수학으로부터 나온 구조를 사용한다. 하위 그룹은 관련된 연산(add를 말함/한쌍의 A를 합치고 또다른 A를 리턴)을 가진 집합 A에 대한 수학적인 구조이다. */
     abstract class SemiGroup[A] {
       def add(x: A, y: A): A
@@ -31,7 +31,7 @@ _암시적 파라미터_ 를 갖는 메서드 역시 다른 일반적인 메서
     object ImplicitTest extends App {
       /** 암묵적 파라미터들의 동작을 보여주기 위해서, 우리는 먼저 문자열과 숫자에 대한 monoid를 정의했다. implicit 키워드는 해당하는 object가 암묵적으로 어떤 함수의 implicit으로 표시된 파라미터에 이 scope안에서 사용될수 있음을 나타낸다. */
       implicit object StringMonoid extends Monoid[String] {
-        def add(x: String, y: String): String = x concat y
+        def add(x: String, y: String): String = x ++ y
         def unit: String = ""
       }
       implicit object IntMonoid extends Monoid[Int] {
@@ -48,7 +48,7 @@ _암시적 파라미터_ 를 갖는 메서드 역시 다른 일반적인 메서
       println(sum(List("a", "b", "c")))    // uses StringMonoid implicitly
     }
 
-아래는 이 스칼라 프로그램의 결과이다. 
+아래는 이 스칼라 프로그램의 결과이다.
 
     6
     abc
diff --git a/_ko/tour/mixin-class-composition.md b/_ko/tour/mixin-class-composition.md
index 94f21d2244..dcf6f2d9dd 100644
--- a/_ko/tour/mixin-class-composition.md
+++ b/_ko/tour/mixin-class-composition.md
@@ -30,7 +30,7 @@ _단일 상속_ 만을 지원하는 여러 언어와는 달리, 스칼라는 더
       type T = Char
       private var i = 0
       def hasNext = i < s.length()
-      def next() = { val ch = s charAt i; i += 1; ch }
+      def next() = { val ch = s.charAt(i); i += 1; ch }
     }
 
 `StringIterator`와 `RichIterator`를 하나의 클래스로 합치고 싶다면 어떻게 할까. 두 클래스 모두는 코드가 포함된 멤버 구현을 담고 있기 때문에 단일 상속과 인터페이스 만으론 불가능한 일이다. 스칼라는 _믹스인 클래스 컴포지션_ 으로 이런 상황을 해결해준다. 프로그래머는 이를 사용해 클래스 정의에서 변경된 부분을 재사용할 수 있다. 이 기법은 주어진 문자열에 포함된 모든 캐릭터를 한 줄로 출력해주는 다음의 테스트 프로그램에서와 같이, `StringIterator`와 `RichIterator`를 통합할 수 있도록 해준다.
@@ -39,7 +39,7 @@ _단일 상속_ 만을 지원하는 여러 언어와는 달리, 스칼라는 더
       def main(args: Array[String]): Unit = {
         class Iter extends StringIterator("Scala") with RichIterator
         val iter = new Iter
-        iter foreach println
+        iter.foreach(println)
       }
     }
 
diff --git a/_ko/tour/operators.md b/_ko/tour/operators.md
index 4306b08744..8c9a90d0ff 100644
--- a/_ko/tour/operators.md
+++ b/_ko/tour/operators.md
@@ -13,15 +13,15 @@ previous-page: type-inference
 스칼라에선 단일 파라미터를 취하는 모든 메소드를 *중위 연산자*로 사용할 수 있다. 다음은 `and`와 `or`, `negate` 등의 세 가지 메소드를 정의하고 있는 클래스 `MyBool`의 정의다.
 
     class MyBool(x: Boolean) {
-      def and(that: MyBool): MyBool = if (x) that else this
-      def or(that: MyBool): MyBool = if (x) this else that
+      infix def and(that: MyBool): MyBool = if (x) that else this
+      infix def or(that: MyBool): MyBool = if (x) this else that
       def negate: MyBool = new MyBool(!x)
     }
 
 이제 `and`와 `or`를 중위 연산자로 사용할 수 있다.
 
     def not(x: MyBool) = x negate; // 여기엔 세미콜론이 필요함
-    def xor(x: MyBool, y: MyBool) = (x or y) and not(x and y)
+    def xor(x: MyBool, y: MyBool) = (infix ) and not(x and y)
 
 이 코드의 첫 번째 줄에서 알 수 있듯이, 무항 메소드는 후위 연산자로 사용할 수도 있다. 두 번째 줄에선 `and`와 `or` 메소드와 함께 새로운 함수 `not`을 사용해 `xor` 함수를 정의했다. 이 예제에선 _중위 연산자_를 사용해 `xor` 정의의 가독성을 높일 수 있다.
 
diff --git a/_overviews/collections/iterators.md b/_overviews/collections/iterators.md
index 78dfcc69f0..c132d485ed 100644
--- a/_overviews/collections/iterators.md
+++ b/_overviews/collections/iterators.md
@@ -20,7 +20,7 @@ The most straightforward way to "step through" all the elements returned by an i
 
 Iterators in Scala also provide analogues of most of the methods that you find in the `Traversable`, `Iterable` and `Seq` classes. For instance, they provide a `foreach` method which executes a given procedure on each element returned by an iterator. Using `foreach`, the loop above could be abbreviated to:
 
-    it foreach println
+    it.foreach(println)
 
 As always, for-expressions can be used as an alternate syntax for expressions involving `foreach`, `map`, `withFilter`, and `flatMap`, so yet another way to print all elements returned by an iterator would be:
 
@@ -34,7 +34,7 @@ The other operations that Iterator has in common with `Traversable` have the sam
     it: Iterator[java.lang.String] = non-empty iterator
     scala> it.map(_.length)
     res1: Iterator[Int] = non-empty iterator
-    scala> res1 foreach println
+    scala> res1.foreach(println)
     1
     6
     2
diff --git a/_pl/tour/implicit-parameters.md b/_pl/tour/implicit-parameters.md
index 2ce27415ea..998d3daf16 100644
--- a/_pl/tour/implicit-parameters.md
+++ b/_pl/tour/implicit-parameters.md
@@ -17,7 +17,7 @@ Argumenty, które mogą być przekazywane jako parametry domniemane, można podz
 * W drugiej kolejności dobrane mogą być elementy modułów towarzyszących odpowiadających typom tych parametrów domniemanych, które są oznaczone jako `implicit`.
 
 W poniższym przykładzie zdefiniujemy metodę `sum`, która oblicza sumę listy elementów wykorzystując operacje `add` i `unit` obiektu `Monoid`. Należy dodać, że wartości domniemane nie mogą być zdefiniowane globalnie, tylko muszą być elementem pewnego modułu.
- 
+
 ```scala mdoc
 /** Ten przykład wykorzystuje strukturę z algebry abstrakcyjnej aby zilustrować działanie parametrów domniemanych. Półgrupa jest strukturą algebraiczną na zbiorze A z łączną operacją (czyli taką, która spełnia warunek: add(x, add(y, z)) == add(add(x, y), z)) nazwaną add, która łączy parę obiektów A by zwrócić inny obiekt A. */
 abstract class SemiGroup[A] {
@@ -30,7 +30,7 @@ abstract class Monoid[A] extends SemiGroup[A] {
 object ImplicitTest extends App {
   /** Aby zademonstrować jak działają parametry domniemane, najpierw zdefiniujemy monoidy dla łańcuchów znaków oraz liczb całkowitych. Słowo kluczowe implicit sprawia, że oznaczone nimi wartości mogą być użyte aby zrealizować parametry domniemane. */
   implicit object StringMonoid extends Monoid[String] {
-    def add(x: String, y: String): String = x concat y
+    def add(x: String, y: String): String = x ++ y
     def unit: String = ""
   }
   implicit object IntMonoid extends Monoid[Int] {
diff --git a/_pl/tour/mixin-class-composition.md b/_pl/tour/mixin-class-composition.md
index 9f346fd72c..df6e7174e3 100644
--- a/_pl/tour/mixin-class-composition.md
+++ b/_pl/tour/mixin-class-composition.md
@@ -50,7 +50,7 @@ class StringIterator(s: String) extends AbsIterator {
   private var i = 0
   def hasNext = i < s.length
   def next() = {
-    val ch = s charAt i
+    val ch = s.charAt(i)
     i += 1
     ch
   }
@@ -76,7 +76,7 @@ Spróbujmy teraz połączyć funkcjonalności `StringIterator` oraz `RichIterato
 object StringIteratorTest extends App {
   class RichStringIter extends StringIterator("Scala") with RichIterator
   val richStringIter = new RichStringIter
-  richStringIter foreach println
+  richStringIter.foreach(println)
 }
 ```
 
diff --git a/_pl/tour/operators.md b/_pl/tour/operators.md
index 8730570849..c6f2800ce3 100644
--- a/_pl/tour/operators.md
+++ b/_pl/tour/operators.md
@@ -13,8 +13,8 @@ Każda metoda, która przyjmuje jeden parametr, może być użyta jako *operator
 
 ```scala mdoc
 case class MyBool(x: Boolean) {
-  def and(that: MyBool): MyBool = if (x) that else this
-  def or(that: MyBool): MyBool = if (x) this else that
+  infix def and(that: MyBool): MyBool = if (x) that else this
+  infix def or(that: MyBool): MyBool = if (x) this else that
   def negate: MyBool = MyBool(!x)
 }
 ```
diff --git a/_pt-br/tour/implicit-parameters.md b/_pt-br/tour/implicit-parameters.md
index 7f1f0d0a98..6514141462 100644
--- a/_pt-br/tour/implicit-parameters.md
+++ b/_pt-br/tour/implicit-parameters.md
@@ -31,7 +31,7 @@ abstract class Monoid[A] extends SemiGroup[A] {
 object ImplicitTest extends App {
   /** Para mostrar como os parâmetros implícitos funcionam, primeiro definimos os monóides para strings e inteiros. A palavra-chave implicit indica que o objeto correspondente pode ser usado implicitamente, dentro deste escopo, como um parâmetro de uma função definia como implícita. */
   implicit object StringMonoid extends Monoid[String] {
-    def add(x: String, y: String): String = x concat y
+    def add(x: String, y: String): String = x ++ y
     def unit: String = ""
   }
   implicit object IntMonoid extends Monoid[Int] {
diff --git a/_pt-br/tour/mixin-class-composition.md b/_pt-br/tour/mixin-class-composition.md
index e317924e0b..e7d4183fa8 100644
--- a/_pt-br/tour/mixin-class-composition.md
+++ b/_pt-br/tour/mixin-class-composition.md
@@ -35,7 +35,7 @@ class StringIterator(s: String) extends AbsIterator {
   type T = Char
   private var i = 0
   def hasNext = i < s.length()
-  def next() = { val ch = s charAt i; i += 1; ch }
+  def next() = { val ch = s.charAt(i); i += 1; ch }
 }
 ```
 
@@ -46,7 +46,7 @@ object StringIteratorTest {
   def main(args: Array[String]): Unit = {
     class Iter extends StringIterator("Scala") with RichIterator
     val iter = new Iter
-    iter foreach println
+    iter.foreach(println)
   }
 }
 ```
diff --git a/_pt-br/tour/operators.md b/_pt-br/tour/operators.md
index 627b968e73..b1d716f6c6 100644
--- a/_pt-br/tour/operators.md
+++ b/_pt-br/tour/operators.md
@@ -13,8 +13,8 @@ Qualquer método que tenha um único parâmetro pode ser usado como um *operador
 
 ```scala mdoc
 case class MyBool(x: Boolean) {
-  def and(that: MyBool): MyBool = if (x) that else this
-  def or(that: MyBool): MyBool = if (x) this else that
+  infix def and(that: MyBool): MyBool = if (x) that else this
+  infix def or(that: MyBool): MyBool = if (x) this else that
   def negate: MyBool = MyBool(!x)
 }
 ```
diff --git a/_ru/overviews/collections-2.13/iterators.md b/_ru/overviews/collections-2.13/iterators.md
index 2c472e918f..9c0237d464 100644
--- a/_ru/overviews/collections-2.13/iterators.md
+++ b/_ru/overviews/collections-2.13/iterators.md
@@ -18,12 +18,12 @@ language: ru
 
 У итераторов в Scala есть аналоги большинству методов, которые вы можете найдти в классах `Traversable`, `Iterable` и `Seq`. Например, метод "foreach", который на итераторе выполняет процедуру на каждом элементе, возвращаемого итератором. Используя `foreach`, описанный выше цикл можно сократить до:
 
-    it foreach println
+    it.foreach(println)
 
 Как всегда, "for выражения" могут быть использованы в качестве альтернативного синтаксиса для выражений, включающих в себя `foreach`, `map`, ` WithFilter` и `flatMap`, поэтому еще одним способом вывести все элементы, возвращаемые итератором, будет:
 
     for (elem <- it) println(elem)
-    
+
 Существует важное различие между методом foreach на итераторах и тем же методом на _traversable_ коллекциях: При вызове метода `foreach` на итераторе, итератор остается в конце, указывая что все элементы закончились. Поэтому очередной вызов `next` на томже самом итераторе выбросит исключение `NoSuchElementException`. В отличие от этого, при обращении к коллекции, команда `foreach` оставляет количество элементов в коллекции неизменным (если только переданная функция не добавляет элементов, но это крайне не желательно, так как может привести к неожиданным результатам).
 
 Другие общие операции между `Iterator` и `Iterable`, имеют одни и те же свойства. Например, итераторы предоставляют метод `map`, который возвращает новый итератор:
@@ -34,7 +34,7 @@ language: ru
     res1: Iterator[Int] = <iterator>
     scala> it.hasNext
     res2: Boolean = true
-    scala> res1 foreach println
+    scala> res1.foreach(println)
     1
     6
     2
@@ -69,13 +69,13 @@ language: ru
     scala> val count = ns.map(_.length).sum
     count: Int = 14
 
-Оба итератора работают независимо друг от друга: продвижение одного не влияет на другого, так что каждый из них может быть модифицирован независимо от другого. 
+Оба итератора работают независимо друг от друга: продвижение одного не влияет на другого, так что каждый из них может быть модифицирован независимо от другого.
 Может создаться впечатление что итератор подвергается двойному обходу над элементами, но это не так, результат достигается за счет внутреннего буферизации.
 Как обычно, базовый итератор `it` не пригоден для прямого использования и должен быть исключен из дальнейших операций.
 
 Обобщая вышесказанное, итераторы ведут себя как коллекции, _если после вызова метода на них сам итератор больше не вызывается_. В библиотеке коллекции Scala это достигается явным образом с помощью абстракции [IterableOnce](https://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/IterableOnce.html), который является общим суперкласом для [Iterable](https://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/Iterable.html) и [Iterator](https://www.scala-lang.org/api/{{ site.scala-version }}/scala/collection/Iterator.html). У `IterableOnce[A]` только два метода: `iterator: Iterator[A]` и `knownSize: Int`.
 
-Если объект `IterableOnce` является `Iterator`, то его операция `iterator` всегда возвращает себя, в своем текущем состоянии, но если он `Iterable`, то операция `iterator` всегда возвращает новый `Iterator`. Типовой вариант использования `IterableOnce` - в качестве типа аргумента для методов, которые могут принимать или итератор или коллекцию в качестве аргумента. Примером может служить метод соединения `concat` в классе `Iterable`. Он принимает `IterableOnce` параметр, поэтому вы можете соединять элементы, поступающие или из итератора или коллекции. 
+Если объект `IterableOnce` является `Iterator`, то его операция `iterator` всегда возвращает себя, в своем текущем состоянии, но если он `Iterable`, то операция `iterator` всегда возвращает новый `Iterator`. Типовой вариант использования `IterableOnce` - в качестве типа аргумента для методов, которые могут принимать или итератор или коллекцию в качестве аргумента. Примером может служить метод соединения `concat` в классе `Iterable`. Он принимает `IterableOnce` параметр, поэтому вы можете соединять элементы, поступающие или из итератора или коллекции.
 
 Все операции на итераторах собраны в таблице ниже.
 
@@ -165,7 +165,7 @@ language: ru
 
 Ленивая операция не сразу вычисляет результаты. Вместо этого она рассчитывает результаты тогда когда они непосредственно запрашиваются.
 
-Поэтому выражение `(1 to 10).iterator.map(println)` не выведет ничего на экран. 
+Поэтому выражение `(1 to 10).iterator.map(println)` не выведет ничего на экран.
 Метод `map` в данном случае не применяет функцию в аргументе к значениям в диапазоне, вместо этого будет возвращен новый `Iterator`, который будет выполнять операции тогда когда будет запрошен их результат. Добавление `.toList` в конец этого выражения фактически вызовет вывод элементов на печать.
 
 Как следствие, такие методы как `map` или `filter` не обязательно применят функцию в аргументе ко всем входным элементам. Выражение `(1 to 10).iterator.map(println).take(5).toList` выводит только значения от `1` до `5`, поскольку это те значения, которые запрашиваются у `Iterator`, возвращаемого из `map`.
diff --git a/_ru/tour/extractor-objects.md b/_ru/tour/extractor-objects.md
index f93981cd6c..1dfd29d68f 100644
--- a/_ru/tour/extractor-objects.md
+++ b/_ru/tour/extractor-objects.md
@@ -69,7 +69,7 @@ customer1ID match
 
 ```scala mdoc
 val customer2ID = CustomerID("Nico")
-val CustomerID(name) = customer2ID
+val CustomerID(name) = customer2ID: @unchecked
 println(name)  // выведет Nico
 ```
 
@@ -84,7 +84,7 @@ println(name)  // выведет Nico
 {% tab 'Scala 2 и 3' for=extractor-objects_use-case-2 %}
 
 ```scala mdoc
-val CustomerID(name2) = "--asdfasdfasdf"
+val CustomerID(name2) = "--asdfasdfasdf": @unchecked
 ```
 
 {% endtab %}
diff --git a/_ru/tour/mixin-class-composition.md b/_ru/tour/mixin-class-composition.md
index d8cbb24f30..a3ab5ba0d9 100644
--- a/_ru/tour/mixin-class-composition.md
+++ b/_ru/tour/mixin-class-composition.md
@@ -106,7 +106,7 @@ class StringIterator(s: String) extends AbsIterator {
   private var i = 0
   def hasNext = i < s.length
   def next() = {
-    val ch = s charAt i
+    val ch = s.charAt(i)
     i += 1
     ch
   }
@@ -123,7 +123,7 @@ class StringIterator(s: String) extends AbsIterator:
   private var i = 0
   def hasNext = i < s.length
   def next() =
-    val ch = s charAt i
+    val ch = s.charAt(i)
     i += 1
     ch
 ```
@@ -176,7 +176,7 @@ trait RichIterator extends AbsIterator:
 ```scala mdoc
 class RichStringIter extends StringIterator("Scala") with RichIterator
 val richStringIter = new RichStringIter
-richStringIter.foreach(println)
+richStringIter.foreach(println).foreach(println)
 ```
 
 {% endtab %}
diff --git a/_ru/tour/multiple-parameter-lists.md b/_ru/tour/multiple-parameter-lists.md
index 99f84700d5..91918dad55 100644
--- a/_ru/tour/multiple-parameter-lists.md
+++ b/_ru/tour/multiple-parameter-lists.md
@@ -173,7 +173,7 @@ def execute(arg: Int)(using ec: scala.concurrent.ExecutionContext) = ???
 
 ```scala mdoc:nest
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
-val numberFunc = numbers.foldLeft(List[Int]()) _
+val numberFunc = numbers.foldLeft(List[Int]())
 
 val squares = numberFunc((xs, x) => xs :+ x*x)
 println(squares) // List(1, 4, 9, 16, 25, 36, 49, 64, 81, 100)
diff --git a/_ru/tour/operators.md b/_ru/tour/operators.md
index c8ec47bb3e..cf3f40c84a 100644
--- a/_ru/tour/operators.md
+++ b/_ru/tour/operators.md
@@ -89,8 +89,8 @@ case class MyBool(x: Boolean) {
 
 ```scala
 case class MyBool(x: Boolean):
-  def and(that: MyBool): MyBool = if x then that else this
-  def or(that: MyBool): MyBool = if x then this else that
+  infix def and(that: MyBool): MyBool = if x then that else this
+  infix def or(that: MyBool): MyBool = if x then this else that
   def negate: MyBool = MyBool(!x)
 ```
 
diff --git a/_tour/extractor-objects.md b/_tour/extractor-objects.md
index a859d6cdda..5879e479c1 100644
--- a/_tour/extractor-objects.md
+++ b/_tour/extractor-objects.md
@@ -66,7 +66,7 @@ Since a value definition can use a pattern to introduce a new variable, an extra
 {% tab 'Scala 2 and 3' for=extractor-objects_use-case-1 %}
 ```scala mdoc
 val customer2ID = CustomerID("Nico")
-val CustomerID(name) = customer2ID
+val CustomerID(name) = customer2ID: @unchecked
 println(name)  // prints Nico
 ```
 {% endtab %}
@@ -79,7 +79,7 @@ This is equivalent to `val name = CustomerID.unapply(customer2ID).get`.
 
 {% tab 'Scala 2 and 3' for=extractor-objects_use-case-2 %}
 ```scala mdoc
-val CustomerID(name2) = "--asdfasdfasdf"
+val CustomerID(name2) = "--asdfasdfasdf": @unchecked
 ```
 {% endtab %}
 
diff --git a/_tour/mixin-class-composition.md b/_tour/mixin-class-composition.md
index 27eeafbf61..1c802789d5 100644
--- a/_tour/mixin-class-composition.md
+++ b/_tour/mixin-class-composition.md
@@ -93,7 +93,7 @@ class StringIterator(s: String) extends AbsIterator {
   private var i = 0
   def hasNext = i < s.length
   def next() = {
-    val ch = s charAt i
+    val ch = s.charAt(i)
     i += 1
     ch
   }
@@ -108,7 +108,7 @@ class StringIterator(s: String) extends AbsIterator:
   private var i = 0
   def hasNext = i < s.length
   def next() =
-    val ch = s charAt i
+    val ch = s.charAt(i)
     i += 1
     ch
 ```
diff --git a/_tour/multiple-parameter-lists.md b/_tour/multiple-parameter-lists.md
index 324795b6c0..676ab8cfe2 100644
--- a/_tour/multiple-parameter-lists.md
+++ b/_tour/multiple-parameter-lists.md
@@ -146,7 +146,7 @@ For example,
 {% tabs foldLeft_partial class=tabs-scala-version %}
 
 {% tab 'Scala 2' for=foldLeft_partial %}
-```scala mdoc:nest
+```scala
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 val numberFunc = numbers.foldLeft(List[Int]()) _
 
@@ -159,7 +159,7 @@ println(cubes)  // List(1, 8, 27, 64, 125, 216, 343, 512, 729, 1000)
 {% endtab %}
 
 {% tab 'Scala 3' for=foldLeft_partial %}
-```scala
+```scala mdoc:nest
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 val numberFunc = numbers.foldLeft(List[Int]())
 
diff --git a/_tour/operators.md b/_tour/operators.md
index fb157ce334..12c4bd11b1 100644
--- a/_tour/operators.md
+++ b/_tour/operators.md
@@ -67,7 +67,7 @@ The class Vec has a method `+` which we used to add `vector1` and `vector2`. Usi
 
 {% tabs operators_4 class=tabs-scala-version %}
 {% tab 'Scala 2' for=operators_4 %}
-```scala mdoc
+```scala
 case class MyBool(x: Boolean) {
   def and(that: MyBool): MyBool = if (x) that else this
   def or(that: MyBool): MyBool = if (x) this else that
@@ -76,10 +76,10 @@ case class MyBool(x: Boolean) {
 ```
 {% endtab %}
 {% tab 'Scala 3' for=operators_4 %}
-```scala
+```scala mdoc
 case class MyBool(x: Boolean):
-  def and(that: MyBool): MyBool = if x then that else this
-  def or(that: MyBool): MyBool = if x then this else that
+  infix def and(that: MyBool): MyBool = if x then that else this
+  infix def or(that: MyBool): MyBool = if x then this else that
   def negate: MyBool = MyBool(!x)
 ```
 {% endtab %}
diff --git a/_zh-cn/overviews/collections/iterators.md b/_zh-cn/overviews/collections/iterators.md
index 68da25ed2b..1ba6ca5d45 100644
--- a/_zh-cn/overviews/collections/iterators.md
+++ b/_zh-cn/overviews/collections/iterators.md
@@ -17,7 +17,7 @@ language: zh-cn
 
 Scala为Traversable, Iterable和Seq类中的迭代器提供了许多类似的方法。比如：这些类提供了foreach方法以便在迭代器返回的每个元素上执行指定的程序。使用foreach方法可以将上面的循环缩写为：
 
-    it foreach println
+    it.foreach(println)
 
 与往常一样，for表达式可以作为foreach、map、withFilter和flatMap表达式的替代语法，所以另一种打印出迭代器返回的所有元素的方式会是这样：
 
@@ -31,7 +31,7 @@ Scala为Traversable, Iterable和Seq类中的迭代器提供了许多类似的方
     it: Iterator[java.lang.String] = non-empty iterator
     scala> it.map(_.length)
     res1: Iterator[Int] = non-empty iterator
-    scala> res1 foreach println
+    scala> res1.foreach(println)
     1
     6
     2
diff --git a/_zh-cn/tour/extractor-objects.md b/_zh-cn/tour/extractor-objects.md
index c74d946482..3914971b8b 100644
--- a/_zh-cn/tour/extractor-objects.md
+++ b/_zh-cn/tour/extractor-objects.md
@@ -39,14 +39,14 @@ customer1ID match {
 
 ```scala mdoc
 val customer2ID = CustomerID("Nico")
-val CustomerID(name) = customer2ID
+val CustomerID(name) = customer2ID: @unchecked
 println(name)  // prints Nico
 ```
 
 上面的代码等价于 `val name = CustomerID.unapply(customer2ID).get`。
 
 ```scala mdoc
-val CustomerID(name2) = "--asdfasdfasdf"
+val CustomerID(name2) = "--asdfasdfasdf": @unchecked
 ```
 
 如果没有匹配的值，会抛出 `scala.MatchError`：
diff --git a/_zh-cn/tour/implicit-parameters.md b/_zh-cn/tour/implicit-parameters.md
index e8e89451e6..cd9f04df9a 100644
--- a/_zh-cn/tour/implicit-parameters.md
+++ b/_zh-cn/tour/implicit-parameters.md
@@ -30,19 +30,19 @@ abstract class Monoid[A] {
 
 object ImplicitTest {
   implicit val stringMonoid: Monoid[String] = new Monoid[String] {
-    def add(x: String, y: String): String = x concat y
+    def add(x: String, y: String): String = x ++ y
     def unit: String = ""
   }
-  
+
   implicit val intMonoid: Monoid[Int] = new Monoid[Int] {
     def add(x: Int, y: Int): Int = x + y
     def unit: Int = 0
   }
-  
+
   def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
     if (xs.isEmpty) m.unit
     else m.add(xs.head, sum(xs.tail))
-    
+
   def main(args: Array[String]): Unit = {
     println(sum(List(1, 2, 3)))       // uses IntMonoid implicitly
     println(sum(List("a", "b", "c"))) // uses StringMonoid implicitly
diff --git a/_zh-cn/tour/mixin-class-composition.md b/_zh-cn/tour/mixin-class-composition.md
index 1b4c6bab36..8850deafc6 100644
--- a/_zh-cn/tour/mixin-class-composition.md
+++ b/_zh-cn/tour/mixin-class-composition.md
@@ -52,7 +52,7 @@ class StringIterator(s: String) extends AbsIterator {
   private var i = 0
   def hasNext = i < s.length
   def next() = {
-    val ch = s charAt i
+    val ch = s.charAt(i)
     i += 1
     ch
   }
@@ -77,7 +77,7 @@ trait RichIterator extends AbsIterator {
 object StringIteratorTest extends App {
   class RichStringIter extends StringIterator("Scala") with RichIterator
   val richStringIter = new RichStringIter
-  richStringIter foreach println
+  richStringIter.foreach(println)
 }
 ```
 
diff --git a/_zh-cn/tour/operators.md b/_zh-cn/tour/operators.md
index 9bca79a928..23b64b93f9 100644
--- a/_zh-cn/tour/operators.md
+++ b/_zh-cn/tour/operators.md
@@ -38,8 +38,8 @@ vector3.y  // 3.0
 
 ```scala mdoc
 case class MyBool(x: Boolean) {
-  def and(that: MyBool): MyBool = if (x) that else this
-  def or(that: MyBool): MyBool = if (x) this else that
+  infix def and(that: MyBool): MyBool = if (x) that else this
+  infix def or(that: MyBool): MyBool = if (x) this else that
   def negate: MyBool = MyBool(!x)
 }
 ```
diff --git a/scripts/run-mdoc.sh b/scripts/run-mdoc.sh
index 6eba63be0c..4de516c5fa 100755
--- a/scripts/run-mdoc.sh
+++ b/scripts/run-mdoc.sh
@@ -1,12 +1,11 @@
 #!/bin/bash
 set -eux
 
-cs launch --scala-version 2.13.17 org.scalameta::mdoc:2.3.3 -- \
+cs launch --scala-version 3.7.4 org.scalameta::mdoc:2.8.0 -- \
   --in . \
   --out /tmp/mdoc-out/ \
   --classpath \
-  $(cs fetch --scala-version 2.13.17 -p \
-    com.chuusai::shapeless:2.3.10 \
+  $(cs fetch --scala-version 3.7.4 -p \
     org.scala-lang::toolkit:0.7.0 \
     org.scala-lang::toolkit-test:0.7.0 \
   ) \