Làm cách nào tôi có thể sử dụng danh sách có độ dài tối thiểu cố định một cách tổng thể và thanh lịch?

Tôi hiện đang xử lý một chức năng như thế này:

foo = (\(a:b:c:d:e:f:_) -> foobar a b c d e f) . (++ repeat def)

Nói cách khác, được đưa ra một danh sách, nó sử dụng sáu yếu tố đầu tiên cho một cái gì đó, và nếu danh sách đó dài hơn sáu yếu tố, nó sẽ sử dụng defnhư một điểm thay thế cho những yếu tố còn thiếu. Đây là tổng số, nhưng các phần của nó không (giống như map fromJust . filter isJust), vì vậy tôi không thích nó. Tôi đã cố gắng viết lại cái này để nó không cần sử dụng bất kỳ bộ phận nào và nhận được cái này:

foo [] = foobar def def def def def def
foo [a] = foobar a def def def def def
foo [a,b] = foobar a b def def def def
foo [a,b,c] = foobar a b c def def def
foo [a,b,c,d] = foobar a b c d def def
foo [a,b,c,d,e] = foobar a b c d e def
foo (a:b:c:d:e:f:_) = foobar a b c d e f

Về mặt kỹ thuật tôi đã làm những gì tôi muốn, nhưng bây giờ đây là một mớ hỗn độn khổng lồ. Làm thế nào tôi có thể làm điều này một cách thanh lịch và ít lặp đi lặp lại?

Sử dụng gói an toàn , bạn có thể viết, ví dụ:

(!) = atDef def
foo xs = foobar (xs ! 0) (xs ! 1) (xs ! 2) (xs ! 3) (xs ! 4) (xs ! 5)

Điều này ít nhất là ngắn hơn:

foo (a:b:c:d:e:f:_) = foobar a b c d e f
foo xs = foo (xs ++ repeat def)

Bạn có thể dễ dàng thấy rằng các mô hình là đầy đủ, nhưng bây giờ bạn phải suy nghĩ một chút để thấy rằng nó luôn luôn chấm dứt. Vì vậy, tôi không biết nếu bạn có thể coi đó là một cải tiến.

Nếu không, chúng ta có thể làm điều đó với đơn nguyên nhà nước, mặc dù nó hơi nặng:

foo = evalState (foobar <$> pop <*> pop <*> pop <*> pop <*> pop <*> pop)
  where
    pop = do xs <- get
             case xs of [] -> pure def
                        y:ys -> put ys >> pure y

Tôi cũng có thể tưởng tượng sử dụng một loại luồng vô hạn như

data S a = S a (S a)

bởi vì sau đó bạn có thể xây dựng foora khỏi repeat :: a -> S a, prepend :: [a] -> S a -> S avà take6 :: S a -> (a,a,a,a,a,a), tất cả đều có thể là tổng. Có lẽ không đáng nếu bạn chưa có loại tiện dụng như vậy.

Chỉ để cho vui (và không được đề xuất, đây là cho các cuộc vui), đây là một cách khác:

import Data.Default

data Cons f a = a :- f a
infixr 5 :-

data Nil a = Nil -- or use Proxy

class TakeDef f where takeDef :: Default a => [a] -> f a
instance TakeDef Nil where takeDef _ = Nil
instance TakeDef f => TakeDef (Cons f) where
    takeDef (x:xs) = x :- takeDef xs
    takeDef xs = def :- takeDef xs

foo xs = case takeDef xs of
    a:-b:-c:-d:-e:-f:-Nil -> foobar a b c d e f

Loại mà bạn sử dụng trong mẫu khớp với số lượng để vượt qua mức tự nhiên cấp loại để takeDefnói có bao nhiêu yếu tố cần xem xét.