Mapping über ein heterogenes Datenstruktur mit einer generischen Funktion

Question

ich auf einer hList Implementierung bin zu arbeiten und ich bin fest versuchen, eine map Funktion für sie umzusetzen. Ich habe viele verschiedene Ansätze ausprobiert, aber mit jedem erreiche ich Compiler Fehler in Bezug auf diese Funktion.

Es folgt ein Beispiel dafür, wie ich will Just eine generische Funktion verwenden, um alle Elemente der Eingabedatenstruktur anzuwenden.

{-# LANGUAGE MultiParamTypeClasses #-} 
{-# LANGUAGE FlexibleInstances #-} 

-- | An input heterogenous data structure 
recursivePairs :: (Int, (Char, (Bool,()))) 
recursivePairs = (1, ('a', (True,()))) 

-- | This is how I want to use it 
recursivePairs' :: (Maybe Int, (Maybe Char, (Maybe Bool,()))) 
recursivePairs' = hMap Just recursivePairs 

class HMap f input output where 
    hMap :: f -> input -> output 

-- | A counterpart of a Nil pattern match for a list 
instance HMap f()() where 
    hMap _ _ =() 

-- | A counterpart of a Cons pattern match for a list 
instance 
    (HMap f iTail oTail, 
    Apply f iHead oHead) => 
    HMap f (iHead, iTail) (oHead, oTail) 
    where 
    hMap f (head, tail) = (apply f head, hMap f tail) 

class Apply f input output where 
    apply :: f -> input -> output 

instance Apply (input -> output) input output where 
    apply = id 

Damit erhalte ich den folgenden Compiler-Fehler:

No instance for (Apply (a0 -> Maybe a0) Int (Maybe Int)) 
    arising from a use of `hMap' 
The type variable `a0' is ambiguous 

Gibt es überhaupt eine Möglichkeit, dies zu lösen, und wenn nicht, dann warum?

Answer 1

Das Problem ist, dass Sie versuchen, eine polymorphe Funktion mit verschiedenen Argumenten zu verwenden, aber Ihre Apply Instanz nimmt eine Funktion (ein Monotyp). Sie können dies mehrere Möglichkeiten leicht beheben

data JustIfy = JustIfy 
instance Apply JustIfy a (Maybe a) where 
    apply _ = Just 

recursivePairs' :: (Maybe Int, (Maybe Char, (Maybe Bool,()))) 
recursivePairs' = hMap JustIfy recursivePairs 

Arbeiten mit Ihrem Code einfach gut

EDIT: Ein allgemeiner Ansatz für die gleiche Sache (erfordert RankNTypes)

--A "universal" action that works on all types 
newtype Univ f = Univ (forall x. x -> f x) 
instance Apply (Univ f) x (f x) where 
    apply (Univ f) x = f x 

recursivePairs' :: (Maybe Int, (Maybe Char, (Maybe Bool,()))) 
recursivePairs' = hMap (Univ Just) recursivePairs 

oder wenn Sie Verwenden einer aktuellen ish-Version von GHC und sind bereit, weitere Erweiterungen zu aktivieren

das ist nett seit dann können Sie Dinge tun, wie eine "Show" in die Funktion, die Sie zuordnen, zu tun.

Für eine allgemeinere Lösung, überprüfen Sie Oleg's Type level lambda caclulus, die Sie Code auf der Werteebene schreiben können und dann automatisch das entsprechende Programm auf Typenebene leitet. Unglücklicherweise ist Olegs Lösung zu diesem Zeitpunkt ziemlich alt und verwendet eine nominale Implementierung des LC, die ich nicht besonders mag. Ich habe darüber nachgedacht, wie ich es besser machen könnte, aber ich halte es vielleicht aus, bis die verwertbare Gleichheit zu Typfamilien kommt.

Meine Ansicht ist, dass HLists sollte in diesen Tagen mit GADTs und DataKinds statt Tupeln erfolgen. Typfamilien sind funktionalen Abhängigkeiten vorzuziehen, sind aber derzeit begrenzter, da sie keine entscheidbare Gleichheit aufweisen.

Answer 2

Obwohl die folgende nicht genau die Frage beantworten (also werde ich es nicht sein zu akzeptieren), ist es das Problem nicht lösen, die die Struktur abbildet, ohne zusätzliche Instanzen für applicative functors zu erfordern:

{-# LANGUAGE MultiParamTypeClasses #-} 
{-# LANGUAGE FlexibleInstances #-} 

import Control.Applicative 

main = do 
    print $ (hPure recursivePairs :: (Maybe Int, (Maybe Char, (Maybe Bool,())))) 
    print $ (hPure recursivePairs :: ([Int], ([Char], ([Bool],())))) 

recursivePairs :: (Int, (Char, (Bool,()))) 
recursivePairs = (1, ('a', (True,()))) 

class HPure input output where 
    hPure :: input -> output 

instance HPure()() where 
    hPure _ =() 

instance 
    (Applicative f, 
    HPure iTail oTail) => 
    HPure (iHead, iTail) (f iHead, oTail) 
    where hPure (iHead, iTail) = (pure iHead, hPure iTail) 

Ausgänge :

(Just 1,(Just 'a',(Just True,()))) 
([1],("a",([True],())))