Tworzenie (a, a) Functor

Question

Jak mogę wykonać (a, a) a Functor bez odwoływania się do ?

Zasadniczo chcę go do pracy tak:

instance Functor (a, a) where 
    fmap f (x, y) = (f x, f y) 

Ale oczywiście nie jest to legalny sposób, aby to wyrazić:

Kind mis-match 
The first argument of `Functor' should have kind `* -> *', 
but `(a, a)' has kind `*' 
In the instance declaration for `Functor (a, a)' 

Co naprawdę chcę to funkcja typu poziom jak to: \a -> (a, a) (nieprawidłowa składnia). A może typowy alias?

type V2 a = (a, a) 
instance Functor V2 where 
    fmap f (x, y) = (f x, f y) 

Myślę, że to zadziała, ale tak nie jest. Po pierwsze mam tego zarzutu

Illegal instance declaration for `Functor V2' 
(All instance types must be of the form (T t1 ... tn) 
where T is not a synonym. 
Use -XTypeSynonymInstances if you want to disable this.) 
In the instance declaration for `Functor V2' 

Jeśli śledzę informacje i dodaj rozszerzenie TypeSynonymInstances, pojawia się nowy błąd:

Type synonym `V2' should have 1 argument, but has been given 0 
In the instance declaration for `Functor V2' 

Dobrze, duh, że o to chodzi! V2 ma rodzaj * -> *, co jest wymagane od instancji Functor. No, ok, mogę użyć newtype takiego:

newtype V2 a = V2 (a, a) 
instance Functor V2 where 
    fmap f (V2 (x, y)) = V2 (f x, f y) 

Ale teraz muszę posypać V2 s obficie w całym moim kodu zamiast po prostu będąc w stanie radzić sobie z prostymi krotek, które niby pokonuje punkt uczynienia tego Functor; w tym momencie mogę równie dobrze spełniać swoją funkcję vmap :: (a -> b) -> (a, a) -> (b, b).

Czy istnieje sposób, aby to zrobić ładnie, tj. Bez numeru newtype?

Answer 1

Jak stwierdzili inni, nie można tego zrobić bez odwoływania się do nowych typów lub deklaracji danych. Jednak, czy spojrzałeś na Control.Arrow?Wiele z tych funkcji są bardzo użyteczne z krotek, na przykład:

vmap :: (a -> b) -> (a,a) -> (b,b) 
vmap f = f *** f 

Answer 2

Można zadeklarować

instance Functor ((,) a) where 
    ... 

jednak, że nie ogranicza to pierwszy element swojej pary i fmap będzie działać tylko na drugim elemencie.

Problem polega na tym, że krotka nie wymusza relacji między typami dwóch elementów.

Jeśli nie chcesz newtype dekorator można zrobić własne świeżego typ:

data Pair a = P a a 

instance Functor Pair where 
    ... 

który będzie łatwiej pracować niż newtype wokół krotki.

Answer 3

Z singletons można zdefiniować klasę Functor typu dla odfunkcyjniony symboli (Type ~> Type zamiast Type -> Type)

{-# Language ExplicitNamespaces, TypeApplications, TypeOperators, KindSignatures, ScopedTypeVariables, DataKinds, TypeInType, TypeFamilies, AllowAmbiguousTypes, InstanceSigs #-} 

import Data.Kind (Type) 
import Data.Singletons (type (~>), Apply) 

class Functor' (f :: Type ~> Type) where 
    fmap' :: (a -> a') -> (Apply f a -> Apply f a') 

data Dup :: Type ~> Type 

type instance Dup `Apply` a = (a, a) 

instance Functor' Dup where 
    fmap' :: (a -> a') -> ((a, a) -> (a', a')) 
    fmap' f (a1, a2) = (f a1, f a2) 

To daje Prelude.Functor instancja automatycznie

newtype f $ a = App (Apply f a) 

instance Functor' f => Functor (($) f) where 
    fmap :: (a -> a') -> (f $ a -> f $ a') 
    fmap f (App fa) = App (fmap' @f f fa)