函数式编程中cps(continuation-passing style )是什么意思?
有没有不基于lisp、c++的例子,最好是python的,也有lamdba expression嘛。
回复内容:
CPS把函数调用完之后接下来要执行的代码通过闭包包裹并作为函数参数调用要执行的函数。
Continuation Passing Style Revisited Part Five: CPS and AsynchronyCPS变换本质上就是调用一个函数的时候,给它传入另一个函数(所以,语言必须得支持高阶函数和闭包才行),被调函数不把结果返回调用者,而是将结果返回给通过参数传进来的那个函数。
我不清楚这个概念在别的语言里有没有实现,或者叫不同的名字。
这里有个 scheme 的例子:call/cc 探秘从另一个角度回答下吧。
带 callcc 的 Lambda 演算(叫演算)可以经 Curry-Howard 同构到经典逻辑,而普通的
演算只能同构到直觉逻辑。但是形式逻辑中有一个 Gilvenko 定理,它声称:
对任何命题和前提
,在经典逻辑中
若且唯若在直觉逻辑中
![]()
在证明这个定理之后哥德尔(对,就是证明存在不确定命题的那个)和根岑(自然演绎和相继式演算的发明人)发明了双否定变换,也叫哥德尔-根岑变换,其规则是:
注意到哥德尔-根岑变换任意命题都和原命题经典等价,但并非直觉等价(直觉逻辑本身否认),但是按照 Gilvenko 定理,双否定命题
若在直觉逻辑体系中可证明为真,则在经典逻辑体系里
必为真,反之亦然。
那么按照 Curry-Howard 同构,演算下的类型指派
可以经过哥德尔-根岑变换得到一个
演算类型指派:
,将表达式(同构于证明过程)
变为
的过程就是 CPS 变换。直接照搬哥德尔-根岑变换里的类型的话,我们有如下结果:
原子
调用
抽象
call/cc 算子
可以证明,,即:CPS 变换不改变语义。
当然这个版本的 CPS 是非常冗长的,市面上见到的那些都是在变换是之后直接做了规约,删掉大堆 Redex 的。
上面这些再一次说明了,逻辑学和编程有多么紧密的联系。
来个简明补充。
这是个简单函数计算输出:
static int Times3(int x) { return x * 3; } Console.WriteLine(Times3(5));
(答案抄袭自http://www.cs.indiana.edu/cgi-pub/lkuper/c311/_media/cps-notes.scm)
定义下面四个函数(为了保持和原答案一致,其实两个就够了)
def f(var0): passdef g(var0, var1): return passdef h(var0): return passdef j(var0): return pass
其实就是把
Fuckee FindFuckee(){return kula;}void Fuck(Fuckee fuckee, int count){ for(int i=0;i<count;i++) fuckee.Fuck();}void Main(){Fuck(FindFuckee(), 100);}
可以补一补逻辑学....
@Belleve的回答太抽象了,没逻辑背景的人看不懂,
我在Quora上看到一个回答写得挺好的,里面从逻辑学的角度解释的一节或许可以作为 @Belleve答案的补充:
What is continuation-passing style in functional programming?
以上就是函数式编程中cps(continuation-passing style )是什么意思?的内容,更多相关内容请关注PHP中文网(www.php.cn)!

Outils d'IA chauds

Undresser.AI Undress
Application basée sur l'IA pour créer des photos de nu réalistes

AI Clothes Remover
Outil d'IA en ligne pour supprimer les vêtements des photos.

Undress AI Tool
Images de déshabillage gratuites

Clothoff.io
Dissolvant de vêtements AI

Video Face Swap
Échangez les visages dans n'importe quelle vidéo sans effort grâce à notre outil d'échange de visage AI entièrement gratuit !

Article chaud

Outils chauds

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

SublimeText3 version Mac
Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Dans le monde contemporain de la programmation, la programmation fonctionnelle (FP) est progressivement devenue un paradigme de programmation populaire. Il met l'accent sur l'utilisation des fonctions comme éléments de base pour créer des programmes et considère le processus de calcul comme un transfert et une conversion continus entre les fonctions. Ces dernières années, le langage Go (également connu sous le nom de Golang) a progressivement été largement utilisé dans divers domaines en raison de sa simplicité, de son efficacité, de la sécurité de la concurrence et d'autres caractéristiques. Bien que le langage Go lui-même ne soit pas un langage de programmation purement fonctionnel, il offre des fonctionnalités suffisantes.

Il existe de nombreuses excellentes techniques de programmation dans le langage C++, parmi lesquelles la programmation fonctionnelle est une technologie très pratique. La programmation fonctionnelle met l'accent sur la réutilisabilité et la flexibilité des fonctions, ce qui peut rendre le code plus clair et maintenable. Dans cet article, nous présenterons les techniques de programmation fonctionnelle en C++. 1. Objet fonction Un objet fonction est un objet appelable, qui peut être considéré comme une fonction. Les objets fonction en C++ peuvent être des objets de classe ou des pointeurs de fonction. Les objets fonction peuvent être utilisés dans les algorithmes STL et peuvent également être utilisés comme paramètres d'autres fonctions. Voici un simple

Les expressions lambda C++ apportent des avantages à la programmation fonctionnelle, notamment : Simplicité : les fonctions en ligne anonymes améliorent la lisibilité du code. Réutilisation du code : les expressions Lambda peuvent être transmises ou stockées pour faciliter la réutilisation du code. Encapsulation : fournit un moyen d'encapsuler un morceau de code sans créer de fonction distincte. Cas pratique : filtrer les nombres impairs dans la liste. Calculer la somme des éléments d'une liste. Les expressions Lambda offrent la simplicité, la réutilisabilité et l'encapsulation de la programmation fonctionnelle.

L'évaluation paresseuse peut être implémentée dans Go en utilisant des structures de données paresseuses : en créant un type de wrapper qui encapsule la valeur réelle et ne l'évalue qu'en cas de besoin. Optimisez le calcul des séquences de Fibonacci dans les programmes fonctionnels, en différant le calcul des valeurs intermédiaires jusqu'à ce que cela soit réellement nécessaire. Cela peut éliminer les frais généraux inutiles et améliorer les performances des programmes fonctionnels.

Il existe cinq erreurs et pièges courants dont il faut être conscient lors de l'utilisation de la programmation fonctionnelle dans Go : Évitez toute modification accidentelle des références et assurez-vous que les variables nouvellement créées sont renvoyées. Pour résoudre les problèmes de concurrence, utilisez des mécanismes de synchronisation ou évitez de capturer un état mutable externe. Utilisez la fonctionnalisation partielle avec parcimonie pour améliorer la lisibilité et la maintenabilité du code. Gérez toujours les erreurs dans les fonctions pour garantir la robustesse de votre application. Tenez compte de l'impact sur les performances et optimisez votre code à l'aide de fonctions en ligne, de structures de données aplaties et de lots d'opérations.

Les expressions pythonLambda sont un outil puissant et flexible pour créer du code concis, lisible et facile à utiliser. Ils sont parfaits pour créer rapidement des fonctions anonymes qui peuvent être transmises comme arguments à d'autres fonctions ou stockées dans des variables. La syntaxe de base d'une expression Lambda est la suivante : lambdaarguments:expression Par exemple, l'expression Lambda suivante ajoute deux nombres : lambdax,y:x+y Cette expression Lambda peut être transmise à une autre fonction en tant qu'argument comme suit : defsum( x ,y):returnx+yresult=sum(lambdax,y:x+y,1,2)Dans cet exemple

Avec l’application généralisée du C++ dans le domaine informatique et l’exploration continue des paradigmes de programmation, la programmation fonctionnelle est également devenue un sujet de grande préoccupation. En C++, la programmation fonctionnelle comporte de nombreux concepts et syntaxes spéciaux, de sorte que des questions connexes sont souvent impliquées dans les entretiens. Cet article résume et répond aux questions d'entretien courantes sur la programmation fonctionnelle en C++. 1. Avantages et inconvénients de la programmation fonctionnelle L'intervieweur peut vous poser des questions sur votre compréhension des avantages et des inconvénients de la programmation fonctionnelle. La programmation fonctionnelle présente les avantages suivants : Grande lisibilité. La programmation fonctionnelle se concentre uniquement sur la sortie des fonctions

L'expression lambda en python est une autre forme syntaxique de fonction anonyme. C'est une petite fonction anonyme qui peut être définie n'importe où dans le programme. Une expression lambda se compose d'une liste de paramètres et d'une expression, qui peut être n'importe quelle expression Python valide. La syntaxe d'une expression Lambda est la suivante : lambdaargument_list:expression Par exemple, l'expression Lambda suivante renvoie la somme de deux nombres : lambdax,y:x+y. Cette expression Lambda peut être transmise à d'autres fonctions, telles que la carte. () fonction : nombres=[ 1,2,3,4,5]result=map(lambda
