Comment by saagarjha | Hacker News Reader

Comment by saagarjha | Hacker News Reader

Parent Full thread

I think it’s interesting how similar a lot of this stuff is to what I do, except I’m not very good at Advent of Code and also I decided to hack Python to do this instead of writing my own language. For example:

* I couldn’t really make operators first class functions, but I just autoimported operator which has this but in words

* I wanted partial application and hated lambda syntax, so I hacked it together with some magic. “_0 + 1” is basically equivalent to lambda x: x + 1

* Python really likes to make everything a free function, which messes with the whole left-to-right thing. So I monkey-patched functional methods onto all the collections

Together this means that if I have like a comma separated list of numbers in str and I want to, idk, count how many are above five I’d do something like

  str.split(",").map(int).filter(_0 > 5).len

which matches how my brain things about it far better than how Python would like me to write it. It uses some tricks but it’s not actually that bad of a hack IMO: https://github.com/saagarjha/advent-of-code/blob/main/aoc.py

reads a bit like javascript now. You might want to consider switching languages

Oh it definitely does. The reason I stick with Python is that it has a somewhat decent standard library, and IMO fewer surprises (I don’t know Python or JavaScript all that well, since I basically never use it professionally, so I need to reduce footguns for myself).

Type cohersion and type juggling can bring a few surprises. But usually only when you do something weird to hit those edge cases. Otherwise, it's standard library is actually very decent now. Especially when working with arrays. You have all the nice to have methods, like, split, find, filter, map, reduce, every, some, etc... Which makes it a really nice language for these kind of tasks.

The example above would like this in modern javascript:

      str.split(',').map(char => Number(char)).filter(num => num > 5).length

Or if you like to live dangerously:

    str.split(',').filter(n => +n > 5).length

Not all that dangerous, tbh. My main concern would be NaN potentially cascading through, but not only is `NaN > 5` false, `!!NaN` is too.

To be clear by “standard library” I mean that Python has like actual data structures that are useful. Also while not part of the standard library arbitrary precision integers and associated functions (e.g. modular pow) can be quite helpful.

Javascript now has Map, Set, and bigint. But no powmod.

Python also has niceties like defaultdict or heapq

Honestly I'm jealous of JavaScript's arrow syntax. I don't really need anything else but the arrows are nice (and Turing complete).

I really wish python would steal 'let' from JS, specifically in a block scoped form - coming from perl's 'my' as a way of life, python's (and ruby's) function level scoping and "surprise! variable just popped into existence on assignment!" behaviour really messed me up.

Can you tell me more about the usefulness of 'let'? I'm an intermediate(?) programmer but I've worked mostly in Python, C and C++. I did one JS project and everything I saw about 'let' seemed redundant.

Firstly (compared to python at least) there's the obvious 'typo in variable name barfs early' advantage, which honestly is not to be sniffed at on its own.

But my big thing is about being able to scope values to the specific block where they belong:

    ...
    let foo;
    {
        let x = blah();
        let y = frob(x);
        foo = munge(y);
    }

and the temporaries 'x' and 'y' have gone away as soon as the } happens.

also, if you've ever had "fun" trying to capture a loop variable,

    for (let val of things) {
      callbacks.push(() => val.finish());
    }

has a different 'val' for each iteration of the loop so you can do that safely without requiring some sort of copying or an intermediate function invocation to create an extra scope.

Oh, and it also renders impossible certain weird constructs like

    if <test>:
        some_name = ...

where now whether the some_name variable even -exists- after that if block is indeterminate without knowing which way the <test> went.

I also like being able to do e.g.

    for (let thing of things) {
        let blah = thing.blah;
        callbacks.push(() => blah.doThing());
    }

Without 'let' you'd have to write (for the first 'for' example)

    for (var val of things) {
      callbacks.push(((val) => {
        return () => { val.finish() }
      })(val));
    }

to perpetrate let-over-lambda to get a separate scope for the callback function.

This is not my favourite thing to write, and -very- far from my favourite thing to read later.

Hopefully that gives you a better idea of why I, at least, prefer having 'let' available.

I always figured that once Python got the walrus operator it would be a matter of time until arrow functions of some sort made more and more sense on Python.

I really hope not tbh, once you break that seal it will consume the entire language into nested anonymous function soup without all the facilities JS has accumulated over the years to mitigate it. Python is an iterator based language and it leads to some very nice code if you design with that in mind.

It's really incredible how much such a small feature in the grand scheme of things `(function() { })()` influences all API and library design. Right now passing around functions in Python is ugly and reads as such which is enough of a deterrent for most people.

Ever played with a more stack-oriented / concatenative / postfix language, like Factor?

  "," split [ string>number 5 > ] count

or

  "," split [ string>number ] map [ 5 > ] count

or

  "," split [ string>number 5 > ] filter length

I think Ruby might be your next language :)

But I do do the following sort of thing in Python: ``` from chainzzz import C

C(some_list).group_by(lambda x: x + 1).map(lambda key: key % 2).size() ```

Where C(...) gives us the same object but with some methods added to it as you can see

Hmm, that's an interesting way of doing it. I'll keep it in my back pocket if they ever break this :)

Reply on news.ycombinator.com