Re: var vs def

Hi,

I think you may struggle on three points:

1.) expressions vs. statements and the Unit type and value: in Scala
each statement is also an expression. This means that statements will
return a value, the Unit value (), that can be put into a variable
(even if that's not particularly useful).

That's what happens in

var greatWorld2 = println("great world")

afterwards greatWorld2 contains the value ().

2.) the meaning of the syntax `var xyz = expression`. Actually, you
could see this as a short-form of

var xyz: Boolean = _
xyz = expression

The first line basically reserves a memory slot of type Boolean and
initializes it with the default value for that type. The second line
assigns the value of the expression to that memory slot.

Constrast this to

def xyz = expression

which is a line that isn't really executed at runtime i.e. when the
control flow reaches this line nothing happens. The expression is only
then evaluated when you "call the method". The repl sometimes makes
things harder to understand because it mixes up compile-time and
runtime, so I'd suggest also playing around writing real programs that
you first compile and then run.

3.) What the Scala compiler meant with "recursive without any return
type". The recursion that is meant here doesn't mean that there's
actually a recursive call happening at any point in time for your
`var` line, but it just means that in a var-definition you reference
the symbol which is currently being defined on the right-hand-side.
The Scala compiler won't be able to infer a type for these kind of
definitions so it complains.

The question remains what the semantics of the recursive occurrence of
the variable inside of its own definition is. If you make the
expansion I suggested at 2.) you will see why things are as they are:

 var greatWorld3:Boolean =
  if (i>10) true
  else {
    println("Print i:"+i)
    i += 1
    greatWorld3
  }

is actually short for

var greatWorld3: Boolean = _
greatWorld3 =
  if (i>10) true
  else {
    println("Print i:"+i)
    i += 1
    greatWorld3
  }

So, first, the memory slot for greatWorld3 is reserved and initialized
with the default value of Boolean which is `false`, then the
expression of the right-hand-side of the assignment is executed (which
will access the current value of `greatWorld3` which is still the
default `false`, and then the result of this expression will be saved
to `greatWorld3`.

I hope this explains things a bit further :)
Johannes


On Sat, May 2, 2015 at 6:26 PM, scalanewbie <[email protected]> wrote:
> Thank you Martin and Oliver,
>
> This is now clear to me (I think), correct me if am wrong below:
>
> I created another small example, but this time with no variable in var
> declaration. Here is the example, and I start with initialising a variable i
> with 0
>
> scala> var i = 0
>
> i: Int = 0
>
>
> scala> var greatWorld3:Boolean = if (i>10) true else { println("Print i:"+i)
>
>      | i += 1
>
>      | greatWorld3 }
>
> Print i:0
>
> greatWorld3: Boolean = false
>
>
> scala> i
>
> res44: Int = 1
>
>
> scala> greatWorld3
>
> res45: Boolean = false
>
>
> Now, I start with a variable i set to 0; and declare a function (I think it
> is still a Function/Method; as when I did not provide :Boolean return type
> it complained as being recursive without any return type; do correct me if I
> am getting this wrong).
>
>
> Given that the right side of '=' sign is only evaluated once, the statement
> is run once therefore the i ends up with 1 value at the end of it. And for
> the same reason, the greatWorld3 variable/function (ummm... I am still
> confused here if I defined a function or variable...) has the default for
> boolean, which is false.
>
>
> And at end of the definition the interpreter prints:
>
>
> greatWorld3: Boolean = false
>
>
> which might have happened either because:
>
>  a. the interpreter returns the type of the just created function/variable
> by default
>
> OR
>
>  b. Because there is a recursive call to greatWorld3, and the interpreter
> prints the vale of greatWorld3.
>
>
> Not sure which one these above 2 is applied?
>
>
> Next I go into function definition, with def
>
>
> I then move on to define a new variable j with 0, and now replace the
> definition of greatWorld3 with a function def as below:
>
>
> scala> var j = 0
>
> j: Int = 0
>
>
> scala> def greatWorld3:Boolean = if(j>10) true else {println("Print j:"+j)
>
>      | j += 1
>
>      | greatWorld3 }
>
> greatWorld3: Boolean
>
>
> scala> greatWorld3
>
> Print j:0
>
> Print j:1
>
> Print j:2
>
> Print j:3
>
> Print j:4
>
> Print j:5
>
> Print j:6
>
> Print j:7
>
> Print j:8
>
> Print j:9
>
> Print j:10
>
> res46: Boolean = true
>
>
> scala> j
>
> res47: Int = 11
>
>
> Output for def block, is all ok.
>
>
> Thanks for your help and time again.
>
>
> Regard,
>
> S
>
>
>
> On Saturday, May 2, 2015 at 2:36:39 PM UTC+1, martin wrote:
>>
>> On Sat, May 2, 2015 at 12:57 PM, scalanewbie <[email protected]> wrote:
>> > Hello All,
>> >
>> > I am a newbie to scala and getting in grasp with val and def.
>> >
>> > I noticed that I could write :
>> >
>> > scala> var greatWorld2 = println("great world")
>> >
>> > great world
>> >
>> > greatWorld2: Unit = ()
>> >
>> >
>> > AND
>> >
>> >
>> > scala> def greatWorld() = println("great world")
>> >
>> > greatWorld: ()Unit
>> >
>> >
>> > Can someone please help me understand the difference?
>> >
>> >
>> > I am aware that var is generally used to define variables and def is
>> > used to
>> > define functions.
>> >
>> >
>> > Now, keeping in mind that greatWorld2 is actually a variable and not a
>> > function, I am trying to print it, and I get:
>> >
>> >
>> > scala> greatWorld2
>> >
>> You are probably surprised that you see no output. That's because
>> greatWorld2 returns a unit value (after all, its type is Unit) and the
>> REPL does not print unit values. It could print () but it assumes that
>> you executed the expression for its side effects only.
>>
>> Hope this helps
>>
>>  - Martin
>>
>> >
>> > OR, if I try calling it as a function, it throws an error e.g. below
>> > (which
>> > sounds ok as I did not declare this as a function, so was expecting this
>> > anyway).
>> >
>> >
>> > scala> greatWorld2()
>> >
>> > <console>:9: error: Unit does not take parameters
>> >
>> >               greatWorld2()
>> >
>> >
>> >
>> >  Long story short, difference between var and def , in terms of what the
>> > interpreter and or compiler is doing underneath will be very good to
>> > understand.
>> >
>> >
>> > Thanks Guys,
>> >
>> > S
>> >
>> >
>> >
>> > --
>> > You received this message because you are subscribed to the Google
>> > Groups
>> > "scala-language" group.
>> > To unsubscribe from this group and stop receiving emails from it, send
>> > an
>> > email to [email protected].
>> > For more options, visit https://groups.google.com/d/optout.
>>
>>
>>
>> --
>> Martin Odersky
>> EPFL
>
> --
> You received this message because you are subscribed to the Google Groups
> "scala-language" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to [email protected].
> For more options, visit https://groups.google.com/d/optout.



-- 
Johannes

-----------------------------------------------
Johannes Rudolph
http://virtual-void.net

-- 
You received this message because you are subscribed to the Google Groups "scala-language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to [email protected].
For more options, visit https://groups.google.com/d/optout.