CODEWITHSUNDEEP
scala
mistahenry
mistahenry

Reputation: 8724

How to invoke no-arg anonymous function with no parentheses

Take this code:

var x = 10
val y = () => x + 1

I then want to treat y as if its a variable that holds an Int and changes anytime x changes. Essentially I want to bind y to x.

Problem is, if I just type y then I get the result res0: () => Int = <function0> I was under the impression that you could invoke 0-arity functions without any parens, but I am required to use y() to get the behavior I am trying to achieve.

Is there a better way to define the anonymous function or do I need to use a different approach?

Upvotes: 0

Views: 111

Answers (2)

Vinicius Miana
Vinicius Miana

Reputation: 2067

Why do you need to do it like that? Just do def y = x + 1

scala> var x = 1
x: Int = 1

scala> def y = x + 1
y: Int

scala> y
res0: Int = 2

scala> x = 3
x: Int = 3

scala> y
res1: Int = 4

EDIT to address some comments:

If you define val y = () => x + 1, you are defining y as a value that holds a function that takes no argument and returns an Int. To call the function that is held by this variable, you will need to call it with (), to tell the compiler that you don't want to pass the value, but to execute (evaluate) the function that is within it.

If you define val y = x + 1, you are defining a value (constant), that is assigned in the moment it is executed, you could postpone evaluation using lazy, but once it is assigned, it will not be evaluated again.

If you define def y = x + 1, you are defining a function that returns x+1, which is what you want.

Upvotes: 2

wheaties
wheaties

Reputation: 35980

You have not defined a 0-arity function. You have actually defined a Unit => Int function. That is why you can not invoke it like you would like to invoke it. I've rarely seen 0-arity functions outside the context of come contained function scope:

def something[V](value: Int)(f: => V) = 
  if(value %2 == 0) f 
  else throw new Exception("not even (and also not evaluated f)")

where it is used as a lazily deferred execution body.

Edit: I would use the other person's answer.

Upvotes: 1

Related Questions