Liste Format die Ausgabe in Haskell?

Ich habe Probleme versuchen, formatieren Sie die Ausgabe einer Liste von meinen eigenen Typ in Haskell.

Ich würde gerne so etwas wie dieses:

Make  | Model | Years(this is a list)    <- this would be the headers if you like
-------------------
Item1 | Item1 | Item1s,Item1s           
Item2 | Item2 | Item2s,Items2,Items2

^
Dies wäre der geladenen Daten von meinem String String [Int] Typ.

Wie würde ich dies in Haskell?

InformationsquelleAutor Ash | 2011-05-08
  1. 4

    Sowas?

    import Data.List (intercalate)
data Foo = Foo String String [Int]

fooToLine :: Foo -> String
fooToLine (Foo a b cs) = a ++ " | " ++ b ++ " | " ++ intercalate ", " (map show cs)

    Nun, Sie tun können,

    >>> fooToLine (Foo "Hello" "World" [1, 2, 3])
"Hello | World | 1, 2, 3"
    • Ahhh ich habe gesehen, so etwas wie dies heute - wie funktioniert es?
    • Wie würde ich die Verwendung von test-Daten für diese? damit Sie nicht tatsächlich geben in nichts frm te-Benutzer Ende, seine nur in aus antoehr Funktion namens Testdaten??
    • Ich habe ein einfaches Beispiel. Beachten Sie, dass dies setzt Voraus, dass die strings die gleiche Länge, da sonst die Spalten nicht ausgerichtet. Sehen Sie, Don Stewart Antwort für wie zu handhaben, ausrichten von Spalten verschiedener Breite.
    • wie also würde ich diese eine andere Funktion aufrufen für den test-Daten? das ist eine ganz andere Funktion: testData = [("type1","type2",["item1","item12"], "type2","type3",["item2","item22"])], wie kann ich den es so es nicht die eine Eingabe erfordern vom Benutzer?
    • Sie konnte etwas tun, wie mapM_ (putStrLn . fooToLine) testData, aber Sie würde sich entweder ändern müssen Foos auf Tupel-oder Umgekehrt.
    InformationsquelleAutor hammar
  2. 13

    Im Allgemeinen verwenden wir "pretty-printing" - Bibliotheken zu tun, schön formatierte Ausgabe. Der standard, dass Sie wissen sollten, ist,Text.PrettyPrint. Gegeben ein Daten-Typ, können Sie zu Fuß, die Art, den Aufbau einer gut-formatiertes Dokument.

    Beispiel:

    import Text.PrettyPrint
import Data.List

-- a type for records
data T = T { make  :: String
           , model :: String
           , years :: [Int] }
    deriving Show

-- test data
test =
    [ T "foo" "avenger" [1990, 1992]
    , T "bar" "eagle"   [1980, 1982]
    ]

-- print lists of records: a header, then each row
draw :: [T] -> Doc
draw xs =
    text "Make\t|\tModel\t|\tYear"
   $+$
    vcat (map row xs)
 where
    -- print a row
    row t = foldl1 (<|>) [ text (make t)
                         , text (model t)
                         , foldl1 (<^>) (map int (years t))
                         ]

-- helpers
x <|> y = x <> text "\t|\t" <> y
x <^> y = x <> text "," <+> y

    Testen:

    main = putStrLn (render (draw test))

    Ergebnisse in:

    Make    |   Model   |   Year
foo     |   avenger |   1990, 1992
bar     |   eagle   |   1980, 1982

    Die Fähigkeit, schnell zu schreiben, ziemlich Druckern ist eine unglaublich nützliche Fähigkeit.

    • Wenn Sie möchten, dass die Spaltenbreite anpassen, um die breiteste Element, das Sie brauchen etwas mehr code.
    • id lieber nicht, diese Bibliotheken zu nutzen, wie ich die Methode unten, aber im nicht sicher, wie Sie eine Reihe von test-Daten mit sich?
    • Sie hatte gelesen, die test-Daten aus einer Datei oder Datenbank. Edit: ah, ich sehe, Sie sind auf der Suche, wie zu tun, IO als gut. Schauen Sie für weitere Fragen, die auf dieser Website über io + haskell.
    • die in einer Funktion: testData = [("type1","type2",["item1","item12"], "type2","type3",["item2","item22"])] yeahh thats, wie die Daten kommen aus meinem eigenen format/Typ...
    InformationsquelleAutor Don Stewart
  3. 5

    Hier ist eine generalisierte Tabelle generator. Es berechnet die Spaltenbreiten passen die breitesten Reihe. Die ColDesc Typ können Sie angeben, für jede Spalte, die Bezeichnung Ausrichtung, der Titel-string, die Daten Ausrichtung, und eine Funktion zum formatieren der Daten.

    import Data.List (transpose, intercalate)

-- a type for records
data T = T { make  :: String
           , model :: String
           , years :: [Int] }
    deriving Show

-- a type for fill functions
type Filler = Int -> String -> String

-- a type for describing table columns
data ColDesc t = ColDesc { colTitleFill :: Filler
                         , colTitle     :: String
                         , colValueFill :: Filler
                         , colValue     :: t -> String
                         }

-- test data
test =
    [ T "foo" "avenger" [1990, 1992]
    , T "bar" "eagle"   [1980, 1982, 1983]
    ]

-- functions that fill a string (s) to a given width (n) by adding pad
-- character (c) to align left, right, or center
fillLeft c n s = s ++ replicate (n - length s) c
fillRight c n s = replicate (n - length s) c ++ s
fillCenter c n s = replicate l c ++ s ++ replicate r c
    where x = n - length s
          l = x `div` 2
          r = x - l

-- functions that fill with spaces
left = fillLeft ' '
right = fillRight ' '
center = fillCenter ' '

-- converts a list of items into a table according to a list
-- of column descriptors
showTable :: [ColDesc t] -> [t] -> String
showTable cs ts =
    let header = map colTitle cs
        rows = [[colValue c t | c <- cs] | t <- ts]
        widths = [maximum $ map length col | col <- transpose $ header : rows]
        separator = intercalate "-+-" [replicate width '-' | width <- widths]
        fillCols fill cols = intercalate " | " [fill c width col | (c, width, col) <- zip3 cs widths cols]
    in
        unlines $ fillCols colTitleFill header : separator : map (fillCols colValueFill) rows

    Ausgeführt:

    putStrLn $ showTable [ ColDesc center "Make"  left  make
                     , ColDesc center "Model" left  model
                     , ColDesc center "Year"  right (intercalate ", " . map show . years)
                     ] test

    Ergebnisse in:

    Make |  Model  |       Year      
-----+---------+-----------------
foo  | avenger |       1990, 1992
bar  | eagle   | 1980, 1982, 1983
    • Dies ist meine Lieblings-pretty-Drucker jetzt für Tabellen. Ich mag, dass es einfach und zusammensetzbar.
    InformationsquelleAutor pat
Schreibe einen Kommentar