Proprio quando non sono sicuri, #., E. # Non sicuri?

Question

unsafeVacuous in Data.Void.Unsafe e .# e #. in Data.Profunctor.Unsafe entrambi avvertono sui pericoli dell'utilizzo di quelle funzioni con funtori/profuncatori che sono GADT. Alcuni esempi pericolosi sono evidenti:

data Foo a where 
    P :: a -> Foo a 
    Q :: Foo Void 

instance Functor Foo where 
    fmap f (P x) = P (f x) 
    fmap f Q = P (f undefined) 

Qui, unsafeVacuous Q produrrà un costruttore Q con un tipo fasullo.

Questo esempio non è molto preoccupante perché non sembra nemmeno lontanamente come un'istanza ragionevole Functor. Ci sono esempi che fanno? In particolare, sarebbe possibile costruire quelli che obbediscono alle leggi del funtore/profunctor quando vengono manipolati usando solo le loro API pubbliche, ma si rompono orribilmente di fronte a queste funzioni non sicure?

Answer 1

Non credo che ci sia un vero functor in cui unsafeVacuous causerebbe un problema. Ma se scrivi un pessimo Functor puoi creare il tuo unsafeCoerce, il che significa che deve essere etichettato con {-# LANGUAGE Unsafe #-}. C'era an issue about it in void.

Ecco un unsafeCoerce mi si avvicinò con

{-# LANGUAGE GADTs    #-} 
{-# LANGUAGE ScopedTypeVariables #-} 
{-# LANGUAGE TypeFamilies  #-} 
import Data.Void 
import Data.Void.Unsafe 

type family F a b where 
    F a Void = a 
    F a b = b 

data Foo a b where 
    Foo :: F a b -> Foo a b 

instance Functor (Foo a) where 
    fmap = undefined 

unsafeCoerce :: forall a b. (F a b ~ b) => a -> b 
unsafeCoerce a = (\(Foo b) -> b) $ (unsafeVacuous (Foo a :: Foo a Void) :: Foo a b) 

main :: IO() 
main = print $ (unsafeCoerce 'a' :: Int) 

che stampa 97.