Data.Stream的monad instanc定义方式如下:
instance Monad Stream where
return = repeat
xs >>= f = join (fmap f xs)
where
join :: Stream (Stream a) -> Stream a
join ~(Cons xs xss) = Cons (head xs) (join (map tail xss))
这意味着join获取第一个流的第一个元素,第二个流的第二个元素等,因此得到的流可以被视为"主对角线",丢弃所有其他元素.
现在有一种方法可以通过一个无限的二维表,由Georg Cantor发现,因为他的证据表明存在与自然数一样多的有理数:http://www.jcu.edu/math/vignettes/infinity.htm
现在我的问题是,如果join沿着所有辅助对角线使用路径(访问每个流的每个元素)也是一个有效的实现.或者这会违反monad法律之一吗？
我找到了解释Haskell 之间newtype和之间差异的答案data.但如果我有以下类型的同义词:
type Point = (Int,Int)
这会更有效,而不是使用:
data Point = Pt (Int,Int) ?
在Vaadin中,字段验证工作很简单,但你不能用它来检查字段之间的关系(例如,加入日期必须在离开日期之前),这真的很烦人.所以我使用JSR 303添加了标准的类级别验证,可以做到这一点.这很好用.
但是只有在我提交字段后才能执行此交叉字段验证.这意味着bean已经包含所有字段更改,并且在验证问题的情况下,我需要有可能在字段提交之前"返回"到有效状态(或以某种方式强制"重新加载"bean),否则我坚持更改,例如,如果用户决定取消编辑操作.
当然我之前可以保存所有字段内容,并手动重置状态,但鉴于Vaadin在简单字段验证的情况下完全相同,我想重用该机制.但是看看Vaadin代码,我不太自信我能弄明白该做什么,并且做得对.
请给我一些提示,如何在不重新发明轮子的情况下解决这个问题.
我有一个名为str的字符串.
str = "hi john";
现在我想将jchar 设置为g.我怎样才能做到这一点？
在以下情况中,如何定义方法返回类型:
工作代码
def deleteInstance(model: String, uid: Long) = model match {
case "menu" => Model.all(classOf[Menu]).filter("uid", uid).get().delete()
case "articles" => Model.all(classOf[Articles]).filter("uid", uid).get().delete()
case "news" => Model.all(classOf[News]).filter("uid", uid).get().delete()
case "image" =>Model.all(classOf[Image]).filter("uid", uid).get().delete()
case "files" =>Model.all(classOf[Files]).filter("uid", uid).get().delete()
case _ => false
}
非工作代码:
class ModelManager{
def getModel(model: String) = {
model match{
case "menu" => classOf[Menu]
case "articles" => classOf[Articles]
case _ => false
}
def deleteInstance(model:String, uid: Long) = {
Model.all(getModel(model)).filter("uid", uid).get().delete()
}
}
}
引发的错误是:
递归方法getModel需要结果类型
考虑一下:
map fromEnum $ zipWith (==) "aaaa" "abaa"
-- [1,0,1,1]
在这里只有一步是很好的:
zipWith (\x y -> fromEnum (x == y)) "aaaa" "abaa"
现在我可以消除y:
zipWith (\x -> fromEnum.(x ==)) "aaaa" "abaa"
但我没能消除x.当然有办法"欺骗"......
zipWith (curry (fromEnum . uncurry (==))) "aaaa" "abaa"
......但这看起来比原来的lambda更丑陋.
我寻找的功能有点类似Data.Function.on,但"相反".我觉得有一个令人尴尬的简单解决方案.我忽略了什么吗？
我想废弃一些样板文件。假设我有一个带有自定义注释的自定义界面：
interface MyInterface {
@DoSomething("crazy")
public String aMethod(int numberOfJumps);
}
现在我可以编写一个InvocationHandler, 并生成一个Proxy实现，该实现根据注释和方法参数执行或多或少有用的操作，并返回适当的结果。这很好用。
我的问题是我是否可以使用 Spring 的某种机制来获得相同的结果，但也许更安全、更快、更灵活和/或更可配置。Spring AOP 注释看起来很有前途，但它们似乎需要一个类，而不是一个接口。
[更新]
为了清楚地说明我想要什么，我当前代码的概要：
public interface TestInterface {
@MyAnnotation(name = "foo")
public void testMethod(String arg);
}
public class AnnotationProxy {
@SuppressWarnings("unchecked")
public static <T> T getImplementation(Class<T> annotatedInterface) {
return (T) Proxy.newProxyInstance(annotatedInterface.getClassLoader(),
new Class<?>[]{annotatedInterface},
new AnnotationHandler());
}
private static class AnnotationHandler implements InvocationHandler {
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("Args " + Arrays.toString(args));
System.out.println("Annotations" + Arrays.toString(method.getAnnotations())); …考虑
foldr (\x (a,b) -> (a || x==2, b || x==7 )) (False,False) [1..6]
--(True,False)
忽略这个可以轻松使用的事实elem,我有强烈的感觉,我可以使用Arrow语法来简化lambda,我只是无法正确使用它.
这个lambda可以用箭头简化吗？你是否有任何关于如何"看到"箭头可能工作的一般提示,以及如何找到正确的表达方式？
我有这样的代码:
Prelude> let n = [1,2,3,4]
Prelude> n
[1,2,3,4]
Prelude> 0:n
[0,1,2,3,4]
Prelude> let n = 0:n
当我在上面输入Haskell解释器后:
Prelude> n
我得到了无限的结果:
[0,0,0,0,0,0,0,0,0
打印"0"的地方是无限的.
为什么我会得到这样的结果？
是否有一些递归的东西,为什么/它如何在解释器级别工作？
我可以抓住堆栈溢出,GHCi上的这些东西是不是？
谢谢,
最诚挚的问候!
我正在将XML转换为基于Java的Spring 3配置,并且无法找到一种方法来"翻译"使用通配符作为资源路径的bean:
<bean id="messageSource" class="MyResourceBundleMessageSource">
<property name="resources" value="classpath*:messages/*.properties" />
</bean>
相应的类看起来像:
public class MyResourceBundleMessageSource
extends org.springframework.context.support.ResourceBundleMessageSource {
...
public void setResources(org.springframework.core.io.Resource... resources)
throws java.io.IOException { ... }
...
}
"手动"枚举所有文件是没有选择的,因为这是一个包含相当多文件的多模块项目,我也想避免更改bean类(因为它实际上位于公共库中).
假设我有2个列表:
val list1:List[CustomObject] = List(obj1, obj2, obj3)
val list2:List[CustomObject] = List(obj4, obj5, obj6)
我想知道在Scala中是否存在一种采用这两个列表的方法,并且比较obj.name第二个列表中是否存在第一个列表.
这可以使用2个内部循环和一个标志来完成.但是,我想知道Scala中是否可以做到这一点.