小编Bab*_*ham的帖子

我理解两者之间的基本区别,我经常在程序中使用std :: async,这给了我并发性.

是否有任何可靠/值得注意的库可以在C++中提供并行性？(我知道这可能是C++的一个特色17).如果是这样,您对它们的体验是什么？

谢谢!芭芭拉

这是一个示例函数:

import qualified Data.ByteString.Lazy as LAZ
import qualified Data.ByteString.Lazy.Char8 as CHA
import Network.Wreq

makeRequest :: IO (Network.Wreq.Response LAZ.ByteString)
makeRequest = do 
   res <- get "http://www.example.com" 
   let resBody = res ^. responseBody :: CHA.ByteString
   --Do stuff....
   return (res)

我很难理解CHA.ByteString在这一行中的确切目的:

let resBody = res ^. responseBody :: CHA.ByteString

这是明确说明类型必须是CHA.ByteString？还是它扮演另一个角色？

我刚刚开始研究 OpenCV，我看过一些类似的问题，但我没有找到有用的答案。我有许多像素尺寸为 50 宽和 50 高（拇指指甲大小）的图像。

我对以下内容有些困惑：

问：通过增加这些图像的比例，我是否会自动增加分辨率？还是我需要执行其他功能？

我必须在增加图像比例的同时获得尽可能大的分辨率。

我正在使用以下功能：

int IncreaseScale()
{
  char *image_name {"./image/my_image.jpg"};
  cv::Mat Image;
  Image = cv::imread(image_name, 1);
  if(!Image.data)
  {
    //Cant find image
    return 0;
  }
  const float rescale_value {4.10}; 
  cv::Mat Image2;
  cv::resize(Image, Image2, cvSize(0, 0), rescale_value, rescale_value);
  return 1;
}

我有许多与它们各自的类对象绑定的函数指针：

ExampleClass EO;
std::function<void()> Example=std::bind(&ExampleClass::ExampleFunction, &EO);

但是，我想稍后“解除绑定”这些，特别是确定每个“std::function”相关的特定类。

auto Unbind(std::function<void()> &Example)->void
{
  //Find which object &Example is bound with (in this case EO/ExampleClass)
}

这样做的最佳方法是什么？

我花了很多时间查看learnyouahaskell,我还没有找到多态递归的好解释!

我理解基本的递归结构:

myFunction :: [Int] -> [Int]
myFunction [] = []
myFunction (x : xs) = (\x -> x + 1) x : myFunction xs

多态递归会是什么样的？它的好处/用途是什么？

我怎么能得到一个向量的尾部:

std::vector<int> Example {1,2,3,4,5};

//head = [1]
//tail = [2,3,4,5]

蟒蛇:

head = Array[0]
tail = Array[1:]

哈斯克尔

myRecursiveFunction :: [Int] -> [Int]
myRecursiveFunction (x : xs) = x + 1 : myRecursiveFunction xs

我知道我可以使用迭代STL算法,例如accumulate:

std::vector<int> Example {1,2,3,4,5};
std::accumulate(Example.begin() + 1, Example.end(), 0);

然而,这似乎相当冗长,有更简单的解决方案吗？我不介意解决方案复制或查看尾部,我只是在寻找一种方法,可以在不使用迭代器的情况下轻松访问向量的尾部.

我正在覆盖多态性,我试图看到这种功能的实际用途.

我对Rank 2的基本了解是:

type MyType = ? a. a -> a

subFunction :: a -> a
subFunction el = el

mainFunction :: MyType -> Int
mainFunction func = func 3

我知道这允许用户在mainFunction中使用多态函数(subFunction)并严格指定它的输出(Int).这似乎与GADT非常相似:

data Example a where
 ExampleInt :: Int -> Example Int
 ExampleBool :: Bool -> Example Bool

1)鉴于以上情况,我对Rank 2多态性的理解是否正确？

2)与GADT相比,可以使用Rank 2多态性的一般情况是什么？

我正在学习基本类型类,并functor为我的类型编写了自己的实现Test a(行为就像Maybe):

data Test a = Test a | Emp

class FC c a where
  t :: (a -> b) -> c a -> c b

instance FC Test a where
  t f (Test a) = Test (f a) 
  t f (Emp) = Emp

instance FC Maybe a where
  t f (Just a) = Just (f a) 
  t f (Nothing) = Nothing

有可能实现类似的东西:

instance FC c where
  t f (c v) = c (f …

我熟悉newtype声明:

newtype MyAge = Age {age :: Int} deriving (Show, Eq, Ord)

在这个例子中,Age是一个Int,但是我遇到了下面的代码,我无法理解它:

newtype Ages a = Ages {age :: String -> [(a,String)]}

这似乎是一个功能声明？(接受字符串,返回包含'a'和字符串的元组列表) - 这是正确的吗？

NB我刚刚意识到这只是声明一个函数的基本记录语法.

另外,我试图实现这种类型,但我必须做错事:

newtype Example a = Example {ex :: Int -> Int}

myexample = Example {ex = (\x -> x + 1)}

这编译,但我不明白为什么因为我没有通过'a'参数？

我正在经历这些 Haskell'中间'练习,我做了以下实例:

class Fluffy f where
  furry :: (a -> b) -> f a -> f b

instance Fluffy [] where
  furry f [] = []

instance Fluffy Maybe where
  furry f (Just e) = Just (f e)
  furry f (Nothing) = Nothing

但是,第三个问题语法让我难过:

instance Fluffy ((->) t) where
  ...

我上的箭头操作阅读起来也看了答案,这其中解释的作用,(->)在Monad的实例.但是我不太明白(->)Functors的上下文是如何工作的？