# Contributing Scala “When to use Currying” in StackOverflow Documentation

A week or so ago I’ve contributed in StackOverflow Documentation an entry about Currying under the Scala Language tag. I’ve repeated the same exercise for Java Currying Documentation. This is how it goes:

Currying is the technique of translating the evaluation of a function that takes multiple arguments into evaluating a sequence of functions, each with a single argument.

This is normally useful when for example:

1. different arguments of a function are calculated at different times. (Example 1)
2. different arguments of a function are calculated by different tiers of the application. (Example 2)

Example 1

Let’s assume that the total yearly income is a function composed by the income and a bonus:

``val totalYearlyIncome😦Int,Int) => Int =  (income, bonus) => income + bonus``

The curried version of the above 2-arity function is:

``val totalYearlyIncomeCurried: Int => Int => Int = totalYearlyIncome.curried``

Note in the above definition that the type can be also viewed/written as:

``Int => (Int => Int)``

Let’s assume that the yearly income portion is known in advance:

``val partialTotalYearlyIncome: Int => Int = totalYearlyIncomeCurried(10000)``

And at some point down the line the bonus is known:

``partialTotalYearlyIncome(100)``

Example 2

Let’s assume that the car manufacturing involves the application of car wheels and car body:

``val carManufacturing😦String,String) => String = (wheels, body) => wheels + body``

These parts are applied by different factories:

``````class CarWheelsFactory {
def applyCarWheels(carManufacturing😦String,String) => String): String => String =
carManufacturing.curried("applied wheels..")
}

class CarBodyFactory {
def applyCarBody(partialCarWithWheels: String => String): String = partialCarWithWheels("applied car body..")
}``````

Notice that the `CarWheelsFactory` above curries the car manufacturing function and only applies the wheels.

The car manufacturing process then will take the below form:

``````val carWheelsFactory = new CarWheelsFactory()
val carBodyFactory   = new CarBodyFactory()

val carManufacturing😦String,String) => String = (wheels, body) => wheels + body

val partialCarWheelsApplied: String => String  = carWheelsFactory.applyCarWheels(carManufacturing)
val carCompleted = carBodyFactory.applyCarBody(partialCarWheelsApplied)``````

# DSL example in Scala

Here’s a DSL example in Scala that will allow us to express amounts in the context of currencies taking into account the FX rates too.

By the end of it we’ll be able to write the following:

`'USD(100) + 'EUR(200) in 'EUR`

Here’s the code for it:

```object ScalaForexRatesDSL {

implicit class ccy2money(ccy :Symbol) {
def apply(amount: BigDecimal) = Money(amount, ccy)
}
}

case class FromToCcy(ccyFrom: Symbol, ccyTo: Symbol)

case class Money(amount:BigDecimal, ccy:Symbol) {

def + (other: Money)(implicit rates: Map[FromToCcy, BigDecimal]): Money =
if(ccy == other.ccy) Money(amount + other.amount, ccy) else {
val convertedOther = convertedOtherMoney(other)
Money(amount + convertedOther.amount, ccy)
}

def - (other: Money)(implicit rates: Map[FromToCcy, BigDecimal]): Money =
if(ccy == other.ccy) Money(amount - other.amount, ccy) else {
val convertedOther = convertedOtherMoney(other)
Money(amount - convertedOther.amount, ccy)
}

def * (other: Money)(implicit rates: Map[FromToCcy, BigDecimal]): Money =
if(ccy == other.ccy) Money(amount * other.amount, ccy) else {
val convertedOther = convertedOtherMoney(other)
Money(amount * convertedOther.amount, ccy)
}

def / (other: Money)(implicit rates: Map[FromToCcy, BigDecimal]): Money =
if(ccy == other.ccy) Money(amount / other.amount, ccy) else {
val convertedOther = convertedOtherMoney(other)
Money(amount / convertedOther.amount, ccy)
}

private def convertedOtherMoney(other: Money)(implicit rates: Map[FromToCcy, BigDecimal]): Money = {
val rate = rates.get(FromToCcy(other.ccy, ccy)).getOrElse(1 / rates.get(FromToCcy(ccy, other.ccy)).get)
Money(other.amount * rate, ccy)
}

def in(ccy: Symbol)(implicit rates: Map[FromToCcy, BigDecimal]): Money =
if (this.ccy == ccy) this else {
val rate = rates.get(FromToCcy(this.ccy, ccy)).getOrElse(1 / rates.get(FromToCcy(ccy, this.ccy)).get)
Money(amount * rate, ccy)
}

override def toString = amount + " " + ccy.name
}

object Main extends App {

import ScalaForexRatesDSL._

implicit val rates = Map((FromToCcy('EUR, 'USD) -> BigDecimal(1.13)))

print( 'USD(100) + 'EUR(200) in 'EUR )

}
```

I’ve been tinkering with mime types in a toy Scalatra file server so while maintain a file with all known mime types a common task is to figure out the extension of a given file name.

With a bit out-of-the-box thinking on capturing the extension but without using Options therefore open to failures:

```def findExtension(s:String)=s.reverse.takeWhile(_!='.').reverse
```

Here’s how it looks while wrapping the string in the Option monad and performing type-safe operations on it before returning a Some or None of the extension:

```scala> def findExtension(s:String)=
Option(s) //wrap into Option
.filter(_.exists(_=='.'))  //ignore files without a dot
.map(_.reverse)  //out-of-the-box thinking
.map(_.takeWhile(_!='.'))  //maybe could be done with some non-greedy advanced regex too
.filter(_.trim.nonEmpty)  //take "" empty strings as None
.map(_.reverse)  //reverse back
findExtension: (s: String)Option[String]

scala> findExtension("hi")
res128: Option[String] = None

scala> findExtension("h.io")
res129: Option[String] = Some(io)

scala> findExtension("www.github.io")
res130: Option[String] = Some(io)
```
By dimitrisli Posted in Scala Tagged

Let’s say we want to find all three-pair additions that equate to 10 (order is irrelevant so we don’t want dups). What we would normally do in imperative Java would be 3 nested for loops with indexes say `i`, `j` and `k` where `i` ranges from 1 till 10, `j` starts from `i+1` and k starts from `j+1`. The body of the for loop would be the if predicate case. We would also need a variable to store the results.

```
val l = List(1,2,3,4,5,6,7,8,9,10)

for {
(a,i) <- l.zipWithIndex
(b,j) <- l.zipWithIndex.drop(i+1)
c  <- l.drop(j+1)
if 10 == a + b + c
} println(s"\$a \$b \$c")
```

We can also use for comprehension with `yield` as a returned assignable result rather than `println`

By dimitrisli Posted in Scala Tagged

# Stopwatch implementation in Scala

Timing method operations can be a labouring task littering the method body with the timing variables (sometimes short-lived as in debug mode). Thankfully we can treat the timing activity as a pass-by-name method argument of our newly defined timing operation:

```def timed [T] (f: => T): T = {
val startTime = System.currentTimeMillis()
try f finally println(s"Function completed in: \${System.currentTimeMillis() - startTime} ms" )
}
```
By dimitrisli Posted in Scala Tagged

# Scala call-by-name

The arguement notation : => A denotes passing the argument in call-by-name manner not the traditional call-by-value fashion. That essentially means:

• If the parameter is never used, it is never evaluated
• If the parameter is used multiple times, it is getting evaluated each and every time in the by-name invocation

Traditionally call-by-value invocation would be evalutated just once and the calculated value would be just pushed in the method stack:

```def myprint(date: java.util.Date):Unit = for(i->1 to 5) println(date)

scala> myprint( {Thread.sleep(1000); new java.util.Date()} )
Sun Apr 27 10:10:37 GMT 2014
Sun Apr 27 10:10:37 GMT 2014
Sun Apr 27 10:10:37 GMT 2014
Sun Apr 27 10:10:37 GMT 2014
Sun Apr 27 10:10:37 GMT 2014
```

whereas call-by-name would be evaluated each and every time anew:

```def myprint(date :=> java.util.Date):Unit = for(i->1 to 5) println(date)

scala&gt; myprint( {Thread.sleep(1000); new java.util.Date()} )
Sun Apr 27 10:12:46 GMT 2014
Sun Apr 27 10:12:47 GMT 2014
Sun Apr 27 10:12:48 GMT 2014
Sun Apr 27 10:12:49 GMT 2014
Sun Apr 27 10:12:50 GMT 2014
```

# How to add Options in Scala

Options are Monads and we can perform operations in their underlying types in a typesafe way using Scalaz:

```  import scalaz._
import Scalaz._

val a: Option[BigDecimal] = BigDecimal("0.123").some
val b: Option[BigDecimal] = BigDecimal("1.234").some
val c: Option[BigDecimal] = BigDecimal("2.345").some

println( (a |@| b |@| c) { _ + _ + _ } )

//yields: Some(3.702)
```

and if the chain is broken, we don’t have to worry since it’s getting short-circuited:

```  import scalaz._
import Scalaz._

val a: Option[BigDecimal] = BigDecimal("0.123").some
val b: Option[BigDecimal] = None
val c: Option[BigDecimal] = BigDecimal("2.345").some

println( (a |@| b |@| c) { _ + _ + _ } )

//yields: None
```

# Type Inference in Scala example

Let’s take a function definition and slim it down using type inference in our advantage:

```def f: (Int => Int) = (x:Int) => x + 1
def f: (Int => Int) =  x      => x + 1
def f: (Int => Int) =            _ + 1
def f               = (x:Int) => x + 1
```

# Scala Pimp-My-Library example

Recently working on a project test there was an incompatibility of the assert keyword between ScalaTest and Scalaz. I was looking after Scalaz’s feature of invoking some on any data type after import scalaz.Scalaz._

After a while I gave up and wrote it myself, surprisingly simple and concise:

```class SomeType[T](t:T){
def some = Some(t)
}
implicit def typeToSomeType[T](t:T) = new SomeType(t)
```

Making possible:

```scala> 123.some
res7: Some[Int] = Some(123)

scala>"hi".some
res8: Some[String] = Some(hi)
```

Implicits is a nice way to type-safe upon compile time some global state (as long as it doesn’t become unwieldy long).

In Groovy we could achieve same effect via the MetaClass object, but without compile time type-safety as Groovy it’s a dynamic language and all the magic happens at runtime. Also we can’t use parametric polymorphism while invoking the MetaClass object (or at least I don’t know how to do it!).

```groovy> String.metaClass.quote={"*"+delegate+"*"}
===> groovysh_evaluate\$_run_closure1@4b51ac10
groovy:000> "hi".quote()
===> *hi*
```

# Visitor Design Pattern in Scala

Scala provides built-in support for the Visitor Design Pattern through the use of pattern matching.

The Visitor Design Pattern is trying to address the problem of never-ending new functionality that is otherwise implemented by adding new methods in the inheritance tree.

According to the Visitor pattern the inheritance tree is decoupled from a new functionality and encapsulated in a separate object that packs all implementations according to the inheritance tree normally by using method overloading of all the various types.

In Scala by the use of the built-in pattern matching this becomes very easy:

```class Animal { def walk:String }

class Dog extends Animal { override def walk = "on 4" }

class Man extends Animal { override def walk = "on 2" }

/**
*  Visitor Pattern provides a solution to never-ending new
*  functionality that would otherwise be implemented with new
*  method in the hierarchy tree.
*/
def talk(animal: Animal) = animal match {
case Dog => "wav wav"
case Man => "hi"
}

/**
*  New functionality implemented in separate methods that
*  uses pattern matching to implement tailored functionality.
*/
def swim(animal: Animal) = animal match {
case Dog => "on 4"
case Man => "on 4"
}```