Làm cách nào để nén nhiều danh sách trong Haskell?

Question

Trong python zip chức năng chấp nhận số lượng danh sách tùy ý và nén chúng lại với nhau.

>>> l1 = [1,2,3] 
>>> l2 = [5,6,7] 
>>> l3 = [7,4,8] 
>>> zip(l1,l2,l3) 
[(1, 5, 7), (2, 6, 4), (3, 7, 8)] 
>>> 

Làm cách nào tôi có thể zip cùng nhau nhiều danh sách trong haskell?

Answer 1

Một tổng quát của zip có thể đạt được bằng Applicative Notation. Đó là một chút khó chịu để sử dụng vì gói mới/unwrapping, nhưng nếu bạn đang làm một cái gì đó mà không thể được thực hiện với một zipWithn cho n nhỏ hợp lý, bạn có thể đã ở mức độ cao trừu tượng, nơi các cơn đau hợp lý là vắng mặt.

Loại là ZipList a và phiên bản ứng dụng của nó nén các danh sách cùng nhau. Ví dụ:

(+) <$> ZipList [1,2] <*> ZipList [3,4] == ZipList [4,6] 

này khái quát chức năng của arity tùy ý và gõ sử dụng ứng dụng phần:

(+) <$> ZipList [1,2] :: ZipList (Int -> Int) 

Xem cách (+) là một phần áp dụng ở đây?

Nếu bạn không thích thêm ZipList và getZipList ở khắp mọi nơi, bạn có thể tái tạo các ký hiệu dễ dàng đủ:

(<$>) :: (a -> b) -> [a] -> [b] 
(<$>) = map 

(<*>) :: [a -> b] -> [a] -> [b] 
(<*>) = zipWith ($) 

Sau đó các ký hiệu cho zipWith f a b c d ... là:

f <$> a <*> b <*> c <*> d <*> ... 

ký hiệu applicative là rất kỹ thuật mạnh mẽ và tổng quát có phạm vi rộng hơn nhiều so với việc nén tổng quát. Xem Typeclassopedia để biết thêm về ký hiệu áp dụng.

Answer 2

Có vẻ như cũng có zip3 (doc) và chức năng zip4 (doc) trong Haskell. Nhưng zipn có vẻ phức tạp vì hệ thống kiểu mạnh. Here is a good discussion Tôi đã tìm thấy trong quá trình nghiên cứu của mình.

Answer 3

Bạn có thể transpose một danh sách liệt kê:

>>> import Data.List 
>>> transpose [l1,l2,l3] 
[[1,5,7],[2,6,4],[3,7,8]] 

Answer 4

Đó là không tầm thường, nhưng nó là doable. Xem this blog post. Tôi không biết liệu điều này được thực hiện vào một số thư viện.

Đây là another version, đơn giản hơn. Cái này thực sự có thể được cắt-n-dán ở đây:

{-# LANGUAGE MultiParamTypeClasses 
      , FunctionalDependencies 
      , FlexibleInstances 
      , UndecidableInstances 
      #-} 

-- | 
-- Module  : Data.List.ZipWithN 
-- Copyright : Copyright (c) 2009 wren ng thornton 
-- License  : BSD3 
-- Maintainer : wren@community.haskell.org 
-- Stability : experimental 
-- Portability : non-portable (MPTCs, FunDeps,...) 
-- 
-- Provides a polyvariadic 'map'/'zipWith' like the @map@ in Scheme. 
-- For more details on this style of type hackery, see: 
-- 
-- * Chung-chieh Shan, /A polyvariadic function of a non-regular/ 
--  /type (Int->)^N ([]^N e)->.../ 
--  <http://okmij.org/ftp/Haskell/polyvariadic.html#polyvartype-fn> 
---------------------------------------------------------------- 
module Data.List.ZipWithN (ZipWithN(), zipWithN) where 

-- | This class provides the necessary polymorphism. It is only 
-- exported for the sake of giving type signatures. 
-- 
-- Because we can't do functor composition without a lot of noise 
-- from newtype wrappers, we use @gr@ and @kr@ to precompose the 
-- direct/list functor with the reader functor and the return type. 
class ZipWithN a gr kr | kr -> gr a where 
    _zipWithN :: [a -> gr] -> [a] -> kr 

instance ZipWithN a b [b] where 
    _zipWithN = zipWith ($) 

instance ZipWithN b gr kr => ZipWithN a (b -> gr) ([b] -> kr) where 
    _zipWithN = (_zipWithN .) . zipWith ($) 


-- | Polyadic version of 'map'/'zipWith'. The given type signature 
-- isn't terribly helpful or intuitive. The /real/ type signature 
-- is: 
-- 
-- > zipWithN :: {forall a}^N. ({a->}^N r) -> ({[a]->}^N r) 
-- 
-- Note that the @a@ type variables are meta and so are independent 
-- from one another, despite being correlated in N across all 
-- repetitions. 
zipWithN :: (ZipWithN a gr kr) => (a -> gr) -> [a] -> kr 
zipWithN = _zipWithN . repeat 

Nếu bạn chỉ mới bắt đầu học Haskell, hoãn hiểu nó trong một thời gian :)

Answer 5

Nếu tất cả các dữ liệu của bạn là cùng loại bạn có thể làm:

import Data.List (transpose) 

zipAllWith :: ([a] -> b) -> [[a]] -> [b] 
zipAllWith _ [] = [] 
zipAllWith f xss = map f . transpose $ xss 

zipAll = zipAllWith id 

Ví dụ:

> zipAll [[1, 2, 3], [4, 5, 6], [7, 8]] 
[[1,4,7],[2,5,8],[3,6]] 

Answer 6

Đối với một số cụ thể của danh sách, bạn có thể để một cái gì đó như thế này:

> let l1 = [1,2,3] 
> let l2 = "abc" 
> let l3 = [10.0, 11.0, 12.0] 
> let l4 = [True, False, False] 

> [ (e1,e2,e3,e4) | (((e1,e2),e3),e4) <- zip (zip (zip l1 l2) l3) l4 ] 
[(1,'a',10.0,True),(2,'b',11.0,False),(3,'c',12.0,False)] 

Đây không phải là chức năng chung, nhưng bạn có thể áp dụng mẫu cho một số danh sách khác.

Answer 7

GHC also supports parallel list comprehensions:

{-# LANGUAGE ParallelListComp #-} 

[(x,y) | x <- [1..3] 
     | y <- ['a'..'c'] 
     ] 

==> [(1,'a'),(2,'b'),(3,'c')] 

tôi chỉ thử nghiệm nó lên đến 26 biến song song, mà nên là đủ cho tất cả các mục đích thực tế.

Đó là một chút hacky (và không chuẩn) mặc dù, vì vậy trong trường hợp bạn đang viết một cái gì đó nghiêm trọng, ZipList có thể là cách tốt hơn để đi.

Answer 8

Việc tổng hợp nén thực sự khá dễ dàng. Bạn chỉ cần viết các phiên bản đặc biệt của Applicative combinators cho ZipList:

z :: [a -> b] -> [a] -> [b] 
z = zipWith ($) 

infixl 4 `z` 

Bây giờ bạn có thể zip như nhiều danh sách như bạn muốn:

f <$> xs `z` ys `z` zs 

hoặc cách khác:

repeat f `z` xs `z` ys `z` zs 

Answer 9

tôi nghĩ rằng nó có lẽ là giải pháp ít thanh lịch nhất được đề xuất, nhưng vì lợi ích của sự hoàn chỉnh, nên thêm rằng những điều như vậy nên có thể với Templa te Haskell.

Đây là thực tế được đề cập trong những gì tôi nghĩ là giấy gốc Template Haskell (Tìm kiếm zipn trong văn bản): http://research.microsoft.com/en-us/um/people/simonpj/Papers/meta-haskell/meta-haskell.pdf

Nhưng tôi nghĩ rằng mã không bao giờ thực tế làm việc, thấy điều này: http://www.haskell.org/pipermail/template-haskell/2003-July/000126.html (lát mẫu không được triển khai).

đó đã không được thực hiện vào năm 2003, nhưng nó vẫn không được thực hiện ngày hôm nay: http://www.haskell.org/ghc/docs/7.6.1/html/users_guide/template-haskell.html (mẫu lát không được hỗ trợ)

Tuy nhiên có một thực hiện zipWithN sử dụng mẫu Haskell: http://www.haskell.org/haskellwiki/Template_Haskell#zipWithN

Tôi có đã xác minh rằng nó hoạt động với chương trình thử nghiệm này:

{-# LANGUAGE TemplateHaskell #-} 
import Zipn 

main = do 
    let l1 = [1,2,3] 
    let l2 = [5,6,7] 
    let l3 = [7,4,8] 
    print $ $(zipWithN 3) (,,) l1 l2 l3 

Trong mô-đun Zipn, tôi đã dán zipn, chỉ cần đổi tên thành zipWithN cho c larity (và nhớ thêm TemplateHaskell pragma ở phía trên). Lưu ý rằng N thực tế bị bẻ khóa hai lần ở đây, bởi vì tôi đã phải cung cấp (,,) làm hàm "with". Bạn sẽ phải thay đổi số lượng dấu phẩy tùy thuộc vào N.

(,,) là viết tắt của \a b c -> (a,b,c)

Tôi đoán một ai đó với mẫu tốt kỹ năng Haskell (mà không phải là trường hợp của tôi vào thời điểm này) có thể làm cho một zipN thẳng sử dụng Template Haskell.