module SortTable where

-- flexible Sortierung von Tabellen
-- mit Semigroup Instanz fuer Vergleichsfunktionen

import Data.Function (on)
import Data.List     (sortBy)

{-
sortBy :: (a -> a -> Ordering) -> [a] -> [a]

on     :: (b -> b -> c) -> (a -> b) -> a -> a -> c
-}

data Person = P
  { name :: String
  , vorname :: String
  , plz :: Int
  , ort :: String
  }
  deriving (Eq, Ord, Show)

type Personen = [Person]

personen :: Personen
personen =
  [ P "Merkel"   "Angela" 10115 "Berlin"
  , P "FH Wedel" ""       22880 "Wedel"
  , P ""         "Eto"    30449 "Hannover"
  , P "Seeler"   "Uwe"    22419 "Hamburg"
  ]

cName, cVorname, cPlz, cOrt :: Person -> Person -> Ordering
cName    = compare `on` name
cVorname = compare `on` vorname
cPlz     = compare `on` plz
cOrt     = compare `on` ort

p0, p1, p2, p3 :: Personen
p0 = sortBy compare personen
p1 = sortBy (cOrt <> cPlz <> cName <> cVorname) personen
p2 = sortBy (cVorname <> cName <> cOrt <> cPlz) personen
p3 = sortBy (flip cOrt <> cPlz <> cName <> cVorname) personen

pp :: Person -> String
pp (P n v p o) =
  fmt 10 n <> fmt 8 v <> fmt 6 (show p) <> o

pps :: Personen -> String
pps = unlines . map pp

fmt :: Int -> String -> String
fmt n = take n . reverse . (replicate n ' ' ++) . reverse

pr :: Personen  -> IO ()
pr = putStrLn . pps