Haskell: Wie type-cast

C#:

static int F(object x)
{
 return x is string ? 1 : 2;
}

Haskell?
Das knifflige bit scheint mir, dass Haskell nicht über einen root geben Objekt.

Bearbeitet: ich kümmern sich nicht, über die Konvertierung zum string. Ich möchte wissen, wie man Typumwandlung (zum Beispiel zu sehen, ob ein Objekt ist ein Kunden oder eine Um.

Die Idee der Umwandlung eines beliebigen Typs in eine andere macht nicht viel Sinn in Haskell (oder jede andere Sprache für diese Angelegenheit). Macht es Sinn für bestimmte Paare von Typen (integer, string, integer, float, etc., für die Haskell hat entsprechende Funktionen show, fromIntegral etc.) oder für Arten, zwischen denen Sie definiert Funktionen für die Konvertierung, in welchem Fall Sie Sie verwenden.
Ich denke, es macht Sinn. Vielleicht will ich nicht zum erstellen einer virtuellen Methode in meiner Klasse Hierarchie zu trennen, zwei Anliegen. Also ich muss zu einem expliziten Typ-Schalter an anderer Stelle.
Es ist keine gute Praxis aber.

InformationsquelleAutor usr | 2009-12-12

  1. 37

    In Haskell, alle Typen, erlauben eine Konvertierung in einen string instanziieren der Show typeclass bietet

    show :: Show a => a -> String

    Also Ihre ganze code ist nichts aber

    f x = show x

    oder 

    f = show

    mit dem gleichen generischen Typ f :: Show a => a -> String (Forall Arten a sind conversible auf eine Zeichenfolge, die der Wert von diesem Typ und einen string zurückgeben).

    Beachten Sie, dass Sie nicht zu tun haben, eine explizite, run-time-type-überprüfung wie in C#, die generische Vorlage behoben ist zur compile-Zeit. Sie brauchen nicht eine polymorphe root geben - Eine Besetzung wie in C# wäre in der Tat etwas kompliziert und gegen die Sprache Konzeption. Anstatt beliebige Typumwandlungen zwischen den Typen, es definiert typeclasses für bestimmte sinnvolle Umbauten.

    Beachten Sie, dass die Kompatibilität geprüft wird zur compile-Zeit:

    -- Working
f 1
f "Hallo"
f (1, 2)
f [1, 2, 3]

-- Not working
f (\x -> x + 1)

    In Antwort auf Ihre Frage bearbeitet:

    Wie ich schon sagte, eigenmächtige Umbauten sind nicht zulässig in Haskell (ohne sehr sehr unsafe code). Und da Haskell ist nicht objektorientiert, es gibt keine Erbschafts-Beziehung erforderlich, dass jede Umwandlung. Gibt es einfach nicht sinnlos object Werte, die benötigten runtime-checking/Gießen. Für das Ausdrücken von alternativen, die Sie haben zu definieren, die ein union-Typ, eine typeclass oder verwenden Sie den Either geben.

    In welchem Fall zu tun, der Begegnung mit einem Objekt, das ein Customer oder eine Order? Ein Wert von diesem Typ ist einfach unsinnig. Bitte noch einmal verdeutlichen.

    Als zu Ihrem logger Beispiel:
    Sie benötigen eine typeclass:

    class Loggable a where
    writeToLog :: a -> IO ()
    Ich bearbeitet meine Frage ein wenig zu klären.
    Können sagen, ich wurde ein logger, der sich einloggen will, alles in eine text-Datei nur die Objekte vom Typ "Kunde", werden in einer Datenbank protokolliert. Ich will, dass die logging-Funktion zum tragen der Last zu überprüfen. Ich will nicht, dass die Anrufer zum anrufen eine andere Methode, je nach Objekt-Typ. Wie die Anmeldung wird getan, ist eine Implementierung detail.
    Eine typeclass tut, was ich will. Schön.

    InformationsquelleAutor Dario

  2. 19

    Dario ist richtig, in der Regel in Haskell, die Sie erstellen möchten ein Typ class Versand auf etwas geben. That being said, es ist eine Art sichere Weg zu werfen in Haskell. Dies ist Teil der Schrott Ihre boilerplate generische Programmierung-Bibliothek, die Ihnen erlaubt zu schreiben, die "interessanten" Teile von Manipulationen durch komplexe, verschachtelte Datentypen, während SYB füllt die Lücken aus. Gehirn schmelzend genial. Hier ist eine Präsentation auf es in ppt oder html.

    Hier ist, was der cast sieht wie folgt aus:

    cast :: (Typeable a, Typeable b) => a -> Maybe b
ghci> (cast 'a') :: Maybe Char
Just 'a'
ghci> (cast 'a') :: Maybe Bool
Nothing
ghci> (cast True) :: Maybe Bool
Just True
    Ich von Ihnen positiv bewertet werden, weil dies wäre auch eine Lösung.
    Gibt es eine funktionale Semantik der :: Betreiber? Es scheint nicht zu existieren, in der Sprache selbst, sondern vielmehr eine Art von compiler-annotation. Wenn ja, wie kann ich formal zu verstehen, die :: und seine Interaktion mit der cast-Funktion?

    InformationsquelleAutor Kobold

  3. 9

    Gießen und is/instanceof Sinn machen, in Sprachen, die Funktion subtypisierung. Ihre Frage kann beantwortet werden, gibt es mehrere Möglichkeiten:

    • Haskell keine subtypisierung und so is/instanceof keinen Sinn in Haskell; es gibt nur die explizite Konvertierungen. Es gibt keine object Typ, von dem alle Arten erweitern.
    • Haskell Typ-Klassen bieten ad-hoc-Polymorphismus und Hilfe bei überlastung einer einzelnen Namen für viele Umbauten. Zum Beispiel (wie andere haben darauf hingewiesen) show ist die überladene Namen für die Umwandlung von beliebigen Datentyps in einen String. Typ-Klassen können auch verwendet werden, um bestimmte Konvertierungen (scheinen) implizite.
    • Verwendung von Typ-Klassen, die Autoren der generic Schrott Ihre Boilerplate Bibliothek erstellt haben, eine sicher gewirkt - Funktion (auch von anderen darauf hingewiesen).

    InformationsquelleAutor Martijn

  4. 3

    Wenn Sie wollen, um Objekte, die entweder Kunden oder Aufträge, dann würden Sie die Einführung einer neuen Datentyp "Kunde|Auftrag", so dass jedes Objekt trägt eine Art tag sagen, was es ist.

    Weiß ich nicht, Haskell syntax offhand, aber in F#, es wäre

    type CustOrOrd =
    | Cust of Customer
    | Ord of Order

let F (x:CustOrOrd) : int =
    match x with
    | Cust c -> 1
    | Ord o -> 2

let thing1 = Cust someCustomer
let thing2 = Ord someOrder
// can call F on thing1 or thing2

    Allgemein in Haskell, wenn Sie wollen, etwas zu tun, wie eine Feste OO-Typ-Hierarchie (für eine Feste Gruppe von eng verwandten Arten, in der Lage sein, Sie zu behandeln, wie die gleiche Art in einigen Fällen), können Sie verwenden eine union-Typ wie oben beschrieben. Auf der anderen Seite, für gemeinsame Operationen über eine Vielzahl von nicht verwandten Arten (wie ToString/Karte) können Sie eine Haskell-Typ-Klasse.

    InformationsquelleAutor Brian

  5. 3

    Dies ist etwas, was ich schon zuvor versucht, und ich glaube nicht, dass Sie es tun können.

    Einführung in Haskell Reinen Funktionen

    Haskell nimmt eine sehr unterschiedliche
    Ansatz. Es beginnt mit der performing Art
    die Analyse mit einem Typ-checker
    verstehen Sie Ihr Programm zu kompilieren
    Zeit. Der Typ checker streng
    verbietet Typumwandlung und nicht
    erlauben Sie Fehler, um ignoriert zu werden.
    Da sind die Typen überprüft beim kompilieren
    Zeit, und es gibt kein entrinnen aus der
    Typ-checker, Haskell ist Häufig
    wie beschrieben, sowohl statisch typisierte und
    stark typisiert.

    InformationsquelleAutor Farley Knight

  6. 3

    Die einfachste Möglichkeit ist die Verwendung Daten.Typeable, als Dario beobachtet, die für alle standard-Typen, wenn Sie brauchen, um passieren "Deriving Typeable", oder andernfalls implementieren typeOf für Ihre eigenen Typ-Definitionen abgedeckt werden. Dies ist keine standard-Haskell 98, aber es ist in ghc seit 6.2.2.

    Code konnte realisiert werden:

     stringtyperep :: TypeRep 
stringtyperep = typeOf "classextender" 

F :: (Typeable a) =>'a -> Integer 
F x | (typeOf x == stringtyperep) = 1 
F x = 2

    Im Allgemeinen OO-Stil Art der Reflexion ist besser getan, bei der generischen Programmierung ist, aber wäre dies nicht ein gutes Beispiel dafür.

    Darüber hinaus werden alle Arten in typeclass Typeable werden können "cast" in Daten.Dynamische.

    InformationsquelleAutor Charles Stewart

  7. 2

    In C# ist es wahrscheinlich effizienter, nicht die Darsteller:

    return x == null ? null : x.ToString();

    In Haskell gibt es die "show" Typ-Klasse, die etwas implementiert, dass die Typ-Klasse haben kann, zeigen auf Sie und so kein casting notwendig ist.

    InformationsquelleAutor Tom

  8. 2

    Definieren Object sich

    Wenn Ihr Anwendungsfall ist ganz einfach, es ist wahrscheinlich am besten nur zu definieren, die dem Typ des Objekts selbst, so:

    data Type = String | Integer | List | Bool
    deriving (Eq, Show)

class Object a where
    typeOf :: a -> Type

instance Object String  where typeOf _ = String
instance Object Integer where typeOf _ = Integer
instance Object [a]     where typeOf _ = List
instance Object Bool    where typeOf _ = Bool

f :: (Object a, Num b) => a -> b
f x = if typeOf x == String then 1 else 2

    Natürlich werden Sie schreiben ein instance Erklärung für jede Art, die Sie wollen zu verwenden, wie ein Objekt in Ihrer Funktion, die verwendet typeOf. Dies könnte schwierig werden, wenn Sie versuchen zu definieren instances für Tupel, da in Haskell zwei Tupel sind von verschiedenen Arten, wenn Sie nicht über die gleiche Anzahl von Elemente, so dass Sie vielleicht haben zu schreiben, eine unendliche Anzahl von instance Erklärungen, eher wie dieser:

    data Type = String | Integer | List | Bool | Tuple
    deriving (Eq, Show)

instance Object ()              where typeOf _ = Tuple
instance Object (a)             where typeOf _ = Tuple
instance Object (a,b)           where typeOf _ = Tuple
instance Object (a,b,c)         where typeOf _ = Tuple
instance Object (a,b,c,d)       where typeOf _ = Tuple
instance Object (a,b,c,d,e)     where typeOf _ = Tuple
instance Object (a,b,c,d,e,f)   where typeOf _ = Tuple
instance Object (a,b,c,d,e,f,g) where typeOf _ = Tuple

    Verwenden Data.Typeable

    Wenn Ihre Nutzung komplizierter wird, könnten Sie versuchen, - Daten.Typeable: 

    import Data.Typeable

f :: (Typeable a, Num b) => a -> b
f x = if typeOf x == typeOf (undefined::String) then 1 else 2

    Können Sie ersetzen die (undefined::String) mit nur "" wenn Sie es vorziehen, je nachdem, was liest sich leichter für Sie.

    InformationsquelleAutor Beetle

Schreibe einen Kommentar