Gibt es eine polymorphe toString-Funktion, die keine Anführungszeichen hinzufügt?

Question

In den meisten OO-Sprachen, die ich kenne, ist die toString Methode von String eigentlich nur die Identitätsfunktion. Aber in Haskell show fügt doppelte Anführungszeichen hinzu.

Also, wenn ich eine Funktion schreiben, so etwas wie dies

f :: Show a => [a] -> String 
f = concat . map show 

es für Zahlen

f [0,1,2,3] -- "0123" 

aber Strings am Ende mit zusätzlichen Anführungszeichen wie erwartet funktioniert

f ["one", "two", "three"] -- "\"one\"\"two\"\"three\"" 

wenn ich wirklich wollen "onetwothree".

Wenn ich polymorph schreiben wollte f, gibt es eine Möglichkeit, es mit nur einer Show Einschränkung zu tun, und ohne die Show-Instanz für String überschreiben (wenn das überhaupt möglich ist).

Das Beste, was ich mit oben kommen kann, ist meine eigene Art Klasse zu erstellen:

class (Show a) => ToString a where 
    toString = show 

und eine Instanz für alles hinzufügen?

instance ToString String where toString = id 
instance ToString Char where toString = pure 
instance ToString Int 
instance ToString Maybe 
...etc 

Answer 1

Sie können dies tun:

{-# LANGUAGE FlexibleInstances, UndecidableInstances, OverlappingInstances #-} 

class Show a => ToString a where 
    toString :: a -> String 

instance Show a => ToString a where 
    toString = show 

instance ToString String where 
    toString = id 

Prelude> toString "hello" 
"hello" 
Prelude> toString 3 
"3" 

Hinweis, dass dies wahrscheinlich eine schreckliche Idee.

Answer 2

könnten Sie verwenden newtype mit OverloadedStrings:

{-# LANGUAGE OverloadedStrings #-} 

import   Data.ByteString.Char8  (ByteString) 
import qualified Data.ByteString.Char8 as B 

newtype LiteralString = LS ByteString 
instance IsString LiteralString where fromString = LS . B.pack 
instance Show  LiteralString where show (LS x) = B.unpack x 
instance Read  LiteralString where readsPrec p s = map (\(!s, !r) -> (LS s,r)) $! readsPrec p s 

hello :: LiteralString 
hello = "hello world" 

main :: IO() 
main = putStrLn . show $! hello 

---

Ausgang:

hello world 

---

Die doppelten Anführungszeichen im Normalfall sind tatsächlich sinnvoll, wenn eine dargestellte Zeichenfolge zurück in dem Lese der Kontext größerer Ausdrücke, da sie die angezeigten Zeichenfolgenwerte eindeutig von Werten abgrenzen von anderen gezeigt Typen:

x :: (ByteString, Int) 
x =  read . show $! ("go", 10) 
-- string value starts --^^-- ends 

y :: (LiteralString, Int) 
y =  read . show $! ("go", 10) 
-- string value starts --^  ^consumes all characters; read fails 

Answer 3

Die Pretty Klasse und ihrem entsprechenden Typ Doc haben das erforderliche Verhalten für Show. Ihr Link zeigt jedoch einen anderen Anwendungsfall; vielleicht könnten Sie die Frage bearbeiten?

Answer 4

Ich denke, die Ursache für Ihr Problem ist, dass show ist nicht wirklich renderToText. Es soll Text erzeugen, den Sie in Haskell-Code einfügen können, um den gleichen Wert zu erhalten, oder mit read wieder in denselben Wert konvertieren.

Für diesen Zweck würde show "foo" = "foo" nicht funktionieren, weil und show 1 = "1", die Informationen verliert.

Der Vorgang, den Sie in der Lage sein wollen "foo" anzuwenden "foo" zu erhalten und zu 1"1" zu bekommen, ist etwas anderes als show. show ist einfach kein Java-esque toString.

Wenn ich das vorher benötigt habe, habe ich tatsächlich meine eigene neue Typklasse gemacht und eine Menge Dinge davon gemacht, und dann diese anstelle von Show verwendet. Die meisten Instanzen wurden mit show implementiert, aber String war nicht der einzige, den ich anpassen wollte, so dass die separate Typklasse nicht vollständig verschwendet wurde. In der Praxis stellte ich fest, dass es nur eine Handvoll Typen gab, für die ich die Instanz tatsächlich benötigte, und es war ziemlich trivial, sie hinzuzufügen, da ich Kompilierfehler bekam.