{"id":476419,"date":"2023-08-09T07:29:55","date_gmt":"2023-08-09T07:29:55","guid":{"rendered":""},"modified":"2023-09-05T11:12:43","modified_gmt":"2023-09-05T11:12:43","slug":"continuation-passing-style-cps","status":"publish","type":"wiki","link":"https:\/\/oneproxy.pro\/it\/wiki\/continuation-passing-style-cps\/","title":{"rendered":"Stile di passaggio di continuazione (CPS)"},"content":{"rendered":"<p>Lo stile di passaggio di continuazione (CPS) \u00e8 un metodo per gestire il flusso di controllo nella programmazione del computer che prevede il passaggio esplicito del controllo attraverso un parametro di funzione.<\/p>\n<h2>L\u2019evoluzione dello stile di passaggio di continuazione (CPS)<\/h2>\n<p>Le origini dello stile a passaggio di continuazione possono essere ricondotte allo sviluppo dell&#039;informatica teorica e il concetto stesso di continuazione ha radici nel lambda calcolo. La prima menzione esplicita dello \u201cstile a passaggio di continuazione\u201d come frase e del suo utilizzo nella pratica fu introdotta dallo scienziato informatico Christopher Strachey negli anni &#039;60. Fu durante questo periodo che lui e i suoi colleghi esplorarono la semantica denotazionale, una struttura per definire i significati dei linguaggi di programmazione.<\/p>\n<h2>Stile di passaggio di continuazione (CPS)<\/h2>\n<p>Lo stile di passaggio di continuazione (CPS) \u00e8 una forma di organizzazione del programma che prevede l&#039;uso esplicito di continuazioni. Una continuazione \u00e8 una rappresentazione dello stato di un programma per computer in un determinato momento, incluso lo stack di chiamate e i valori delle variabili.<\/p>\n<p>In CPS, ogni funzione riceve un argomento aggiuntivo, tipicamente chiamato \u201ccont\u201d o \u201ck\u201d, che rappresenta la continuazione del programma, ovvero cosa dovrebbe accadere dopo che la funzione ha terminato il suo calcolo. Quando la funzione ha calcolato il suo risultato, \u201crestituisce\u201d questo risultato passandolo alla continuazione, invece di restituirlo nel solito modo.<\/p>\n<p>Il concetto pu\u00f2 essere visto come un modo per rendere esplicito il flusso di controllo: invece di passare implicitamente il controllo al chiamante quando termina, una funzione CPS passa il controllo chiamando la continuazione.<\/p>\n<h2>La struttura dello stile di passaggio di continuazione (CPS)<\/h2>\n<p>Nella convenzione tradizionale di chiamata delle funzioni, quando viene chiamata una funzione, viene eseguita e restituisce il controllo al chiamante con un valore restituito. Tuttavia, nello stile di passaggio di continuazione, il controllo viene passato esplicitamente tramite un parametro di funzione, spesso definito &quot;continuazione&quot;.<\/p>\n<p>La continuazione rappresenta il resto del calcolo. Cio\u00e8, quando una funzione riceve una continuazione, esegue alcune operazioni e poi passa il risultato alla continuazione ricevuta. Pertanto, nello stile a passaggio di continuazione, il ritorno non viene mai eseguito in modo implicito.<\/p>\n<p>Una tipica funzione CPS in uno pseudo linguaggio potrebbe assomigliare a:<\/p>\n<pre><div class=\"bg-black rounded-md mb-4\"><div class=\"flex items-center relative text-gray-200 bg-gray-800 px-4 py-2 text-xs font-sans justify-between rounded-t-md\"><span>css<\/span><button class=\"flex ml-auto gap-2\"><svg stroke=\"currentColor\" fill=\"none\" stroke-width=\"2\" viewbox=\"0 0 24 24\" stroke-linecap=\"round\" stroke-linejoin=\"round\" class=\"h-4 w-4\" height=\"1em\" width=\"1em\" ><path d=\"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2\"><\/path><rect x=\"8\" y=\"2\" width=\"8\" height=\"4\" rx=\"1\" ry=\"1\"><\/rect><\/svg>Copia il codice<\/button><\/div><div class=\"p-4 overflow-y-auto\"><code class=\"!whitespace-pre hljs language-css\" data-no-translation=\"\">function add(<span class=\"hljs-selector-tag\">a<\/span>, <span class=\"hljs-selector-tag\">b<\/span>, continuation) {\n    result = <span class=\"hljs-selector-tag\">a<\/span> + <span class=\"hljs-selector-tag\">b<\/span>;\n    continuation(result);\n}\n<\/code><\/div><\/div><\/pre>\n<p>Questa funzione &quot;aggiungi&quot; esegue un&#039;operazione di addizione e quindi passa il risultato alla continuazione.<\/p>\n<h2>Caratteristiche principali dello stile a passaggio di continuazione (CPS)<\/h2>\n<ol>\n<li>\n<p><strong>Flusso di controllo esplicito<\/strong>: In CPS, il flusso di controllo \u00e8 esplicito. Non esiste alcuna traccia dello stack nascosta e puoi vedere chiaramente l&#039;ordine di esecuzione nel codice.<\/p>\n<\/li>\n<li>\n<p><strong>Flessibilit\u00e0<\/strong>: Poich\u00e9 CPS disaccoppia il calcolo dal flusso di controllo, offre maggiore flessibilit\u00e0 per manipolare il flusso di controllo.<\/p>\n<\/li>\n<li>\n<p><strong>Operazioni non bloccanti<\/strong>: CPS \u00e8 molto utile nella gestione di operazioni non bloccanti o asincrone. Pu\u00f2 essere utilizzato per evitare l&#039;inferno delle richiamate e gestire scenari complessi di flussi di controllo in codice non bloccante.<\/p>\n<\/li>\n<li>\n<p><strong>Ottimizzazione delle chiamate in coda<\/strong>: I linguaggi che supportano l&#039;ottimizzazione delle chiamate in coda possono trarre vantaggio da CPS poich\u00e9 trasforma tutte le chiamate in chiamate in coda, il che pu\u00f2 essere pi\u00f9 efficiente in termini di utilizzo della memoria.<\/p>\n<\/li>\n<\/ol>\n<h2>Tipi di stile di passaggio di continuazione (CPS)<\/h2>\n<p>Esistono principalmente due tipi di continuazioni, <strong>stile diretto<\/strong> E <strong>stile di passaggio di continuazione<\/strong>. Di seguito \u00e8 riportato un confronto tra i due:<\/p>\n<table>\n<thead>\n<tr>\n<th>Stile<\/th>\n<th>Descrizione<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Stile diretto<\/td>\n<td>Nello stile diretto, una funzione completa la sua esecuzione e restituisce il controllo alla funzione chiamante. Il valore restituito \u00e8 spesso un risultato di calcolo.<\/td>\n<\/tr>\n<tr>\n<td>Stile di passaggio di continuazione<\/td>\n<td>In CPS, la funzione riceve un argomento aggiuntivo, la continuazione, e passa il risultato a questa continuazione. Il flusso di controllo \u00e8 esplicito.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Utilizzo, problemi e soluzioni<\/h2>\n<p>CPS trova il suo utilizzo soprattutto nei linguaggi di programmazione funzionale e nella gestione di operazioni asincrone.<\/p>\n<ol>\n<li>\n<p><strong>JavaScript asincrono<\/strong>: JavaScript, soprattutto in Node.js, utilizza CPS per gestire operazioni asincrone non bloccanti. I callback in JavaScript sono esempi di CPS.<\/p>\n<\/li>\n<li>\n<p><strong>Programmazione Funzionale<\/strong>: Linguaggi come Scheme e Haskell utilizzano CPS per gestire strutture di controllo come loop e gestione delle eccezioni.<\/p>\n<\/li>\n<\/ol>\n<p>Tuttavia, il CPS pu\u00f2 portare ad alcuni problemi:<\/p>\n<ul>\n<li><strong>Leggibilit\u00e0<\/strong>: CPS a volte pu\u00f2 portare a un codice difficile da leggere e comprendere a causa dell&#039;inferno dei callback, soprattutto se sono presenti molti callback annidati.<\/li>\n<li><strong>Efficienza<\/strong>: la trasformazione CPS pu\u00f2 potenzialmente aumentare la dimensione del codice a causa di parametri aggiuntivi e chiamate di funzioni.<\/li>\n<\/ul>\n<p>Le soluzioni a questi problemi sono:<\/p>\n<ul>\n<li>Utilizzo <strong>Promesse<\/strong> O <strong>asincrono\/attendo<\/strong> in JavaScript per evitare l&#039;inferno delle richiamate e migliorare la leggibilit\u00e0.<\/li>\n<li>L&#039;utilizzo di linguaggi di programmazione che supportano l&#039;ottimizzazione delle chiamate in coda pu\u00f2 mitigare i problemi di efficienza.<\/li>\n<\/ul>\n<h2>Confronti<\/h2>\n<p>Ecco un confronto di CPS con altri paradigmi di programmazione:<\/p>\n<table>\n<thead>\n<tr>\n<th>Paradigma di programmazione<\/th>\n<th>Flusso di controllo<\/th>\n<th>Caso d&#039;uso<\/th>\n<\/tr>\n<\/thead>\n<tbody>\n<tr>\n<td>Stile di passaggio di continuazione (CPS)<\/td>\n<td>Esplicito, con seguito.<\/td>\n<td>Operazioni non bloccanti\/asincrone, ottimizzazione delle chiamate in coda.<\/td>\n<\/tr>\n<tr>\n<td>Stile diretto<\/td>\n<td>Implicitamente, la funzione ritorna al chiamante.<\/td>\n<td>Operazioni sincrone\/bloccanti.<\/td>\n<\/tr>\n<tr>\n<td>Coroutine<\/td>\n<td>Multitasking cooperativo consentendo alle funzioni di sospendere e riprendere l&#039;esecuzione.<\/td>\n<td>Flusso di controllo complesso, multitasking cooperativo.<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<h2>Prospettive future<\/h2>\n<p>CPS continua a svolgere un ruolo essenziale nella strutturazione del codice asincrono, soprattutto in JavaScript. L&#039;introduzione di async\/await, che \u00e8 uno zucchero sintattico rispetto a Promises, pu\u00f2 essere vista come uno sviluppo rispetto al CPS tradizionale, fornendo una sintassi migliore ed evitando l&#039;inferno delle richiamate.<\/p>\n<p>Man mano che le applicazioni web e server diventano pi\u00f9 complesse e la concorrenza diventa pi\u00f9 importante, \u00e8 probabile che CPS e altri paradigmi di programmazione asincrona diventino ancora pi\u00f9 importanti. \u00c8 in corso una ricerca per migliorare i linguaggi di programmazione e i sistemi runtime per supportare meglio questi paradigmi.<\/p>\n<h2>Server proxy e CPS<\/h2>\n<p>I server proxy fungono da intermediario per le richieste dei client che cercano risorse da altri server. Quando si gestiscono richieste client simultanee, un server proxy potrebbe utilizzare CPS o paradigmi di programmazione asincroni simili per gestire queste richieste senza bloccarle, migliorando cos\u00ec la velocit\u00e0 effettiva e le prestazioni.<\/p>\n<h2>Link correlati<\/h2>\n<ol>\n<li><a href=\"https:\/\/en.wikipedia.org\/wiki\/Continuation-passing_style\" target=\"_new\" rel=\"noopener nofollow\">Stile di passaggio di continuazione su Wikipedia<\/a><\/li>\n<li><a href=\"https:\/\/www.cs.utah.edu\/plt\/publications\/icfp07-fyff.pdf\" target=\"_new\" rel=\"noopener nofollow\">L&#039;arte del continuatore<\/a><\/li>\n<li><a href=\"https:\/\/www.microsoft.com\/en-us\/research\/publication\/a-history-of-haskell-being-lazy-with-class\/\" target=\"_new\" rel=\"noopener nofollow\">Una storia di Haskell: essere pigri con la classe<\/a><\/li>\n<\/ol>","protected":false},"featured_media":468006,"menu_order":0,"template":"","meta":{"_acf_changed":false,"content-type":"","inline_featured_image":false,"footnotes":""},"class_list":["post-476419","wiki","type-wiki","status-publish","has-post-thumbnail","hentry"],"acf":{"faq_title":"Frequently Asked Questions about <mark>A Deep Dive into Continuation-passing Style (CPS)<\/mark>","faq_items":[{"question":"What is Continuation-passing Style (CPS)?","answer":"<p>Continuation-passing Style (CPS) is a method of managing control flow in computer programming. Instead of returning a value to the caller in the usual way, functions in CPS receive an extra argument (often termed as \"continuation\") representing what should happen after the function finishes its computation.<\/p>"},{"question":"When was Continuation-passing Style (CPS) first mentioned?","answer":"<p>The concept of Continuation-passing Style (CPS) was first introduced by computer scientist Christopher Strachey in the 1960s when exploring denotational semantics, a framework for defining the meanings of programming languages.<\/p>"},{"question":"How does a Continuation-passing Style (CPS) function work?","answer":"<p>In CPS, every function receives an extra argument, representing the continuation of the program. When the function has computed its result, it \"returns\" this result by passing it to the continuation, making control flow explicit.<\/p>"},{"question":"What are the key features of Continuation-passing Style (CPS)?","answer":"<p>The key features of CPS include explicit control flow, increased flexibility, improved handling of non-blocking or asynchronous operations, and enhanced tail call optimization.<\/p>"},{"question":"What types of Continuation-passing Style (CPS) exist?","answer":"<p>There are mainly two types of continuations: direct style and continuation-passing style. In direct style, a function completes its execution and returns control to the calling function. In continuation-passing style, the function passes the result to a received continuation, making the control flow explicit.<\/p>"},{"question":"What are the main uses and problems related to CPS?","answer":"<p>CPS is mostly used in functional programming languages and for managing asynchronous operations. It's useful in JavaScript, particularly in Node.js, and languages like Scheme and Haskell. However, it can lead to problems like reduced code readability (due to callback hell) and increased code size. These can be mitigated by using Promises or async\/await in JavaScript and tail-call optimization in other languages.<\/p>"},{"question":"What is the future perspective of Continuation-passing Style (CPS)?","answer":"<p>CPS continues to be essential in structuring asynchronous code, with developments like async\/await in JavaScript improving upon traditional CPS. As web and server applications become more complex and concurrent, CPS and other asynchronous programming paradigms are likely to become more important.<\/p>"},{"question":"How are proxy servers related to Continuation-passing Style (CPS)?","answer":"<p>Proxy servers, acting as intermediaries for requests from clients seeking resources from other servers, might use CPS or similar asynchronous programming paradigms to manage concurrent client requests without blocking, thereby improving throughput and performance.<\/p>"}]},"_links":{"self":[{"href":"https:\/\/oneproxy.pro\/it\/wp-json\/wp\/v2\/wiki\/476419","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/oneproxy.pro\/it\/wp-json\/wp\/v2\/wiki"}],"about":[{"href":"https:\/\/oneproxy.pro\/it\/wp-json\/wp\/v2\/types\/wiki"}],"version-history":[{"count":0,"href":"https:\/\/oneproxy.pro\/it\/wp-json\/wp\/v2\/wiki\/476419\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/oneproxy.pro\/it\/wp-json\/wp\/v2\/media\/468006"}],"wp:attachment":[{"href":"https:\/\/oneproxy.pro\/it\/wp-json\/wp\/v2\/media?parent=476419"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}