반복하지 않고이 알고리즘을 더 게으르게 만드는 방법은 무엇입니까?

( 이 질문에 대한 나의 대답에서 영감을 얻었습니다 .)

이 코드를 고려하십시오 (주어진 입력보다 작거나 같은 가장 큰 요소를 찾아야합니다).

data TreeMap v = Leaf | Node Integer v (TreeMap v) (TreeMap v) deriving (Show, Read, Eq, Ord)

closestLess :: Integer -> TreeMap v -> Maybe (Integer, v)
closestLess i = precise Nothing where
  precise :: Maybe (Integer, v) -> TreeMap v -> Maybe (Integer, v)
  precise closestSoFar Leaf = closestSoFar
  precise closestSoFar (Node k v l r) = case i `compare` k of
    LT -> precise closestSoFar l
    EQ -> Just (k, v)
    GT -> precise (Just (k, v)) r

이것은 매우 게으르지 않습니다. GT사례가 입력 되면 최종 반환 값이 Just아닌 값이 될 것임을 Nothing알지만 Just끝날 때까지는 여전히 사용할 수 없습니다. 사례를 입력 Just하자마자 사용할 수 있도록이 게으름을 피우고 싶습니다 GT. 이것에 대한 나의 테스트 사례 는 바닥 Data.Maybe.isJust $ closestLess 5 (Node 3 () Leaf undefined)이 True아닌 평가를 원한다는 것입니다. 이 작업을 수행 할 수있는 한 가지 방법이 있습니다.

data TreeMap v = Leaf | Node Integer v (TreeMap v) (TreeMap v) deriving (Show, Read, Eq, Ord)

closestLess :: Integer -> TreeMap v -> Maybe (Integer, v)
closestLess _ Leaf = Nothing
closestLess i (Node k v l r) = case i `compare` k of
  LT -> closestLess i l
  EQ -> Just (k, v)
  GT -> Just (precise (k, v) r)
  where
    precise :: (Integer, v) -> TreeMap v -> (Integer, v)
    precise closestSoFar Leaf = closestSoFar
    precise closestSoFar (Node k v l r) = case i `compare` k of
      LT -> precise closestSoFar l
      EQ -> (k, v)
      GT -> precise (k, v) r

그러나, 나는 지금 나 자신을 반복하고있다 : 핵심 논리는 이제 closestLess와에있다 precise. 게으르지 만 반복하지 않도록 어떻게 작성할 수 있습니까?

명시 적 랩퍼를 사용하지 않고 유형 시스템을 활용할 수 있습니다. 참고 버전이 precise그 용도 Maybe첫 번째 코드에 대한 :

precise :: Maybe (Integer, v) -> TreeMap v -> Maybe (Integer, v)
precise closestSoFar Leaf = closestSoFar
precise closestSoFar (Node k v l r) = case i `compare` k of
  LT -> precise closestSoFar l
  EQ -> Just (k, v)
  GT -> precise (Just (k, v)) r

두 번째 코드 스 니펫 이 precise없는 버전과 거의 정확히 동일한 알고리즘이며 functor Maybe에서 다음 Identity과 같이 작성할 수 있습니다 .

precise :: Identity (Integer, v) -> TreeMap v -> Identity (Integer, v)
precise closestSoFar Leaf = closestSoFar
precise closestSoFar (Node k v l r) = case i `compare` k of
  LT -> precise closestSoFar l
  EQ -> Identity (k, v)
  GT -> precise (Identity (k, v)) r

이들은 다음에서 버전 다형성으로 통합 될 수 있습니다 Applicative.

precise :: (Applicative f) => f (Integer, v) -> TreeMap v -> f (Integer, v)
precise closestSoFar Leaf = closestSoFar
precise closestSoFar (Node k v l r) = case i `compare` k of
  LT -> precise closestSoFar l
  EQ -> pure (k, v)
  GT -> precise (pure (k, v)) r

그 자체로는 그다지 큰 성과는 아니지만 GT분기가 항상 값을 반환 한다는 것을 알고 있다면 Identity시작 functor에 관계없이 functor 에서 강제로 실행할 수 있습니다 . 즉, 우리는 Maybefunctor 에서 시작할 수 있지만 지점 의 Identityfunctor 로 재귀 합니다 GT.

closestLess :: Integer -> TreeMap v -> Maybe (Integer, v)
closestLess i = precise Nothing
  where
    precise :: (Applicative t) => t (Integer, v) -> TreeMap v -> t (Integer, v)
    precise closestSoFar Leaf = closestSoFar
    precise closestSoFar (Node k v l r) = case i `compare` k of
      LT -> precise closestSoFar l
      EQ -> pure (k, v)
      GT -> pure . runIdentity $ precise (Identity (k, v)) r

이것은 테스트 케이스에서 잘 작동합니다.

> isJust $ closestLess 5 (Node 3 () Leaf undefined)
True

다형성 재귀의 좋은 예입니다.

성능 관점에서이 접근 방식의 또 다른 좋은 점은 -ddump-simpl래퍼 나 사전이 없다는 것을 보여줍니다. 두 가지 기능에 대한 특수 기능을 사용하여 유형 수준에서 모두 지워졌습니다.

closestLess
  = \ @ v i eta ->
      letrec {
        $sprecise
        $sprecise
          = \ @ v1 closestSoFar ds ->
              case ds of {
                Leaf -> closestSoFar;
                Node k v2 l r ->
                  case compareInteger i k of {
                    LT -> $sprecise closestSoFar l;
                    EQ -> (k, v2) `cast` <Co:5>;
                    GT -> $sprecise ((k, v2) `cast` <Co:5>) r
                  }
              }; } in
      letrec {
        $sprecise1
        $sprecise1
          = \ @ v1 closestSoFar ds ->
              case ds of {
                Leaf -> closestSoFar;
                Node k v2 l r ->
                  case compareInteger i k of {
                    LT -> $sprecise1 closestSoFar l;
                    EQ -> Just (k, v2);
                    GT -> Just (($sprecise ((k, v2) `cast` <Co:5>) r) `cast` <Co:4>)
                  }
              }; } in
      $sprecise1 Nothing eta

비 게으른 구현에서 시작하여 먼저 인수 precise로 수신하기 위해 리팩터링 하고 Just그에 따라 유형을 일반화했습니다.

data TreeMap v = Leaf | Node Integer v (TreeMap v) (TreeMap v) deriving (Show, Read, Eq, Ord)

closestLess :: Integer -> TreeMap v -> Maybe (Integer, v)
closestLess i = precise Just Nothing where
  precise :: ((Integer, v) -> t) -> t -> TreeMap v -> t
  precise _ closestSoFar Leaf = closestSoFar
  precise wrap closestSoFar (Node k v l r) = case i `compare` k of
    LT -> precise wrap closestSoFar l
    EQ -> wrap (k, v)
    GT -> precise wrap (wrap (k, v)) r

그럼, 어떻게 그것을 변경 wrap초기에 자신을 호출 id의 GT경우 :

data TreeMap v = Leaf | Node Integer v (TreeMap v) (TreeMap v) deriving (Show, Read, Eq, Ord)

closestLess :: Integer -> TreeMap v -> Maybe (Integer, v)
closestLess i = precise Just Nothing where
  precise :: ((Integer, v) -> t) -> t -> TreeMap v -> t
  precise _ closestSoFar Leaf = closestSoFar
  precise wrap closestSoFar (Node k v l r) = case i `compare` k of
    LT -> precise wrap closestSoFar l
    EQ -> wrap (k, v)
    GT -> wrap (precise id (k, v) r)

추가 된 게으름의 이점을 제외하고는 여전히 이전과 동일하게 작동합니다.

본인이 직접 대답 한 CPS 버전이 최고라고 생각하지만 완성도를 위해 몇 가지 아이디어가 더 있습니다. (편집 : Buhr의 답변이 이제 가장 성능이 우수합니다.)

첫 번째 아이디어는 " closestSoFar"누산기를 제거 하고 대신 GT인수보다 가장 작은 값을 선택하는 모든 논리를 처리 하도록하는 것입니다. 이 형식에서 GT사례는 다음을 직접 반환 할 수 있습니다 Just.

closestLess1 :: Integer -> TreeMap v -> Maybe (Integer, v)
closestLess1 _ Leaf = Nothing
closestLess1 i (Node k v l r) =
  case i `compare` k of
    LT -> closestLess1 i l
    EQ -> Just (k, v)
    GT -> Just (fromMaybe (k, v) (closestLess1 i r))

이것은 더 간단하지만 많은 GT경우에 스택에 약간의 공간이 필요합니다 . 기술적 fromMaybe으로는 누산기 형태로 도 사용할 수 있지만 (즉, fromJustluqui의 답변에서 암시 적 대체 ) 중복되고 도달 할 수없는 지점이 될 것입니다.

알고리즘에 실제로 두 개의 "단계"가 있고, 하나를 누른 후에 하나는 다른 두 가지 아이디어가 GT있으므로 부울로 매개 변수화 하여이 두 단계를 나타내며 종속 유형을 사용하여 항상 두 번째 단계에서 발생합니다.

data SBool (b :: Bool) where
  STrue :: SBool 'True
  SFalse :: SBool 'False

type family MaybeUnless (b :: Bool) a where
  MaybeUnless 'True a = a
  MaybeUnless 'False a = Maybe a

ret :: SBool b -> a -> MaybeUnless b a
ret SFalse = Just
ret STrue = id

closestLess2 :: Integer -> TreeMap v -> Maybe (Integer, v)
closestLess2 i = precise SFalse Nothing where
  precise :: SBool b -> MaybeUnless b (Integer, v) -> TreeMap v -> MaybeUnless b (Integer, v)
  precise _ closestSoFar Leaf = closestSoFar
  precise b closestSoFar (Node k v l r) = case i `compare` k of
    LT -> precise b closestSoFar l
    EQ -> ret b (k, v)
    GT -> ret b (precise STrue (k, v) r)

어때요?

GT -> let Just v = precise (Just (k,v) r) in Just v

?

뿐만 아니라 우리는 항상 알고 Just, 후 최초의 발견, 우리는 항상 알고 Nothing 때까지 다음. 그것은 실제로 두 가지 다른 "논리"입니다.

그래서 우리는 우선 왼쪽으로 가서, 그래서 만들 즉 명시 :

data TreeMap v = Leaf | Node Integer v (TreeMap v) (TreeMap v) 
                 deriving (Show, Read, Eq, Ord)

closestLess :: Integer 
            -> TreeMap v 
            -> Maybe (Integer, v)
closestLess i = goLeft 
  where
  goLeft :: TreeMap v -> Maybe (Integer, v)
  goLeft n@(Node k v l _) = case i `compare` k of
          LT -> goLeft l
          _  -> Just (precise (k, v) n)
  goLeft Leaf = Nothing

  -- no more maybe if we're here
  precise :: (Integer, v) -> TreeMap v -> (Integer, v)
  precise closestSoFar Leaf           = closestSoFar
  precise closestSoFar (Node k v l r) = case i `compare` k of
        LT -> precise closestSoFar l
        EQ -> (k, v)
        GT -> precise (k, v) r

가격은 최대 한 번만 한 단계 씩 반복됩니다 .