let

I want to use Lazy initialization for some of my properties in Swift. My current code looks like this: lazy var fontSize : CGFloat = { if (someCase) { return CGFloat(30) } else { return CGFloat(17) } }() The thing is that once the fontSize is set it will NEVER change. So I wanted to do something like this: lazy let fontSize : CGFloat = { if (someCase) { return CGFloat(30) } else { return CGFloat(17) } }() Which is impossible. Only this works: let fontSize : CGFloat = { if (someCase) { return CGFloat(30) } else { return CGFloat(17) } }() So - I want a property that will be lazy loaded but will

Often I face following situation: suppose I have these three functions def firstFn: Int = ... def secondFn(b: Int): Long = ... def thirdFn(x: Int, y: Long, z: Long): Long = ... and I also have calculate function. My first approach can look like this: def calculate(a: Long) = thirdFn(firstFn, secondFn(firstFn), secondFn(firstFn) + a) It looks beautiful and without any curly brackets - just one expression. But it's not optimal, so I end up with this code: def calculate(a: Long) = { val first = firstFn val second = secondFn(first) thirdFn(first, second, second + a) } Now it's several expressions

I understand that they're different since one works for setting *compile-path* and one doesn't. However, I need help with why they're different. let creates a new scope with the given bindings, but binding ...? Brian Carper let creates a lexically scoped immutable alias for some value. binding creates a dynamically scoped binding for some Var . Dynamic binding means that the code inside your binding form and any code which that code calls (even if not in the local lexical scope) will see the new binding. Given: user> (def ^:dynamic x 0) #'user/x binding actually creates a dynamic binding for a

I am taking an online JS course and the instructor used the syntax : let = names = ["Bob","Tim","Larry"] . I am convinced that was an accident, but somehow allowed by the JS environment he was using. What he ended up doing (probably by accident) was assign the array to the "names" variable, which assigned it to the "let" variable. My question: why is this not an error? Why can "let" be used as an variable? We know "let" is a keyword. Or is it just something they haven't outlawed yet? You can still do it in the Chrome and Firefox console... and in Node, too, for that matter. In ES3 and earlier

I was going through the Difference between var and let documentation example and was testing that when an undeclared variable is invoked, the global scope automatically provides a declaration for it (that's why the following snippet does not throw an error in any of the variables): x = 3; console.log(x); (function() { y=x+39; })() console.log(y); However, when one variable is declared with let after the assignment in the same global scope: x=3; let x = 42; console.log(x); One of the following errors is thrown: ReferenceError : x is not defined (Chromium) ReferenceError : can't access lexical