小编Lan*_*dei的帖子

我想在Spring中从基于XML的配置切换到基于Java的配置.现在我们在应用程序上下文中有这样的东西:

<context:component-scan base-package="foo.bar">
    <context:exclude-filter type="annotation" expression="o.s.s.Service"/>
</context:component-scan>
<context:component-scan base-package="foo.baz" />

但如果我写这样的东西......

 @ComponentScan(
    basePackages = {"foo.bar", "foo.baz"},
    excludeFilters = @ComponentScan.Filter(
       value= Service.class, 
       type = FilterType.ANNOTATION
    )
 )

...它将从两个包中排除服务.我有强烈的感觉,我忽略了一些令人尴尬的琐碎,但我找不到一个解决方案来限制过滤器的范围foo.bar.

Haskell Data.Bifunctor基本上是:

class Bifunctor f where
  bimap :: (a -> c) -> (b -> d) -> f a b -> f c d 

我也能找到一个Biapply.我的问题是,为什么不存在完整的双层次结构(层次结构？),如:

class Bifunctor f => Biapplicative f where
  bipure :: a -> b -> f a b
  biap :: f (a -> b) (c -> d) -> f a c -> f b d 

class Biapplicative m => Bimonad m where
  bibind :: m a b -> (a -> b -> m c d) …

ArrowLoop包含的函数实例

loop :: ((b,d) -> (c,d)) -> (b -> c)
loop f b = let (c,d) = f (b,d) in c

首先,我有签名一个问题:我们如何能够得到b -> c从(b,d) -> (c,d)？我的意思是,c在结果元组中可能取决于输入的两个元素,如何"切断" d？的影响？

其次我不知道let这里的作品如何.不包含(c,d) = f (b,d)循环定义d？哪里d来的？说实话,我很惊讶这是有效的语法,因为它看起来像我们会重新定义d.

我的意思是在数学中这会有点意义,例如f可能是一个复杂的函数,但我只提供实部b,我需要选择虚部d,它不会改变我的时候评估f(b,d),这将使它成为某种固定点.但是,如果这个比喻成立,let表达式必须以某种方式"搜索"d的固定点(并且可能有多个).这对我来说看起来很神奇.或者我觉得太复杂了？

我不时偶然发现我想要表达的问题"请使用两次最后一个参数",例如为了编写无点样式或避免使用lambda.例如

sqr x = x * x

可写成

sqr = doubleArgs (*) where
   doubleArgs f x = f x x

或者考虑这个稍微复杂的功能(取自这个问题):

ins x xs = zipWith (\ a b -> a ++ (x:b)) (inits xs) (tails xs)

如果有这样的函数,我可以写这个代码pointfree:

ins x = dup (zipWith (\ a b -> a ++ (x:b))) inits tails where
     dup f f1 f2 x = f (f1 x) (f2 x)

但是因为我在Hoogle中找不到像doubleArgs或dup这样的东西,所以我猜我可能会错过这里的伎俩或成语.

如果我理解正确,可以使用scala.util.control.TailCalls通过使用trampoline来避免非尾递归函数的堆栈溢出.API中给出的示例很简单:

import scala.util.control.TailCalls._

def isEven(xs: List[Int]): TailRec[Boolean] =
   if (xs.isEmpty) done(true) else tailcall(isOdd(xs.tail))

def isOdd(xs: List[Int]): TailRec[Boolean] =
   if (xs.isEmpty) done(false) else tailcall(isEven(xs.tail))

isEven((1 to 100000).toList).result 

但是,更有趣的情况是,如果要在重新调用之后执行某些操作.我有一个"天真"的因子实现以某种方式运行

def fac(n:Long): TailRec[Long] = 
    if (n == 0) done(1) else done(n * tailcall(fac(n - 1)).result)

但这看起来很可怕,我怀疑这是用途.所以我的问题是如何使用TailCalls正确编写阶乘或斐波纳契函数(是的,我知道如何使用累加器来使它们尾递归)？或者TailCalls不适合这种问题吗？

我已经在使用Guice作为我的应用程序的数据模型,到目前为止我对此非常满意.然而,GUI部分即将成为一个泥球大球.我觉得这里很难使用Guice,因为Swing组件和模型紧密耦合,并且经常强制执行某个初始化顺序.

我的应用程序基本上包含一个包含大量过滤器的标题,一个中心且非常复杂的JTree组件,以及许多操作(例如来自JPopup),菜单,对话框,向导等.主要问题是我有很多组件和动作之间的耦合(例如复杂的验证,树更新......).你能给我一些如何用Guice构建GUI的建议吗？

我知道像GUTS这样的库,但文档很薄,我宁愿避免在我的项目中添加另一个依赖项并学习另一个API(例如我不知道Swing应用程序框架).

我想用Java定义一个Functor类.这有效:

//a Function
public interface F<A,R> {
   public R apply(A a);
}

public interface Functor<A> {
   public <B> Functor<B> fmap(F<A,B> f);
}

但是fmap的返回值不应该是Functor,而是适当的子类.通常这可以使用CRTP进行编码,但是由于附加参数,我似乎在这里遇到了问题A.例如,以下和类似的编码不起作用("类型参数FInst不在其范围内"):

public interface Functor<A, FInst extends Functor<A,FInst>> {
    public <B, I extends Functor<B,FInst>> I fmap(F<A,B> f);
}

[澄清]

对于"适当的子类",我指的是被称为自身的类的类型.例如列表是算子,所以我想写类似的东西

public class ListFunctor<A> implements ??? {
  final private List<A> list;
  public ListFunctor(List<A> list) {
     this.list = list;
  } 

  @Override
  <B> ListFunctor<B> fmap(F<A,B> f) {
     List<B> result = new ArrayList<B>();
     for(A a: list) result.add(f.apply(a)); …

通常你会有像Applicative没有的pure东西,或类似的东西Monad,但没有return.该semigroupoid包涵盖这些案件Apply和Bind.现在我处于类似的情况Arrow,我无法定义一个有意义的arr功能,但我认为其他功能将是完美的.

我定义了一个包含函数的类型和它的反向函数:

import Control.Category

data Rev a b = Rev (a -> b) (b -> a)

reverse (Rev f g) = Rev g f
apply (Rev f _) x = f x
applyReverse (Rev _ g) y = g y
compose (Rev f f') (Rev g g') = Rev ((Prelude..) f g) ((Prelude..) g' f') 

instance Category Rev where
  id = Rev …

通常你有"对称"匹配,并想写下这样的东西:

def g(p:(Int,Int)) = p match {
  case (10,n) | (n,10) => println(n)
  case _ => println("nope")
}

这是不允许的,但如果每一个可选项具有相同的变量与同一类型的,这不应该是一个问题,因为它可以被翻译成不同的情况:

def g(p:(Int,Int)) = p match {
  case (10,n) => println(n)
  case (n,10) => println(n)
  case _ => println("nope")
}

那么为什么我们有这个限制呢？

考虑这个例子(来自https://codereview.stackexchange.com/questions/23456/crtitique-my-haskell-function-capitalize):

import Data.Char

capWord [] = []
capWord (h:t) = toUpper h : map toLower t

capitalize = unwords . map capWord . words

是否有一种很好的方式来抽象"来回"转换,例如unwords . f . words？我能想到的最好的是

class Lift a b | a -> b where
  up :: a -> b
  down :: b -> a

instance Lift String [String] where
  up = words
  down = unwords

lifted :: (Lift a b) => (b -> b) -> a -> a
lifted f = down …