Haskell，用它的长度压缩列表的元素

Question

The next lines should show how its has to work..

[14,2,344,41,5,666] after [(14,2),(2,1),(344,3),(5,1),(666,3)]

["Zoo","School","Net"] after [("Zoo",3),("School",6),("Net",3)]

Thats my code up to now

zipWithLength :: [a] -> [(a, Int)]
zipWithLength (x:xs) = zipWith (\acc x -> (x, length x):acc) [] xs

I want to figure out what the problem in the second line is.

Answer 1

If you transform the numbers into strings (using show ), you can apply length on them:

Prelude> let zipWithLength = map (\x -> (x, length (show x)))
Prelude> zipWithLength [14,2,344,41,5,666]
[(14,2),(2,1),(344,3),(41,2),(5,1),(666,3)]

However, you cannot use the same function on a list of strings:

Prelude> zipWithLength ["Zoo","School","Net"]
[("Zoo",5),("School",8),("Net",5)]

The numbers are not the lengths of the strings, but of their representations:

Prelude> show "Zoo"
"\"Zoo\""
Prelude> length (show "Zoo")
5

As noted in the comments, similar problems may happen with other types of elements:

Prelude> zipWithLength [(1.0,3),(2.5,3)]
[((1.0,3),7),((2.5,3),7)]
Prelude> show (1.0,3)
"(1.0,3)"
Prelude> length (show (1.0,3))
7

Answer 2

If you want to apply a function on every element of a list, that is a map :: (a -> b) -> [a] -> [b] . The map thus takes a function f and a list xs , and generates a list ys , such that the i -th element of ys , is f applied to the i -th element of xs .

So now the only question is what mapping function we want. We want to take an element x , and return a 2-tuple (x, length x) , we can express this with a lambda expression :

mapwithlength = map (\x -> (x, length x))

Or we can use ap :: Monad m => m (a -> b) -> ma -> mb for that:

import Control.Monad(ap)

mapwithlength = map (ap (,) length)

A problem is that this does not work for Int s, since these have no length . We can use show here, but there is an extra problem with that: if we perform show on a String , we get a string literal (this means that we get a string that has quotation marks, and where some characters are escaped). Based on the question, we do not want that.

We can define a parameterized function for that like:

mapwithlength f = map (ap (,) (length . f))

We can basically leave it to the user. In case they want to work with integers, they have to call it with:

forintegers = mapwithlength show

and for String s:

forstrings = mapwithlength id

Answer 3

After installing the number-length package, you can do:

module Test where
import           Data.NumberLength

-- use e.g for list of String
withLength :: [[a]] -> [([a], Int)]
withLength = map (\x -> (x, length x))

-- use e.g for list of Int
withLength' :: NumberLength a => [a] -> [(a, Int)]
withLength' = map (\x -> (x, numberLength x))

Examples:

>>> withLength ["Zoo", "bear"]
[("Zoo",3),("bear",4)]
>>> withLength' [14, 344]
[(14,2),(344,3)]

Answer 4

As bli points out, calculating the length of a number using length (show n) does not transfer to calculating the length of a string, since show "foo" becomes "\\"foo\\"" . Since it is not obvious what the length of something is, you could parameterise the zip function with a length function:

zipWithLength :: (a -> Int) -> [a] -> [(a, Int)]
zipWithLength len = map (\x -> (x, len x))

Examples of use:

> zipWithLength (length . show) [7,13,666]
[(7,1),(13,2),(666,3)]

> zipWithLength length ["Zoo", "School", "Bear"]
[("Zoo",3),("School",6),("Bear",4)]

> zipWithLength (length . concat) [[[1,2],[3],[4,5,6,7]], [[],[],[6],[6,6]]]
[([[1,2],[3,4],[5,6,7]],7),([[],[],[6],[6,6]],3)]