is this working by fluke or is it expected behaviour?

On Fri, Jan 6, 2012 at 08:06, Aishwarya Singhal wrote:
>    def method2(i: Int)  {
>        // ... some code
>    }
>
>    method1(list) { (i, l) => method2(i) }
[...]
> another method (test) defines a function (method2) that only takes an
> Int and then invokes method1. when invoking method1, I pass method2 to
> it.

No, you're constructing a function literal with the { (i, l) => ... }
syntax. This function literal takes two parameters, and since it is
passed as the second argument list to method1, Scala infers the types
of these two parameters as (i: Int, l: Array[AnyRef]).

In the body of your function literal, you're only making use of one of
the input parameters -- in your call to method2(i). There's no
requirement in Scala (nor any other programming language I know of)
that the body of a function must make use of all the function's input
parameters.

> it makes my code simple and flexible so I am happy with the outcome,
> but I am not sure if this is the expected behaviour.
>
> what do you think?

I'd expect this behaviour.

Am 06.01.2012 08:06, schrieb Aishwarya Singhal:
> Hi all
>
> while writing some code, I made a slightly surprising observation.
> Please consider the following piece of code:
>
> // first method definition. expects a function to be passed to it
> def method1(list: Array[AnyRef])(f: (Int, Array[AnyRef]) => Unit) {
> // ... some code
> val i = 0
>
> f(i, list)
>
> }
>
> // the main API that the external using code will invoke
> def test(list: Array[AnyRef]) = {
>
> def method2(i: Int) {
> // ... some code
> }
>
> method1(list) { (i, l) => method2(i) }
> }
>
>
> basically, I have defined a method1 that will expect a function that
> takes an int and an array and will execute this function internally.
> another method (test) defines a function (method2) that only takes an
> Int and then invokes method1. when invoking method1, I pass method2 to
> it.
>
> now, my confusion is that the method signature of method1 expected a
> function with 2 params where as I am actually passing it a method that
> takes just one. Is this ok? I know i have cheated here by capturing
> both variables in the closure and using just one, but the method
> passed does not seem to match the expected definition nevertheless.
>
> it makes my code simple and flexible so I am happy with the outcome,
> but I am not sure if this is the expected behaviour.
>
> what do you think?

"(i,l) => code"

creates a function which takes 2 parameters, which is exactly what
method1 expects as a parameter. what you do inside the function is
completely irrelevant to the compiler, it doesn't care about unused
parameters.

>
> best regards
> Aishwarya
>

thanks guys, you are right. i was too narrowly focused on the method i
was passing to ignore the function i was creating on the go :-)

apologies and best regards
aishwarya

On Jan 6, 2:03 pm, HamsterofDeath wrote:
> Am 06.01.2012 08:06, schrieb Aishwarya Singhal:
>
>
>
>
>
>
>
>
>
> > Hi all
>
> > while writing some code, I made a slightly surprising observation.
> > Please consider the following piece of code:
>
> > // first method definition. expects a function to be passed to it
> > def method1(list: Array[AnyRef])(f: (Int, Array[AnyRef]) => Unit) {
> >     // ... some code
> >     val i = 0
>
> >     f(i, list)
>
> > }
>
> > // the main API that the external using code will invoke
> > def test(list: Array[AnyRef]) = {
>
> >     def method2(i: Int)  {
> >         // ... some code
> >     }
>
> >     method1(list) { (i, l) => method2(i) }
> > }
>
> > basically, I have defined a method1 that will expect a function that
> > takes an int and an array and will execute this function internally.
> > another method (test) defines a function (method2) that only takes an
> > Int and then invokes method1. when invoking method1, I pass method2 to
> > it.
>
> > now, my confusion is that the method signature of method1 expected a
> > function with 2 params where as I am actually passing it a method that
> > takes just one. Is this ok? I know i have cheated here by capturing
> > both variables in the closure and using just one, but the method
> > passed does not seem to match the expected definition nevertheless.
>
> > it makes my code simple and flexible so I am happy with the outcome,
> > but I am not sure if this is the expected behaviour.
>
> > what do you think?
>
> "(i,l) => code"
>
> creates a function which takes 2 parameters, which is exactly what
> method1 expects as a parameter. what you do inside the function is
> completely irrelevant to the compiler, it doesn't care about unused
> parameters.
>
>
>
>
>
>
>
>
>
> > best regards
> > Aishwarya