小编Raf*_*ini的帖子

是否可以使用C++(或C#)模板模拟Haskell的类型类功能？

这样做有意义还是有任何回报？

我试图用C++编写一个Functor类,但我无法做到.我试过这样的事情:

#include <iostream>
using namespace std;

//A function class to make types more readable
template <class input, class output> class Function {
private:
  output (*ptrfunc )(input);
public:
  Function(output (* ptr)(input)) {
    ptrfunc = ptr;
  }
  output call(input x) {return  (*ptrfunc)(x);}
  output operator() (input x) { return call(x);}
};


//the functor "typeclass"
template <class a> class Functor{
public:
  template <class b> Functor<b> fmap(Function<a,b> func);
};

// an container type to be declared "instance" of functor:
template <class a> class …

我有一个类在他们的函数上有一个沉闷的重复模式,我想把这个模式变成一个装饰器.但问题是这个装饰器必须访问当前实例的一些属性,所以我想把它变成这个类中的方法.我遇到了一些问题.

所以,这与我想要的类似:

class DullRepetitiveClass:
    def __init__(self, nicevariable):
        self.nicevariable = nicevariable

    def mydecorator(self, myfunction):
        def call(*args, **kwargs):
            print "Hi! The value of nicevariable is %s"%(self.nicevariable,)
            return myfunction(*args, **kwargs)
        return call

    @mydecorator            #Here, comment (1) below.
    def somemethod(self, x):
        return x + 1

(1)这是问题所在.我想用这个DullRepetitiveClass.mydecorator方法来装饰somemethod方法.但我不知道如何使用当前实例中的方法作为装饰器.

有一个简单的方法吗？

编辑:好的,答案很明显.正如Sven所说,装饰器本身只是改变了方法.该方法本身应该处理与实例有关的所有事情:

def mydecorator(method):
    def call(self, *args, **kwargs):
        print "Hi! The value of nicevariable is %s"%(self.nicevariable,)
        return method(self, *args, **kwargs)
    return call


class DullRepetitiveClass:
    def __init__(self, nicevariable):
        self.nicevariable = nicevariable

    @mydecorator            
    def somemethod(self, x): …

我想学习模板Haskell,但我找到的所有教程要么假设你学习了lisp并且知道什么是lisp宏,或者你知道一些cs理论行话 - 作为拼接,quasiquotations等等 - 或者关于宏的一些理论结果.

我不能编写一行lisp代码(虽然我打算有一天这样做,但我现在没时间学习它).Haskell是我的第一个函数式语言,我学到了它,我可以定期编写代码,使用monad,applicative,理解类型系统等等......但我不太了解(也想学习但是我对它来说太愚蠢......:P)关于它背后的理论背景.所以我对通常在TH教程中找到的术语一无所知.

因此,问题是:对于编写Haskell的人,有没有关于TH的教程,而不是作为一名专业的计算机科学家,而是作为一个使用编程进行日常琐事的人,他将Haskell作为他的第一个函数语言学习？也许介绍一下以TH为例的宏和元编程？

谢谢大家.:)

我见过很多人抱怨标准库中的某些类型类,比如"Monad应该要求Functor",甚至"Monad应该要求Applicative","Applicative应该要求Pointed","Num不应该要求Show"等等,所以,我有一些问题:

1. 是否存在类型类依赖关系树具有社区感知的"缺陷"的方式的论证,或者这仅仅是历史上事情的结果？

2. 这种变化有多大程度会破坏现有代码？

3. 是否有基本类型类的替代实现(特别是箭头,monad,applicative等等)实现"正确"的类依赖关系？

嗯,问题是自我解释.假设我想实现一些特殊的语法只是为了好玩.可能吗？我应该使用什么工具？

我需要用于模拟的小型高斯随机数列表,所以我尝试了以下方法:

import System.Random

seed = 10101
gen = mkStdGen seed

boxMuller mu sigma (r1,r2) =  mu + sigma * sqrt (-2 * log r1) * cos (2 * pi * r2) 

这只是Box-Muller算法 - 给定r1,r2在[0,1]区间内的均匀随机数,它返回一个高斯随机数.

normals 0 g = [] 
normals n g = take n $ map (boxMuller 0 1) $ pairs $ randoms g
    where pairs (x:y:zs) = (x,y):(pairs zs)

所以我normals每次需要我的随机数列表时都会使用这个函数.

问题必须明显:它始终生成相同的序列,因为我总是使用相同的种子!我没有得到新的序列,我只是一直得到序列的前n个值.

我明确假装的是,当我输入时:

x = normal 10 
y = normal 50

我要将x作为前10个值,将map (boxMuller 0 1) $ …

我正在努力掌握State Monad并且为了这个目的,我想编写一个使用线性同余生成器生成一系列随机数的monadic代码(可能不好,但我的目的只是学习State Monad,而不是建立一个好的RNG库).

生成器就是这样(Bool为了简单起见,我想生成一系列s):

type Seed = Int

random :: Seed -> (Bool, Seed)
random seed = let (a, c, m) = (1664525, 1013904223, 2^32)  -- some params for the LCG
                  seed' = (a*seed + c) `mod` m
              in  (even seed', seed')   -- return True/False if seed' is even/odd 

不要担心数字,这只是种子的更新规则(根据Numerical Recipes)应该生成Ints 的伪随机序列.现在,如果我想按顺序生成随机数,我会这样做:

rand3Bools :: Seed -> ([Bool], Seed)
rand3Bools seed0  = let (b1, seed1) = random seed0
                        (b2, seed2) = random seed1
                        (b3, seed3) = random …

是否有已知的算法+数据结构来维持动态直方图？

想象一下,我有一个数据流(x_1,w_1),(x_2,w_2),...其中x_t是双精度数,代表一些测量变量,w_t是相关权重.

我可以做明显的(伪python代码):

x0,xN = 0, 10
numbins = 100
hist = [(x0 + i * delta , 0) for i in xrange(numbins)]
def updateHistogram(x, w):
    k = lookup(x,  hist)    #find the adequated bin where to put x
    hist[k][1] += 1

但是当我有连续的数据流时,我遇到了一些问题.我手头没有完整的数据集,我必须在数据收集之间检查直方图.而且我没有期望:

• 理想的箱子大小,不会有很多空箱子,
• 数据范围

所以我想动态定义二进制文件.我可以做愚蠢的事情:

 for x in data_stream:
      data.append(x)
      hist = make_histogram(data)

但我想这会很快变慢......

如果所有权重等于我认为的事情之一就是将数据存储在排序数组中并以保持数组排序的方式插入新数据.这样我可以:

data = sortedarray();
for x in data_stream:
     data.insert(x)
     bins = [ data[int(i * data.size()/numbins)] for i in xrange(numbins)]

并且每个bin中的计数等于所有bin的data.size()/ numbins.

我想不出在这方面包括权重的方法......有没有人有建议？(关于这样做的c ++库的知识也会受到欢迎).

编辑:(对于要求的澄清)

x_t是浮点数.要计算直方图,我必须将x所属的连续范围除以多个区间.所以我将有一个数字序列bin [0],bin …

许多事情让哈斯克尔非常好的在我看来,使用的组合程序,如(.),flip,$ <*>等这感觉就像当我需要我可以创建新的语法.

前段时间我正在做一些事情,如果我能"翻转"一个类型的构造函数,那将是非常方便的.假设我有一些类型构造函数:

m  :: * -> * -> * 

并且我有一个类MyClass需要带有类型构造函数的类型* -> *.当然,我会选择以这样的方式对类型进行编码:

instance MyClass (m a) 

但是假设我无法改变那些代码,并假设真正适合的代码MyClass就是这样

type w b = m b a 

instance MyClass w where 
    ...

然后我必须激活XTypeSynonymInstances.有没有办法创建一个"类型级组合器" Flip,我可以这样做:

instance MyClass (Flip m a)  where 
   ...

?? 或者我们在haskell中使用的常见运算符的其他类型级概括？这甚至是有用的还是我只是漫无目的？

编辑:

我可以这样做:

newtype Flip m a b = Flip (m b a)

newtype Dot m w a  = Dot m (w a)

...

但后来我不得不使用这些数据构造 …

有一种绘制系列直方图的方法,但是有一个函数可以检索直方图计数以在其上进行进一步的计算吗？

我继续使用numpy的函数来执行此操作,并在需要时将结果转换为DataFrame或Series.一直与熊猫物体呆在一起会很好.