Haskelling My Python

https://unnamed.website/posts/haskelling-my-python/

by barrenko • 1 year ago

172 70 1 year ago

Generators are one of my favorite features of Python when used in this way. You can assemble complex transformation pipelines that don’t do any actual work and save it all for one single materialization.

nurettin• 1 year ago

Excited to read their next blog where they discover functools.partial and return self.

nickpsecurity• 1 year ago

I just discovered one from your comment. Thank you!

BiteCode_dev• 1 year ago

Or, you know, use numpy.

shash• 1 year ago

Yeah, that’s much more efficient.

But there’s something beautiful in the way that a Taylor expansion or a trigonometric identity emerge from the function definition. Also, it teaches an interesting concept in lazy evaluation.

I mean, why not write straight up assembler? That would be even more efficient…

brianberns2• 1 year ago

This idea comes from a functional pearl called "Power Series, Power Serious" [0], which is well worth reading.

I implemented the same thing myself in F#. [1]

[0] https://citeseerx.ist.psu.edu/document?repid=rep1&type=pdf&d...

[1] https://github.com/brianberns/PowerSeries

abeppu• 1 year ago

Huh, there must have been something in the water leading up to this. Also from 1998 is this paper, "Calculus in coinductive form" and neither of these cites the other. https://ieeexplore.ieee.org/document/705675

brianberns2• 1 year ago

These are indeed very similar. Thanks for the link!

The math is a bit over my head, but this formulation seems more difficult than the one I'm familiar with. For example, x^2 is represented as 0::0::2 instead of 0::0::1 (because 2! = 2) and x^3 is represented as 0::0::0::6 instead of 0::0::0::1 (because 3! = 6). Is there a benefit to that?

barrenko2• 1 year ago

I was introduced to the notion of power series two weeks ago, and now it's seemingly everywhere...

coliveira• 1 year ago

Power series have been everywhere for 200 years!

angra_mainyu• 1 year ago

Power series are possibly one of the most powerful tools in analysis.

fp645• 1 year ago

This is one of the reasons I hate python, it allows for so many weird things that are only borderline standardised, if at all. When I started with python decades ago, I was also all hype, list comprehensions and functional patterns everywhere, and why not monkey patch a third party library on runtime? Now I regularly see such code written by the new junior devs, painful to maintain, painful to integrate into a larger code base, most certainly failing with TorchScript, and plainly convoluted for the sake of appearing smart.

If you want to code it Haskell, have you considered using Haskell?

sanderjd3• 1 year ago

There is nothing weird or "borderline standardized" about generators...

fp645• 1 year ago

Fair point, they have a proper PEP. I’ve been burnt by `lst[::-1]` and the likes which TorchScript does not (did not?) support and to my surprise learned that the standard is not clear on this behaviour. Generators are fine but I somewhat fail to see their use as they move state somewhere not really clear and I have seen plenty of problems with needing `list(generator())` confusing people

notpushkin• 1 year ago

Absolutely unrelated, but there’s a Haskell-like syntax for Python: https://web.archive.org/web/20241205024857/https://pyos.gith...

  f = x -> raise if
    x :: int  => IndexError x
    otherwise => ValueError x

Complete with pipelines, of course:

  "> {}: {}".format "Author" "stop using stale memes"
    |> print

sizeofchar• 1 year ago

Wow, this is so awesome! A shame it didn’t progress.

agumonkey• 1 year ago

not too far from that there's https://coconut-lang.org/

sanderjd3• 1 year ago

This is certainly neat. This isn't a criticism, but I think more like an expansion on the author's point:

The reason this all works is that generators plus memoization is "just" an implementation of the lazy sequences that Haskell has built in.

gerad• 1 year ago

Isn’t the original python without the recursion lazy as well? I that was the entire point of generators.

sanderjd3• 1 year ago

You're right, fair enough. This isn't only about generators, it's also about how they interact with recursion and memoization.

mark_l_watson• 1 year ago

Well, definitely very cool, but: the Haskell code is delightfully readable while the Python code takes effort for me to read. This is not meant as a criticism, this article is a neat thought experiment.

abirch• 1 year ago

I agree that this was a great article.

For me, this isn't intuitive. It works; however, it doesn't scream recursion to me.

  def ints():
      yield 1
      yield from map(lambda x: x + 1, ints())

I preferred

  def ints():
      cnt = 1
      while True:
          yield cnt
          cnt += 1

thyrsus• 1 year ago

I'm a python newby, so please correct the following: The first function looks quadratic in time and linear in stack space, while the second function looks linear in time and constant in stack space. Memoizing would convert the first function to linear in time and linear in space (on the heap instead of the stack). For python, wouldn't I always use the second definition? For Haskell, I would use the [1..] syntax which the compiler would turn into constant space linear time machine code.

louthy2• 1 year ago

I've never written a line of python in my life, so I'm interested in how this "recursive function" can do anything different on each recursive call if it takes no arguments?

    def ints():
        yield 1
        yield from map(lambda x: x + 1, ints())

Surely it would always yield a stream of `1`s? Seems very weird to my brain. "As simple as that" it is not!

rowanG0773• 1 year ago

Sure it yields 1. But then it adds one to each yield form the recursive call. And repeat.

lalaithion2• 1 year ago

The first item yielded from ints() is 1.

For the second item, we grab the first item from ints(), and then apply the map operation, and 1+1 is 2.

For the third item, we grab the second item from ints(), and then apply the map operation, and 1+2 is 3.

louthy2• 1 year ago

Got it, thanks! The syntax was throwing me a bit there.

cartoffal• 1 year ago

The $ operator is nothing but syntactic sugar that allows you to write bar $ foo data instead of having to write bar (foo data). That’s it.

Actually, it's even simpler than that: the $ operator is nothing but a function that applies its left argument to its right one! The full definition is

    f $ x = f x

(plus a directive that sets its precedence and association)

IshKebab3• 1 year ago

This kind of thing is emblematic of how little Haskellers care about readability and discoverability. I'm sure it's great for people that are already expert Haskellers but it adds yet another thing to learn (that's really hard to search for!) and the benefit is... you can skip a couple of brackets. Awesome.

yoyohello133• 1 year ago

You can type `:doc $` in ghci and it will tell you how the function is defined and give you usage examples.

gizmo686• 1 year ago

Skipping brackets is incredibly useful for readability. Basically every language that relies on brackets has settled on a style convention that makes the redundant with indentation. Admittedly, the big exception to this is function application. But Haskell is much more function oriented, so requiring brackets on function application is much more burdensome than in most languages.

As to searchability, this should be covered in whatever learn Haskell material you are using. And if it isn't, then you can literally just search for it in the Haskell search engine [0].

[0] https://hoogle.haskell.org/?hoogle=%24&scope=set%3Astackage

sabellito• 1 year ago

I agree with this sentiment. The one thing I liked about Clojure was the simplicity of the syntax, as long as you kept away from writing macros.

In general, after so many decades programming, I've come to dislike languages with optional periods (a.foo) and optional parenthesis for function calls - little gain to a confusion of precedence, what's a field vs method. Seems that the whole DSL craze of 15 years ago was a mistake after all.

Having said all that, I think haskell is awesome, in the original sense of the word. I became a better programmer after working with it for a bit.

lgas2• 1 year ago

You're only new once, but you write lines that benefit from $ every day.

mrkeen3• 1 year ago

Excessive brackets are an evergreen complaint against lisp.

Here's one that made the front page, same time as your comment: https://news.ycombinator.com/item?id=43753381

rowanG0773• 1 year ago

Haskell has it's issues, but this really ain't it. $ is idiomatic and used all over the place and is greatly more readable than stacking up brackets. The discoverability is also great because, like most things in Haskell, you can literally just input it into hoogle: https://hoogle.haskell.org/?hoogle=%24 and the first hit is, of course the definition of it. Which includes a full explanation what it does.

pklausler• 1 year ago

In Haskell, ($) = `id`, because "id f x" = "(id f) x" = "f x".

ltbarcly33• 1 year ago

I have no idea why this is even slightly neat? Like, it's not surprising that it works, it's not clever, it's not performant, and you can't actually code like this because it will overflow the stack pretty quickly. It doesn't even save lines of code.

Alternatives that aren't dumb:

  for x in range(2**256):  # not infinite but go ahead and run it to the end and get back to me

  from itertools import repeat
  for x, _ in enumerate(repeat(None)):  # slightly more annoying but does work infinitely

Granted these aren't clever or non-performant enough to excite functional code fanboys.

mrkeen3• 1 year ago

The functional fanboys have moved onto languages that don't overflow the stack.

ltbarcly33• 1 year ago

Read the article?

hedora• 1 year ago

TIL haskell is Turing complete but only uses bounded memory.

dev360• 1 year ago

So many people neglect the lack of TCO in Python, it’s like a beginner mistake you make when you try to make your Python read like the Haskell you just learned. Not sure why you’re getting downvoted though.

nexo-v1• 1 year ago

I really like this idea too. Generators are one of my favorite parts of Python — super memory efficient, and great for chaining transformations. But in practice, I’ve found they can get hard to reason about, especially when you defer evaluation too much. Debugging gets tricky because you can’t easily inspect intermediate states.

When working with other engineers, I’ve learned to be careful: sometimes it’s better to just materialize things into a list for clarity, even if it’s less “elegant” on paper.

There’s a real balance between cleverness and maintainability here.

pletnes• 1 year ago

There’s some stuff in itertools to cut sequences into batches. Could be a useful intermediate step - grab 100 things at a time and write functions that receive and emit lists, rather than generators all the way down.

ankitml• 1 year ago

It is possible to test the chaining though, if you know your data well. If not, those edge cases in the data quality can throw things off balance very easily.

UltraSane• 1 year ago

I often will intentionally store intermediate values in variables rather than just doing a clever one liner in Python specifically because I know it will make debugging easier.

benrutter• 1 year ago

I like this! Tiny question, is the cache at the end any different from the inbuilt functools cache?

Haskelling My Python

Related Stories