Cache an intermediate variable in an one-liner

Question

Can I somehow cache the i.toString in this simple definition of function?

def palindrome(i: Int) = i.toString == i.toString.reverse

I want to keep this function simple, w/o a classic multi-line, brace-enclosed function..

score 6 · Accepted Answer · answered Apr 11 '13 at 19:04

6

You could do:

def palindrome(i: Int) = ((s:String) => s == s.reverse)(i.toString)

answered Apr 11 '13 at 19:04

Marimuthu Madasamy

13,126
4
30
52

This is basically the same as PipedObject except PipedObject is reusable. – sourcedelica Apr 12 '13 at 22:38

score 6 · Answer 2 · answered Apr 11 '13 at 19:18

6

Well, Scala doesn't have a let statement like some traditional functional languages, but that's largely because val + braces fulfill the same purpose. Are you objecting to the multi-line part or to braces in general? Because it's pretty hard to beat:

def palindrome(i: Int) = { val s = i.toString; s == s.reverse }

Attempts to elide the braces will likely only drive the character count up.

answered Apr 11 '13 at 19:18

Reimer Behrends

8,600
15
19

This is an obvious solution and I guess in real-world problems I'd use it. But while I'm learning Scala, I want something more interesting.. beause as you can see, in Scala even such a simple operation like the one in my question can be solved in 1000 ways .. while in Java (or x, y, z ) the answer is probably "*nah, you can only ... *" . Thanks anyway! – Parobay Apr 12 '13 at 06:08
@Parobay I believe in nearly every programming language there are multiple ways to solve a problem – mgttlinger Dec 16 '13 at 08:23

kiritsuku · Answer 3 · 2013-04-11T23:52:20.377

5

Use the forward pipe operator:

scala> implicit class PipedObject[A](value: A) {
     |   def |>[B](f: A => B): B = f(value)
     | }
defined class PipedObject

scala> def palindrome(i: Int) = i.toString |> (s => s == s.reverse)
palindrome: (i: Int)Boolean

While this solves your problem elegantly I advise to change the signature of palindrome from palindrome(Int) to palindrome(String) and call it with palindrome(i.toString) (and rename it to isPalindrome).

edited Apr 11 '13 at 23:52

answered Apr 11 '13 at 19:20

kiritsuku

52,967
18
114
136

this is nice, but requires a second definition – Parobay Apr 12 '13 at 06:09

axel22 · Answer 4 · 2013-04-11T19:42:08.413

3

It is a one-liner, but the braces are still here. It seems shorter to me, though:

def palindrome(i: Int) = { val s = i.toString; s == s.reverse }

If you have many such functions, you could also do something like this:

@inline def let[T, R](expr: =>T)(body: T => R): R = body(expr)

def palindrome(i: Int) = let(i.toString) { s => s == s.reverse }

edited Apr 11 '13 at 19:42

answered Apr 11 '13 at 19:17

axel22

32,045
9
125
137

though this requires a second definition, I think the 2nd definition is the most universal. Nice solution +1 ! – Parobay Apr 12 '13 at 06:11

score 1 · Answer 5 · answered Oct 03 '18 at 22:00

Starting Scala 2.13, the standard library provides the chaining operation pipe which can be used to convert/pipe i.toString with the function checking if a string is a palindrome:

import scala.util.chaining._

def palindrome(i: Int) = i.toString.pipe(s => s == s.reverse)

score 0 · Answer 6 · answered Apr 11 '13 at 20:20

Needing to refer to something exactly twice comes up often enough that it's useful to have enrich it into a method:

implicit class DiamondMapper[A](val a: A) extends AnyVal {
  def diamond[B](f: (A,A) => B) = f(a,a)
}

Then:

scala> 575.toString.diamond(_ == _.reverse)
res1: Boolean = true

This is a special case of the pipe operator (|> if you like symbolic notation), but it's a common enough use case that you might want to create your own.

(Diamond here because it takes one value, splits it in two, and merges it back together again.)

this is nice, but requires a second definition – Parobay Apr 12 '13 at 06:09 — Parobay, Apr 12 '13 at 06:09

Cache an intermediate variable in an one-liner

6 Answers6

Linked