Haskell Language
응용 펑터

소개

비고

class Functor f => Applicative f where
    pure  :: a -> f a
    (<*>) :: f (a -> b) -> f a -> f b

pure id <*> a = a                              -- identity
pure (.) <*> a <*> b <*> c = a <*> (b <*> c)   -- composition
pure f <*> pure a = pure (f a)                 -- homomorphism
a <*> pure b = pure ($ b) <*> a                -- interchange

대체 정의

모든 Applicative Functor는 Functor 이므로 항상 fmap 사용할 수 있습니다. 따라서 Applicative의 본질은 콘텐츠를 생성 할 수있을뿐만 아니라 수행 된 콘텐츠의 페어링입니다.

class Functor f => PairingFunctor f where
  funit :: f ()                  -- create a context, carrying nothing of import
  fpair :: (f a,f b) -> f (a,b)  -- collapse a pair of contexts into a pair-carrying context

이 클래스는 Applicative 와 동형입니다.

pure a = const a <$> funit = a <$ funit  

fa <*> fb = (\(a,b) -> a b) <$> fpair (fa, fb) = uncurry ($) <$> fpair (fa, fb)

거꾸로,

funit = pure ()

fpair (fa, fb) = (,) <$> fa <*> fb

신청자의 공통 인스턴스

아마도

Maybe 가능성이없는 값을 포함하는 응용 펑터 (functor) 일 수 있습니다.

instance Applicative Maybe where
    pure = Just
    
    Just f <*> Just x = Just $ f x
    _ <*> _ = Nothing

pure 는 Just 값을 적용하여 주어진 값을 Maybe 로 끌어 Maybe . (<*>) 함수는 래핑 기능을 적용 Maybe A의 값 Maybe . 함수와 값이 모두있는 경우 ( Just ) 함수가 값에 적용되고 래핑 된 결과가 반환됩니다. 둘 중 하나가 누락 된 경우 계산을 진행할 수 없으며 대신 Nothing 이 반환됩니다.

기울기

형식 서명 <*> :: [a -> b] -> [a] -> [b] 에 맞는 목록의 한 가지 방법은 두 목록의 Cartesian 제품을 가져 와서 첫 번째 목록의 각 요소를 각각 두 번째 요소 :

fs <*> xs = [f x | f <- fs, x <- xs]
         -- = do { f <- fs; x <- xs; return (f x) }

pure x = [x]

이것은 대개 비 결정론을 모방하는 것으로 해석되며, 값의 목록은 가능한 비표준 값에 해당하며, 비 결정적 값은 해당 목록의 범위를가집니다. 2 개의 비 결정적인 값의 조합은 2 개의리스트의 값의 가능한 모든 편성 범위에 걸친다 :

ghci> [(+1),(+2)] <*> [3,30,300]
[4,31,301,5,32,302]

무한 스트림 및 우편 목록

두 개의 입력을 함께 "압축"하는 Applicative 클래스가 있습니다. 한 가지 간단한 예는 무한한 스트림의 예입니다.

data Stream a = Stream { headS :: a, tailS :: Stream a }

Stream 의 Applicative 인스턴스는 함수 스트림을 인수 스트림에 점 방식으로 적용하여 두 스트림의 값을 한 쌍씩 짝짓기합니다. pure 는 상수 스트림 - 단일 고정 값의 무한한 목록을 반환합니다.

instance Applicative Stream where
    pure x = let s = Stream x s in s
    Stream f fs <*> Stream x xs = Stream (f x) (fs <*> xs)

목록에는 ZipList newtype이있는 "zippy" Applicative 인스턴스도 허용됩니다.

newtype ZipList a = ZipList { getZipList :: [a] }

instance Applicative ZipList where
    ZipList xs <*> ZipList ys = ZipList $ zipWith ($) xs ys

zip 은 가장 짧은 입력에 따라 결과를 다듬기 때문에 Applicative 법칙을 만족하는 pure 구현은 무한한 목록을 반환하는 것입니다.

    pure a = ZipList (repeat a)   -- ZipList (fix (a:)) = ZipList [a,a,a,a,...

예 :

ghci> getZipList $ ZipList [(+1),(+2)] <*> ZipList [3,30,300]
[4,32]

두 가지 가능성은 외부 및 내부 제품을 생각 나게합니다. 첫 번째 경우에는 nx 1 열 ( nx 1 ) 행렬에 1 행 ( 1 xm ) 행렬을 곱한 것과 마찬가지로 nxm 행렬을 결과로 가져옵니다 (단, ); 두 번째 경우에는 1 행 및 1 열 행렬을 곱합니다 (그러나 합계는 포함하지 않음).

기능들

함수 (->) r 특수화 된 경우 pure 및 <*> 유형 서명은 각각 K 및 S 결합 자 유형 서명과 일치합니다.

pure :: a -> (r -> a)
<*> :: (r -> (a -> b)) -> (r -> a) -> (r -> b)

pure 는 const 여야하며 <*> 는 한 쌍의 함수를 취하여 고정 인수에 각각 적용하여 두 결과를 적용합니다.

instance Applicative ((->) r) where
    pure = const
    f <*> g = \x -> f x (g x)

함수는 프로토 타입의 "지루함"응용 프로그램입니다. 예를 들어, 무한한 스트림은 (->) Nat , isomorphic이기 때문에 ...

-- | Index into a stream
to :: Stream a -> (Nat -> a)
to (Stream x xs) Zero = x
to (Stream x xs) (Suc n) = to xs n

-- | List all the return values of the function in order
from :: (Nat -> a) -> Stream a
from f = from' Zero
    where from' n = Stream (f n) (from' (Suc n))

스트림을 고차원으로 표현하면 지겨운 Applicative 인스턴스가 자동으로 생성됩니다.