diff --git a/man/collocationAnalysis-KorAPConnection-method.Rd b/man/collocationAnalysis-KorAPConnection-method.Rd
index 1554ff7..50f4a27 100644
--- a/man/collocationAnalysis-KorAPConnection-method.Rd
+++ b/man/collocationAnalysis-KorAPConnection-method.Rd
@@ -101,9 +101,9 @@
 \dontrun{
 
  # Find top collocates of "Packung" inside and outside the sports domain.
- KorAPConnection(verbose = TRUE) \%>\%
+ KorAPConnection(verbose = TRUE) |>
   collocationAnalysis("Packung", vc=c("textClass=sport", "textClass!=sport"),
-                      leftContextSize=1, rightContextSize=1, topCollocatesLimit=20) \%>\%
+                      leftContextSize=1, rightContextSize=1, topCollocatesLimit=20) |>
   dplyr::filter(logDice >= 5)
 }
 
@@ -111,7 +111,7 @@
 
 # Identify the most prominent light verb construction with "in ... setzen".
 # Note that, currently, the use of focus function disallows exactFrequencies.
-KorAPConnection(verbose = TRUE) \%>\%
+KorAPConnection(verbose = TRUE) |>
   collocationAnalysis("focus(in [tt/p=NN] {[tt/l=setzen]})",
     leftContextSize=1, rightContextSize=0, exactFrequencies=FALSE, topCollocatesLimit=20)
 }
diff --git a/man/collocationScoreQuery-KorAPConnection-method.Rd b/man/collocationScoreQuery-KorAPConnection-method.Rd
index b9e0e94..12d8258 100644
--- a/man/collocationScoreQuery-KorAPConnection-method.Rd
+++ b/man/collocationScoreQuery-KorAPConnection-method.Rd
@@ -58,13 +58,13 @@
 \examples{
 \dontrun{
 
-KorAPConnection(verbose = TRUE) \%>\%
+KorAPConnection(verbose = TRUE) |>
   collocationScoreQuery("Grund", "triftiger")
 }
 
 \dontrun{
 
-KorAPConnection(verbose = TRUE) \%>\%
+KorAPConnection(verbose = TRUE) |>
 collocationScoreQuery("Grund", c("guter", "triftiger"),
    scoreFunctions = list(localMI = function(O1, O2, O, N, E, window_size) { O * log2(O/E) }) )
 }
@@ -73,11 +73,11 @@
 
 library(highcharter)
 library(tidyr)
-KorAPConnection(verbose = TRUE) \%>\%
+KorAPConnection(verbose = TRUE) |>
   collocationScoreQuery("Team", "agil", vc = paste("pubDate in", c(2014:2018)),
-                        lemmatizeNodeQuery = TRUE, lemmatizeCollocateQuery = TRUE) \%>\%
-                         pivot_longer(14:last_col(), names_to = "measure", values_to = "score") \%>\%
-  hchart(type="spline", hcaes(label, score, group=measure)) \%>\%
+                        lemmatizeNodeQuery = TRUE, lemmatizeCollocateQuery = TRUE) |>
+                         pivot_longer(14:last_col(), names_to = "measure", values_to = "score") |>
+  hchart(type="spline", hcaes(label, score, group=measure)) |>
   hc_add_onclick_korap_search()
 }
 
