Receiving als Argument Funktionen mit Constrained Existenziale in Haskell

Question

Ich habe mit einigen GHC Erweiterungen spielen eine Funktion zu definieren, die folgendes tun:

let a = A :: A -- Show A 
    b = B :: B -- Show B 
    in 
    myFunc show a b -- This should return (String, String) 

myFunc sollte in der Signatur von show vollständig polymorph sein, so dass es a und b mit verschiedenen Typen annehmen kann, die Show erfüllen.

Hier ist mein Versuch, mit den GHC Erweiterungen RankNTypes, ConstraintKinds, KindSignatures:

myFunc :: forall (k :: * -> Constraint) a b d. (k a, k b) 
      => (forall c. k c => c -> d) -> a -> b -> (d, d) 

Mein Hauptziel ist es, zu verstehen, wie diese Erweiterungen arbeiten; aber in meinen Augen, so scheint es, wie ich GHC sage, dass es eine Einschränkung k, dass einige a und b erfüllen, und es gibt auch eine Funktion (forall c. k c => c -> d), die jede Art nehmen ck erfüllen und das Rück eine bestimmte d, jetzt, unter diesen Bedingungen ich möchte die Funktion a und b anzuwenden, um ein Tupel erhalten (d,d)

Hier ist, wie GHC klagt:

Could not deduce (k0 a, k0 b) 
from the context (k a, k b) 
    bound by the type signature for 
      myFunc :: (k a, k b) => 
         (forall c. k c => c -> d) -> a -> b -> (d, d) 
    at app/Main.hs:(15,11)-(16,56) 
In the ambiguity check for the type signature for ‘myFunc’: 
    myFunc :: forall (k :: * -> Constraint) a b d. 
      (k a, k b) => 
      (forall c. k c => c -> d) -> a -> b -> (d, d) 
To defer the ambiguity check to use sites, enable AllowAmbiguousTypes 
In the type signature for ‘myFunc’: 
    myFunc :: forall (k :: * -> Constraint) a b d. (k a, k b) => 
      (forall c. k c => c -> d) -> a -> b -> (d, d) 

... 

Could not deduce (k c) 
from the context (k a, k b) 
    bound by the type signature for 
      myFunc :: (k a, k b) => 
         (forall c. k c => c -> d) -> a -> b -> (d, d) 
    at app/Main.hs:(15,11)-(16,56) 
or from (k0 c) 
    bound by the type signature for myFunc :: k0 c => c -> d 
    at app/Main.hs:(15,11)-(16,56) 
In the ambiguity check for the type signature for ‘myFunc’: 
    myFunc :: forall (k :: * -> Constraint) a b d. 
      (k a, k b) => 
      (forall c. k c => c -> d) -> a -> b -> (d, d) 
To defer the ambiguity check to use sites, enable AllowAmbiguousTypes 
In the type signature for ‘myFunc’: 
    myFunc :: forall (k :: * -> Constraint) a b d. (k a, k b) => 
      (forall c. k c => c -> d) -> a -> b -> (d, d) 
app/Main.hs15:40 

Was bin ich?

Answer 1

Das Problem ist, dass nur die Funktion (forall c . k c => c -> d) als Argument übergeben ist nicht genug für den Typ-Checker eindeutig zu bestimmen, was k wirklich ist. die Einschränkung ausdrücklich Passing funktioniert und Sie brauchen nicht einmal die äußeren forall oder explizite Arten:

import Data.Proxy 

myFunc :: (k a, k b) => Proxy k -> (forall c. k c => c -> d) -> a -> b -> (d, d) 
myFunc _ f a b = (f a, f b) 

und dann

let (c, d) = myFunc (Proxy :: Proxy Show) show a b