From b6d2fd5f98f7380ede80b4b67b688e00af8b5b8f Mon Sep 17 00:00:00 2001
From: Julien Richard-Foy <julien@richard-foy.fr>
Date: Tue, 5 Jul 2022 16:11:42 +0200
Subject: [PATCH] Remove remaining references to scalafiddle

We also re-generated the Gemfile.lock
---
 Gemfile                                 |  1 -
 Gemfile.lock                            | 79 ++++++++++++-------------
 _ba/tour/basics.md                      |  2 -
 _config.yml                             |  1 -
 _es/tour/basics.md                      | 14 -----
 _es/tour/multiple-parameter-lists.md    |  4 --
 _ja/tour/basics.md                      | 14 -----
 _ja/tour/multiple-parameter-lists.md    |  2 -
 _ja/tour/nested-functions.md            |  2 -
 _ko/tour/basics.md                      | 14 -----
 _pl/tour/basics.md                      | 28 ---------
 _pl/tour/mixin-class-composition.md     |  2 -
 _pl/tour/multiple-parameter-lists.md    |  2 -
 _pl/tour/nested-functions.md            |  2 -
 _pl/tour/traits.md                      |  4 --
 _pl/tour/tuples.md                      |  4 --
 _pl/tour/unified-types.md               |  2 -
 _ru/tour/basics.md                      | 14 -----
 _ru/tour/nested-functions.md            |  2 -
 _sips/minutes/2018-08-30-sip-minutes.md |  2 +-
 _th/tour/basics.md                      | 14 -----
 _tour/basics.md                         | 14 -----
 _tour/multiple-parameter-lists.md       |  2 -
 _tour/nested-functions.md               |  2 -
 _zh-cn/tour/basics.md                   | 14 -----
 25 files changed, 38 insertions(+), 203 deletions(-)

diff --git a/Gemfile b/Gemfile
index 2152cdafa4..7b332fd508 100644
--- a/Gemfile
+++ b/Gemfile
@@ -1,6 +1,5 @@
 source 'https://rubygems.org'
 gem 'jekyll-redirect-from'
-gem 'jekyll-scalafiddle'
 gem 'html-proofer'
 gem 'kramdown-parser-gfm'
 # gem 'html-proofer' # link-checking: bundle exec htmlproofer ./_site/ --only-4xx --empty-alt-ignore --allow-hash-href
diff --git a/Gemfile.lock b/Gemfile.lock
index 10b4148d6c..3297867749 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -4,93 +4,88 @@ GEM
     addressable (2.8.0)
       public_suffix (>= 2.0.2, < 5.0)
     colorator (1.1.0)
-    concurrent-ruby (1.1.8)
-    em-websocket (0.5.2)
+    concurrent-ruby (1.1.10)
+    em-websocket (0.5.3)
       eventmachine (>= 0.12.9)
-      http_parser.rb (~> 0.6.0)
-    ethon (0.12.0)
-      ffi (>= 1.3.0)
+      http_parser.rb (~> 0)
+    ethon (0.15.0)
+      ffi (>= 1.15.0)
     eventmachine (1.2.7)
-    ffi (1.15.0)
+    ffi (1.15.5)
     forwardable-extended (2.6.0)
-    html-proofer (3.15.3)
+    html-proofer (3.19.4)
       addressable (~> 2.3)
       mercenary (~> 0.3)
-      nokogumbo (~> 2.0)
-      parallel (~> 1.3)
+      nokogiri (~> 1.13)
+      parallel (~> 1.10)
       rainbow (~> 3.0)
       typhoeus (~> 1.3)
       yell (~> 2.0)
-    http_parser.rb (0.6.0)
-    i18n (0.9.5)
+    http_parser.rb (0.8.0)
+    i18n (1.10.0)
       concurrent-ruby (~> 1.0)
-    jekyll (3.9.1)
+    jekyll (4.2.2)
       addressable (~> 2.4)
       colorator (~> 1.0)
       em-websocket (~> 0.5)
-      i18n (~> 0.7)
-      jekyll-sass-converter (~> 1.0)
+      i18n (~> 1.0)
+      jekyll-sass-converter (~> 2.0)
       jekyll-watch (~> 2.0)
-      kramdown (>= 1.17, < 3)
+      kramdown (~> 2.3)
+      kramdown-parser-gfm (~> 1.0)
       liquid (~> 4.0)
-      mercenary (~> 0.3.3)
+      mercenary (~> 0.4.0)
       pathutil (~> 0.9)
-      rouge (>= 1.7, < 4)
+      rouge (~> 3.0)
       safe_yaml (~> 1.0)
+      terminal-table (~> 2.0)
     jekyll-redirect-from (0.16.0)
       jekyll (>= 3.3, < 5.0)
-    jekyll-sass-converter (1.5.2)
-      sass (~> 3.4)
-    jekyll-scalafiddle (1.0.1)
-      jekyll (~> 3.0)
+    jekyll-sass-converter (2.2.0)
+      sassc (> 2.0.1, < 3.0)
     jekyll-watch (2.2.1)
       listen (~> 3.0)
-    kramdown (2.3.1)
+    kramdown (2.4.0)
       rexml
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
     liquid (4.0.3)
-    listen (3.5.1)
+    listen (3.7.1)
       rb-fsevent (~> 0.10, >= 0.10.3)
       rb-inotify (~> 0.9, >= 0.9.10)
-    mercenary (0.3.6)
-    mini_portile2 (2.8.0)
-    nokogiri (1.13.6)
-      mini_portile2 (~> 2.8.0)
+    mercenary (0.4.0)
+    nokogiri (1.13.6-x86_64-linux)
       racc (~> 1.4)
-    nokogumbo (2.0.2)
-      nokogiri (~> 1.8, >= 1.8.4)
-    parallel (1.19.2)
+    parallel (1.22.1)
     pathutil (0.16.2)
       forwardable-extended (~> 2.6)
-    public_suffix (4.0.6)
+    public_suffix (4.0.7)
     racc (1.6.0)
-    rainbow (3.0.0)
-    rb-fsevent (0.11.0)
+    rainbow (3.1.1)
+    rb-fsevent (0.11.1)
     rb-inotify (0.10.1)
       ffi (~> 1.0)
     rexml (3.2.5)
-    rouge (3.26.0)
+    rouge (3.29.0)
     safe_yaml (1.0.5)
-    sass (3.7.4)
-      sass-listen (~> 4.0.0)
-    sass-listen (4.0.0)
-      rb-fsevent (~> 0.9, >= 0.9.4)
-      rb-inotify (~> 0.9, >= 0.9.7)
+    sassc (2.4.0)
+      ffi (~> 1.9)
+    terminal-table (2.0.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
     typhoeus (1.4.0)
       ethon (>= 0.9.0)
+    unicode-display_width (1.8.0)
     webrick (1.7.0)
     yell (2.2.2)
 
 PLATFORMS
-  ruby
+  x86_64-linux
 
 DEPENDENCIES
   html-proofer
   jekyll-redirect-from
-  jekyll-scalafiddle
   kramdown-parser-gfm
   webrick (~> 1.7)
 
 BUNDLED WITH
-   2.3.6
+   2.3.10
diff --git a/_ba/tour/basics.md b/_ba/tour/basics.md
index 0734ab5c7f..3112cb7850 100644
--- a/_ba/tour/basics.md
+++ b/_ba/tour/basics.md
@@ -157,7 +157,6 @@ Postoje i neke druge razlike, ali zasad, možete misliti o njima kao nečemu sli
 
 Metode mogu imati višelinijske izraze također.
 
-{% scalafiddle %}
 ```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
@@ -165,7 +164,6 @@ def getSquareString(input: Double): String = {
 }
 println(getSquareString(2.5)) // 6.25
 ```
-{% endscalafiddle %}
 
 Zadnjo izraz u tijelu metode je povratna vrijednost metode. (Scala ima ključnu riječ `return`, ali se rijetko koristi.)
 
diff --git a/_config.yml b/_config.yml
index 7a1c2219de..fab154effe 100644
--- a/_config.yml
+++ b/_config.yml
@@ -206,4 +206,3 @@ scala3ref: "https://docs.scala-lang.org/scala3/reference"
 exclude: ["vendor"]
 plugins:
   - jekyll-redirect-from
-  - jekyll-scalafiddle
diff --git a/_es/tour/basics.md b/_es/tour/basics.md
index 77f908b386..dcba773802 100644
--- a/_es/tour/basics.md
+++ b/_es/tour/basics.md
@@ -33,14 +33,12 @@ Las expresiones son sentencias computables.
 
 Se puede ver el resultado de evaluar expresiones usando `println`.
 
-{% scalafiddle %}
 ```scala mdoc
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
 println("Hello," + " world!") // Hello, world!
 ```
-{% endscalafiddle %}
 
 ## Valores
 
@@ -110,21 +108,17 @@ La lista de parámetros de la función está a la izquierda de la flecha `=>`, y
 
 También podemos asignarle un nombre a la función.
 
-{% scalafiddle %}
 ```scala mdoc
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
-{% endscalafiddle %}
 
 Las funciones pueden tomar varios parámetros.
 
-{% scalafiddle %}
 ```scala mdoc
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 O ninguno.
 
@@ -139,23 +133,19 @@ Los métodos se parecen y comportan casi como a las funciones, pero se diferenci
 
 Un método se define con la palabra reservada `def`, seguida por el nombre del método, la lista de parámetros, el tipo de valores que el método devuelve, y el cuerpo del método.
 
-{% scalafiddle %}
 ```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 Observe que el tipo de retorno se declara _después_ de la lista de parámetros, y separado con dos puntos, p.ej. `: Int`.
 
 Un método puede tener varias listas de parámetros.
 
-{% scalafiddle %}
 ```scala mdoc
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
-{% endscalafiddle %}
 
 O ninguna lista de parámetros.
 
@@ -168,7 +158,6 @@ Hay otras diferencias, pero para simplificar, podemos pensar que son similares a
 
 Los métodos también pueden tener expresiones de varias lineas.
 
-{% scalafiddle %}
 ```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
@@ -176,7 +165,6 @@ def getSquareString(input: Double): String = {
 }
 println(getSquareString(2.5)) // 6.25
 ```
-{% endscalafiddle %}
 
 La ultima expresión en el cuerpo del método es el valor de retorno del mismo.
 (Scala tiene una palabra reservada `return`, pero se usa raramente y no se aconseja usarla)
@@ -279,7 +267,6 @@ trait Greeter {
 
 Un `trait` también puede definir un método, o un valor, con una implementación por defecto.
 
-{% scalafiddle %}
 ```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
@@ -304,7 +291,6 @@ greeter.greet("Scala developer") // Hello, Scala developer!
 val customGreeter = new CustomizableGreeter("How are you, ", "?")
 customGreeter.greet("Scala developer") // How are you, Scala developer?
 ```
-{% endscalafiddle %}
 
 Aquí, `DefaultGreeter` extiende un solo trait, pero puede extender múltiples traits.
 
diff --git a/_es/tour/multiple-parameter-lists.md b/_es/tour/multiple-parameter-lists.md
index 9ed0531042..cdb652151d 100644
--- a/_es/tour/multiple-parameter-lists.md
+++ b/_es/tour/multiple-parameter-lists.md
@@ -26,18 +26,15 @@ def foldLeft[B](z: B)(op: (B, A) => B): B
 
 Comenzando con un valor inicial 0, `foldLeft` aplica la función `(m, n) => m + n` a cada uno de los elementos de la lista y al valor acumulado previo.
 
-{% scalafiddle %}
 ```scala mdoc
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 val res = numbers.foldLeft(0)((m, n) => m + n)
 println(res) // 55
 ```
-{% endscalafiddle %}
 
 
 A continuación se muestra otro ejemplo:
 
-{% scalafiddle %}
 ```scala mdoc
     object CurryTest extends App {
 
@@ -53,7 +50,6 @@ A continuación se muestra otro ejemplo:
       println(filter(nums, modN(3)))
     }
 ```
-{% endscalafiddle %}
 
 _Nota: el método `modN` está parcialmente aplicado en las dos llamadas a `filter`; esto significa que solo su primer argumento es realmente aplicado. El término `modN(2)` devuelve una función de tipo `Int => Boolean` y es por eso un posible candidato para el segundo argumento de la función `filter`._
 
diff --git a/_ja/tour/basics.md b/_ja/tour/basics.md
index 7010cadab8..1108cbf3ba 100644
--- a/_ja/tour/basics.md
+++ b/_ja/tour/basics.md
@@ -32,14 +32,12 @@ Scastieを利用することでブラウザ上でScalaを実行することが
 ```
 `println`を使うことで、式の結果を出力できます。
 
-{% scalafiddle %}
 ```scala mdoc
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
 println("Hello," + " world!") // Hello, world!
 ```
-{% endscalafiddle %}
 
 ### 値
 
@@ -110,21 +108,17 @@ println({
 
 関数には名前をつけることもできます。
 
-{% scalafiddle %}
 ```scala mdoc
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
-{% endscalafiddle %}
 
 関数は複数のパラメーターをとることもできます。
 
-{% scalafiddle %}
 ```scala mdoc
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 またパラメーターを取らないこともありえます。
 
@@ -139,23 +133,19 @@ println(getTheAnswer()) // 42
 
 メソッドは `def` キーワードで定義されます。 `def` の後ろには名前、パラメーターリスト、戻り値の型、処理の内容が続きます。
 
-{% scalafiddle %}
 ```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 戻り値の型は引数リストとコロンの「後ろ」に宣言することに注意してください。`: Int`
 
 メソッドは複数のパラメーターリストを受け取ることができます。
 
-{% scalafiddle %}
 ```scala mdoc
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
-{% endscalafiddle %}
 
 また、パラメーターリストを一切受け取らないこともあります。
 
@@ -167,7 +157,6 @@ println("Hello, " + name + "!")
 
 メソッドは複数行の式も持つことができます。
 
-{% scalafiddle %}
 ```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
@@ -175,7 +164,6 @@ def getSquareString(input: Double): String = {
 }
 println(getSquareString(2.5)) // 6.25
 ```
-{% endscalafiddle %}
 
 メソッド本体にある最後の式はメソッドの戻り値になります。(Scalaには`return`キーワードはありますが、めったに使われません。)
 
@@ -278,7 +266,6 @@ trait Greeter {
 
 トレイトはデフォルトの実装を持つこともできます。
 
-{% scalafiddle %}
 ```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
@@ -303,7 +290,6 @@ greeter.greet("Scala developer") // Hello, Scala developer!
 val customGreeter = new CustomizableGreeter("How are you, ", "?")
 customGreeter.greet("Scala developer") // How are you, Scala developer?
 ```
-{% endscalafiddle %}
 
 ここでは、`DefaultGreeter`は一つのトレイトだけを継承していますが、複数のトレイトを継承することもできます。
 
diff --git a/_ja/tour/multiple-parameter-lists.md b/_ja/tour/multiple-parameter-lists.md
index c9b70ec998..eb8fffd6cb 100644
--- a/_ja/tour/multiple-parameter-lists.md
+++ b/_ja/tour/multiple-parameter-lists.md
@@ -22,13 +22,11 @@ def foldLeft[B](z: B)(op: (B, A) => B): B
 
 初期値0から始まり、`foldLeft`はここではリスト内の各要素とその一つ前の累積値に関数`(m, n) => m + n`を適用します。
 
-{% scalafiddle %}
 ```scala mdoc
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 val res = numbers.foldLeft(0)((m, n) => m + n)
 println(res) // 55
 ```
-{% endscalafiddle %}
 
 ### ユースケース
 推奨される複数パラメータリストのユースケースは次の通りです。
diff --git a/_ja/tour/nested-functions.md b/_ja/tour/nested-functions.md
index 9fa581bc3e..0e6980451f 100644
--- a/_ja/tour/nested-functions.md
+++ b/_ja/tour/nested-functions.md
@@ -11,7 +11,6 @@ previous-page: higher-order-functions
 Scalaではメソッドの定義をネストする（_訳注：入れ子にする_）ことができます。
 以下のコードは与えられた数値の階乗を計算するための`factorial`メソッドを提供します。
 
-{% scalafiddle %}
 ```scala mdoc
  def factorial(x: Int): Int = {
     def fact(x: Int, accumulator: Int): Int = {
@@ -24,7 +23,6 @@ Scalaではメソッドの定義をネストする（_訳注：入れ子にす
  println("Factorial of 2: " + factorial(2))
  println("Factorial of 3: " + factorial(3))
 ```
-{% endscalafiddle %}
 
 このプログラムの出力は以下の通りです。
 
diff --git a/_ko/tour/basics.md b/_ko/tour/basics.md
index 3b1eb665bc..b8dd2a3259 100644
--- a/_ko/tour/basics.md
+++ b/_ko/tour/basics.md
@@ -34,14 +34,12 @@ Scastie를 사용하면 브라우저에서 스칼라를 실행해 볼 수 있다
 
 `println` 표현식을 사용해 결과를 출력할 수 있다.
 
-{% scalafiddle %}
 ```scala mdoc
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
 println("Hello," + " world!") // Hello, world!
 ```
-{% endscalafiddle %}
 
 ### 값
 
@@ -110,21 +108,17 @@ println({
 
 함수에 이름을 지정할 수 있다.
 
-{% scalafiddle %}
 ```scala mdoc
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
-{% endscalafiddle %}
 
 함수는 여러 매개변수를 가질 수 있다.
 
-{% scalafiddle %}
 ```scala mdoc
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 또는 매개변수를 가지지 않을 수도 있다.
 
@@ -139,23 +133,19 @@ println(getTheAnswer()) // 42
 
 `def` 키워드로 메소드를 정의하고 이름, 매개변수 목록, 반환 타입 그리고 본문이 뒤따른다.
 
-{% scalafiddle %}
 ```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 매개변수 목록과 `: Int` 뒤에 반환 타입이 어떻게 선언되는지 주목하자.
 
 메소드는 여러 매개변수 목록을 가질 수 있다.
 
-{% scalafiddle %}
 ```scala mdoc
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
-{% endscalafiddle %}
 
 또는 매개변수 목록을 가지지 않을 수도 있다.
 
@@ -168,7 +158,6 @@ println("Hello, " + name + "!")
 
 메소드는 여러 줄의 표현식을 가질 수 있다.
 
-{% scalafiddle %}
 ```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
@@ -176,7 +165,6 @@ def getSquareString(input: Double): String = {
 }
 println(getSquareString(2.5)) // 6.25
 ```
-{% endscalafiddle %}
 
 본문의 마지막 표현식은 메소드의 반환 값이다. (스칼라는 `return` 키워드가 있지만 거의 사용하지 않고 생략한다.)
 
@@ -277,7 +265,6 @@ trait Greeter {
 
 또한 트레이트는 기본 구현도 가질 수 있다.
 
-{% scalafiddle %}
 ```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
@@ -302,7 +289,6 @@ greeter.greet("Scala developer") // Hello, Scala developer!
 val customGreeter = new CustomizableGreeter("How are you, ", "?")
 customGreeter.greet("Scala developer") // How are you, Scala developer?
 ```
-{% endscalafiddle %}
 
 `DefaultGreeter` 는 트레이트 하나만 상속하고 있지만 다중 상속도 가능하다.
 
diff --git a/_pl/tour/basics.md b/_pl/tour/basics.md
index 0ef54f6a33..d9083fb1cf 100644
--- a/_pl/tour/basics.md
+++ b/_pl/tour/basics.md
@@ -34,14 +34,12 @@ Wyrażenia są rezultatem ewaluacji fragmentów kodu.
 
 Wyniki wyrażeń można wyświetlić za pomocą funkcji `println`.
 
-{% scalafiddle %}
 ```scala mdoc
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
 println("Hello," + " world!") // Hello, world!
 ```
-{% endscalafiddle %}
 
 ### Wartości
 
@@ -74,13 +72,11 @@ Zauważ, że deklaracja `Int` pojawia po identyfikatorze `x`, potrzebny jest ró
 Zmienne są podobne do wartości, ale z tym wyjątkiem, że można je ponownie przypisywać.
 Zmienną można zdefiniować używając słowa kluczowego `var`.
 
-{% scalafiddle %}
 ```scala mdoc:nest
 var x = 1 + 1
 x = 3 // Kompiluje się, ponieważ "x" jest zdefiniowane z użyciem "var".
 println(x * x) // 9
 ```
-{% endscalafiddle %}
 
 Tak jak przy wartościach, można wyraźnie zdefiniować żądany typ:
 
@@ -94,14 +90,12 @@ Wyrażenia mogą być łączone poprzez zamknięcie ich w nawiasie klamrowym`{}`
 Taką konstrukcję nazywamy blokiem.
 Wynikiem całego bloku kodu jest wynik ostatniego wyrażenia w tym bloku.
 
-{% scalafiddle %}
 ```scala mdoc
 println({
   val x = 1 + 1
   x + 1
 }) // 3
 ```
-{% endscalafiddle %}
 
 ## Funkcje
 
@@ -118,30 +112,24 @@ Po prawej stronie - wyrażenie wykorzystujące te parametry.
 
 Funkcje można również nazywać.
 
-{% scalafiddle %}
 ```scala mdoc
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
-{% endscalafiddle %}
 
 Funkcje mogą przyjmować wiele parametrów.
 
-{% scalafiddle %}
 ```scala mdoc
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 Mogą też wcale nie mieć parametrow.
 
-{% scalafiddle %}
 ```scala mdoc
 val getTheAnswer = () => 42
 println(getTheAnswer()) // 42
 ```
-{% endscalafiddle %}
 
 ## Metody
 
@@ -150,38 +138,31 @@ Metody wyglądają i zachowują się bardzo podobnie jak funkcje, jednak jest mi
 Metody są definiowane z użyciem słowa kluczowego `def`.
 Po `def` następuje nazwa metody, lista parametrów, zwracany typ i ciało metody.
 
-{% scalafiddle %}
 ```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 Zauważ, że zwracany typ jest zadeklarowany _po_ liście parametrów i dwukropku `: Int`.
 
 Metody mogą mieć wiele list parametrów.
 
-{% scalafiddle %}
 ```scala mdoc
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
-{% endscalafiddle %}
 
 Mogą również wcale ich nie posiadać.
 
-{% scalafiddle %}
 ```scala mdoc
 def name: String = System.getProperty("user.name")
 println("Hello, " + name + "!")
 ```
-{% endscalafiddle %}
 
 Od funkcji odróżnia je jeszcze kilka innych rzeczy, ale na razie możesz o nich myśleć jak o bardzo podobnych do funkcji.
 
 Metody mogą zawierać również wyrażenia wielowierszowe.
 
-{% scalafiddle %}
 ```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
@@ -189,7 +170,6 @@ def getSquareString(input: Double): String = {
 }
 println(getSquareString(2.5)) // 6.25
 ```
-{% endscalafiddle %}
 
 Ostatnie wyrażenie w ciele metody jest wartością, jaką zwraca cała metoda.
 Scala posiada słowo kluczowe `return`, ale jest ono wykorzystywane bardzo rzadko.
@@ -198,7 +178,6 @@ Scala posiada słowo kluczowe `return`, ale jest ono wykorzystywane bardzo rzadk
 
 Klasy są definiowane za pomocą słowa kluczowego `class`, po którym następuje nazwa klasy i parametry konstruktora.
 
-{% scalafiddle %}
 ```scala mdoc
 class Greeter(prefix: String, suffix: String) {
   def greet(name: String): Unit =
@@ -216,7 +195,6 @@ Nowe instancje klasy tworzy się za pomocą słowa kluczowego `new`.
 val greeter = new Greeter("Hello, ", "!")
 greeter.greet("Scala developer") // Hello, Scala developer!
 ```
-{% endscalafiddle %}
 
 Klasy zostaną szerzej omówione w [dalszej części](classes.html) tego przewodnika.
 
@@ -226,7 +204,6 @@ W Scali istnieje spacjalny typ klasy - klasa "przypadku" (case class).
 Klasy przypadku są domyślnie niezmienne i porównywane przez wartości.
 Klasy te można definiować używająć słów kluczowych `case class`.
 
-{% scalafiddle %}
 ```scala mdoc
 case class Point(x: Int, y: Int)
 ```
@@ -254,7 +231,6 @@ if (point == yetAnotherPoint) {
   println(point + " i " + yetAnotherPoint + " są inne.")
 } // Point(1,2) i Point(2,2) są inne.
 ```
-{% endscalafiddle %}
 
 Klasy przypadków to dużo szerszy temat, do zapoznania z którym bardzo zachęcamy. Jesteśmy pewni, że Ci się spodoba!
 Jest on dokładnie omówiony w [późniejszym rozdziale](case-classes.html).
@@ -266,7 +242,6 @@ Można o nich myśleć jak o instancjach ich własnych klas - singletonach.
 
 Objekty definiuje się z użyciem słowa kluczowego `object`.
 
-{% scalafiddle %}
 ```scala mdoc
 object IdFactory {
   private var counter = 0
@@ -285,7 +260,6 @@ println(newId) // 1
 val newerId: Int = IdFactory.create()
 println(newerId) // 2
 ```
-{% endscalafiddle %}
 
 Obiekty zostaną szerzej omówione [później](singleton-objects.html).
 
@@ -304,7 +278,6 @@ trait Greeter {
 
 Cechy mogą zawierać domyślną implementację.
 
-{% scalafiddle %}
 ```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
@@ -329,7 +302,6 @@ greeter.greet("Scala developer") // Hello, Scala developer!
 val customGreeter = new CustomizableGreeter("How are you, ", "?")
 customGreeter.greet("Scala developer") // How are you, Scala developer?
 ```
-{% endscalafiddle %}
 
 W tym przykładzie `DefaultGreeter` rozszerza tylko jedną cechę (trait), ale równie dobrze może rozszerzać ich wiele.
 
diff --git a/_pl/tour/mixin-class-composition.md b/_pl/tour/mixin-class-composition.md
index dc7ad8dc4e..9f346fd72c 100644
--- a/_pl/tour/mixin-class-composition.md
+++ b/_pl/tour/mixin-class-composition.md
@@ -11,7 +11,6 @@ previous-page: tuples
 
 Domieszka (ang. mixin) to cecha (trait), która używana jest do komponowania klas.
 
-{% scalafiddle %}
 ```scala mdoc
 abstract class A {
   val message: String
@@ -28,7 +27,6 @@ val d = new D
 println(d.message)  // wyświetli "Jestem instancją klasy B"
 println(d.loudMessage)  // wyświetli "JESTEM INSTANCJĄ KLASY B"
 ```
-{% endscalafiddle %}
 
 Klasa `D` posiada nadklasę `B` oraz domieszkę `C`.
 Klasy mogą mieć tylko jedną nadklasę, ale wiele domieszek (używając kolejno słów kluczowych `extends`, a następnie `with`).
diff --git a/_pl/tour/multiple-parameter-lists.md b/_pl/tour/multiple-parameter-lists.md
index 9bb9e100c5..ba88a323f8 100644
--- a/_pl/tour/multiple-parameter-lists.md
+++ b/_pl/tour/multiple-parameter-lists.md
@@ -23,13 +23,11 @@ Poniżej omówiony jest przykład użycia.
 
 Zaczynając od początkowej wartości 0, funkcja `foldLeft` stosuje funkcję `(m, n) => m + n` na każdym elemencie listy oraz poprzedniej zakumulowanej wartości.
 
-{% scalafiddle %}
 ```scala mdoc
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 val res = numbers.foldLeft(0)((m, n) => m + n)
 println(res) // 55
 ```
-{% endscalafiddle %}
 
 Metody z wieloma listami parametrów mają bardziej dosadną składnię wywoływania, dlatego powinny być używane oszczędnie.
 Sugerowane przypadki użycia obejmują:
diff --git a/_pl/tour/nested-functions.md b/_pl/tour/nested-functions.md
index 1531854082..88553a6d8e 100644
--- a/_pl/tour/nested-functions.md
+++ b/_pl/tour/nested-functions.md
@@ -12,7 +12,6 @@ previous-page: higher-order-functions
 Scala pozwala na zagnieżdżanie definicji funkcji.
 Poniższy obiekt określa funkcję `factorial`, która oblicza silnię dla danej liczby:
 
-{% scalafiddle %}
 ```scala mdoc
  def factorial(x: Int): Int = {
     def fact(x: Int, accumulator: Int): Int = {
@@ -25,7 +24,6 @@ Poniższy obiekt określa funkcję `factorial`, która oblicza silnię dla dane
  println("Factorial of 2: " + factorial(2))
  println("Factorial of 3: " + factorial(3))
 ```
-{% endscalafiddle %}
 
 Wynik działania powyższego programu:
 
diff --git a/_pl/tour/traits.md b/_pl/tour/traits.md
index 4751e0824d..b92057aa2a 100644
--- a/_pl/tour/traits.md
+++ b/_pl/tour/traits.md
@@ -38,7 +38,6 @@ Rozszerzenie cechy `trait Iterator[A]` wymaga wskazania parametru typu `A` oraz
 Aby rozszerzyć cechę należy użyć słowa kluczowego `extends`.
 Następnie wymagane jest zaimplementowanie abstrakcyjnych składników danej cechy używając słowa kluczowego `override.`
 
-{% scalafiddle %}
 ```scala mdoc:nest
 trait Iterator[A] {
   def hasNext: Boolean
@@ -61,7 +60,6 @@ val iterator = new IntIterator(10)
 println(iterator.next())  // wyświetli 0
 println(iterator.next())  // wyświetli 1
 ```
-{% endscalafiddle %}
 
 Klasa `IntIterator` przyjmuje parametr `to` (do) jako ograniczenie górne, oraz rozszerza `extends Iterator[Int]` - co oznacza, że metoda `next` musi zwrócić wartość typu Int.
 
@@ -69,7 +67,6 @@ Klasa `IntIterator` przyjmuje parametr `to` (do) jako ograniczenie górne, oraz
 
 Jeżeli w jakimś miejscu wymagana jest cecha pewnego typu, to zamiast niej można użyć jej podtypu.
 
-{% scalafiddle %}
 ```scala mdoc
 import scala.collection.mutable.ArrayBuffer
 
@@ -88,7 +85,6 @@ animals.append(dog)
 animals.append(cat)
 animals.foreach(pet => println(pet.name))  // wyświetli Harry Sally
 ```
-{% endscalafiddle %}
 
 Cecha `trait Pet` posiada abstrakcyjne pole `name`, które zostaje zaimplementowane przez klasy `Cat` i `Dog` w ich konstruktorach.
 W ostatnim wierszu wywołujemy `pet.name` musi być ono zaimplementowane przez każdy podtyp cechy `Pet`.
diff --git a/_pl/tour/tuples.md b/_pl/tour/tuples.md
index b415c1a348..752b3a9d41 100644
--- a/_pl/tour/tuples.md
+++ b/_pl/tour/tuples.md
@@ -52,7 +52,6 @@ println(quantity) // wyświetli 25
 
 Dekonstrukcja krotek może być bardzo przydatna w dopasowywaniu wzorców (ang. pattern matching)
 
-{% scalafiddle %}
 ```scala mdoc
 val planetDistanceFromSun = List(
   ("Mercury", 57.9),
@@ -69,11 +68,9 @@ planetDistanceFromSun.foreach {
     case _                    => println("Zbyt daleko...")
 }
 ```
-{% endscalafiddle %}
 
 Ma ona też zastosowanie w wyrażeniach 'for'.
 
-{% scalafiddle %}
 ```scala mdoc
 val numPairs = List((2, 5), (3, -7), (20, 56))
 
@@ -81,7 +78,6 @@ for ((a, b) <- numPairs) {
   println(a * b)
 }
 ```
-{% endscalafiddle %}
 
 Wartość `()` typu `Unit` jest koncepcyjnie taka sama jak wartość `()` typu `Tuple0`.
 Może być tylko jedna wartość tego typu, ponieważ nie zawiera żadnych elementów.
diff --git a/_pl/tour/unified-types.md b/_pl/tour/unified-types.md
index e93d2e893b..1845401acd 100644
--- a/_pl/tour/unified-types.md
+++ b/_pl/tour/unified-types.md
@@ -35,7 +35,6 @@ Jeżeli Scala użyta jest w kontekście środowiska uruchomieniowego Javy, to `A
 
 Poniższy przykład pokazuje, że łańcuchy znakowe, liczby całkowite, znaki, wartości logiczne oraz funkcje są obiektami tak samo jak każdy inny obiekt:
 
-{% scalafiddle %}
 ```scala mdoc
 val list: List[Any] = List(
   "Łancuch znaków",
@@ -47,7 +46,6 @@ val list: List[Any] = List(
 
 list.foreach(element => println(element))
 ```
-{% endscalafiddle %}
 
 Program deklaruje wartość `list` typu `List[Any]`.
 Lista jest zainicjowana elementami różnego typu, ale będącymi podtypami `scala.Any` - dlatego można je umieścić na tej liście.
diff --git a/_ru/tour/basics.md b/_ru/tour/basics.md
index af6e4ce4f3..b3ceaaae51 100644
--- a/_ru/tour/basics.md
+++ b/_ru/tour/basics.md
@@ -31,14 +31,12 @@ previous-page: tour-of-scala
 ```
 Вы можете выводить результаты выражений, используя `println`.
 
-{% scalafiddle %}
 ```scala mdoc
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
 println("Hello," + " world!") // Hello, world!
 ```
-{% endscalafiddle %}
 
 ### Значения
 
@@ -110,21 +108,17 @@ println({
 
 Вы также можете назвать функции.
 
-{% scalafiddle %}
 ```scala mdoc
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
-{% endscalafiddle %}
 
 Функции могут принимать множество параметров.
 
-{% scalafiddle %}
 ```scala mdoc
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 Или вообще не принимать никаких параметров.
 
@@ -139,23 +133,19 @@ println(getTheAnswer()) // 42
 
 Методы задаются ключевым словом `def`.  За `def` следует имя, список параметров, возвращаемый тип и тело.
 
-{% scalafiddle %}
 ```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 Обратите внимание, как объявлен возвращаемый тип сразу _после_ списка параметров и двоеточия `: Int`.
 
 Методы могут принимать несколько списков параметров.
 
-{% scalafiddle %}
 ```scala mdoc
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
-{% endscalafiddle %}
 
 Или вообще ни одного списка параметров.
 
@@ -168,7 +158,6 @@ println("Hello, " + name + "!")
 
 Методы также могут иметь многострочные выражения.
 
-{% scalafiddle %}
 ```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
@@ -176,7 +165,6 @@ def getSquareString(input: Double): String = {
 }
 println(getSquareString(2.5)) // 6.25
 ```
-{% endscalafiddle %}
 
 Последнее выражение в теле становится возвращаемым значением метода (у Scala есть ключевое слово `return`, но оно практически не используется).
 
@@ -276,7 +264,6 @@ trait Greeter {
 
 Трейты также могут иметь реализации методов и полей, которые предполагается использовать умолчанию.
 
-{% scalafiddle %}
 ```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
@@ -301,7 +288,6 @@ greeter.greet("Scala developer") // Hello, Scala developer!
 val customGreeter = new CustomizableGreeter("How are you, ", "?")
 customGreeter.greet("Scala developer") // How are you, Scala developer?
 ```
-{% endscalafiddle %}
 
 Здесь `DefaultGreeter` наследуется только от одного трейта, но можно наследоваться от нескольких.
 
diff --git a/_ru/tour/nested-functions.md b/_ru/tour/nested-functions.md
index 6a59ca5a0e..f4b689dbd4 100644
--- a/_ru/tour/nested-functions.md
+++ b/_ru/tour/nested-functions.md
@@ -10,7 +10,6 @@ previous-page: higher-order-functions
 
 В Scala возможно объявление метода вкладывать в тело другого метода. Это реализовано в следующем примере, в котором метод `factorial` используется для вычисления факториала заданного числа:
 
-{% scalafiddle %}
 ```scala mdoc
  def factorial(x: Int): Int = {
     def fact(x: Int, accumulator: Int): Int = {
@@ -23,7 +22,6 @@ previous-page: higher-order-functions
  println("Factorial of 2: " + factorial(2))
  println("Factorial of 3: " + factorial(3))
 ```
-{% endscalafiddle %}
 
 Результат выполнения программы:
 
diff --git a/_sips/minutes/2018-08-30-sip-minutes.md b/_sips/minutes/2018-08-30-sip-minutes.md
index 48bc21c12f..164bf6e3c1 100644
--- a/_sips/minutes/2018-08-30-sip-minutes.md
+++ b/_sips/minutes/2018-08-30-sip-minutes.md
@@ -200,7 +200,7 @@ Related links
   - One in scalaz-deriving: https://gitlab.com/fommil/scalaz-deriving/tree/master/examples/xmlformat/src/main/scala/xmlformat (link behind a login wall, it seems)
 - JSX-style libraries for Scala:
   - https://github.com/OlivierBlanvillain/monadic-html
-  - Binding.scala, TODO app: https://scalafiddle.io/sf/dGkVqlV/9
+  - Binding.scala,
 - Ammonite script to convert HTML to the VDOM DSL of scalajs-react (a ScalaTags flavor):
 https://gist.github.com/nafg/112bf83e5676ed316f17cea505ea5d93
 
diff --git a/_th/tour/basics.md b/_th/tour/basics.md
index 2b2100b153..c2e4653d1a 100644
--- a/_th/tour/basics.md
+++ b/_th/tour/basics.md
@@ -33,14 +33,12 @@ Expression หรือ นิพจน์ เป็นโค้ดที่ท
 ```
 เราสามารถแสดงผลลัพธ์ของ Expression ด้วยการใช้ `println`
 
-{% scalafiddle %}
 ```scala mdoc
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
 println("Hello," + " world!") // Hello, world!
 ```
-{% endscalafiddle %}
 
 ### Values
 
@@ -111,21 +109,17 @@ function เป็น expression ที่รับ parameter ได้
 
 เราสามารถตั้งชื่อของ function ได้ดังนี้
 
-{% scalafiddle %}
 ```scala mdoc
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
-{% endscalafiddle %}
 
 function สามารถรับ parameter ได้หลายตัว
 
-{% scalafiddle %}
 ```scala mdoc
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 หรือ เราจะไม่รับ parameter เลยก็ได้
 
@@ -140,23 +134,19 @@ Method มีลักษณะเหมือนกับ function มาก 
 
 Method จะประกาศได้ด้วย keyword `def` ตามด้วยชื่อของ function, รายการ parameter, return type และ body ของ function
 
-{% scalafiddle %}
 ```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 สังเกตว่า การ return type จะประกาศ _หลังจาก_ รายการ parameter และ colon `: Int`
 
 Method ยังสามารถรับรายการ parameter ได้หลายรายการ
 
-{% scalafiddle %}
 ```scala mdoc
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
-{% endscalafiddle %}
 
 หรือ ไม่มีรายการ parameter เลยก็ได้ อย่างเช่น
 
@@ -169,7 +159,6 @@ println("Hello, " + name + "!")
 
 Method สามารถมี expression ได้หลายบรรทัด
 
-{% scalafiddle %}
 ```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
@@ -177,7 +166,6 @@ def getSquareString(input: Double): String = {
 }
 println(getSquareString(2.5)) // 6.25
 ```
-{% endscalafiddle %}
 
 expression สุดท้ายใน body เป็น expression ที่ return value ของ method (Scala ก็มี keyword `return` แต่ว่าไม่ค่อยได้ใช้)
 
@@ -277,7 +265,6 @@ trait Greeter {
 
 Trait สามารถมี default implementation ได้
 
-{% scalafiddle %}
 ```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
@@ -302,7 +289,6 @@ greeter.greet("Scala developer") // Hello, Scala developer!
 val customGreeter = new CustomizableGreeter("How are you, ", "?")
 customGreeter.greet("Scala developer") // How are you, Scala developer?
 ```
-{% endscalafiddle %}
 
 จากตัวอย่างนี้ `defaultGreeter` ขยายเพียง trait เดียว แต่มันสามารถขยายหลาย trait
 
diff --git a/_tour/basics.md b/_tour/basics.md
index 5ef700a039..77795299da 100644
--- a/_tour/basics.md
+++ b/_tour/basics.md
@@ -30,14 +30,12 @@ Expressions are computable statements:
 ```
 You can output the results of expressions using `println`:
 
-{% scalafiddle %}
 ```scala mdoc
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
 println("Hello," + " world!") // Hello, world!
 ```
-{% endscalafiddle %}
 
 ### Values
 
@@ -109,21 +107,17 @@ On the left of `=>` is a list of parameters. On the right is an expression invol
 
 You can also name functions:
 
-{% scalafiddle %}
 ```scala mdoc
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
-{% endscalafiddle %}
 
 A function can have multiple parameters:
 
-{% scalafiddle %}
 ```scala mdoc
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 Or it can have no parameters at all:
 
@@ -138,23 +132,19 @@ Methods look and behave very similar to functions, but there are a few key diffe
 
 Methods are defined with the `def` keyword.  `def` is followed by a name, parameter list(s), a return type, and a body:
 
-{% scalafiddle %}
 ```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 Notice how the return type `Int` is declared _after_ the parameter list and a `:`.
 
 A method can take multiple parameter lists:
 
-{% scalafiddle %}
 ```scala mdoc
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
-{% endscalafiddle %}
 
 Or no parameter lists at all:
 
@@ -167,7 +157,6 @@ There are some other differences, but for now, you can think of methods as somet
 
 Methods can have multi-line expressions as well:
 
-{% scalafiddle %}
 ```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
@@ -175,7 +164,6 @@ def getSquareString(input: Double): String = {
 }
 println(getSquareString(2.5)) // 6.25
 ```
-{% endscalafiddle %}
 
 The last expression in the body is the method's return value. (Scala does have a `return` keyword, but it is rarely used.)
 
@@ -277,7 +265,6 @@ trait Greeter {
 
 Traits can also have default implementations:
 
-{% scalafiddle %}
 ```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
@@ -302,7 +289,6 @@ greeter.greet("Scala developer") // Hello, Scala developer!
 val customGreeter = new CustomizableGreeter("How are you, ", "?")
 customGreeter.greet("Scala developer") // How are you, Scala developer?
 ```
-{% endscalafiddle %}
 
 Here, `DefaultGreeter` extends only one single trait, but it could extend multiple traits.
 
diff --git a/_tour/multiple-parameter-lists.md b/_tour/multiple-parameter-lists.md
index 9aa3add880..034a1be341 100644
--- a/_tour/multiple-parameter-lists.md
+++ b/_tour/multiple-parameter-lists.md
@@ -28,13 +28,11 @@ trait Iterable[A] {
 
 Starting with an initial value of 0, `foldLeft` here applies the function `(m, n) => m + n` to each element in the List and the previous accumulated value.
 
-{% scalafiddle %}
 ```scala mdoc
 val numbers = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
 val res = numbers.foldLeft(0)((m, n) => m + n)
 println(res) // 55
 ```
-{% endscalafiddle %}
 
 ### Use cases
 
diff --git a/_tour/nested-functions.md b/_tour/nested-functions.md
index a250fc2238..18b123d49f 100644
--- a/_tour/nested-functions.md
+++ b/_tour/nested-functions.md
@@ -12,7 +12,6 @@ redirect_from: "/tutorials/tour/nested-functions.html"
 
 In Scala it is possible to nest method definitions. The following object provides a `factorial` method for computing the factorial of a given number:
 
-{% scalafiddle %}
 ```scala mdoc
  def factorial(x: Int): Int = {
     def fact(x: Int, accumulator: Int): Int = {
@@ -25,7 +24,6 @@ In Scala it is possible to nest method definitions. The following object provide
  println("Factorial of 2: " + factorial(2))
  println("Factorial of 3: " + factorial(3))
 ```
-{% endscalafiddle %}
 
 The output of this program is:
 
diff --git a/_zh-cn/tour/basics.md b/_zh-cn/tour/basics.md
index 4a270d9776..5312c39a2c 100644
--- a/_zh-cn/tour/basics.md
+++ b/_zh-cn/tour/basics.md
@@ -32,14 +32,12 @@ previous-page: tour-of-scala
 ```
 你可以使用`println`来输出表达式的结果。
 
-{% scalafiddle %}
 ```scala mdoc
 println(1) // 1
 println(1 + 1) // 2
 println("Hello!") // Hello!
 println("Hello," + " world!") // Hello, world!
 ```
-{% endscalafiddle %}
 
 ### 常量（`Values`）
 
@@ -110,21 +108,17 @@ println({
 
 你也可以给函数命名。
 
-{% scalafiddle %}
 ```scala mdoc
 val addOne = (x: Int) => x + 1
 println(addOne(1)) // 2
 ```
-{% endscalafiddle %}
 
 函数可带有多个参数。
 
-{% scalafiddle %}
 ```scala mdoc
 val add = (x: Int, y: Int) => x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 或者不带参数。
 
@@ -139,23 +133,19 @@ println(getTheAnswer()) // 42
 
 方法由`def`关键字定义。`def`后面跟着一个名字、参数列表、返回类型和方法体。
 
-{% scalafiddle %}
 ```scala mdoc:nest
 def add(x: Int, y: Int): Int = x + y
 println(add(1, 2)) // 3
 ```
-{% endscalafiddle %}
 
 注意返回类型是怎么在函数列表和一个冒号`: Int`之后声明的。
 
 方法可以接受多个参数列表。
 
-{% scalafiddle %}
 ```scala mdoc
 def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplier
 println(addThenMultiply(1, 2)(3)) // 9
 ```
-{% endscalafiddle %}
 
 或者没有参数列表。
 
@@ -168,7 +158,6 @@ println("Hello, " + name + "!")
 
 方法也可以有多行的表达式。
 
-{% scalafiddle %}
 ```scala mdoc
 def getSquareString(input: Double): String = {
   val square = input * input
@@ -176,7 +165,6 @@ def getSquareString(input: Double): String = {
 }
 println(getSquareString(2.5)) // 6.25
 ```
-{% endscalafiddle %}
 
 方法体的最后一个表达式就是方法的返回值。（Scala中也有一个`return`关键字，但是很少使用）
 
@@ -276,7 +264,6 @@ trait Greeter {
 
 特质也可以有默认的实现。
 
-{% scalafiddle %}
 ```scala mdoc:reset
 trait Greeter {
   def greet(name: String): Unit =
@@ -301,7 +288,6 @@ greeter.greet("Scala developer") // Hello, Scala developer!
 val customGreeter = new CustomizableGreeter("How are you, ", "?")
 customGreeter.greet("Scala developer") // How are you, Scala developer?
 ```
-{% endscalafiddle %}
 
 这里，`DefaultGreeter`仅仅继承了一个特质，它还可以继承多个特质。