How can I apply an arbitrary function in an existential envelope?

I'm trying to write a function (called here hide

) that can enforce a fairly polymorphic function inside an existential wrapper (or hoist functions to work with wrappers with hidden types and therefore "hide"):

{-# LANGUAGE GADTs
           , RankNTypes
  #-}

data Some f
  where Some :: f a -> Some f


hide :: (forall a. f a -> g b) -> Some f -> Some g
hide f (Some x) = Some (f x)


data Phantom a = Phantom

cast :: Phantom a -> Phantom b
cast Phantom = Phantom

works :: Some Phantom -> Some Phantom
works = hide cast


doesn't :: Functor f => Some f -> Some f
doesn't = hide (fmap $ \x -> [x])
{-
foo.hs:23:17:
    Couldn't match type ‘b0’ with ‘[a]’
      because type variable ‘a’ would escape its scope
    This (rigid, skolem) type variable is bound by
      a type expected by the context: f a -> f b0
      at foo.hs:23:11-33
    Expected type: f a -> f b0
      Actual type: f a -> f [a]
    In the first argument of ‘hide’, namely ‘(fmap $ \ x -> [x])’
    In the expression: hide (fmap $ \ x -> [x])
    In an equation for ‘doesn't’: doesn't = hide (fmap $ \ x -> [x])
Failed, modules loaded: none.
-}


but :: Functor f => Some f -> Some f
but = hide' (fmap $ \x -> [x])
  where hide' :: (forall a. f a -> g [a]) -> Some f -> Some g
        hide' f (Some x) = Some (f x)

      

        
        
        
      

    

So, I really understand why this is happening; works

shows what hide

really works when the return type is completely unrelated to the input type, but in doesn't

I call hide

with a type argument a -> [a]

. hide

should get "select" type a

( RankNTypes

), but is b

usually polymorphic. When it b

actually depends a

, it a

can seep.

But in the context where I am actually calling it, a

it doesn't really leak; I end it immediately at Some

. And in fact I can write an alternative hide'

that accepts specifically a -> [a]

functions and works with the same implementation , just a different type of signature.

Is there any way to introduce an implementation hide f (Some x) = Some (f x)

to make it work more broadly? In fact, I'm interested in lifting functions with a type a -> q a

, where q

is some arbitrary function of the type; that is, I expect the return type to depend on a

, but I don't care how it's done. There are probably cases where q a

is a constant (i.e. the return type is independent of a

), but I think they will be much less common.

This example is pretty silly, obviously. In my actual use case, I have a GADT Schema a

that roughly represents types in the external type system; the phantom parameter provides a Haskell type that can be used to represent values ​​in the external type system. I need this phantom parameter to keep all types safe, but sometimes I build Schema

from runtime data, in which case I don't know what the parameter type is.

I think you need a different type that is type parameter agnostic. Instead of doing (yet) another parallel type, I was hoping to use a simple existential type wrapper Some

to build it from Schema

, and be able to elevate the type's functions forall a. Schema a -> Schema b

to Some Schema -> Some Schema

. So if I have an XY problem and I would be better off using some other ways to pass Schema a

for the unknown a

, that would also solve my problem.