DRY when passing similar functions to Scala map() - scala

Question

def doubleList(noList:List[Int]) = {
val result = noList.map{ number =>
number*2
}
result
}
def halfList(noList:List[Int]) = {
val result = noList.map{ number =>
number/2
}
result
}
def mapFunctionDRY(noList:List[Int])(codeBlock: () => Int) = {
}
println(halfList(List(1,2,3)))
println(doubleList(List(1,2,4)))
I was playing around with scala and noticed violation of DRY (Dont Repeat Yourself) in the above two functions doubleList and halfList. I want the code common in both the function to be isolated and just pass the code block which is different. That way my code would not be violating DRY principle. I know that you could pass in code block as argument in scala. That is what I intend to do in mapFunctionDRY
I want mapFunctionDRY to be in this way
def mapFunctionDRY(noList:List[Int])(codeBlock: () => Int) = {
noList.map{ number =>
codeBlock()
}
}
And code in doubleList and halfList to be similar to this
def doubleList(noList:List[Int]) = { mapFunctionDRY(noList){ () => number*2 } }
But I would get a compilation error if I do such thing. How can I make the code pass in as the parameter in this case to avoid violation of DRY. Can this code be reduced further to keep it DRY?

Answer 1

You don't need to reinvent job that map does quite DRY:
def double(x: Int) = x * 2
def half(x: Int) = x / 2
val xs = List(1,2,3,4)
xs.map(double)
// List[Int] = List(2, 4, 6, 8)
xs.map(half)
// List[Int] = List(0, 1, 1, 2)

Answer 2

The compilation error occurs because you want to map each Int to another Int. codeBlock: () => Int is a function that takes no argument.
codeBlock: Int => Int should do what you want. Then you can define something like this:
def doubleList(noList:List[Int]) = { mapFunctionDRY(noList){ (number : Int) => number*2 } }
Haven't tested it though.
Edit: And like the others said. This function is not really useful because it's like map but weaker in the sense that it can only be applied to List[Int]

Answer 3

Why are you building a wrapper around map, which actually provides the dry-est solution to your problem? I would suggest a different strategy:
val mapDouble = (x: Int) => x * 2
val mapHalf = (x: Int) => x / 2
List(1, 2, 3).map(mapDouble)
List(1, 2, 3).map(mapHalf)

Answer 4

Your functions operate on one element of a list. Therefore instead of codeBlock being a () => Int, I would change it to (Int) => Int. So given one element of a list what do you want to do with it.
This results in the following code:
def mapFunctionDRY(noList:List[Int])(elementFn: (Int) => Int) = {
noList.map{ number =>
elementFn(number)
}
}
And if you're into short code, then the equivalent code is:
def mapFunctionDRY(noList:List[Int])(elementFn: (Int) => Int) = noList.map(elementFn)
There are many other ways to keep being DRY. For an example your could define the operations separately to be able to reuse them:
val doubleOperation: Int => Int = _ * 2
val halfOperation: Int => Int = _ / 2
def doubleList(noList:List[Int]) = noList.map(doubleOperation)
def halfList(noList:List[Int]) = noList.map(halfOperation)
Or you could use function currying to save yourself one line of code:
def mapFunction(fn: (Int) => Int)(noList: List[Int]) = noList.map(fn)
val doubleList = mapFunction(_ * 2)
val halfList = mapFunction(_ / 2)

Answer 5

I think what you are looking for is Currying in this regard.
def func(factor:Double)(noList:List[Int]) ={
val result = noList.map{ number =>
number*factor
}
result
Now you can pass this function with func(0.5f)(noList) or func(1.0f)(noList)
You could even have References to the different Versions of your Function.
halfed = x:List[Int] => func(0.5f)(x)
doubled = x:List[Int] => func(2.0f)(x)