Decrementing ranges in Haskell

by

Basically, because [10..1] is translated to enumFromTo 10 1 which itself has the semantics to create a list by taking all elements less-than 1 which result from counting upward (with step-size +1) from (including) 10.

Whereas [10, 9..1] is translated to enumFromToThen 10 9 1 which explicitly states the counting step-size as 9-10, i.e. -1 (which is hard-coded to +1 for enumFromTo)

A more accurate specification can be found in the Haskell Report (6.3.4 The Enum Class):

enumFrom       :: a -> [a]            -- [n..]
enumFromThen   :: a -> a -> [a]       -- [n,n'..]
enumFromTo     :: a -> a -> [a]       -- [n..m]
enumFromThenTo :: a -> a -> a -> [a]  -- [n,n'..m]

For the types Int and Integer, the enumeration functions have the following meaning:

  • The sequence enumFrom e1 is the list [e1,e1+1,e1+2,...].

  • The sequence enumFromThen e1 e2 is the list [e1,e1+i,e1+2i,...], where the increment, i, is e2-e1. The increment may be zero or negative. If the increment is zero, all the list elements are the same.

  • The sequence enumFromTo e1 e3 is the list [e1,e1+1,e1+2,...e3]. The list is empty if e1 > e3.

  • The sequence enumFromThenTo e1 e2 e3 is the list [e1,e1+i,e1+2i,...e3], where the increment, i, is e2-e1. If the increment is positive or zero, the list terminates when the next element would be greater than e3; the list is empty if e1 > e3. If the increment is negative, the list terminates when the next element would be less than e3; the list is empty if e1 < e3.

More Related Contents:

  1. Haskell finding mean of cubes of odd members Any ideas? [closed]
  2. Histogram in Haskell [closed]
  3. What is Haskell’s Stream Fusion
  4. Using return vs. not using return in the list monad
  5. Cartesian product of infinite lists in Haskell
  6. Zip with default value instead of dropping values?
  7. Replace individual list elements in Haskell?
  8. Using Haskell’s map function to calculate the sum of a list
  9. Need to partition a list into lists based on breaks in ascending order of elements (Haskell)
  10. Merging two lists in Haskell
  11. Haskell Monad – How does Monad on list work?
  12. Is there a function to flatten a nested list of elements?
  13. Understanding a recursively defined list (fibs in terms of zipWith)
  14. Removing duplicates from a list in Haskell without elem
  15. Removing syntactic sugar: List comprehension in Haskell
  16. Counting unique elements in a list
  17. Unsequence Monad function within Haskell
  18. Grouping a list into lists of n elements in Haskell
  19. Concatenating two lists – difference between ‘+=’ and extend()
  20. Subsets in Prolog
  21. Java 8: sort list of objects by attribute without custom comparator
  22. Lazy lists in Prolog?
  23. How to clone or copy a list in kotlin
  24. Intersection and union of 2 lists
  25. Difference between a Seq and a List in Scala
  26. XPath 1.0 to find if an element’s value is in a list of values
  27. How can I read the contents of a file into a list in Lisp?
  28. R: Print list to a text file
  29. Add or remove an entry from a List type attribute in a DynamoDB table item
  30. Recursive Prolog predicate for reverse / palindrome

Leave a Comment