b'\n_START_ARTICLE_\nThunk\n_START_PARAGRAPH_\nThunk es un t\xc3\xa9rmino usado en la jerga del desarrollo de software que designa la llamada o invocaci\xc3\xb3n a un c\xc3\xb3digo que pertenece a otra plataforma o a otro Framework. En el paso de 16 a 32 bit por ejemplo, los sistemas operativos (OS/2, Windows NT etc.) pod\xc3\xadan resolver c\xc3\xb3digo de 16 bit a trav\xc3\xa9s de la transformaci\xc3\xb3n de los par\xc3\xa1metros de llamadas y direcciones, de modo tal que fue posible seguir utilizando los programas de 16 bit.  _NEWLINE_En el desarrollo de software moderno, un thunk es la llamada del c\xc3\xb3digo nativo desde el c\xc3\xb3digo gestionado y viceversa (v\xc3\xa9ase por ejemplo Java Native Access o .NET P/Invoke). Es decir, se trata de una plataforma de transici\xc3\xb3n, en la que las convenciones y/o par\xc3\xa1metros de invocaci\xc3\xb3n tienen que transformarse correspondientemente (Marshalling). El lenguaje de programaci\xc3\xb3n C++/CLI del  .NET-Framework de Microsoft fue concebido especialmente para posibilitar tales thunks en ambas direcciones:\n_START_SECTION_\nInvocaci\xc3\xb3n por \xc2\xabgestionada\xc2\xbb a \xc2\xabno gestionada\xc2\xbb\n_START_PARAGRAPH_\nSea dada una clase nativa en C++, por ejemplo un proyecto C++ o como parte integrante de un proyecto C++/CLI, que se utilizar\xc3\xa1 m\xc3\xa1s abajo en c\xc3\xb3digo gestionado:_NEWLINE_ public class CNativeClass_NEWLINE_ {_NEWLINE_ private:_NEWLINE_   int m_i;_NEWLINE_ public:_NEWLINE_   void SetValue( int i )_NEWLINE_   {_NEWLINE_     m_i = i;_NEWLINE_   }_NEWLINE_ };_NEWLINE_La clase gestionada C++/CLI (que en esta forma puede ser directamente instanciada, por ejemplo, en C#), la cual utiliza la clase nativa mostrada anteriormente:_NEWLINE_ public ref class CManagedClass_NEWLINE_ {_NEWLINE_ public:_NEWLINE_   CManagedClass()_NEWLINE_   {_NEWLINE_     System::Int32 i = 42;_NEWLINE_     CNativeClass* pNativeClass = new CNativeClass();_NEWLINE_     pNativeClass->SetValue( i ); // Implementaci\xc3\xb3n del tipo de datos_NEWLINE_     delete pNativeClass;_NEWLINE_   }_NEWLINE_ };\n_START_SECTION_\nInvocaci\xc3\xb3n por \xc2\xabno gestionada\xc2\xbb a \xc2\xabgestionada\xc2\xbb\n_START_PARAGRAPH_\nLa clase gestionada C++/CLI\xc2\xa0:_NEWLINE_ public ref class CManagedClass_NEWLINE_ {_NEWLINE_ private:_NEWLINE_   System::Int32 m_i;_NEWLINE_ public:_NEWLINE_   void SetValue( int i )_NEWLINE_   {_NEWLINE_     m_i = i; // Implementaci\xc3\xb3n del tipo de datos_NEWLINE_   }_NEWLINE_ };_NEWLINE_Las clases nativas C++ en un proyecto C++/CLI. Aqu\xc3\xad se puede ver que tambi\xc3\xa9n el camino inverso es posible, es decir, instanciar el c\xc3\xb3digo  gestionado dentro de una clase no gestionada. La condici\xc3\xb3n es, sin embargo, que se trate de un proyecto C++/CLI, de modo tal que el compilador comprenda la correspondiente sintaxis. El thunk ya aparece en la instrucci\xc3\xb3n \xc2\xabgcnew\xc2\xbb, ya que aqu\xc3\xad se invoca al constructor de la clase gestionada:_NEWLINE_ public class CNativeClass_NEWLINE_ {_NEWLINE_ public:_NEWLINE_   void Foo()_NEWLINE_   {_NEWLINE_     int i = 42;_NEWLINE_     CManagedClass^ pManagedClass = gcnew CManagedClass();_NEWLINE_     pManagedClass->SetValue( i );_NEWLINE_   }_NEWLINE_ };\n_START_SECTION_\nLa programaci\xc3\xb3n funcional\n_START_PARAGRAPH_\nA pesar de que la industria estandarizada del software, ha estado dominada en gran medida por la programaci\xc3\xb3n funcional con referencias de evaluaci\xc3\xb3n,\xe2\x80\x8b el Thunk posee una amplia comunidad que lo usa para aplicaciones de investigaci\xc3\xb3n en programaci\xc3\xb3n funcional para crear lenguajes de programaci\xc3\xb3n. Esta investigaci\xc3\xb3n produjo una serie de lenguajes de programaci\xc3\xb3n con Evaluaciones perezosas en el que las variantes depend\xc3\xadan de estrategias de evaluaci\xc3\xb3n est\xc3\xa1ndar. Los compiladores de idiomas, como el caso del Glasgow Haskell Compiler, han dependido en gran medida de los procesadores sencillos, con la caracter\xc3\xadstica a\xc3\xb1adida de que los procesadores salvan su resultado inicial de modo que as\xc3\xad pueden evitar volver a calcularlo;\xe2\x80\x8b esto se conoce en ingl\xc3\xa9s como memoization.'