ฉันจะใช้รายการความยาวขั้นต่ำคงที่ได้ทั้งหมดและสวยงามได้อย่างไร

ฉันกำลังจัดการกับฟังก์ชั่นที่จะเป็นดังนี้:

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

กล่าวอีกนัยหนึ่งเมื่อได้รับรายการจะใช้องค์ประกอบหกรายการแรกสำหรับบางสิ่งและหากรายการมีความยาวน้อยกว่าหกองค์ประกอบรายการนั้นจะใช้defเป็นรายการสแตนด์บายสำหรับรายการที่หายไป นี่คือทั้งหมด แต่ชิ้นส่วนของมันไม่ได้ (เหมือนmap fromJust . filter isJust) ดังนั้นฉันจึงไม่ชอบ ฉันพยายามเขียนใหม่เพื่อที่ว่ามันไม่จำเป็นต้องใช้ความลำเอียงและได้สิ่งนี้:

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

ฉันทำสิ่งที่ฉันต้องการในทางเทคนิคแล้ว แต่ตอนนี้มันเป็นเรื่องใหญ่โต ฉันจะทำสิ่งนี้อย่างสง่างามและซ้ำซากน้อยลงได้อย่างไร

การใช้แพ็คเกจที่ปลอดภัยคุณสามารถเขียนตัวอย่างเช่น:

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

อย่างน้อยสั้นกว่านี้:

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

คุณสามารถเห็นได้อย่างง่ายดายว่ารูปแบบหมดจด แต่ตอนนี้คุณต้องคิดสักหน่อยเพื่อดูว่ามันจะยุติลงเสมอ ดังนั้นฉันไม่รู้ว่าคุณสามารถพิจารณาได้หรือไม่ว่าเป็นการปรับปรุง

มิฉะนั้นเราสามารถทำกับรัฐ monad ได้แม้ว่ามันจะเป็นเฮฟวี่เวทเล็กน้อย:

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

ฉันสามารถจินตนาการโดยใช้ประเภทสตรีมไม่สิ้นสุดเช่น

data S a = S a (S a)

แล้วเพราะคุณสามารถสร้างfooออกจากrepeat :: a -> S a, prepend :: [a] -> S a -> S aและtake6 :: S a -> (a,a,a,a,a,a)ทั้งหมดซึ่งอาจจะรวม อาจไม่คุ้มค่าหากคุณยังไม่มีประเภทที่สะดวก

เพียงเพื่อความสนุก (และไม่แนะนำนี่คือเพื่อ funsies) นี่เป็นอีกวิธีหนึ่ง:

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

ประเภทที่คุณใช้ในรูปแบบจับคู่กับจำนวนการส่งผ่านประเภทระดับธรรมชาติเพื่อtakeDefบอกจำนวนองค์ประกอบที่ต้องดู