例如,我有两个异步方法
(get-a 10 (lambda (a) (get-b a (lambda (b) (display b)))
但我想写一些类似的东西
(define (a (get-a 10)))
(define (b (get-b a)))
(display b)
scheme continuations functional-programming callcc continuation-passing
嘿伙计们,我正在尝试使用函数式编程(特别是使用F#),并且在构建尾递归函数时我遇到了问题.我很好地将基本递归(函数基本上每次调用一次调用自身)转换为尾递归,但我现在有一个稍微复杂的情况.
在我的例子中,该函数必须接受一个列表作为参数.调用该函数时,我必须从列表中删除第一个元素,然后使用列表的其余部分重复.然后我需要将我以某种方式删除的第一个元素应用于递归的结果.接下来,我删除第二个元素并执行相同的操作(注意:当我说"删除seond元素"时,即来自原始列表,因此在递归时传递的列表也包括第一个元素).我对列表的第三,第四等元素也这样做.
有没有办法将上述情况转换为尾递归函数？也许嵌套的尾递归函数??? 谢谢你的任何答案.
好的,这是我的基本代码.这个特定的一个是置换生成器(我不太关心置换部分,但是 - 这是我想关注的递归):
let permutationsOther str =
match str with
| value :: [] ->
[[value]]
| _ ->
let list = (List.map (fun a -> // This applies the remove part for every element a
let lst = (List.filter (fun b -> b <> a) str) // This part removes element a from the list
let permutedLst = permutations lst // recursive call
consToAll a permutedLst // constToAll this is my own function which performs …例如,假设我有一些不想要的联合集:
bigSet = bigSet.union(<listOfSets>)
我可以简单地折叠每一组,即:
bigSet = reduce(lambda x,y: x.union(y), listOfSets)
另一种方法是使用eval函数:
stringTuple = str(listOfSets)
stringTuple = stringTuple.strip("[")
stringTuple = stringTupl.strip("]")
bigSet = eval("bigSet.union(" + stringTuple + ")")
我问的原因是因为在python2.6中,将多个参数传递给union(而不是将其折叠到一个联合列表中)优化了union,这样最小的集合首先被联合起来.因为python中的集合通常是非常大的数据集的最佳数据结构(特别是当它们需要联合或交叉时),并且看起来很常见,你需要传递不确定数量的集合,所以应该做一个更优化的方法.如果没有,哪个更快:使用eval或折叠整套？
我是Haskell的新手.我试图在Haskell中编写代码,从列表中找到第一个重复元素,如果它没有重复元素,则给出消息没有重复.我知道我可以通过nub功能来做到这一点,但我试图在没有它的情况下做到这一点.
我试图创建一个函数,允许我向树添加一个新的值,如果给定路径的值等于ND(没有数据),这是我的第一次尝试.
它会检查值等,但问题是,我希望能够使用新数据打印修改后的树.谁能给我任何指针？我还试过制作第二个函数来检查路径,看它是否可以添加数据,但我只是输掉了如何打印出修改过的树？
目前,当我正在尝试功能语言的延续时,我的理解是继续记录当前程序计数器和寄存器文件,当返回延续时,PC和注册文件将恢复为它记录的值.
所以在Might博客文章中的以下愚蠢的例子中,
; right-now : -> moment
(define (right-now)
(call-with-current-continuation
(lambda (cc)
(cc cc))))
; go-when : moment -> ...
(define (go-when then)
(then then))
; An infinite loop:
(let ((the-beginning (right-now)))
(display "Hello, world!")
(newline)
(go-when the-beginning)) ; here the-beginning continuation passed to go-when, which ultimately will have an continuation applied to an continuation, that returns a continuation, which will cause the the program point resumed to the PC and registers states recorded in it.
我不确定我的理解是对的..如果你认为不是,请纠正我.....
这个功能有什么问题？这似乎是一个范围错误(虽然我认为我通过将每个callable放在列表中而不是直接使用它来修复它).错误是达到最大递归深度(调用comp(inv,dbl,inc)时)...
注意:问题是:为什么它甚至会递归,而不是它达到最大深度的原因......
def comp(*funcs):
if len(funcs) in (0,1):
raise ValueError('need at least two functions to compose')
# get most inner function
composed = []
print("appending func 1")
composed.append(funcs[-1])
# pop last and reverse
funcs = funcs[:-1][::-1]
i = 1
for func in funcs:
i += 1
print("appending func %s" % i)
composed.append(lambda *args, **kwargs: func(composed[-1](*args,**kwargs)))
return composed[-1]
def inc(x):
print("inc called with %s" % x)
return x+1
def dbl(x):
print("dbl called with %s" % x)
return x*2
def inv(x):
print("inv …python recursion functional-programming composition function-composition
可以请一些人解释原因
(some #(= 3 %) (range))
返回true但是
(some #(= 4/3 %) (range))
永远不回来？
嗨:我们正在将Java用于多线程应用程序.我们发现了Java I/O的瓶颈.功能编程,例如scala,有更好的I/O吞吐量吗？我们将拥有许多内核cpu,从这个意义上讲,业务逻辑可以非常快速地处理,但I/O将成为瓶颈.有什么好的解决方案吗？