4 ms·
I think a huge benefit is the readability of more complex expressions (e.g. when you start introducing zip, groupBy, folds etc into the mix).
by tsimionescu 7y ago
I think a huge benefit is the readability of more complex expressions (e.g. when you start introducing zip, groupBy, folds etc into the mix).
- 11235813213455 7y agoIf you want to show some code examples of list comprehensions, I'd be glad to show the equivalent without list-comprehensions in JS (which had a rejected proposal for list-comphensions https://www.reddit.com/r/javascript/comments/5eottt/why_the_hell_did_they_have_to_remove_list/ https://www.reddit.com/r/javascript/comments/5eottt/why_the_..., no regret though), so we can compare the readability
- omaranto 7y agoHow about finding triples a<b<c<30 of pairwise relatively prime integers such that the sum of their cubes is a perfect cube? Here's a list comprehension in Python (notice the weird syntax Python uses for "let x = y", namely "for x in [y]" :P): [(a,b,c) for a in range(1,30) for b in range(a+1,30) if gcd(a,b)==1 for c in range(b+1,30) if gcd(a,c)==1 and gcd(b,c)==1 for d in [int((a**3+b**3+c**3)**(1.0/3)+0.5)] if a**3+b**3+c**3==d**3] I doubt that would look any nicer with higher order functions. Specially if you want to get the same efficiency: notice how here we test that gcd(a,b)==1 as soon as possible. In general efficient comprehensions involve pushing any filtering as early as possible, so with higher order functions you get an alternation of filter with map/flatmap. Here's a (probably lame) attempt at a Python higher order version: flatmap = lambda f, l: [x for t in l for x in f(t)] flatmap(lambda a: flatmap(lambda b: flatmap(lambda c: (lambda d: [(a,b,c)] if a**3+b**3+c**3==d**3 else [])(int((a**3+b**3+c**3)**(1.0/3)+0.5)) if gcd(a,c)==1 and gcd(b,c)==1 else [], range(b+1, 30)) if gcd(a,b)==1 else [], range(a+1,30)), range(1,30)) Maybe it would look nicer with some filters thrown in instead of abusing flatmap of empty lists, but it would be longer since you definitely need a flatmap for a and b, and either a flatmap or map for c. I'd love to see a cleaner version with higher order function.
- tel 7y agoThe same sensibilities apply in Haskell. These sort of longer, more structured problems are exactly when do notation comes out do a <- [1 .. 29] b <- [a+1 .. 29] guard $ gcd a b == 1 c <- [b+1 .. 29] guard $ gcd a c == 1 guard $ gcd b c == 1 let z = a ** 3 + b ** 3 + c ** 3 let d = z ** (1/3) + 0.5 guard $ z == d ** 3 return (a, b, c) Translation of this into HOFs is straightforward (the method guard uses helps tremendously), but it's not worth it most of the time. In Python where HOFs are so restricted it would be even worse.
- omaranto 7y agoHere's the flatmap version with better formatting: flatmap(lambda a: flatmap(lambda b: flatmap(lambda c: (lambda d: [(a,b,c)] if a**3+b**3+c**3==d**3 else [])( int((a**3+b**3+c**3)**(1.0/3)+0.5)) if gcd(a,c)==1 and gcd(b,c)==1 else [], range(b+1, 30)) if gcd(a,b)==1 else [], range(a+1,30)), range(1,30))
- 11235813213455 7y agothe a:b notation for JS is still in proposal phase https://github.com/tc39/proposal-slice-notation/pull/32 https://github.com/tc39/proposal-slice-notation/pull/32, but I'll use it below to create ranges I don't understand your `+0.5`, I've written below the transcription for your description [...1:30].map(a => [...a+1:30].filter(b => gcd(a,b)==1).map(b => [...b+1:30].filter(c => gcd(a,c)==1 && gcd(b,c)==1 && Number.isInteger((a**3+b**3+c**3)**(1/3)) .map(c => [a, b, c]) ) ).flat(2) Or another equivalent way: [...1:30].flatMap(a => [...a+1:30].filter(b => gcd(a,b)==1).flatMap(b => [...b+1:30].filter(c => gcd(a,c)==1 && gcd(b,c)==1 && Number.isInteger((a**3+b**3+c**3)**(1/3))) .flatMap(c => [[a, b, c]]) Or another way (generating first all the triples): [...1:30].flatMap(a => [...a+1:30].flatMap(b => [...b+1:30].flatMap(c => [[a, b, c]]))) .filter(([a, b, c]) => gcd(a,b)==1 && gcd(a,c)==1 && gcd(b,c)==1 && Number.isInteger((a**3+b**3+c**3)**(1/3))) with https://github.com/tc39/proposal-iterator-helpers https://github.com/tc39/proposal-iterator-helpers, which would allow lazy evaluation, and make more sense than above (1:30).flatMap(a => (a+1:30).flatMap(b => (b+1:30).flatMap(c => [[a, b, c]]))) .filter(([a, b, c]) => gcd(a,b)==1 && gcd(a,c)==1 && gcd(b,c)==1 && Number.isInteger((a**3+b**3+c**3)**(1/3))) without the slice-notation, it's really ugly (hence the proposal in the first link) Array.from({length: 30},(_,a)=>a+1) .flatMap(a=>Array.from({length: 30-a-1},(_,b)=>a+b+1) .flatMap(b => Array.from({length: 30-b-1},(_,c)=>b+c+1).flatMap(c => [[a, b, c]]))) .filter(([a, b, c]) => gcd(a,b)==1 && gcd(a,c)==1 && gcd(b,c)==1 && Number.isInteger((a**3+b**3+c**3)**(1/3)))
- tsimionescu 7y agoI'll show an example in C#, which has some of the best list comprehension syntax in my opinion (LINQ): from category in categories where category.Name.Contains("food") join product in products on product.CategoryID equals category.ID select new { Name = category.Name, MostExpensive = (from categoryProduct in productGroup orderby categoryProduct.Price descending select categoryProduct) .First() } In C#, with HOFs, this becomes: categories .Where( category => category.Name.Contains("food")) .GroupJoin(products, category => category.ID, product => product.CategoryID, (category, productGroup) => new { Name = category.Name, MostExpensive = productGroup.OrderByDescending( product => product.Price) .First() } ) The second higher-oder function form has 2 disadvantages that I see: (1) for every subclause, it must mention the lambda parameter again (with more filtering/ordering/mapping this becomes much more noticeable); (2) it is easier to mess up the order of parameters, especially for something like Join/GroupJoin, which takes 5 parameters.
- 11235813213455 7y agoIt's probably this in JS: categories .filter( category => category.Name.includes('food')) .flatMap(category => { const productGroup = products.filter(product => product.CategoryID === category.ID); return productGroup.length === 0 ? [] : [{ Name: category.Name, MostExpensive: products.reduce((a, b) => a.Price < b.Price ? b : a) }]; })
- dorfsmay 7y agoOnce you have lazy iterators (eg: generator expressions in Python) you can split your complex iterator operations into multiple lines without losing on performance nor conciseness, and increase readability over even list compréhensions.