Backport scala.util.chaining

Author: NthPortal

compat/src/main/scala-2.11_2.12/scala/util/ChainingOps.scala

@@ -0,0 +1,68 @@
+/*
+ * Scala (https://www.scala-lang.org)
+ *
+ * Copyright EPFL and Lightbend, Inc.
+ *
+ * Licensed under Apache License 2.0
+ * (http://www.apache.org/licenses/LICENSE-2.0).
+ *
+ * See the NOTICE file distributed with this work for
+ * additional information regarding copyright ownership.
+ */
+
+package scala.util
+
+trait ChainingSyntax {
+  @`inline` implicit final def scalaUtilChainingOps[A](a: A): ChainingOps[A] = new ChainingOps(a)
+}
+
+/**
+ * Adds chaining methods `tap` and `pipe` to every type. See [[ChainingOps]].
+ */
+object chaining extends ChainingSyntax
+
+/** Adds chaining methods `tap` and `pipe` to every type.
+ */
+final class ChainingOps[A](private val self: A) extends AnyVal {
+
+  /** Applies `f` to the value for its side effects, and returns the original value.
+   *
+   * {{{
+   *   scala> import scala.util.chaining._
+   *
+   *   scala> val xs = List(1, 2, 3).tap(ys => println("debug " + ys.toString))
+   *   debug List(1, 2, 3)
+   *   xs: List[Int] = List(1, 2, 3)
+   * }}}
+   *
+   *  @param f      the function to apply to the value.
+   *  @tparam U     the result type of the function `f`.
+   *  @return       the original value `self`.
+   */
+  def tap[U](f: A => U): A = {
+    f(self)
+    self
+  }
+
+  /** Converts the value by applying the function `f`.
+   *
+   * {{{
+   *   scala> import scala.util.chaining._
+   *
+   *   scala> val times6 = (_: Int) * 6
+   *   times6: Int => Int = \$\$Lambda\$2023/975629453@17143b3b
+   *
+   *   scala> val i = (1 - 2 - 3).pipe(times6).pipe(scala.math.abs)
+   *   i: Int = 24
+   * }}}
+   *
+   * Note: `(1 - 2 - 3).pipe(times6)` may have a small amount of overhead at
+   * runtime compared to the equivalent  `{ val temp = 1 - 2 - 3; times6(temp) }`.
+   *
+   *  @param f      the function to apply to the value.
+   *  @tparam B     the result type of the function `f`.
+   *  @return       a new value resulting from applying the given function
+   *                `f` to this value.
+   */
+  def pipe[B](f: A => B): B = f(self)
+}

compat/src/test/scala/scala/util/ChainingOpsTest.scala

@@ -0,0 +1,37 @@
+package scala.util
+
+import org.junit.Assert._
+import org.junit.Test
+
+//import scala.tools.reflect.ToolBoxError
+//import scala.tools.testkit.RunTesting
+
+class ChainingOpsTest {
+  import scala.util.chaining._
+
+  @Test
+  def testAnyTap(): Unit = {
+    var x: Int = 0
+    val result = List(1, 2, 3)
+      .tap(xs => x = xs.head)
+
+    assertEquals(1, x)
+    assertEquals(List(1, 2, 3), result)
+  }
+
+  @Test def testAnyValTap(): Unit = assertEquals(42.tap(x => x), 42)
+
+  @Test
+  def testAnyPipe(): Unit = {
+    val times6 = (_: Int) * 6
+    val result = (1 - 2 - 3)
+      .pipe(times6)
+      .pipe(scala.math.abs)
+
+    assertEquals(24, result)
+  }
+
+//  @Test(expected = classOf[ToolBoxError])
+//  def testNoSelf(): Unit =
+//    runner.run("import scala.util.chaining._; Nil.self")
+}