Haskell：从具有静态元素的元组和列表创建元组列表

Question

Need to create a list of tuples from a tuple with a static element and a list. Such as:

(Int, [String]) -> [(Int, String)]

Feel like this should be a simple map call but am having trouble actually getting it to output a tuple as zip would need a list input, not a constant.

Answer 1

I think this is the most direct and easy to understand solution (you already seem to be acquainted with map anyway):

f :: (Int, [String]) -> [(Int, String)]
f (i, xs) = map (\x -> (i, x)) xs

(which also happens to be the desugared version of [(i, x) | x < xs] , which Landei proposed)

then

Prelude> f (3, ["a", "b", "c"])
[(3,"a"),(3,"b"),(3,"c")]

This solution uses pattern matching to "unpack" the tuple argument, so that the first tuple element is i and the second element is xs . It then does a simple map over the elements of xs to convert each element x to the tuple (i, x) , which I think is what you're after. Without pattern matching it would be slightly more verbose:

f pair = let i  = fst pair  -- get the FIRST element
             xs = snd pair  -- get the SECOND element
         in map (\x -> (i, x)) xs

---

Furthermore:

The algorithm is no way specific to (Int, [String]) , so you can safely generalize the function by replacing Int and String with type parameters a and b :

f :: (a, [b]) -> [(a, b)]
f (i, xs) = map (\x -> (i, x)) xs

this way you can do

Prelude> f (True, [1.2, 2.3, 3.4])
[(True,1.2),(True,2.3),(True,3.4)]

and of course if you simply get rid of the type annotation altogether, the type (a, [b]) -> [(a, b)] is exactly the type that Haskell infers (only with different names):

Prelude> let f (i, xs) = map (\x -> (i, x)) xs
Prelude> :t f
f :: (t, [t1]) -> [(t, t1)]

---

Bonus: you can also shorten \\x -> (i, x) to just (i,) using the TupleSections language extension:

{-# LANGUAGE TupleSections #-}

f :: (a, [b]) -> [(a, b)]
f (i, xs) = map (i,) xs

Also, as Ørjan Johansen has pointed out, the function sequence does indeed generalize this even further, but the mechanisms thereof are a bit beyond the scope.

Answer 2

For completeness, consider also cycle ,

f i = zip (cycle [i])

Using foldl ,

f i = foldl (\a v -> (i,v) : a ) []

Using a recursive function that illustrates how to divide the problem,

f :: Int -> [a] -> [(Int,a)]
f _ [] = []
f i (x:xs) = (i,x) : f i xs

Answer 3

列表理解将是非常直观和可读的：

f (i,xs) = [(i,x) | x <- xs]

Answer 4

Do you want the Int to always be the same, just feed zip with an infinite list. You can use repeat for that.

f i xs = zip (repeat i) xs