为什么从Data.Text构建一个Haskell字符串非常缓慢(Why is building a Haskell String from Data.Text so slow)

 所以我有一个地点类 
 
data Location = Location {
    title :: String
  , description :: String
  }

instance Show Location where
  show l = title l ++ "\n"
         ++ replicate (length $ title l) '-' ++ "\n"
         ++ description l
 
 然后我将其更改为使用Data.Text 
 
data Location = Location {
    title :: Text
  , description :: Text
  }

instance Show Location where
  show l = T.unpack $
    title l <> "\n"
    <> T.replicate (T.length $ title l) "-" <> "\n"
    <> description l
 
 使用标准，我对show和Data.Text实现上show的时间进行了基准测试： 
 
benchmarks = [ bench "show" (whnf show l) ]
  where l = Location {
                title="My Title"
              , description = "This is the description."
              }
 
 String实现花费了34ns， Data.Text实现速度几乎慢了六倍，达到了170ns 
 
 如何使Data.Text工作速度与String类似？ 
 
 编辑：愚蠢的错误 
 
 我不确定这是怎么发生的，但我无法复制原来的速度差异：现在对于字符串和文本我分别获得了28ns和24ns 
 
 对于更具侵略性的bench "length.show" (whnf (length . show) l)基准，对于String和Text，我分别得到467ns和3954ns。 
 
 如果我使用非常基本的懒惰生成器，没有复制的破折号 
 
import qualified Data.Text.Lazy.Builder as Bldr

instance Show Location where
  show l = show $
    Bldr.fromText (title l) <> Bldr.singleton '\n'
  --  <> Bldr.fromText (T.replicate (T.length $ title l) "-") <> Bldr.singleton '\n'
    <> Bldr.fromText (description l)
 
 并尝试原版，普通show基准，我获得19ns。 现在，这是错误的，因为使用show将构建器转换为String将会转义换行符。 如果我用LT.unpack $ Bldr.toLazyText替换它，其中LT是Data.Text.Lazy的限定导入，那么我得到192ns。 
 
 我正在Mac笔记本电脑上测试这个，我怀疑我的计时受到机器噪音的严重损坏。 感谢您的指导。 

So I had a location class
 
data Location = Location {
    title :: String
  , description :: String
  }

instance Show Location where
  show l = title l ++ "\n"
         ++ replicate (length $ title l) '-' ++ "\n"
         ++ description l
 
Then I changed it to use Data.Text
 
data Location = Location {
    title :: Text
  , description :: Text
  }

instance Show Location where
  show l = T.unpack $
    title l <> "\n"
    <> T.replicate (T.length $ title l) "-" <> "\n"
    <> description l
 
Using criterion, I benchmarked the time taken by show on both the String and Data.Text implementations:
 
benchmarks = [ bench "show" (whnf show l) ]
  where l = Location {
                title="My Title"
              , description = "This is the description."
              }
 
The String implementation took 34ns, the Data.Text implementation was almost six times slower, at 170ns
 
How do I get Data.Text working as fast as String?
 
Edit: Silly mistakes
 
I'm not sure how this happened, but I cannot replicate the original speed difference: now for String and Text I get 28ns and 24ns respectively
 
For the more aggressive bench "length.show" (whnf (length . show) l) benchmark, for String and Text, I get 467ns and 3954ns respectively.
 
If I use a very basic lazy builder, without the replicated dashes
 
import qualified Data.Text.Lazy.Builder as Bldr

instance Show Location where
  show l = show $
    Bldr.fromText (title l) <> Bldr.singleton '\n'
  --  <> Bldr.fromText (T.replicate (T.length $ title l) "-") <> Bldr.singleton '\n'
    <> Bldr.fromText (description l)
 
and try the original, ordinary show benchmark, I get 19ns. Now this is buggy, as using show to convert a builder to a String will escape newlines. If I replace it with LT.unpack $ Bldr.toLazyText, where LT is a qualified import of Data.Text.Lazy, then I get 192ns. 
 
I'm testing this on a Mac laptop, and I suspect my timings are getting horribly corrupted by machine noise. Thanks for the guidance.

原文：https://stackoverflow.com/questions/33710015