登录
当前位置： 首页 > 知识库问答 >
问题：

Haskell性能：组合与应用？

苏宏逸
2023-03-14

我看到了一些关于函数组合和应用程序之间的异同以及各种实现方法的问题，但有一件事开始让我有点困惑（据我搜索，还没有人问过这个问题）是关于性能的差异。

当我学习F#时，我爱上了管道操作符>，它在Haskell的反向应用程序&中具有等效性。但在我看来，F#变体无疑更漂亮（我不认为我是唯一一个）。

现在，可以很容易地将管道操作符黑客攻击到Haskell中：

(|>) x f = f x

管道（在F#和我们的haskell技巧中）之间的最大区别是它不组成函数，而是基于函数应用程序。它接受左边的值并将其传递到右边的函数中，而不是组合，后者接受2个函数并返回另一个函数，然后可以用作任何常规函数。

至少对我来说，这使得代码更漂亮，因为您只使用一个运算符来引导信息流从参数到最终值的整个函数，因为在基本组合（或>>>)中，您不能将一个值放在左侧，以使其通过“链”传递。

但是从性能的角度来看，看看这些常规选项，结果应该是完全相同的：

f x = x |> func1 |> func2 |> someLambda |> someMap |> someFold |> show

f x = x & (func1 >>> func2 >>> someLambda >>> someMap >>> someFold >>> show)

f x = (func1 >>> func2 >>> someLambda >>> someMap >>> someFold >>> show) x

共有1个答案

凌永逸
2023-03-14

只要(>)和(>>)内联，就不会有任何区别。让我们编写一个示例，使用四个不同的函数，两个是F#样式的，两个是Haskell样式的：

import Data.Char (isUpper)

{-# INLINE (|>) #-}
(|>) :: a -> (a -> b) -> b
(|>) x f = f x

{-# INLINE (>>>) #-}
(>>>) :: (a -> b) -> (b -> c) -> a -> c
(>>>) f g x = g (f x)

compositionF :: String -> String
compositionF = filter isUpper >>> length >>> show 

applicationF :: String -> String
applicationF x = x |> filter isUpper |> length |> show 

compositionH :: String -> String
compositionH = show . length . filter isUpper

applicationH :: String -> String
applicationH x = show $ length $ filter isUpper $ x

main :: IO ()
main = do
  getLine >>= putStrLn . compositionF  -- using the functions
  getLine >>= putStrLn . applicationF  -- to make sure that
  getLine >>= putStrLn . compositionH  -- we actually get the
  getLine >>= putStrLn . applicationH  -- corresponding GHC core

如果我们用-ddump-simpl-dsuppres-all-o0编译代码，我们将得到：

==================== Tidy Core ====================
Result size of Tidy Core = {terms: 82, types: 104, coercions: 0}

-- RHS size: {terms: 9, types: 11, coercions: 0}
>>>_rqe
>>>_rqe =
  \ @ a_a1cE @ b_a1cF @ c_a1cG f_aqr g_aqs x_aqt ->
    g_aqs (f_aqr x_aqt)

-- RHS size: {terms: 2, types: 0, coercions: 0}
$trModule1_r1gR
$trModule1_r1gR = TrNameS "main"#

-- RHS size: {terms: 2, types: 0, coercions: 0}
$trModule2_r1h6
$trModule2_r1h6 = TrNameS "Main"#

-- RHS size: {terms: 3, types: 0, coercions: 0}
$trModule
$trModule = Module $trModule1_r1gR $trModule2_r1h6

-- RHS size: {terms: 58, types: 73, coercions: 0}
main
main =
  >>
    $fMonadIO
    (>>=
       $fMonadIO
       getLine
       (. putStrLn
          (>>>_rqe
             (>>>_rqe (filter isUpper) (length $fFoldable[]))
             (show $fShowInt))))
    (>>
       $fMonadIO
       (>>=
          $fMonadIO
          getLine
          (. putStrLn
             (\ x_a10M ->
                show $fShowInt (length $fFoldable[] (filter isUpper x_a10M)))))
       (>>
          $fMonadIO
          (>>=
             $fMonadIO
             getLine
             (. putStrLn
                (. (show $fShowInt) (. (length $fFoldable[]) (filter isUpper)))))
          (>>=
             $fMonadIO
             getLine
             (. putStrLn
                (\ x_a10N ->
                   show $fShowInt (length $fFoldable[] (filter isUpper x_a10N)))))))

-- RHS size: {terms: 2, types: 1, coercions: 0}
main
main = runMainIO main

因此，如果我们不启用优化，>>>就不会内联。但是，如果启用优化，则根本看不到>>>或(.)。我们的函数略有不同，因为(.)在该阶段没有内联，但这在一定程度上是意料之中的。

如果我们在函数中添加{-#NOINLINE…#-}并启用优化，我们将看到这四个函数不会有任何不同：

$ ghc -ddump-simpl -dsuppress-all -O2 Example.hs
[1 of 1] Compiling Main             ( Example.hs, Example.o )

==================== Tidy Core ====================
Result size of Tidy Core = {terms: 261, types: 255, coercions: 29}

-- RHS size: {terms: 2, types: 0, coercions: 0}
$trModule2
$trModule2 = TrNameS "main"#

-- RHS size: {terms: 2, types: 0, coercions: 0}
$trModule1
$trModule1 = TrNameS "Main"#

-- RHS size: {terms: 3, types: 0, coercions: 0}
$trModule
$trModule = Module $trModule2 $trModule1

Rec {
-- RHS size: {terms: 29, types: 20, coercions: 0}
$sgo_r574
$sgo_r574 =
  \ sc_s55y sc1_s55x ->
    case sc1_s55x of _ {
      [] -> I# sc_s55y;
      : y_a2j9 ys_a2ja ->
        case y_a2j9 of _ { C# c#_a2hF ->
        case {__pkg_ccall base-4.9.1.0 u_iswupper Int#
                                     -> State# RealWorld -> (# State# RealWorld, Int# #)}_a2hE
               (ord# c#_a2hF) realWorld#
        of _ { (# ds_a2hJ, ds1_a2hK #) ->
        case ds1_a2hK of _ {
          __DEFAULT -> $sgo_r574 (+# sc_s55y 1#) ys_a2ja;
          0# -> $sgo_r574 sc_s55y ys_a2ja
        }
        }
        }
    }
end Rec }

-- RHS size: {terms: 15, types: 14, coercions: 0}
applicationH
applicationH =
  \ x_a12X ->
    case $sgo_r574 0# x_a12X of _ { I# ww3_a2iO ->
    case $wshowSignedInt 0# ww3_a2iO []
    of _ { (# ww5_a2iS, ww6_a2iT #) ->
    : ww5_a2iS ww6_a2iT
    }
    }

Rec {
-- RHS size: {terms: 29, types: 20, coercions: 0}
$sgo1_r575
$sgo1_r575 =
  \ sc_s55r sc1_s55q ->
    case sc1_s55q of _ {
      [] -> I# sc_s55r;
      : y_a2j9 ys_a2ja ->
        case y_a2j9 of _ { C# c#_a2hF ->
        case {__pkg_ccall base-4.9.1.0 u_iswupper Int#
                                     -> State# RealWorld -> (# State# RealWorld, Int# #)}_a2hE
               (ord# c#_a2hF) realWorld#
        of _ { (# ds_a2hJ, ds1_a2hK #) ->
        case ds1_a2hK of _ {
          __DEFAULT -> $sgo1_r575 (+# sc_s55r 1#) ys_a2ja;
          0# -> $sgo1_r575 sc_s55r ys_a2ja
        }
        }
        }
    }
end Rec }

-- RHS size: {terms: 15, types: 15, coercions: 0}
compositionH
compositionH =
  \ x_a1jF ->
    case $sgo1_r575 0# x_a1jF of _ { I# ww3_a2iO ->
    case $wshowSignedInt 0# ww3_a2iO []
    of _ { (# ww5_a2iS, ww6_a2iT #) ->
    : ww5_a2iS ww6_a2iT
    }
    }

Rec {
-- RHS size: {terms: 29, types: 20, coercions: 0}
$sgo2_r576
$sgo2_r576 =
  \ sc_s55k sc1_s55j ->
    case sc1_s55j of _ {
      [] -> I# sc_s55k;
      : y_a2j9 ys_a2ja ->
        case y_a2j9 of _ { C# c#_a2hF ->
        case {__pkg_ccall base-4.9.1.0 u_iswupper Int#
                                     -> State# RealWorld -> (# State# RealWorld, Int# #)}_a2hE
               (ord# c#_a2hF) realWorld#
        of _ { (# ds_a2hJ, ds1_a2hK #) ->
        case ds1_a2hK of _ {
          __DEFAULT -> $sgo2_r576 (+# sc_s55k 1#) ys_a2ja;
          0# -> $sgo2_r576 sc_s55k ys_a2ja
        }
        }
        }
    }
end Rec }

-- RHS size: {terms: 15, types: 15, coercions: 0}
compositionF
compositionF =
  \ x_a1jF ->
    case $sgo2_r576 0# x_a1jF of _ { I# ww3_a2iO ->
    case $wshowSignedInt 0# ww3_a2iO []
    of _ { (# ww5_a2iS, ww6_a2iT #) ->
    : ww5_a2iS ww6_a2iT
    }
    }

Rec {
-- RHS size: {terms: 29, types: 20, coercions: 0}
$sgo3_r577
$sgo3_r577 =
  \ sc_s55d sc1_s55c ->
    case sc1_s55c of _ {
      [] -> I# sc_s55d;
      : y_a2j9 ys_a2ja ->
        case y_a2j9 of _ { C# c#_a2hF ->
        case {__pkg_ccall base-4.9.1.0 u_iswupper Int#
                                     -> State# RealWorld -> (# State# RealWorld, Int# #)}_a2hE
               (ord# c#_a2hF) realWorld#
        of _ { (# ds_a2hJ, ds1_a2hK #) ->
        case ds1_a2hK of _ {
          __DEFAULT -> $sgo3_r577 (+# sc_s55d 1#) ys_a2ja;
          0# -> $sgo3_r577 sc_s55d ys_a2ja
        }
        }
        }
    }
end Rec }

-- RHS size: {terms: 15, types: 14, coercions: 0}
applicationF
applicationF =
  \ x_a12W ->
    case $sgo3_r577 0# x_a12W of _ { I# ww3_a2iO ->
    case $wshowSignedInt 0# ww3_a2iO []
    of _ { (# ww5_a2iS, ww6_a2iT #) ->
    : ww5_a2iS ww6_a2iT
    }
    }
...

所有go函数完全相同（SAN变量名），application*与composition*相同。所以继续在Haskell中创建您自己的F#前奏吧，应该不会有任何性能问题。

 类似资料：
  • Haskell函数组合

    函数组合是将一个函数的输出用作另一个函数的输入的过程。在数学中，合成用表示，其中是一个函数，其输出用作另一个函数(即)的输入。 如果一个函数的输出类型与第二个函数的输入类型匹配，则可以使用这两个函数来实现函数组合。我们使用点运算符()在Haskell中实现函数组合。 看下面的示例代码。演示如何使用函数组合来计算输入数字是偶数还是奇数。 在这里，在函数中，同时调用了两个函数和。编译器将首先以作为参数

  • Haskell-函数组合(().())

    ； ； ； 在2.中，设3。；因此，应为，，替换为1。，为，应为 但是，应该彼此相等，？如何使两者在GHCi中相互适应，它似乎用或代替了，那么它是如何前进的呢？

  • Swift与Objective-C：应用性能

    问题内容： 我正在研究Swift及其与Objective-C的区别。据我所知，Swift的当前版本相当快，甚至比Objective- C还快：请参见此处。 但是，由于大多数测试都是使用排序算法等完成的，所以我想知道，当Swift用于iOS应用开发时，它实际上是否会比Objective- C更快。任何人都可以（最好是从他们自己的经验中）启发我。 问题答案： 有一篇很棒的博客文章，特别是关于Swift

  • MongoDB查找与聚合性能

    但在我看来不对。有人能建议别的方法做这件事吗。

  • Java 8：流与集合的性能

    我是Java 8的新手。我仍然不了解这个API，但是我做了一个小型的非正式基准测试来比较新的Streams API与好的旧集合的性能。 测试包括筛选一个列表，并对每个偶数计算平方根，并将其存储在的结果中。 代码如下： 问题： 这个测试公平吗？我犯错了吗？ 流比集合慢吗？有没有人在这方面做了一个很好的正式基准？ 我应该争取哪种方法？ 更新结果。 按照@pveentjer的建议，我在JVM预热（1k次

  • 制作串联Haskell变体：应用程序和组合的优先级

    我正在学习串联语言的基础知识，其最初的想法是函数名串联与函数组合相同，而不是像Haskell那样是函数应用程序。 Joy、Forth或Factor是postfix，这意味着基于堆栈，但也有一些前缀级联语言，如OM。 我想知道Haskell变体在理论上是否可以通过交换（甚至相等）组合优先级（现在9）和函数应用优先级（现在10）而成为一种串联语言。 如果Haskell中的值只是零参数函数，为什么函数应

相关问答

论元在Haskell函数合成中的应用Android即时应用能否与混合应用集成？双参数Haskell合成桶排序与合并排序相结合的可能性Java8streams.reduce（）与组合器

相关文章

性能createNamedNativeQuerie与createNativeQuery性能：Matlab与PythonSQL Server：合并性能Java中的关联与聚合与组合JavaScript数组特性与实践应用深入详解

相关阅读

Haskell简介Haskell教程Haskell函子(functor)组合模式组合模式

相关工具

Haskellmu-haskellserverless-haskellHaskell GHCCloud Haskell

相关文档

你不懂JS: 异步与性能HASKELL 趣学指南Haskell 中文教程Real World Haskell 中文版Mininet 应用与源码剖析
快捷导航： 新手教程 算法原理 架构设计 Java进阶 数据库进阶 大厂专栏 面试经验 编程笔记 编程问答 所有专题 文档资料 工具软件 电子书籍 小牛导航
在线工具： 房贷计算器 个税计算器 Linux命令查询 Json格式化 正则表达式 颜色转换 AES加解密 SHA1加密 MD5加密 毒鸡汤 字数统计 随机密码生成 进制转换 Base64编解码 励志句子
Copyright © 2019-2024 小牛知识库@xnip.cn. All Rights Reserved.