# Lambda with one primitive parameter

With

```
var listOfInt=(1 to 100).toList
listOfInt.foldRight(0)((current,acc)=>current+acc)
```

you have a lambda function operating on two parameter.

# Lambda with one parameter of type tuple

With

```
var listOfTuple=List((1,"a"),(2,"b"),(3," "))
listOfTuple.map(x => x._1.toString + x._2.toString)
```

you have a lambda function working on one parameter (of type `Tuple2[Int, String]`

)

Both works fine with type inference.

# Partial lambda with one parameter

With

```
listOfTuple.map{case (x,y) => x.toString + y.toString}
```

you have a lambda function, working with one parameter (of type `Tuple2[Int, String]`

). This lambda function then uses `Tuple2.unapply`

internally to decompose the one parameter in multiple values. This still works fine with type inference. The `case`

is needed for the decomposition ("pattern matching") of the value.

This example is a little bit unintuitive, because unapply returns a Tuple as its result. In this special case there might indeed be a trick, so Scala uses the provided tuple directly. But I am not really aware of such a trick.

# Update: Lambda function with currying

Indeed there is a trick. With

```
import Function.tupled
listOfTuple map tupled{(x,y) => x.toString + y.toString}
```

you can directly work with the tuple. But of course this is really a trick: You provide a function operating on two parameters and not with a tuple. `tupled`

then takes that function and changes it to a different function, operating on a tuple. This technique is also called uncurrying.

# Remark:

The `y.toString`

is superfluous when `y`

is already a string. This is not considered good style. I leave it in for the sake of the example. You should omit it in real code.