我有以下Haskell代码,实现了"cat"unix命令行实用程序的简单版本.在400MB文件上以"时间"测试性能,速度大约慢3倍.(我用来测试它的确切脚本在代码下面).

我的问题是:

1. 这是性能的有效测试吗？
2. 如何让这个程序运行得更快？
3. 如何识别Haskell程序中的性能瓶颈？

关于问题2和3:我使用了GHC -prof,然后使用+ RTS -p运行,但我发现这里的输出有点无法提供信息.

来源(Main.hs)

module Main where

import System.IO
import System.Environment
import Data.ByteString as BS

import Control.Monad

-- Copied from cat source code
bufsize = 1024*128

go handle buf = do
  hPut stdout buf
  eof <- hIsEOF handle
  unless eof $ do
    buf <- hGetSome handle bufsize
    go handle buf

main = do
  file    <- fmap Prelude.head getArgs
  handle  <- openFile file ReadMode
  buf     <- hGetSome handle bufsize
  hSetBuffering stdin $ BlockBuffering (Just bufsize) …

背景

我正在查看WebGL2 库PicoGL.js中的示例代码。

它描述了一个三角形（三个顶点：）(-0.5, -0.5), (0.5, -0.5), (0.0, 0.5)，顶点着色器为每个三角形分配了一种颜色（红、绿、蓝）：

    #version 300 es

    layout(location=0) in vec4 position;
    layout(location=1) in vec3 color;

    out vec3 vColor; 
    void main() {
        vColor = color;
        gl_Position = position;
    }

输出vColor被传递到片段着色器：

    #version 300 es
    precision highp float;

    in vec3 vColor;

    out vec4 fragColor;
    void main() {
        fragColor = vec4(vColor, 1.0);
    }

它们一起渲染出以下图像：

问题）

我的理解是，顶点着色器每个顶点调用一次，而片段着色器每个像素调用一次。

然而，片段着色器引用该vColor变量，每次调用每个顶点时仅分配一次该变量，但像素比顶点多得多！

生成的图像清楚地显示出颜色渐变 - 为什么？vColorWebGL 是否会自动在顶点之间插入像素值？如果是这样，插值是如何完成的？

概括

我有一个类型类，我想为其编写一些“通用术语”。我有两个问题：

1. 使用:t向 GHCi 询问通用术语的类型有效，但使用推断的类型失败 - 为什么？
2. 如何使用TypeApplications类型类的方法？

我正在使用GHC 8.8.4。对于这两个问题，我有以下示例，Main.hs其中包含一个类型类F和类型Empty，它是F.

{-# LANGUAGE NoStarIsType #-}
{-# LANGUAGE PolyKinds    #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
module Main where

import GHC.Types (Type)

class F (f :: k -> Type) where
  type Plus f (a :: k) (b :: k) :: k

  zero :: f a
  plus :: f …

在Haskell中,我最近发现以下函数很有用:

listCase :: (a -> [a] -> b) -> [a] -> [b]
listCase f [] = []
listCase f (x:xs) = f x xs : listCase f xs

我用它从列表中生成大小为3的滑动窗口,如下所示:

*Main> listCase (\_ -> take 3) [1..5]
[[2,3,4],[3,4,5],[4,5],[5],[]]

是否有更一般的递归方案来捕获这种模式？更具体地说,这允许您通过反复将数据分成"头部"和"尾部"来生成某种结果结构？