小编whe*_*ies的帖子

在使用Java或C++进行编程时,有很多次我遇到了一个简单的模式,自定义控件结构可以减少代码中的样板.它类似于:

 if( Predicate ){
     Action

     return Value
 }

也就是说,"return if"类型语句.我已经尝试过制作带有签名的功能foo[A,B]( pred:((A,A)=>Boolean), value:Option[B] )但是我最终会检查我是否已经返回了Some或None.我被return声明绊倒了.

是否有继承方式在函数式语言或更具体的Scala中创建这样的控制结构？

编辑:

我的描述并不那么清楚,而且那些试图帮助我的人会感到困惑.我foo不工作的关键原因是它不能使包含函数的评估短路.那是

def intersect( geometry:Geometry, reference:Geometry ):Geometry = {
    return_if( withinBounds( geometry, projection ), logToString( logger, "Geometry outside " + projection.toString ), EmptyGeometry() )
    return_if( topologicallyCorrect( geometry ), intersect( correct( geometry ), reference )
    //rest of the function
}

并且仍允许在内部进行尾递归return_if.

通常不要在Python中进行OO编程.这个项目需要它,并且遇到了一些麻烦.这是我的试图找出它出错的地方代码:

class trial(object):
    def output( func, x ):
        def ya( self, y ):
            return func( self, x ) + y
        return ya
    def f1( func ):
        return output( func, 1 )
    @f1
    def sum1( self, x ):
        return x

哪个不编译.我试图将@staticmethod标签添加到"输出"和"f1"功能但无济于事.通常我会这样做

def output( func, x ):
    def ya( y ):
        return func( x ) + y
    return ya

def f1( func ):
    return output( func, 1 )

@f1
def sum1( x ):
    return x

哪个确实有效.那么如何在课堂上学习呢？

我有一些看起来像这样的遗留代码:

void* getData(DataType  dataType)
{

    switch(dataType)
    {
    case TYPE_FLOAT:
        return new float[ rows * clms ];

    case TYPE_INT:
        return new int[ rows * clms ];

    case TYPE_DOUBLE:
        return new double[ rows * clms ];
    default:
        return NULL;
    }
}

我希望能够这样做:

boost::shared_array < void > getData(DataType   dataType)
{

    boost::shared_array < void > theData;

    switch(dataType)
    {
    case TYPE_FLOAT:
        theData = boost::shared_array<float>(new float[ rows * clms ]);
                    break;

    case TYPE_INT:
        theData = boost::shared_array<int>(new int[ rows * clms ]);
                    break;

    case TYPE_DOUBLE:
        theData = …

我的任务是将审计跟踪附加到一堆计算之后用于重构值(即具有业务领域知识的人来解读出错的地方.)当前代码看起来像这样:

def doSomething = f(x) orElse g(x,y,z) orElse h(p,q,r) orElse default

其中每个都返回一个选项.新代码应返回(选项,审计)元组.

我已经实现了它

def doSomething = f(x) match{
  case None => g_prime(x,y,z)
  case x @ Some(_) => (x, SomeAuditObject)
}
//and taking some liberties with the actual signature...
def g_prime(x,y,z) = g(x,y,z) match{

依此类推,直至"默认".每个函数链接到下一个和下一个,依此类推.我不喜欢它.感觉太必要了.我错过了什么.有一些思考这个问题的方法,我只是没有看到.除了将返回值包装到另一个选项中之外,它是什么？

有一个scala课程(来自coursera反应课程)

class Counter extends Actor {
   def counter(n: Int): Receive = {
    case "inc" => context.become(counter(n + 1))        
    case "get" => sender ! n
  }

  def receive = counter(0)
}

所有这个actor都是通过inc请求递增计数器并通过get请求返回当前计数器值.我认为context.become会为行为堆栈添加新的行为.所以,如果我添加线

    case "dec" => context.unbecome()

它将从堆栈中恢复先前的行为,并且进一步获取请求将返回先前的值.但如果我跑

counter ! "inc"
counter ! "inc"
counter ! "inc"
counter ! "inc"

counter ! "dec"
counter ! "get"

返回的结果是0但不是我预期的3.有谁可以形容为什么？

我们一直在讨论在我们小组内设计数据仓库策略,以满足测试,可重复性和数据同步要求.建议的一个想法是使用现有工具调整NoSQL方法,而不是尝试在文件系统上重新实现大量相同的方法.我不知道NoSQL方法是否是我们想要实现的目标的最佳方法,但也许如果我描述我们需要/希望你们所有人都可以提供帮助.

1. 我们的大多数文件都是大型的,大小超过50个,以专有的第三方格式保存.我们需要能够通过名称/日期/源/时间/工件组合访问每个文件.基本上是键值对样式查找.
2. 当我们查询文件时,我们不希望将所有文件加载到内存中.他们真的太大了,会淹没我们的服务器.我们希望能够以某种方式获得对该文件的引用,然后使用专有的第三方API来提取它的部分内容.
3. 我们希望从存储中轻松添加,删除和导出文件.
4. 我们想在两台服务器之间设置自动文件复制(我们可以为此编写一个脚本.)也就是说,将一台服务器的内容与另一台服务器同步.我们不需要一个分布式系统,它只显示我们有一台服务器.我们想要完全复制.
5. 我们还有其他较小的文件与Big文件具有树型关系.一个文件的内容将指向下一个,依此类推,依此类推.它不是一个"辐条轮",它是一棵完整的树.

我们更喜欢使用Python,C或C++ API来处理这样的系统,但我们大多数人都有各种语言的经验.我们不介意只要它有效,完成工作,并节省我们的时间.你认为呢？有这样的东西吗？

在我去查看其他人的代码之前,我一直在尝试编写自己版本的memoizing装饰器.老实说,这更像是一种有趣的运动.然而,在玩耍的过程中,我发现我不能用装饰器做我想做的事情.

def addValue( func, val ):
    def add( x ):
        return func( x ) + val
    return add

@addValue( val=4 )
def computeSomething( x ):
    #function gets defined

如果我想这样做,我必须这样做:

def addTwo( func ):
    return addValue( func, 2 )

@addTwo
def computeSomething( x ):
    #function gets defined

为什么我不能以这种方式使用装饰器的关键字参数？我做错了什么,你能告诉我我应该怎么做吗？

使用VS2005在Windows上工作,并努力理解我得到的错误消息.如果以前问过这个问题,我很抱歉.我找不到它.

我正在测试的是:

#include <functional>
using std::unary_function;

template<typename F, typename G>
struct UnaryConvolution : unary_function<typename G::argument_type,typename F::result_type>{
    UnaryConvolution(const F &_f, const G &_g) : m_F(_f), m_G(_g){}

    result_type operator()(const argument_type &_arg){
        return m_F( m_G( _arg ) );
    }

    F m_F;
    G m_G;
};

单元测试我写过:

using std::bind2nd;
using std::equal_to;
using std::less;

bool unaryConvolution_test(){
    UnaryConvolution obj(bind2nd( equal_to<bool>(), true ), bind2nd( less<int>(), 5 ));

    return obj( 3 );
}

我得到的错误:

1. 错误C2955:'UnaryConvolution':使用类模板需要模板参数列表
2. 错误C3848:具有'UnaryConvolution'类型的表达式会丢失一些const-volatile限定符,以便调用'_Result UnaryConvolution :: operator()(const _Arg&)'
3. 错误C2514:'UnaryConvolution':类没有构造函数

即使添加线int val = 3然后传递val也没有效果.(顺便说一句,项目被禁止使用Boost或任何第三方库.不要问,我尽量不这样做.)

通常有人会去抓住Boost的函数输出迭代器,但我不允许在工作中使用Boost.也就是说,我只想使用该copy函数遍历一个集合,在每个项目上调用一个函数,获取该函数的输出,最后将push_back它传递到另一个集合.我写了一些代码:

#include <iterator>
using std::iterator;
using std::output_iterator_tag;

template<typename Container, typename Function>
struct Back_Transform_Iterator : public iterator<output_iterator_tag,void,void,void,void>{
    explicit Back_Transform_Iterator(Container &_container, const Function &_function) 
        : m_Container(_container),
        m_Function(_function){}

    Back_Transform_Iterator<Container,Function>& operator= (const typename Function::argument_type &value){ 
      m_Container.push_back( m_Function( value ) );

      return *this; 
    }

    Back_Transform_Iterator<Container,Function>& operator* (){ return *this; }
    Back_Transform_Iterator<Container,Function>& operator++ (){ return *this; }
    Back_Transform_Iterator<Container,Function> operator++ (int){ return *this; }

    typedef Container container_type;

private:
    Container   &m_Container;
    Function    m_Function;
};

template<typename C, typename F>
Back_Transform_Iterator<C,F> back_transform_inserter(C &_container, F …