haskell - 为什么 <$> 慢？-6ren

haskell - 为什么 <$> 慢？

转载作者：行者123 更新时间：2023-12-02 05:35:47

我最近对我的代码进行了一些清理，并在此过程中更改了此内容(不完全是真实的代码):

read = act readSTRef
test1 term i var = do
    t <- fromRTerm term
    v <- rep var 
    ty <- v^!varType.read
    ts <- v^!terms.read
    let ts' = TL.toVector ts
    when (ty /= Void && V.length ts' == 1) . updateChild term t i $ ts' V.! 0
    V.mapM_ substitute ts'

对此:

read = act readSTRef
test2 term i var = do
    t <- fromRTerm term
    v <- rep var
    ty <- v^!varType.read
    ts <- TL.toVector <$> v^!terms.read
    when (ty /= Void && V.length ts == 1) . updateChild term t i $ ts V.! 0
    V.mapM_ substitute ts

显然，它们在语义上是相同的。然而，后者的运行速度明显慢(我测试时仅更改这些行以确保这是实际原因)。看看转储的核心，我无法识别任何明显的差异，并且 <$>似乎两者都内联。为什么GHC不能将后者优化为前者？

我应该注意到，我的程序中有多个地方可以用任何一种方式编写，以及 <$> 的性能影响它们之间是一致的(大约每半秒)。

我已经删除了测试的核心，因为很明显它们是相同的。所以，这里是实际功能的核心。

第一种方式:

case ipv5_X2Q6 of _ [Occ=Dead] {
  __DEFAULT ->
    case GHC.Prim.writeMutVar#
           @ s_aJBu
           @ TypeInferencer.Stage
           dt5_dMoe
           TypeInferencer.Substituted
           ipv4_X2Q4
    of s2#_aP5h { __DEFAULT ->
    letrec {
      a15_sSPP [Occ=LoopBreaker]
        :: [GHC.Types.Int]
           -> [TypeInferencer.RNode s_aJBu]
           -> GHC.Prim.State# s_aJBu
           -> (# GHC.Prim.State# s_aJBu, () #)
      [LclId, Arity=3, Str=DmdType <S,1*U><L,1*U><L,U>]
      a15_sSPP =
        \ (ds_aPlu :: [GHC.Types.Int])
          (_ys_aPlv :: [TypeInferencer.RNode s_aJBu])
          (eta_B1 :: GHC.Prim.State# s_aJBu) ->
          case ds_aPlu of _ [Occ=Dead] {
            [] -> (# eta_B1, GHC.Tuple.() #);
            : ipv6_aPlA ipv7_aPlB ->
              case _ys_aPlv of _ [Occ=Dead] {
                [] -> (# eta_B1, GHC.Tuple.() #);
                : ipv8_aPlH ipv9_aPlI ->
                  tick<substitute.go>
                  case scc<substitute.go>
                       (scctick<fromRNode>
                        GHC.STRef.readSTRef1
                          @ s_aJBu
                          @ (Data.Either.Either
                               (TypeInferencer.Term s_aJBu) (TypeInferencer.Var s_aJBu))
                          (ipv8_aPlH
                           `cast` (TypeInferencer.NTCo:RNode[0] <s_aJBu>_N
                                   :: TypeInferencer.RNode s_aJBu
                                        ~#
                                      GHC.STRef.STRef
                                        s_aJBu
                                        (Data.Either.Either
                                           (TypeInferencer.Term s_aJBu)
                                           (TypeInferencer.Var s_aJBu)))))
                         eta_B1
                  of _ [Occ=Dead] { (# ipv10_X2DV, ipv11_X2DX #) ->
                  case ipv11_X2DX of _ [Occ=Dead] {
                    Data.Either.Left ds5_dLX6 ->
                      case scc<substitute.go> a11_rYpY @ s_aJBu ipv8_aPlH ipv10_X2DV
                      of _ [Occ=Dead] { (# ipv12_a2tf, ipv13_a2tg #) ->
                      a15_sSPP ipv7_aPlB ipv9_aPlI ipv12_a2tf
                      };
                    Data.Either.Right var_aJrt ->
                      case scc<substitute.go> a14_sPTG ipv10_X2DV
                      of _ [Occ=Dead] { (# ipv12_X2PP, ipv13_X2PR #) ->
                      tick<rep>
                      case scc<substitute.go>
                           scc<rep> a4_rYnT @ s_aJBu var_aJrt ipv12_X2PP
                      of _ [Occ=Dead] { (# ipv14_X2PW, ipv15_X2PY #) ->
                      case scc<substitute.go>
                           scc<rep> a3_rYnR @ s_aJBu ipv15_X2PY var_aJrt ipv14_X2PW
                      of _ [Occ=Dead] { (# ipv16_X2Q0, ipv17_X2Q2 #) ->
                      case ipv17_X2Q2
                      of _ [Occ=Dead]
                      { TypeInferencer.Var dt6_dMth x1_XJka dt7_dMti dt8_dMtj dt9_dMtk
                                           dt10_dMtl dt11_dMtm ->
                      case scc<substitute.go>
                           GHC.Prim.readMutVar#
                             @ s_aJBu @ TypeInferencer.VarType dt7_dMti ipv16_X2Q0
                      of _ [Occ=Dead] { (# ipv18_X2Qt, ipv19_X2Qv #) ->
                      case scc<substitute.go>
                           GHC.Prim.readMutVar#
                             @ s_aJBu
                             @ (TreeList.TreeList (TypeInferencer.RNode s_aJBu))
                             dt9_dMtk
                             ipv18_X2Qt
                      of _ [Occ=Dead] { (# ipv20_X2QL, ipv21_X2QN #) ->
                      case scc<substitute.go>
                           scctick<substitute.go.ts'>
                           TreeList.toVector @ (TypeInferencer.RNode s_aJBu) ipv21_X2QN
                      of _ [Occ=Dead] { Data.Vector.Vector ww1_sTzM ww2_sTzN ww3_sTzO ->
                      tick<==>
                      tick</=>
                      case scc<substitute.go>
                           let {
                             $w$j_sTA0
                               :: GHC.Prim.State# s_aJBu -> (# GHC.Prim.State# s_aJBu, () #)
                             [LclId, Arity=1, Str=DmdType <L,U>]
                             $w$j_sTA0 =
                               \ (w_sTzY :: GHC.Prim.State# s_aJBu) ->
                                 letrec {
                                   $s$wa_sWUL [Occ=LoopBreaker]
                                     :: GHC.Prim.Int#
                                        -> GHC.Prim.State# s_aJBu
                                        -> (# GHC.Prim.State# s_aJBu, () #)
                                   [LclId, Arity=2, Str=DmdType <L,U><L,U>]
                                   $s$wa_sWUL =
                                     \ (sc_sWUJ :: GHC.Prim.Int#)
                                       (sc1_sWUK :: GHC.Prim.State# s_aJBu) ->
                                       case GHC.Prim.tagToEnum#
                                              @ GHC.Types.Bool (GHC.Prim.>=# sc_sWUJ ww2_sTzN)
                                       of _ [Occ=Dead] {
                                         GHC.Types.False ->
                                           case GHC.Prim.indexArray#
                                                  @ (TypeInferencer.RNode s_aJBu)
                                                  ww3_sTzO
                                                  (GHC.Prim.+# ww1_sTzM sc_sWUJ)
                                           of _ [Occ=Dead] { (# ipv22_aQSr #) ->
                                           case a11_rYpY @ s_aJBu ipv22_aQSr sc1_sWUK
                                           of _ [Occ=Dead] { (# ipv23_X2EL, ipv24_X2EN #) ->
                                           $s$wa_sWUL (GHC.Prim.+# sc_sWUJ 1) ipv23_X2EL
                                           }
                                           };
                                         GHC.Types.True -> (# sc1_sWUK, GHC.Tuple.() #)
                                       }; } in
                                 $s$wa_sWUL 0 w_sTzY } in

第二种方式:

case ipv5_X2Q6 of _ [Occ=Dead] {
  __DEFAULT ->
    case GHC.Prim.writeMutVar#
           @ s_aJBt
           @ TypeInferencer.Stage
           dt5_dMog
           TypeInferencer.Substituted
           ipv4_X2Q4
    of s2#_aP5h { __DEFAULT ->
    letrec {
      a15_sSPP [Occ=LoopBreaker]
        :: [GHC.Types.Int]
           -> [TypeInferencer.RNode s_aJBt]
           -> GHC.Prim.State# s_aJBt
           -> (# GHC.Prim.State# s_aJBt, () #)
      [LclId, Arity=3, Str=DmdType <S,1*U><L,1*U><L,U>]
      a15_sSPP =
        \ (ds_aPlu :: [GHC.Types.Int])
          (_ys_aPlv :: [TypeInferencer.RNode s_aJBt])
          (eta_B1 :: GHC.Prim.State# s_aJBt) ->
          case ds_aPlu of _ [Occ=Dead] {
            [] -> (# eta_B1, GHC.Tuple.() #);
            : ipv6_aPlA ipv7_aPlB ->
              case _ys_aPlv of _ [Occ=Dead] {
                [] -> (# eta_B1, GHC.Tuple.() #);
                : ipv8_aPlH ipv9_aPlI ->
                  tick<substitute.go>
                  case scc<substitute.go>
                       (scctick<fromRNode>
                        GHC.STRef.readSTRef1
                          @ s_aJBt
                          @ (Data.Either.Either
                               (TypeInferencer.Term s_aJBt) (TypeInferencer.Var s_aJBt))
                          (ipv8_aPlH
                           `cast` (TypeInferencer.NTCo:RNode[0] <s_aJBt>_N
                                   :: TypeInferencer.RNode s_aJBt
                                        ~#
                                      GHC.STRef.STRef
                                        s_aJBt
                                        (Data.Either.Either
                                           (TypeInferencer.Term s_aJBt)
                                           (TypeInferencer.Var s_aJBt)))))
                         eta_B1
                  of _ [Occ=Dead] { (# ipv10_X2DV, ipv11_X2DX #) ->
                  case ipv11_X2DX of _ [Occ=Dead] {
                    Data.Either.Left ds5_dLX8 ->
                      case scc<substitute.go> a11_rYpY @ s_aJBt ipv8_aPlH ipv10_X2DV
                      of _ [Occ=Dead] { (# ipv12_a2tf, ipv13_a2tg #) ->
                      a15_sSPP ipv7_aPlB ipv9_aPlI ipv12_a2tf
                      };
                    Data.Either.Right var_aJrt ->
                      case scc<substitute.go> a14_sPTG ipv10_X2DV
                      of _ [Occ=Dead] { (# ipv12_X2PP, ipv13_X2PR #) ->
                      tick<rep>
                      case scc<substitute.go>
                           scc<rep> a4_rYnT @ s_aJBt var_aJrt ipv12_X2PP
                      of _ [Occ=Dead] { (# ipv14_X2PW, ipv15_X2PY #) ->
                      case scc<substitute.go>
                           scc<rep> a3_rYnR @ s_aJBt ipv15_X2PY var_aJrt ipv14_X2PW
                      of _ [Occ=Dead] { (# ipv16_X2Q0, ipv17_X2Q2 #) ->
                      case ipv17_X2Q2
                      of _ [Occ=Dead]
                      { TypeInferencer.Var dt6_dMtj x1_XJka dt7_dMtk dt8_dMtl dt9_dMtm
                                           dt10_dMtn dt11_dMto ->
                      case scc<substitute.go>
                           GHC.Prim.readMutVar#
                             @ s_aJBt @ TypeInferencer.VarType dt7_dMtk ipv16_X2Q0
                      of _ [Occ=Dead] { (# ipv18_X2Qt, ipv19_X2Qv #) ->
                      case scc<substitute.go>
                           GHC.Prim.readMutVar#
                             @ s_aJBt
                             @ (TreeList.TreeList (TypeInferencer.RNode s_aJBt))
                             dt9_dMtm
                             ipv18_X2Qt
                      of _ [Occ=Dead] { (# ipv20_a6bS, ipv21_a6bT #) ->
                      case scc<substitute.go>
                           TreeList.toVector @ (TypeInferencer.RNode s_aJBt) ipv21_a6bT
                      of _ [Occ=Dead] { Data.Vector.Vector ww1_sTzM ww2_sTzN ww3_sTzO ->
                      tick<==>
                      tick</=>
                      case scc<substitute.go>
                           let {
                             $w$j_sTA0
                               :: GHC.Prim.State# s_aJBt -> (# GHC.Prim.State# s_aJBt, () #)
                             [LclId, Arity=1, Str=DmdType <L,U>]
                             $w$j_sTA0 =
                               \ (w_sTzY :: GHC.Prim.State# s_aJBt) ->
                                 letrec {
                                   $s$wa_sWUL [Occ=LoopBreaker]
                                     :: GHC.Prim.Int#
                                        -> GHC.Prim.State# s_aJBt
                                        -> (# GHC.Prim.State# s_aJBt, () #)
                                   [LclId, Arity=2, Str=DmdType <L,U><L,U>]
                                   $s$wa_sWUL =
                                     \ (sc_sWUJ :: GHC.Prim.Int#)
                                       (sc1_sWUK :: GHC.Prim.State# s_aJBt) ->
                                       case GHC.Prim.tagToEnum#
                                              @ GHC.Types.Bool (GHC.Prim.>=# sc_sWUJ ww2_sTzN)
                                       of _ [Occ=Dead] {
                                         GHC.Types.False ->
                                           case GHC.Prim.indexArray#
                                                  @ (TypeInferencer.RNode s_aJBt)
                                                  ww3_sTzO
                                                  (GHC.Prim.+# ww1_sTzM sc_sWUJ)
                                           of _ [Occ=Dead] { (# ipv22_aQSr #) ->
                                           case a11_rYpY @ s_aJBt ipv22_aQSr sc1_sWUK
                                           of _ [Occ=Dead] { (# ipv23_X2EL, ipv24_X2EN #) ->
                                           $s$wa_sWUL (GHC.Prim.+# sc_sWUJ 1) ipv23_X2EL
                                           }
                                           };
                                         GHC.Types.True -> (# sc1_sWUK, GHC.Tuple.() #)
                                       }; } in
                                 $s$wa_sWUL 0 w_sTzY } in

最佳答案

我想为后代回答这个问题——“当程序在没有启用分析的情况下构建时，它们运行得完全相同”。这是非常有意义的，因为当启用分析时，内联的附加函数调用必须为成本中心留下一些痕迹。

海森堡的行动原理 - 如果我们过于密切地观察我们的程序，我们最终会改变它!

关于haskell - 为什么 <$> 慢？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/27313273/

文章推荐： arrays - Haskell 中的非整体数组

文章推荐： c++ - 为什么 `decltype(static_cast(...))` 并不总是 `T` ？

文章推荐： google-maps - 使用 Google map 的混合内容

haskell - Haskell 和类 Haskell 语言之间的类型声明语法差异
在 Haskell 中，类型声明使用双冒号，即 (::)，如 not::Bool -> Bool。但是在许多语法与 Haskell 类似的语言中，例如榆树、 Agda 、他们使用单个冒号(:)来声明
haskell - 在模板 haskell 中运行模板 haskell
insertST :: StateDecoder -> SomeState -> Update SomeState SomeThing insertST stDecoder st = ... Stat
haskell - 在 Haskell ("second order Haskell"中生成 Haskell 类型的工具？
如果这个问题有点含糊，请提前道歉。这是一些周末白日梦的结果。借助 Haskell 出色的类型系统，将数学(尤其是代数)结构表达为类型类是非常令人愉快的。我的意思是，看看 numeric-prelud
haskell - 如何仅使用 Haskell 无休止地运行 Haskell 程序？
我有需要每 5 分钟执行一次的小程序。目前，我有执行该任务的 shell 脚本，但我想通过 CLI 中的键为用户提供无需其他脚本即可运行它的能力。实现这一目标的最佳方法是什么？最佳答案我想你会
haskell - 需要以真实世界 Haskell 风格解决哪些 Haskell 主题？
RWH 面世已经有一段时间了(将近 3 年)。在在线跟踪这本书的渐进式写作之后，我渴望获得我的副本(我认为这是写书的最佳方式之一。)在所有相当学术性的论文中，作为一个 haskell 学生，读起来多么
haskell - 用 Haskell 编写 Haskell 解释器
一个经典的编程练习是用 Lisp/Scheme 编写一个 Lisp/Scheme 解释器。可以利用完整语言的力量来为该语言的子集生成解释器。 Haskell 有类似的练习吗？我想使用 Haskell
haskell - Haskell 中的仿函数定义及其在 Learn You a Haskell 中的解释令人困惑
以下摘自' Learn You a Haskell ' 表示 f 在函数中用作“值的类型”。这是什么意思？即“值的类型”是什么意思？ Int 是“值的类型”，对吗？但是 Maybe 不是“值的类型”
haskell - haskell 中有包含字符串和列表的类型吗？
现在我正在尝试创建一个基本函数，用于删除句子中的所有空格或逗号。 stringToIntList :: [Char] -> [Char] stringToIntList inpt = [ a | a
haskell - 案例中的模式匹配，Haskell
我是 Haskell 的新手，对模式匹配有疑问。这是代码的高度简化版本: data Value = MyBool Bool | MyInt Integer codeDuplicate1 :: Valu
haskell - Haskell 中的这个仿函数是什么意思？
如何解释这个表达式？ :t (+) (+3) (*100) 自和具有相同的优先级并且是左结合的。我认为这与 ((+) (+3)) (*100) 相同.但是，我不知道它的作用。在 Learn
haskell - Haskell 如何计算表达式
这怎么行 > (* 30) 4 120 但这不是 > * 30 40 error: parse error on input ‘*’ 最佳答案 (* 30) 是一个 section，它仍然将 * 视为
haskell - 删除满足谓词的第一个元素(Haskell)
我想创建一个函数，删除满足第二个参数中给定谓词的第一个元素。像这样: removeFirst "abab" ( 'b') = "abab" removeFirst [1,2,3,4] even =
haskell - Haskell 中的内存
Context : def fib(n): if n aand returns a memoized version of the same function. The trick is t
haskell - 惰性评估和严格评估 Haskell
我明白惰性求值是什么，它是如何工作的以及它有什么优势，但是你能解释一下 Haskell 中什么是严格求值吗？我似乎找不到太多关于它的信息，因为惰性评估是最著名的。他们各自的优势是什么。什么时候真正使
haskell - Haskell 中的反向函数行为
digits :: Int -> [Int] digits n = reverse (x) where x | n digits 1234 = [3,1,2,4]
haskell - Haskell 是否支持类型类的匿名实例？
我在 F# 中有以下代码(来自一本书) open System.Collections.Generic type Table = abstract Item : 'T -> 'U with ge
haskell - 使用需要多个输入的过滤器 - Haskell
我对 Haskell 比较陌生，过去几周一直在尝试学习它，但一直停留在过滤器和谓词上，我希望能得到帮助以帮助理解。我遇到了一个问题，我有一个元组列表。每个元组包含一个 (songName, song
haskell - 或采用两个值参数 haskell
我是 haskell 的初学者，我试图为埃拉托色尼筛法定义一个简单的函数，但它说错误: • Couldn't match expected type ‘Bool -> Bool’
haskell - Haskell 中的读取函数
我是 Haskell 语言的新手，我在使用 read 函数时遇到了一些问题。准确地说，我的理解是: read "8.2" + 3.8 应该返回 12.0，因为我们希望返回与第二个成员相同的类型。我真正
haskell - Haskell 声明中的感叹号是什么意思？
当我尝试使用真实项目来驱动它来学习 Haskell 时，我遇到了以下定义。我不明白每个参数前面的感叹号是什么意思，我的书上好像也没有提到。 data MidiMessage = MidiMessage

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

haskell - 为什么 <$> 慢？