我正在学习使用Racket的CPS,我已经设法编写了这些函数:
;lift a regular single-arg function into CPS
(define (lift/k f)
(lambda (x k)
(k (f x))))
;compose two CPS functions
(define (compose/k f g)
(lambda (x k)
(g x (lambda (y)
(f y k)))))
他们似乎工作正常
(define (is-two/k x k)
(k (= x 2)))
(define is-not-two/k (compose/k (lift/k not) is-two/k))
(is-not-two/k 3 display)
(is-not-two/k 2 display)
#t#f
我想知道这些功能是否仍然是"真正的CPS".我是否搞砸了"真正的"继续传递这些功能？在CPS中使用函数组合技术是犹太的吗？是鼓励吗？或者它会被视为"妥协"吗？是否有更多的CPS-y方式来做到这一点？
是的我知道我刚问了5个问题,但是他们背后的基本思想(我不确定我是否正确理解)是一样的.其他Lisps,Haskell,Erlang或其他函数式语言的解释都很好.
lisp haskell function-composition continuation-passing racket
如果类型foldr是
> :t foldr
forall a b. (a -> b -> b) -> b -> [a] -> b
和
> :t id
forall a. a -> a
然后我希望foldr (.) id有相同的类型foldr,而不是
> :t foldr (.) id
forall b. [b -> b] -> b -> b
看来我错了有关成分是如何工作的,因为我原本以为,对于一个功能f是f . id将给予f(id(x)) == f(x),保持的类型f.我foldr (.) id更容易误解的是如何更普遍地澄清其含义和构成？
我试图了解如何fmap fmap适用于 say 之类的函数(*3)。
的类型fmap fmap：
(fmap fmap):: (Functor f1, Functor f) => f (a -> b) -> f (f1 a -> f1 b)
类型(*3)：
(*3) :: Num a => a -> a
这意味着签名a -> a对应于f (a -> b)，对吗？
Prelude> :t (fmap fmap (*3))
(fmap fmap (*3)):: (Num (a -> b), Functor f) => (a -> b) -> f a -> f b
我尝试创建一个简单的测试：
test :: (Functor f) …在Haskell中,我可以通过调用以获得无限的顺序函数应用程序列表:
iterate :: (A -> A) -> A -> [A]
假设我有scala f(x: A): A.是否有一个函数会产生顺序函数应用程序流？喜欢iter(f: A => A, x: A): Stream[A]？
我试图通过使用 Lodash/FP 清理一些旧代码来了解更多关于在函数式编程中使用柯里化和组合的知识。但是，我反复遇到我有一个函数并且我想传递一个或多个函数的情况。然后我想将将用作参数的值传递给我传递给原始函数的函数。
我发现很难准确解释我想要做什么，所以我制作了一个 JS Fiddle，展示了我是如何尝试解决这个问题的：https : //jsfiddle.net/harimau777/rqkLf1rg/2/
const foo = a => `${a}${a}`
// Desired Behavior: const ans1 = (a, b) => `${foo(a)}${foo(b)}`
const ans1 = _.compose(
(a, b) => `${a}${b}`,
foo,
foo
)
// Desired Result: '1122'
console.log(ans1('1', '2'))
// Desired Behavior: const ans2 = a => a.map(a => a + 1)
const ans2 = _.compose(
_.map,
a => a + 1
)
//Desired Result: [2, 3, 4]
console.log(ans2([1, 2, 3]))
根据下面 Ori Drori 的回答，我认为我可以澄清我的问题（这是人们通常如何跟进 StackOverflow 而不是提出新问题？）：假设不是将相同的函数序列应用于我想要的两个输入将一系列函数应用于第一个输入，将不同的序列应用于第二个输入，并将两个结果用作 …
这是我想要了解的一段代码:
const seq2 = (f1, f2) => {
return (...args) => {
return f2( f1( ...args) );
}
}
const seq = ( f1, ...fRest) =>
fRest.reduce( seq2, f1 );
const elevator = {
floor: 5
};
const up = elevator => {
return {
floor: elevator.floor + 1
}
};
const down = elevator => {
return {
floor: elevator.floor - 1
}
};
const move = seq( up, up, down, up);
const newElevator = move( elevator );
console.log( …javascript functional-programming chaining function-composition
我碰到了的用法。我不太了解的运算子。
我本人试图对此进行推理，但得出的结论与GHCI产生的结论不同。
我正在:t检查表达式的类型。
我正在使用的函数是last和(.)，它们具有以下签名：
last :: [a] -> a
(.) :: (b -> c) -> (a -> b) -> a -> c
我感到困惑的功能是这样的：
(last .)
我不确定这个构造是什么，但是我认为它与函数组成类似。使用我的推理，我希望这会产生以下功能：
(last .) :: (b -> [c]) -> (a -> b) -> a -> [c]
什么:t实际上给了我是这样的：
(last .) :: (a -> [c]) -> a -> c
我正在学习Haskell。目前，我正在研究功能组合。我了解（至少在基本层面上）如何使用函数(.)，但是有两点我不了解。
因此该函数如下所示：
(.) :: (b -> c) -> (a -> b) -> a -> c
f . g = \x -> f (g x)
首先，类型声明。(b -> c) -> (a -> b)本质上是指函数f从函数的结果value（b）g（取value a）中取参数并返回type的value c。我不明白下面的部分-> a -> c，为什么要在-> a那里？为什么(b -> c) -> (a -> b) -> c错了？从我的观点（显然是错误的）来看，函数g已经a作为参数了。
第二，主体的功能f . g = \x -> f (g x)。\x -> …
我有这个功能:
min (max 10 20) (max 30 40)
我可以改写为:
min (max 10 20) $ max 30 40
但是还有办法解决这些最后的括号吗？
不像这不够好,但我不能放下思想,必须有一些方法来做到这一点......
我正在学习scala，想了解如何Futures针对咖喱函数实现
import scala.concurrent.{Await, Future}
import scala.concurrent.duration.Duration
import scala.concurrent.ExecutionContext.Implicits.global
object MainApp {
def main(args: Array[String]): Unit = {
val x = curriedMultiply(10) _ andThen Await.result(curriedAdd(10),Duration.Inf)
println(x(2))
}
def curriedAdd(x: Int)(y: Int) : Future[Int]= Future {
x + y
}
def curriedMultiply(x: Int)(y: Int) : Future[Int] = Future {
x * y
}
}
获取值时出现以下编译器错误
Type mismatch, expected: Awaitable[NotInferedT], actual: Int => Future[Int]