> Personally I think that Python is great for small simple things, but
> as soon as you start to scale the lack of statically checked
> guarantees starts to bite you.

What you said about the problems with dynamically typed
scripting language is very true. Python is so powerful but the
code is so fragile. You need to write a lot of tests. This is
exactly why I'm trying to learn Scala.

Thanks for your explanation about operators.

> Regarding () and {} BTW, you can replace a single-argument argument
> list with {}, e.g.
> def myFunction(a: String): Unit = println(a)
> myFunction("foobar")
> myFunction { "foobar" }

I find the following three lines of code do the same thing.
Thanks for your explanation again. I now understand
why the first and second line are equivalent. (But why
does Scala allow {} here? Isn't () good enough?)

I'm not sure what the {} does in the third line, though.

args.foreach{ arg => greeting += (arg + " ") }
args.foreach( arg => greeting += (arg + " ") )
args.foreach( arg => { greeting += (arg + " ") } )

> The two calls are equivalent. It makes more sense with the latter
> format with multiple argument lists or DSL-like things. I could write
> up an example if you're interested, but it might be somewhat involved
> if you're not familiar with Scala or Lift.

Thanks. Let me finish the tutorials first :-)

> Overall, my suggestion would be to stick with it and ask questions. I
> think it's worth it, and the people here are really helpful.

Yes. I plan to bite the bullet and continue with my learning.
And indeed, this is a very friendly and  helpful list.


You received this message because you are subscribed to the Google Groups 
"Lift" group.
To post to this group, send email to
To unsubscribe from this group, send email to
For more options, visit this group at

Reply via email to