고정 된 최소 길이 목록을 총체적으로 우아하게 사용하려면 어떻게해야합니까?

현재 다음과 같은 기능을 처리하고 있습니다.

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

다시 말해, 목록이 주어지면 처음 6 개의 요소를 무언가에 사용하고, 목록의 길이가 6 개 미만인 경우 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)

패턴이 철저하다는 것을 쉽게 알 수 있지만 이제는 항상 종료되는 것을 볼 수 있습니다. 그래서 당신이 그것을 개선이라고 생각할 수 있는지 모르겠습니다.

그렇지 않으면 우리는 상태 모나드로 할 수 있지만 약간 헤비급입니다.

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은 볼 수있는 요소 수 를 말하는 유형에 따라 자연스럽게 전달 됩니다.