Haskell list comprehension code#

SOME value => value :: tabfilter (from+1, to, f)įun isPythTriple (x, y, z) = x*x + y*y = z*z These basics are essential comprehension as to how the Internet and Ethernet. You could for example combine List.tabulate and List.filter to reduce memory consumption: fun tabfilter (from, to, f) = This list is certainly not exhaustive of cool REST APIs, but simply some.

Haskell list comprehension code#

And as you're hinting at, the multiple nested foldrs does not make the code particularly readable. For example, List.tabulate can't iterate a range of numbers without generating the list in memory. Generally, using library functions is good, but Standard ML's library is somewhat limited. Writing your own helper functions is really not something that should be avoided. I have been thinking on write my own recursive functions This takes several seconds for pyths 10 there really is not reason to generate O(n³) list elements when the solution subset is so sparse. To achieve the same efficiency as the Haskell pyths and use the minimum amount of custom code, here is one version that uses List.filter, ncat and List.tabulate: fun isPythTriple (x, y, z) = x*x + y*y = z*zįun tab1 n f = List.tabulate (n, fn i => f (i+1)) I wanted to do it using the minimum amount of custom code. If you're worrying about performance here, consider the fact that you don't actually need to store these numbers in lists - this is purely a convenience so that you can use list comprehensions to iterate their combinations. Neither SML/NJ's or Moscow ML's List.tabulate is tail-recursive, though. Using rev to achieve a tail-recursive function can be a good choice. Instead of generateIntsUpTo n, use List.tabulate (n, fn i => i+1).

The Haskell pyths is not very efficient, and it contains duplicate answers.įun instead of val/ val rec is syntactic sugar for function declarations. I have been thinking of writing my own recursive functions, but I wanted to do this with the minimum amount of custom code. Commented out is the line that lets me avoid the reversion of the list but then it's not tail recursive.īesides that, there's the three nested foldr calls. The first thing that I don't like is the call to rev at the end of generateIntsUpTo but I did it to accomplish a tail recursive function. Let val rec helper = fn current => fn xs => My Standard ML attempt, not so much: (* No list comprehensions in SML so we need a helper function *) The Haskell version is pretty simple: pyths ∷ Int → Using a list comprehension, define a function pyths ∷ Int → that maps an integer n to all such triples with components in. At the beginning everything seemed pretty similar until I reached list comprehensions:Ī triple (x,y,z) of positive integers is called pythagorean if x2 + y2 = z2. Out of curiosity, I'm porting the Haskell exercises of Programming in Haskell by Graham Hutton to Standard ML.