Performance 具有中间值的融合优化

GHC转换具有中间值的表达式的效率是否与转换不具有中间值的表达式的效率相同

e、 g

似乎有非常不同的核心输出（使用

-ddump simple

）和

f x = foldl1 (++) $ filter (\z -> 'C' /= head z) $ map (map toUpper) x

---

具有中间值的表达式是否需要（显著）更长的时间来计算？

中间

let

绑定的线性使用相当于将

（）

放在两个值之间

GHC将通过此类管道熔断。您可以从

-ddump siml stats

使用let绑定：

15 RuleFired
    1 ++
    1 Class op /=
    1 Class op show
    1 Class op showList
    1 filter
    1 fold/build
    1 foldr/app
    1 map
    1 neChar#->case
    3 unpack
    3 unpack-list

Main.main_go =
  \ (ds_aAz :: [[GHC.Types.Char]]) ->
    case ds_aAz of _ {
      [] -> GHC.Types.[] @ [GHC.Types.Char];
      : y_aAE ys_aAF ->
        case GHC.Base.map
               @ GHC.Types.Char @ GHC.Types.Char GHC.Unicode.toUpper y_aAE
        of wild1_azI {
          [] ->
            GHC.List.badHead
            `cast` (UnsafeCo (forall a_azK. a_azK) [[GHC.Types.Char]]
                    :: (forall a_azK. a_azK) ~ [[GHC.Types.Char]]);
          : x_azM ds1_azN ->
            case x_azM of _ { GHC.Types.C# c2_aAa ->
            case c2_aAa of _ {
              __DEFAULT ->
                GHC.Types.: @ [GHC.Types.Char] wild1_azI (Main.main_go ys_aAF);
              'C' -> Main.main_go ys_aAF
            }

使用管道：

15 RuleFired
    1 ++
    1 Class op /=
    1 Class op show
    1 Class op showList
    1 filter
    1 fold/build
    1 foldr/app
    1 map
    1 neChar#->case
    3 unpack
    3 unpack-list

同一个工人：

使用let绑定：

15 RuleFired
    1 ++
    1 Class op /=
    1 Class op show
    1 Class op showList
    1 filter
    1 fold/build
    1 foldr/app
    1 map
    1 neChar#->case
    3 unpack
    3 unpack-list

Main.main_go =
  \ (ds_aAz :: [[GHC.Types.Char]]) ->
    case ds_aAz of _ {
      [] -> GHC.Types.[] @ [GHC.Types.Char];
      : y_aAE ys_aAF ->
        case GHC.Base.map
               @ GHC.Types.Char @ GHC.Types.Char GHC.Unicode.toUpper y_aAE
        of wild1_azI {
          [] ->
            GHC.List.badHead
            `cast` (UnsafeCo (forall a_azK. a_azK) [[GHC.Types.Char]]
                    :: (forall a_azK. a_azK) ~ [[GHC.Types.Char]]);
          : x_azM ds1_azN ->
            case x_azM of _ { GHC.Types.C# c2_aAa ->
            case c2_aAa of _ {
              __DEFAULT ->
                GHC.Types.: @ [GHC.Types.Char] wild1_azI (Main.main_go ys_aAF);
              'C' -> Main.main_go ys_aAF
            }

管道：

Main.main_go =
  \ (ds_aAA :: [[GHC.Types.Char]]) ->
    case ds_aAA of _ {
      [] -> GHC.Types.[] @ [GHC.Types.Char];
      : y_aAF ys_aAG ->
        case GHC.Base.map
               @ GHC.Types.Char @ GHC.Types.Char GHC.Unicode.toUpper y_aAF
        of wild1_azB {
          [] ->
            GHC.List.badHead
            `cast` (UnsafeCo (forall a_azD. a_azD) [[GHC.Types.Char]]
                    :: (forall a_azD. a_azD) ~ [[GHC.Types.Char]]);
          : x_azF ds1_azG ->
            case x_azF of _ { GHC.Types.C# c2_aA3 ->
            case c2_aA3 of _ {
              __DEFAULT ->
                GHC.Types.: @ [GHC.Types.Char] wild1_azB (Main.main_go ys_aAG);
              'C' -> Main.main_go ys_aAG
            }
            }

---

您忘记使用-O2进行编译了吗？

注意，这是使用build/foldr fusion，因为您使用的是默认的GHC列表实现。如果需要流版本，请使用

流融合

包。这两个版本为我提供了相同的内核，分别是7.6.1和7.2.2（使用

-O

和

-O2

）。您使用了什么版本和优化标志？@DanielFischer:我没有使用任何优化标志；我想知道的是“什么时候这些是不等价的”，答案似乎是“当不使用优化标志时”。@amindfv No optimization的基本意思是“音译已经编写的内容”。这绝不是一个好主意。如果不启用优化，将无法启用重写规则优化。