Migrated String to Text

dist/build/autogen/cabal_macros.h

@@ -63,3 +63,10 @@
   (major1) == 3 && (major2) <  2 || \
   (major1) == 3 && (major2) == 2 && (minor) <= 0)
 
+/* package text-0.11.3.1 */
+#define VERSION_text "0.11.3.1"
+#define MIN_VERSION_text(major1,major2,minor) (\
+  (major1) <  0 || \
+  (major1) == 0 && (major2) <  11 || \
+  (major1) == 0 && (major2) == 11 && (minor) <= 3)
+

hgraph.cabal

@@ -10,7 +10,7 @@ data-dir: ""
 executable hgraph
     build-depends: QuickCheck -any, Stream -any, accelerate -any,
                    base -any, bytestring -any, deepseq -any, ghc -any, monad-par -any,
-                   parallel -any
+                   parallel -any, text -any
     main-is: Main.hs
     buildable: True
     hs-source-dirs: src
@@ -19,7 +19,7 @@ executable hgraph
 test-suite test-hgraph
     build-depends: QuickCheck -any, Stream -any, accelerate -any,
                    base -any, bytestring -any, deepseq -any, ghc -any, monad-par -any,
-                   parallel -any
+                   parallel -any, text -any
     type: exitcode-stdio-1.0
     main-is: Main.hs
     buildable: True

src/Main.hs

@@ -24,12 +24,14 @@ import Data.List
 import System.Exit (exitFailure)
 import System.Environment
 import Test.QuickCheck.All (quickCheckAll)
-import qualified Data.ByteString.Lazy.Char8 as B
+import qualified Data.ByteString.Char8 as B
 import Data.ByteString.Lazy.Char8 (ByteString)
 import Control.Monad.Par.Scheds.Trace
 import qualified Data.Stream as S
 import Data.Either (lefts, rights)
 import Debug.Trace
+import qualified Data.Text as T
+import Data.Text.Encoding
 import qualified Data.Array.Accelerate as A
 -- change to Data.Array.Accelerate.CUDA as I and link accelerate-cuda to use GPU instead of CPU
 import Data.Array.Accelerate.Interpreter as I
@@ -38,19 +40,20 @@ import Stream hiding (map)
 
 type Matrix e = A.Array A.DIM2 e
 
-createGraph :: String -> Either [Int] String
+createGraph :: T.Text -> Either [Int] T.Text
-createGraph input = traceEvent "creating graph" createGraph' input (Left [])
+createGraph input = createGraph' input (Left [])
     where
-        createGraph' :: String -> Either [Int] String -> Either [Int] String
+        createGraph' :: T.Text -> Either [Int] T.Text -> Either [Int] T.Text
-        createGraph' [] r     = traceEvent "recursion done." r
+        createGraph' a r
-        createGraph' (a:as) r =
+            | T.null a = r
-                    let next = (createGraph' as r) in
+            | otherwise =
+                    let next = (createGraph' (T.tail a) r) in
                         case next of
                             Left xs ->
-                                case a of
+                                case T.head a of
                                     '0' -> Left $ 0:xs
                                     '1' -> Left $ 1:xs
-                                    _   -> Right $ "cannot parse " ++ (a:as)
+                                    _   -> Right $ T.append (T.pack "cannot parse ") a
                             Right errstr ->
                                 Right errstr
 --createGraph input = Right $ "Parsing-error in line: " ++ input
@@ -80,19 +83,17 @@ graphFolder l = graphFolder' l (Left [[]])
 concatWith :: String -> String -> String -> String
 concatWith d a b = a ++ d ++ b
 
-emptyLine :: String -> Bool
+emptyLine :: T.Text -> Bool
-emptyLine "" = True
+emptyLine a
-emptyLine "\n" = True
+    | T.null a    = True
-emptyLine "\r\n" = True
+    | otherwise   = False
-emptyLine "\r" = True
-emptyLine _ = False
 
-emptyLog :: [String] -> Bool
+emptyLog :: [T.Text] -> Bool
 emptyLog [] = True
-emptyLog a = emptyLine $ foldl1 (++) a
+emptyLog a = False --emptyLine $ foldl True (&&) (map emptyLine a)
 
 -- TODO: implement calculation
-doCalculation :: Matrix Int -> ByteString
+doCalculation :: Matrix Int -> B.ByteString
 doCalculation a = B.pack $ "" --(show a) ++ "\n"
 
 
@@ -108,10 +109,10 @@ exeMain = do
                                                         -- and filter empty lines
                                         (createGraph) (filter (not . emptyLine)
                                                         -- split at \n, convert to String
-                                                        (map B.unpack (B.split '\n' input)))
+                                                        (T.lines (decodeUtf8 input)))
     --egraph <- return $ graphFolder unrefined_graph
     (graph, log, lines) <- return $ ((foldl1 (++) (lefts unrefined_graph), -- concatenated graph
-                                foldl (concatWith "\n") "" (rights unrefined_graph), -- concat error-log
+                                T.intercalate (T.singleton '\n') (rights unrefined_graph), -- concat error-log
                                 length unrefined_graph) -- number of elements in graph
                                                     -- in parallel
                                                     `using` parTuple3 rdeepseq rdeepseq rdeepseq)
@@ -119,13 +120,14 @@ exeMain = do
     -- validate graph
     log <- return $ let l = length graph in
                         if l /= lines*lines then
-                            log ++ "Lines dont match up. Read " ++ (show l) ++ " lines. Expected "
+                            T.append log $ T.pack $ "Lines dont match up. Read " ++ (show l) ++
-                                ++ (show (lines*lines)) ++ " lines.\n"
+                                                    " chars. Expected " ++ (show (lines*lines)) ++
+                                                    " chars.\n"
                         else
                             log
     output <- return $ case emptyLine log of
         True -> doCalculation $ A.fromList (A.Z A.:. lines A.:. lines) graph
-        _    -> B.pack $ "Error detected:\n" ++ log ++ "\n\n"
+        _    -> encodeUtf8 $ T.append (T.append (T.pack "Error detected:\n") log) (T.pack "\n\n")
     B.putStr output