在使用函数式语言之后,我开始在Java中使用更多的递归 - 但是语言似乎有一个相对较浅的调用堆栈,大约1000.
有没有办法让调用堆栈更大？就像在Erlang中一样,我可以创建数百万次调用的函数吗？
当我做项目欧拉问题时,我越来越注意到这一点.
谢谢.
在观看Nick Partidge关于导出scalaz的演示之后,我开始看这个例子,这真是太棒了:
import scalaz._
import Scalaz._
def even(x: Int) : Validation[NonEmptyList[String], Int]
= if (x % 2 ==0) x.success else "not even: %d".format(x).wrapNel.fail
println( even(3) <|*|> even(5) ) //prints: Failure(NonEmptyList(not even: 3, not even: 5))
我试图了解<|*|>方法正在做什么,这里是源代码:
def <|*|>[B](b: M[B])(implicit t: Functor[M], a: Apply[M]): M[(A, B)]
= <**>(b, (_: A, _: B))
好的,这是相当令人困惑的(!) - 但它引用了<**>声明的方法:
def <**>[B, C](b: M[B], z: (A, B) => C)(implicit t: Functor[M], a: Apply[M]): M[C]
= a(t.fmap(value, z.curried), …我来自JavaScript,它具有一流的功能支持.例如,你可以:
有人能举例说明我将如何在Go中这样做吗？
仍然是Scala中的新手,我现在正在寻找一种方法来实现以下代码:
@Override
public void store(InputStream source, String destination, long size) {
ObjectMetadata metadata = new ObjectMetadata();
metadata.setContentLength(size);
final PutObjectRequest request = new PutObjectRequest(
this.configuration.getBucket(), destination, source, metadata);
new RetryableService(3) {
@Override
public void call() throws Exception {
getClient().putObject(request);
}
};
}
在Scala中实现RetryableService实现的相同功能的最佳方法是什么？
它基本上调用了N次调用方法,如果所有这些都失败,则会引发异常,如果它们成功则继续运行.这个没有返回任何东西但是我有另一个版本允许返回一个值(所以,我有两个Java类)我相信我可以用Scala中的单个类/函数.
有任何想法吗？
编辑
java中的当前实现如下:
public abstract class RetryableService {
private static final JobsLogger log = JobsLogger
.getLogger(RetryableService.class);
private int times;
public RetryableService() {
this(3);
}
public RetryableService(int times) {
this.times = times;
this.run();
}
private void …我一直在尝试学习函数式编程，但我仍然很难像函数式程序员一样思考。其中一个难题是如何实现强烈依赖于循环/执行顺序的索引密集型操作。
例如，考虑以下 Java 代码：
public class Main {
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(1,2,3,4,5,6,7,8,9);
System.out.println("Nums:\t"+ nums);
System.out.println("Prefix:\t"+prefixList(nums));
}
private static List<Integer> prefixList(List<Integer> nums){
List<Integer> prefix = new ArrayList<>(nums);
for(int i = 1; i < prefix.size(); ++i)
prefix.set(i, prefix.get(i) + prefix.get(i-1));
return prefix;
}
}
/*
System.out:
Nums: [1, 2, 3, 4, 5, 6, 7, 8, 9]
Prefix: [1, 3, 6, 10, 15, 21, 28, 36, 45]
*/
这里，在prefixList函数中，首先克隆 nums 列表，然后对其执行迭代操作，其中索引 i 上的值依赖于索引 i-1 （即需要执行顺序）。然后返回这个值。 …
Optionmonad是一种很好的表达方式来处理Scala中的某些东西或者什么都没有.但是如果在"无"发生时需要记录消息呢？根据Scala API文档,
Either类型通常用作scala.Option的替代,其中Left表示失败(按惯例),Right表示类似于Some.
但是,我没有运气找到使用Either的最佳实践或涉及处理失败的Either的良好实际示例.最后,我为自己的项目提出了以下代码:
def logs: Array[String] = {
def props: Option[Map[String, Any]] = configAdmin.map{ ca =>
val config = ca.getConfiguration(PID, null)
config.properties getOrElse immutable.Map.empty
}
def checkType(any: Any): Option[Array[String]] = any match {
case a: Array[String] => Some(a)
case _ => None
}
def lookup: Either[(Symbol, String), Array[String]] =
for {val properties <- props.toRight('warning -> "ConfigurationAdmin service not bound").right
val logsParam <- properties.get("logs").toRight('debug -> "'logs' not defined in the configuration").right
val array <- checkType(logsParam).toRight('warning -> "unknown type of …更具体地说,你如何建模功能程序,或者使用功能样式(没有类)使用图表而不是文本表示开发的功能程序,它是否可能,并且有人可以请我指向最近的应用程序(开源,啤酒中的免费,如果你愿意的话)
我目前正在享受从面向对象语言到功能语言的过渡.这是一股清新的空气,我发现自己比以前更富有成效.
但是 - 有一个方面的OOP我还没有在FP方面看到一个令人满意的答案,那就是多态性.即我有大量的数据项,当它们被传递到某些函数时需要以完全不同的方式处理.为了论证,让我们说有多种因素推动多态行为,因此潜在地指数多种不同的行为组合.
在OOP中,可以使用多态性相对较好地处理:通过组合+继承或基于原型的方法.
在FP中我有点卡在:
对于这种情况,推荐的功能方法是什么？还有其他好的选择吗？
language-agnostic oop polymorphism functional-programming prototype
有没有一种方法可以在Javascript中定义一个函数并立即调用它,以一种允许它重用的方式？
我知道你可以做一次性的匿名功能:
(function(i) {
var product = i * i;
console.log(product);
// Can't recurse here because there's no (ECMA standard) way for the
// function to refer to itself
}(2)); // logs 4
或者你可以命名一个函数然后调用它:
function powers(i) {
var product = i * i;
console.log(i * i);
if (product < 1e6) { powers(product) };
}
powers(2); // Logs 4, 16, 256...
但是,有一种更清晰的方法可以一次性定义和调用函数吗？有点像两个例子的混合？
不能做到这一点并不妨碍我做任何事情,但感觉它是一种很好的表达方式来编写需要运行的递归函数或函数,$(document).ready()但稍后当情况发生变化时等等.