Hacker News Reader

Comment by rcarmo | Hacker News Reader

This. See my other comment for a sizable Hy example and more info, but the lack of "let" mostly killed it for me.

> but the lack of "let" mostly killed it for me

Can you give an example of code that is improved by let significantly? ...and can't be rewritten in a more readable way without it?

> Can you give an example of code that is improved by let significantly

Any piece of code that uses a variable.

I'd be more inclined to day that let mostly encourages you to write zillion-line functions (instead of lots of small ones), simply because with it you "mentally can" since you can see the scope of variables better.

But.. do you really prefer to write huge functions instead of smaller ones?

Also: I think Python's default args being evaluated at function definition time kills the need for the usage of let when defining closures inside loops (you can just pas the value you want to capture in a closure as the default value of a param) or other things like that.

> I'd be more inclined to [s]ay that let mostly encourages you to write zillion-line functions (instead of lots of small ones), simply because with it you "mentally can" since you can see the scope of variables better.

That’s true. I revise my comment as "Any piece of code that uses a variable[ to hold something you use multiple times and don’t want to recompute]."; for example creating an API client then using it twice.

Any macros that expands to code that will reuse a value. You can't do common, and valuable, constructs like once-only without let.

Hmm. Can't argue against this. I agree, this is a legitimate case.

Probably I'm a bit too stuck on "the python way" on this clash-of-cultures to see such cases that are clearly part of "the lisp way"...

    (defun udpate ()
     (let ((pos (find-char-pos)))
       (move-char pos))
     (print (stats))
     (rotate enemies))

    (defun udpate ()
     (set 'pos (find-char-pos))
     (move-char pos)
     (print (stats))
     (rotate enemies))

I now have to keep this 'pos symbol in my head for the rest of the function (in another language, forever in this case), whereas in the first example I can just forget about the variable after the next line. It doesn't exist anymore. It makes code clearer and much easier to refactor since I can immediately see everywhere that the variable is used.

I get it, despite having a small issue with "forever" being defined as "just 2 more loc", but I just:

(1) feel more drawn to "Flat is better than nested." from "Zen of Python" to dislike the extra scoping level despite the conceptual clarity it provides (because I'm sure some "idiot" will abuse it and I'll end up reading a 10 nested let-s monstrosity pretty soon)

(2) like to write small functions, so forever will always be "~10 loc max" for me

...so imho if you're used to "thinking in classic Lisps" you'll miss let, otherwise you won't. What I'd miss for example would be some Haskell-like where (https://wiki.haskell.org/Let_vs._Where#Advantages_of_where) but I'd wake quickly out of it since it would make no sense to someone not already "stuck in Haskell-like thinking mode".

    (defun udpate ()
     (ag-if (find-char-pos)
       (move-char it))
     (print (stats))
     (rotate enemies))

Doesn't Hy's anaphoric macros solve this? And one could even argue it's more readable.

I don't know what that is (tried googling it), but it doesn't look like it's doing the same thing as let.

> Can you give an example of code that is improved by let significantly?

"Let" is one of the most important special operators in Lisp. It allows you to create lexical variables within an s-expression.

Roughly equivalent to creating local variables within a block (in other languages).

So i'd claim it is essential.

Reply on news.ycombinator.com