多种解释性编程语言间的第一类对象共享.pdf

本发明提供了一种系统和方法，其使得用户能够以第一脚本语言编写脚本代码，然后使用第二脚本语言调用以第一脚本语言编写的语言构造。函数，类定义，类实例，模块和其他语言构造被作为能够在不同脚本语言之间共享的第一类对象。本发明的技术也适用于领域特定语言。作为本方法的一部分，这些对象类型的每个的相应底层表示被设计为接口，然后该接口在每种脚本语言中实施。另外，以每种脚本语言实施编写的代码允许后来者使用表示函数、类或其他语言构造的该接口。

权利要求书一种在不同脚本语言之间共享语言构造的方法，所述方法包括：
（a）定义相对多种脚本语言是语言中性的核心应用程序编程接口，所述核心应用程序编程接口包括多种类型语言构造中每种的相应核心接口；
（b）调用以第一脚本语言编写的第一类型语言构造，所述调用由以第二脚本语言编写的所述第一类型语言构造做出；
（c）创建处理所述第一类型语言构造的第一核心接口的第一实例；
（d）重定向所述调用到所述第一核心接口的所述第一实例；以及
（e）重定向由所述第一核心接口的所述第一实例接收的所述调用到以所述第一脚本语言编写的所述第一类型的所述语言构造。
根据权利要求1所述的方法，其进一步包括：
创建第一语言适配器的实例；以及
创建第一核心适配器的实例，
其中，操作（d）由所述第一语言适配器的所述实例实施，以及操作（e）由所述第一核心适配器的所述实例实施。
根据权利要求2所述的方法，其进一步包括：
（f）创建以所述第一脚本语言编写的所述第一类型的所述语言构造的实例以响应所述调用；
（g）返回以所述第一脚本语言编写的所述第一类型的所述语言构造的所述实例的结果；
（h）创建所述第一核心接口的第二实例；
（i）重定向返回的结果到所述第一核心接口的所述第二实例；以及
（j）重定向由所述第一核心接口的所述第二实例接收的返回结果到以所述第二脚本语言编写的所述第一类型的所述语言构造。
根据权利要求3所述的方法，其进一步包括：
创建第二语言适配器的实例，以及
创建第二核心适配器的实例。
其中操作（i）由所述第二语言适配器的所述实例实施，以及操作（j）由所述第二核心适配器的所述实例实施。
根据权利要求1、2、3或4所述的方法，其中所述第一类型语言构造从下列类型集合中选择：原语，字符串，列表，词典，数组，多元组，阵列，函数，类定义，类实例，方法和模块。
根据权利要求1、2、3或4所述的方法，其中所述第一和第二脚本语言是基于Java的。
根据权利要求4、5或6所述的方法，其进一步包括：
（k）调用以第三脚本语言编写的第二类型的语言构造，该调用由以所述第二脚本语言编写的所述第二类型的语言构造做出；
（l）创建用于处理所述第二类型的语言构造的第二核心接口的第一实例；
（m）重定向所述调用到所述第二核心接口的所述第一实例；以及
（n）重定向由所述第二核心接口的所述第一实例接收的调用到以所述第三脚本语言编写所述第二类型的所述语言构造。
根据权利要求4、5、6或7所述的方法，其进一步包括：
创建第三语言适配器的实例；以及
创建第三核心适配器的实例，
其中，操作（m）由所述第三语言适配器的所述实例实施；以及操作（n）由所述第三核心适配器的所述实例实施。
根据权利要求4、5、6、7或8所述的方法，其进一步包括：
（o）创建以所述第三脚本语言编写的所述第二类型的所述语言构造的实例以响应所述调用；
（p）返回以所述第三脚本语言编写的所述第二类型的所述语言构造所述实例的结果；
（q）创建所述第二核心接口的第二实例；
（r）重定向返回的结果到所述第二核心接口的所述第二实例；以及
（s）重定向由所述第二核心接口的所述第二实例接收的返回结果到以所述第二脚本语言编写的所述第二类型的所述语言构造。
根据权利要求9所述的方法，其进一步包括：
创建第四语言适配器的实例；以及
创建第四核心适配器的实例，
其中，操作（r）由所述第四语言适配器的所述实例实施；以及操作（s）由所述第四核心适配器的所述实例实施。
一种使语言构造能够在不同脚本语言之间共享的系统，所述系统包括相对多种脚本语言是语言中性的核心应用程序编程接口和处理器，所述核心应用程序编程接口包括多种类型语言构造中每种的相应核心接口，所述处理器被编程为执行下列操作：
（a）调用以第一脚本语言编写的第一类型语言构造，所述调用由以第二脚本语言编写的所述第一类型语言构造做出；
（b）创建处理所述第一类型语言构造的第一核心接口的第一实例；
（c）重定向所述调用到所述第一核心接口的所述第一实例；以及
（d）重定向由所述第一核心接口的所述第一实例接收的所述调用到以所述第一脚本语言编写的所述第一类型的所述语言构造。
根据权利要求11所述的系统，其中所述处理器进一步被编程为执行下列操作：
创建第一语言适配器的实例；以及
创建第一核心适配器的实例，
其中，操作（c）由所述第一语言适配器的所述实例实施，以及操作（d）由所述第一核心适配器的所述实例实施。
根据权利要求12所述的系统，其中所述处理器进一步被编程为执行下列操作：
（e）创建以所述第一脚本语言编写的所述第一类型的所述语言构造的实例以响应所述调用；
（f）返回以所述第一脚本语言编写的所述第一类型所述语言构造所述实例的结果；
（g）创建所述第一核心接口的第二实例；
（h）重定向返回的结果到所述第一核心接口的所述第二实例；以及
（j）重定向由所述第一核心接口的所述第二实例接收的返回结果到以所述第二脚本语言编写的所述第一类型的所述语言构造。
根据权利要求13所述的系统，其中所述处理器进一步被编程为执行下列操作：
创建第二语言适配器的实例，以及
创建第二核心适配器的实例。
其中操作（h）由所述第二语言适配器的所述实例实施，以及操作（i）由所述第二核心适配器的所述实例实施。
根据权利要求14所述的系统，其中所述处理器进一步被编程为执行下列操作：
（j）调用以第三脚本语言编写的第二类型的语言构造，该调用由以所述第二脚本语言编写的所述第二类型的语言构造做出；
（k）创建用于处理所述第二类型的语言构造的第二核心接口的第一实例；
（l）重定向所述调用到所述第二核心接口的所述第一实例；以及
（m）重定向由所述第二核心接口的所述第一实例接收的调用到以所述第三脚本语言编写所述第二类型的所述语言构造。

说明书多种解释性编程语言间的第一类对象共享
技术领域
本发明主要涉及接口，其允许一种解释性编程语言（interpretedlanguage）的语言构造中使用以不同解释性编程语言编写的语言构造。尤其是，本公开涉及允许高级别脚本用户整合以不同脚本语言编写的低级别脚本的接口。
背景技术
编译语言不能交互使用。标准使用案例是编写代码，编译代码，然后运行代码。这对于正编写应用程序的软件开发人员来说是很好的范例，但是这对于需要探究和解决问题的工程师或数学家来说不是那么有用。
解释性语言能够交互使用。工程师可以在他/她打印代码并且代码被解释以及当底层应用程序在运行时，然后执行该代码的地方具有“提示符”。解释性语言的例子包括Python、Ruby等。
脚本语言添加到应用程序中以允许用户从命令提示符或文本文件驱动应用程序。解释性语言能够用作脚本语言，并且在下文中，本公开将将用于脚本的解释性语言称为“脚本语言”。
Python是一种解释性语言。其具有几个实施，包括CPython和Jython。CPython以C语言编写并且通常称作Python。Jython以Java编写。
Java是在虚拟机器上运行的编译语言。在Java虚拟机器之上建立了几种脚本语言。这些通常称为J基脚本语言。（例子包括Jython，JRuby，Groovy和Rhino。）
众所周知，专用J基脚本语言是设计用于几何形状操纵和啮合（创建离散表示）的领域特定语言。而且，用于几何构造、分析和操控的以Java编写的应用程序是设计成脚本的。底层Java代码定义了很多几何操作。然后，工程师可以利用这些脚本使用具体几何操作解决他们的工程技术问题。这些脚本代表工程过程中的知识收集。存在重用这些脚本的强烈需要。存在能够利用这些事先存在的专有语言脚本驱动上述几何构造应用程序的需要。
考虑由几个较低级别工程过程组成的高级别工程过程。已经编写每个较低级别过程。工程师需要能够编写整合较低级别脚本的高级别脚本。既然这些脚本可能将以不止一种的脚本语言编写，需要一种方法轻松共享在不同脚本语言中创建的函数、类、实例和对象。
目前在现存的脚本环境中共享不同脚本语言之间的数据是可能的，但是做到这点，需要编程技巧以及底层Java语言的知识。应针对工程师设计这种问题的解决方案，而不是针对应用软件开发人员，因此在工程师部分，该解决方案不应该需要额外的编程/软件开发。
因此，存在允许不同工程师以不同脚本语言编程并且没有考虑底层语言实施问题，共享他们通过这些脚本语言编写代码的方法需求。优选地，该解决方案还将包括领域特定语言（DS语言）。
发明内容
公开了使用户能够以第一基于Java的脚本语言，例如Jython，JRuby和Matlab编写脚本代码，然后利用第二基于Java的脚本语言调用以第一脚本语言编写的语言构造或语言构造成分（languageconstruct）。语言构造包括，例如列表、数组、映射、函数、类定义、类实例和代码模块。例如，公开的方法使得工程师能够以一种脚本语言编写函数并且能以另一种脚本语言调用。在这里公开的技术对领域特定语言也是适用的。
根据下文中公开的实施例，函数、类定义、类实例、模块与其他语言构造作为通过不同脚本语言能够共享的第一类对象。在计算中，第一类对象是的实体，其能够以运行时间构造、像参数或自变量一样传递、从子程序返回或分配到变量中。作为本文公开方法的一部分，这些对象类型中每个的各个底层表示设计成Java接口，然后这些接口在每种脚本语言中实施。另外，代码在以每种脚本语言实施来编写，以允许后者使用Java接口表示函数、类或其他语言构造。
本文公开的方法允许不同脚本语言之间以对给出语言是自然的方式互动，以便当使用脚本语言的工程师编写他们的脚本时，他们不需要考虑或具有其他脚本语言的任何专业技能或知识。
更为具体地，本发明的一个方面是在不同脚本语言之间共享语言构造的方法，其包括：（a）定义核心应用程序编程接口，其相对多种脚本语言是语言中性的，该核心应用程序编程接口包括多种类型语言构造中每种的相应核心接口；（b）调用以第一脚本语言编写的语言构造类型，该调用由以第二脚本语言编写的语言构造类型构成；（c）创建处理语言构造类型的核心接口实例；（d）重定向调用到核心接口实例；以及（e）重定向由核心接口实例接收的调用到以第一脚本语言编写的语言构造类型。
本发明的另一个方面是使语言构造能够在不同脚本语言之间共享的系统，该系统包括相对多种脚本语言是语言中性的核心应用程序编程接口和编程以执行操作的处理器，该核心应用程序编程接口包括多种类型语言构造中每种的相应核心接口；所述处理器执行在前面段落中阐述的（b）到（e）作为对用户命令的响应。
本发明的进一步方面是对语言构造做出调用的方法，其中所述调用以第一脚本语言编写，而语言构造以第二脚本语言编写，所述方法包括：（a）定义相对第一和第二脚本语言是语言中性的核心应用程序编程接口，该核心应用程序编程接口包括多种类型语言构造中每种的相应核心接口；（b）创建第一和第二核心接口对象；（c）创建第一语言适配器对象，其重定向调用到第一核心接口对象；（d）创建以第二脚本语言编写的语言构造对象；（e）创建第一核心适配器对象，其重定向由第一核心接口对象接收的调用到语言构造对象；（f）创建第二语言适配器对象，其返回由语言构造对象产生的结果到第二核心接口对象；以及（g）创建第二核心适配器对象，其重定向由第二核心接口对象接收的返回结果到以第一脚本语言编写的语言构造对象。
本发明的另外一个方面是对语言构造做出调用的系统，其中所述调用以第一脚本语言编写而语言构造以第二脚本语言编写，该系统包括相对第一和第二脚本语言是语言中性的核心应用程序编程接口和编程以执行操作的处理器，该核心应用程序编程接口包括多种类型语言构造中每种的相应核心接口；所述处理器被编程为执行在前面段落中阐述的（b）到（g）作为对用户命令的响应。
本发明涉及在不同脚本语言之间共享语言构造的方法，所述方法包括：定义相对第一和第二脚本语言是语言中性的核心应用程序编程接口，所述核心应用程序编程接口包括多种类型语言构造中每种的相应核心接口；调用以第一脚本语言编写的第一类型语言构造，该调用由以第二脚本语言编写的所述第一类型语言构造做出；创建处理所述第一类型语言构造的第一核心接口第一实例；重定向调用到所述第一核心接口所述第一实例；以及重定向由所述第一核心接口所述第一实例接收的调用到以所述第一脚本语言编写的所述第一类型所述语言构造。该方法可以包括创建第一语言适配器的实例；以及创建第一核心适配器的实例，其中操作（d）由所述第一语言适配器所述实例实施，以及操作（e）由所述第一核心适配器所述实例实施。
该方法还包括，创建以所述第一脚本语言编写的所述第一类型所述语言构造的实例作为对调用的响应；返回以所述第一脚本语言编写的所述第一类型所述语言构造所述实例的结果；创建所述第一核心接口的第二实例；重定向返回结果到所述第一核心接口所述第二实例；以及重定向由所述第一核心接口所述第二实例接收的返回结果到以所述第二脚本语言编写的所述第一类型所述语言构造。该方法可以包括创建第二语言适配器的实例；以及创建第二核心适配器的实例，其中操作（i）由所述第二语言适配器的所述实例实施，以及操作（j）由所述第二核心适配器所述实例实施。
第一类型语言构造可以从下列类型集合中选择：原语，字符串，列表，词典，数组，多元组，阵列，函数，类定义，类实例，方法和模块。第一和第二脚本语言可以是J基的。该方法可以包括调用以第三脚本语言编写的第二类型语言构造，该调用由以所述第二脚本语言编写的所述第二类型语言构造做出；创建处理所述第二类型语言构造的第二核心接口第一实例；重定向调用到所述第二核心接口的所述第一实例；以及重定向由所述第二核心接口所述第一实例接收的调用到以所述第三脚本语言编写所述第二类型所述语言构造。
该方法可以包括创建第三语言适配器的实例；以及创建第三核心适配器的实例，其中操作（m）由所述第三语言适配器所述实例实施；以及操作（n）由所述第三核心适配器所述实例实施。另外，该方法可以进一步包括创建以所述第三脚本语言编写的所述第二类型所述语言构造的实例作为对调用的响应；返回以所述第三脚本语言编写所述第二类型所述语言构造所述实例的结果；创建所述第二核心接口的第二实例；重定向返回结果到所述第二核心接口的所述第二实例；以及重定向由所述第二核心接口所述第二实例接收的返回结果到以所述第二脚本语言编写的所述第二类型所述语言构造。其还可以涉及创建第四语言适配器的实例；以及创建第四核心适配器的实例，其中操作（r）由所述第四语言适配器所述实例实施，以及操作（s）由所述第四核心适配器所述实例实施。
可以使语言构造能够在不同脚本语言之间共享的系统，所述系统包括相对多种脚本语言是语言中性的核心应用程序编程接口和处理器，所述核心应用程序编程接口包括多种类型语言构造中每种的相应核心接口，所述处理器编程以执行下列操作作为对用户命令的响应：调用以第一脚本语言编写的第一类型语言构造，该调用由以第二脚本语言编写的所述第一类型语言构造做出；创建处理所述第一类型语言构造的第一核心接口第一实例；重定向调用到所述第一核心接口所述第一实例；以及重定向由所述第一核心接口所述第一实例接收的调用到以所述第一脚本语言编写的所述第一类型所述语言构造。该系统可以包括编程以执行下列操作的处理器：创建第一语言适配器的实例；以及创建第一核心适配器的实例，其中操作（c）由所述第一语言适配器所述实例实施，以及操作（d）由所述第一核心适配器所述实例实施。如权利要求12所述的系统，其中所述处理器进一步编程执行下列操作：创建以所述第一脚本语言编写的所述第一类型所述语言构造的实例作为对调用的响应；返回以所述第一脚本语言编写所述第一类型所述语言构造所述实例的结果；创建所述第一核心接口的第二实例；重定向返回的结果到所述第一核心接口所述第二实例；以及重定向由所述第一核心接口所述第二实例接收的返回结果到以所述第二脚本语言编写的所述第一类型所述语言构造。
该系统所述处理器进一步编程执行下列操作：创建第二语言适配器的实例；以及创建第二核心适配器的实例，其中操作（h）由所述第二语言适配器所述实例实施，以及操作（i）由所述第二核心适配器所述实例实施。该系统可以包括编程执行下列操作的处理器：调用以第三脚本语言编写的第二类型语言构造，该调用由以所述第二脚本语言编写的所述第二类型语言构造做出；创建处理所述第二类型语言构造的第二核心接口的第一实例；重定向调用到所述第二核心接口的所述第一实例；以及重定向由所述第二核心接口所述第一实例接收的调用到以所述第三脚本语言编写的所述第二类型所述语言构造。系统处理器可以编程执行下列操作：创建第三语言适配器的实例；以及创建第三核心适配器的实例，其中操作（l）由所述第三语言适配器所述实例实施，以及操作（m）由所述第三核心适配器所述实例实施。
该系统处理器可以进一步编程执行下列操作：创建以所述第三脚本语言编写的所述第二类型所述语言构造的实例作为对调用的响应；返回以所述第三脚本语言编写所述第二类型所述语言构造所述实例的结果；创建所述第二核心接口第二实例；重定向返回结果到所述第二核心接口所述第二实例；以及重定向由所述第二核心接口所述第二实例接收的返回结果到以所述第二脚本语言编写所述第二类型所述语言构造。该系统处理器还可以编程执行下列操作：创建第四语言适配器的实例；以及创建第四核心适配器的实例，其中操作（r）由所述第四语言适配器实施，以及操作（s）由所述第四核心适配器所述实例实施。
本发明涉及对语言构造做出调用的方法，其中调用以第一脚本语言编写而语言构造以第二脚本语言编写，所述方法包括：定义相对第一和第二脚本语言是语言中性的核心应用程序编程接口，所述核心应用程序编程接口包括多种类型语言构造中每种的相应核心接口；创建第一和第二核心接口对象；创建第一语言适配器对象，其重定向调用到所述第一核心接口对象；创建以第二脚本语言编写的语言构造对象；创建第一核心适配器对象，其重定向由所述第一核心接口对象接收的调用到所述语言构造对象；创建第二语言适配器对象，其返回到由所述语言构造对象产生的结果到所述第二核心接口对象；以及创建第二核心适配器对象，其重定向由所述第二核心接口对象接收的返回结果到以所述第一脚本语言编写的语言构造对象。
对语言构造做出调用的系统，该调用以第一脚本语言编写，而语言构造以第二脚本语言编写，所述系统包括核心应用程序编程接口，其相对所述第一和第二脚本语言是语言中性的，所述核心应用程序编程接口包括多种类型语言构造中每种的相应核心接口，以及处理器编程执行下列操作作为对用户命令的响应：创建第一和第二核心接口对象；创建第一语言适配器对象，其重定向调用到所述第一核心接口对象；创建以第二脚本语言编写的语言构造对象；创建第一核心适配器对象，其重定向由所述第一核心接口对象接收的调用到所述语言构造对象；创建第二语言适配器对象，其返回由所述语言构造对象产生的结果到所述第二核心接口对象；以及创建第二核心适配器对象，其重定向由所述第二核心接口对象接收的返回结果到以所述第一脚本语言编写的语言构造对象。
本发明的其他方面公开和权利要求如下。
附图说明
图1示出用于当Python用户通过CoreAPI（核心应用程序编程接口）的方式调用以领域特定语言（domain‑specific language，即DSL）编写的函数（名为DSLFunction）时的适配器模型示意图。
图2示出根据一个实施例的代表面向对象代码的示意图，面向对象代码便于在多种脚本语言之间的共享语言构造。
下文中将参考附图，其中不同附图中类似部件以相同参考标记表示。
具体实施方式
在随后的详细公开中，术语接口、类定义、类实例、应用程序编程接口和适配器具有下列含义：
接口：相关方法的集合（仅是方法的特征，不是实施）。
类定义：在一起实施的一组方法。类定义可以实施一个或更多接口。该实施常常定义由实施方法封装和操作的一些数据。
类实例：类定义可以多次实例化。类定义的每个实例称为类实例。
应用程序编程接口(API）：一组接口和具有与那些接口和那些类相关的一组行为的类定义。
适配器：一种设计模型，其允许已有API使用不是API一部分的已有类定义。这通常在当类定义与API中的一些接口或类名义上相同时执行。适配器是符合已有API的新类定义。已有类定义（其不在API中）称为被适配者。适配器包括被适配者和通过对被适配者的使用实施在已有API中的接口（或延伸在已有API中的类）。
为了理解下文公开的方法，当两个脚本以相同语言编写时，观察他们之间是如何相互作用的。首先考虑以Python语言编写的简单脚本，其定义对两个数值相加的函数并返回结果。然后，考虑使用第一脚本来执行添加操作的第二脚本。
这里是第一脚本的代码；其在称为pyExample.py的文件中编写：
‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑start example.py‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑
def add(a,b):
return a+b
‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑end example.py‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑
而这里是使用第一脚本的第二脚本代码：
‑‑‑‑‑‑‑‑‑‑‑‑‑‑start use Example.py‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑
from example import add
print‘3+4=‘,add(3,4)
‑‑‑‑‑‑‑‑‑‑‑‑‑‑end use Example.py‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑
这个脚本运行结果是打印出的：3+4=7
本公开采纳Python语法并在下文中将在其自有文件中编写的每个脚本称为“模块”。Python输入语句允许一个模块访问以另一个模块编写的函数。因此，在这种情况下，useExample.py模块输入example.py模块，并从那个模块中获得称为“add”的函数。然后通过将数值3和4相加而使用该函数。需要注意的是输入语句正搜寻在“example”中的“add”并执行，其在Python路径中的目录搜寻名为“example.py”文件（以及.pyo，.pyc等），运行“example.py”，这导致模块对象的生成，然后其在模块中查找名为“add”的东西。
给Jython语言引入额外的功能，即允许用户用以不同脚本语言编写的其他文件替换example.py文件是可取的。这里是以领域特定语言编写的文件例子：
‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑start example.DSL‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑
function add(a as double,b as double)
return a+b
end function
‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑end example.DSL‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑
目的是能够将example.DSL放在Python路径中以取代example.py，然后使模块useExample.py没有修改地工作。下文中公开的方法允许这种情况存在。
这是典型的大多数过程化语言之间的语言构造或语言构造成分（language construct）列表：
数据类型：
原语（包括整数，双精度，字符，短的，浮点，字节和语言特定构造）
字符串
列表
词典（有时候称为映射）
集合（通常以词典关键码实施，仅适用于一些语言）
多元组（固定列表，仅适用于一些语言）
阵列
语言类型：
函数
类定义
类实例
方法（即，类实例的方法）
模块
本文公开的方法使用户能够在不同语言之间共享这些构造类型中的每个。为了做到这点，首先定义相对多种脚本语言中的每种是语言中性的API（以Java编写）。该API包括用于每个数据类型和每种语言类型（即，用于每种语言构造类型）的一个接口。这些语言构造接口在本文中称为核心接口（Core接口），并且他们将被命名，使得单词“Core”在类型的开始处添加（例如，CorePrimitive,CoreString,CoreFunction,CoreClassDefinition等）。另外，组成Core的所有接口将从称为CoreObject的公共接口传承。

本文公开的方法是实施和利用核心（Core）接口的适配器模型的扩展使用。对于每种语言，需要为每种类型语言构造实施两个适配器。
考虑由计算机用户对涉及特定类型语言构造和特定脚本语言的Core做出调用的情形。计算机编程将在特定脚本语言应用程序编程接口（API）中具有可用的语言构造类型实施并且在Core API中具有该类型的接口。两个适配器中的第一个包装特定脚本语言的语言构造类型实施，以便第一适配器符合Core API并且利用语言实施。第二适配器做的相反并且包装那种语言构造类型Core接口，以便其符合该特定脚本语言API，但是利用Core接口的实例。
更为具体地，对于每种类型语言构造，可以采用已有语言类定义和相应已有Core接口，然后编写实施Core接口（下文中称为核心适配器（Core Adapter））和其他适配器的新类定义，允许用于那种语言构造类型的Core接口被用于该语言实施的API（下文中称为语言适配器（Language Adapter））。
例如，考虑Jython语言并考虑函数（Function）类型。Jython语言实施的API实施具有称为PyFunction的类定义。用户需要编写CoreAdapter，其实施CoreFunction接口并重定向对其做出的方法调用到PyFunction中的方法调用。用户还需要编写Language Adapter，其仿真Python Function并且重定向所有调用到被包装的CoreFunction。
图1示出用于Python用户调用以领域特定语言编写函数14（称为DSLFunction）时的适配器模型。Python解译程序（interpreter）确定应当做出调用。其在是Language Adapter的PyWrappedFunction 10中执行该调用，并且重定向该调用到在这种情况下是CoreFunctionFromDSL实施的CoreFunction接口12，这个CoreFunctionFromDSL实施12是重定向该调用到DSLFunction的CoreAdapter。DSLFunction是领域特定语言实施的一部分并且知道如何内部解析该方法。
例如，这里是文本文件中如何定义DSL函数：    ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑
function add(a as double,b as double)
return a+b
end function    ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑
DSL解译程序将解译该文本并创建DSL函数实例。DSL函数通常可以从像下面这样的DSL语言中调用：    ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑
c=add(1.0,2.0)    ‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑‑
DSL解译程序将通过查询名为“add”的已有DSL Function实例来解译上述文本。其导入DSL Function实例两个输入（1.0和2.0）。DSLFunction实例知道在内部如何“解析该函数”。其将执行“a+b”，在此例中是“1.0+2.0”并返回输出，3.0。
因此，当从Python调用这个相同函数时，该系统从Py对象转换到Core对象，然后从Core对象转换到DSL对象，然后调用“真正的”函数，其知道如何利用那些输入并执行用于定义该函数的代码。
将Python函数转换成Core函数的示例性Language Adapter可以采用下列形式：


将Core函数转换成Python函数的示例性Core Adapter具有下列形式：


为了实施每个适配器，用户需要基于另一个API的已有对象，能够创建用于一个API的适配器。为了支持该方法，每种脚本语言必须以两个方法实施AdapterFactory类。一个方法将用于Core API的对象转换到Language API并且另一个方法将Language API对象转换到Core API。工厂可以创建适配器的新实例或可以利用缓存，以便其能够再用适配器。需要注意Python函数包装到Core函数然后需要转换返回到Python语言API的情况。在这种情况下，不想创建适配器，但是取而代之的是应当检索底层Python函数并返回。
详细阐述图1所示的情形，DSL函数将DSL对象作为输入并且将DSL对象作为输出返回。Core函数将Core对象作为输入并将Core对象作为输出返回。Python函数将Python对象作为输入并将Python对象作为输出返回。
对于调用DSL函数的Python，我们需要适配Core函数的Python函数，其中Core函数适配DSL函数。因此，Python函数将Py对象作为输入。这些Py对象转换为Core对象，并且Core函数以那些Core对象输入调用。这个Core函数将Core对象作为输入并且将他们转换为DSL对象输入，并且调用“真正的”DSL函数。DSL对象作为结果被返回。适配DSL函数的Core函数将那个返回的DSL对象转换为Core对象并且返回Core对象。最终，Python函数获得返回的Core对象并将其转换为Python对象。
正如本文所使用的，“转换”意为AdapterFactory被调用，以便能够创建或检索正确的适配器。
应当理解，Core接口不局限于如图1所示的、将DSL对象转换为Python对象和将Python对象转换为DSL对象，而是能够扩展到包括便于以其他脚本语言编写对象共享的Core接口。图2示出能够扩展的便于以三种不同脚本语言：Jython、JRuby和领域特定语言编写的语言构造共享的类CoreObject示意图。
根据图2示出的方案，Core API（类CoreObject及其扩展）使得Jython用户能够访问以JRuby或DSL编写的语言构造；使得JRuby用户能够访问以Jython或DSL编写的语言构造；以及使得DSL用户能够访问以Jython或JRuby编写的语言构造。
例如，为了使Jython用户能够访问以DSL编写的语言构造，JythonLanguage Adaptor（Jython语言适配器）的第一实例（由Jython‑CoreAdaptorFactory（Jython核心适配器工厂）24创建或检索）将PyObject16的第一实例转换为CoreObject 18的第一实例；随后，DSL‑CoreAdaptor（由DSL‑Core AdaptorFactory（DSL核心适配器工厂）26创建或检索）的第一实例将CoreObject 18的第一实例转换为DSLObject20的第一实例。随后，DSL Language Adaptor（DSL语言适配器）的第一实例（由DSL‑Core AdaptorFactory 26创建或检索）将DSLObject20的第二实例转换为CoreObject 18的第二实例；其后，Jython‑CoreAdaptor的第一实例（由Jython‑Core AdaptorFactory 24创建或检索）将CoreObject 18的第二实例转换为PyObject 16的第二实例。
类似地，为了使JRuby用户能够访问以DSL编写的语言构造，JRuby Language Adaptor（JRuby语言适配器）的第一实例（由JRuby‑Core AdaptorFactory（JRuby核心适配器工厂）28创建或检索）将RubyObject 22的第一实例转换为CoreObject 18的第三实例；然后，DSL‑Core Adaptor(由DSL‑Core AdaptorFactory 26创建或检索）的第二实例将CoreObject 18的第三实例转换为DSLObject 20的第三实例。随后，DSL Language Adaptor的第二实例（由DSL‑Core AdaptorFactory26创建或检索）将DSLObject 20的第四实例转换为CoreObject 18的第四实例；并且然后，JRuby‑Core Adaptor的第一实例（由JRuby‑CoreAdaptorFactory 28创建或检索）将CoreObject 18的第四实例转换为RubyObject 22的第二实例。
以类似的方式，DSL用户能够导入由Jython或JRuby脚本语言编写的语言构造；JRuby用户能够导入以Jython脚本语言编写的语言构造；以及Jython用户能够利用Core API导入以JRuby脚本语言编写的语言构造。如上文所述，Core API包括每种语言构造的相应Core接口，其中Core接口从调用CoreObject的公共接口继承。
一些语言对大小写敏感而其他语言不是。因此，Dictionary andClass Instances的接口不由String做检查。相反，对单独的接口实施检查，定义称为CoreKey的关键码。该实施例包括对大小写敏感的CoreKey的实施而其他实施对大小写不敏感。
为了使上述系统可行，每种语言必须支持导入钩（import hook）的概念。术语导入钩来自Python群体并且是重定义当执行导入时被调用函数的机制。导入函数需要被强化，以便其能够处理以其他语言编写的模块。常用惯例是使用文件名的扩展名以确定应当用以解译该文件的语言。一旦文件被解译，应当产生文件内容的一些模块（Module）或词典（Dictionary）表示。然后使用该表示创建能够包装到模块内的CoreModuleAdaptor。
需要注意的是若目标语言不支持导入钩，那么，总体机制仍然将正确工作，但需要调用脚本的一些修改，以便做出导入脚本的函数调用而不是更多自然导入语句。
还需要注意的是一些语言高速缓存导入的模块以便他们不必再次解译（而且，类定义不必再定义）。当在一种语言出现导入时，实施例的实施器需要很小心地将被导入模块高速缓存到支持语言中的每种。
上述方法通过允许工程师轻松共享他们的分析代码而提供了成本节约。以不同语言编写的不同应用软件能够快速整合。还有一个成本节约是工程师能够以他们感觉舒服的语言编写代码。他们不需要花费时间培训新语言。这也避免了成本支出。通过更轻松共享代码，有重复使用代码的更好机会。
虽然已经通过参考不同实施例对本发明进行了描述，本领域的技术人员应当理解，在不偏离本发明范围的前提下，可以对其中的元素做出各种改变或以等价物替换。另外，在不偏离本发明基本范围的前提下，可以做出许多修改以适应本发明教导的特殊情形。因此，本发明不限于已经公开的、拟作为本发明最佳实现模式的特定实施例。
本文阐述的方法不应解释为要求本发明以列举的顺序执行操作。