{"id":2057,"date":"2020-07-19T15:52:45","date_gmt":"2020-07-19T10:22:45","guid":{"rendered":"https:\/\/www.rangakrish.com\/?p=2057"},"modified":"2020-07-19T15:52:45","modified_gmt":"2020-07-19T10:22:45","slug":"calling-lisp-functions-from-elixir","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2020\/07\/19\/calling-lisp-functions-from-elixir\/","title":{"rendered":"Calling Lisp Functions from Elixir"},"content":{"rendered":"

In the last article<\/strong><\/em><\/a>\u00a0I showed how we can simulate the idea of Lisp’s “closure”<\/strong><\/em> in Elixir<\/strong><\/em>. Today, I would like to demonstrate how we can call Lisp<\/strong><\/em> functions from Elixir<\/strong><\/em> using the NIF<\/strong><\/em> interface.<\/p>\n

What is the need to integrate Elixir<\/strong><\/em> with another language? I can think of two reasons:<\/p>\n

1) We have a library written in another language and we want to reuse that library in Elixir<\/strong><\/em> instead of re-writing the entire functionality in Elixir<\/strong><\/em>.\u00a0<\/span><\/span><\/p>\n

2) The other language has some nice features for solving a specific problem and so we want to solve that problem in that language and use that from Elixir<\/strong><\/em>. For instance, it is easy to implement knowledge-based expert systems using KnowledgeWorks<\/strong><\/em><\/a> module of LispWorks<\/strong><\/em>. So I might implement an expert system in LispWorks<\/strong><\/em> Lisp and drive it from Elixir<\/strong><\/em>. In the same vein, Prolog<\/strong><\/em> might be your choice if you wish to take advantage of the backtracking-based reasoning available in the language. In essence, the strategy is to choose a language that is most suitable for solving (possibly, a subset of) the given problem and use Elixir<\/strong><\/em> for what it is good at, say distributed fault-tolerant computing, etc.<\/span><\/p><\/blockquote>\n

Any drawbacks? Yes, of course. The following two points are to be carefully considered before implementing some functionality in NIF<\/strong><\/em>:<\/p>\n

1) Since NIF<\/strong><\/em> operates at the lowest level, it is quite easy to crash the entire VM<\/strong><\/em> if something goes wrong! Rigorous testing is required before the code is made available for use.<\/span><\/p>\n

2) There is considerable overhead in calling a function implemented as NIF<\/strong><\/em> (you will see this later when you actually see the implementation). So there must be a justifiable reason to use NIF<\/strong><\/em> instead of a direct Elixir<\/strong><\/em> implementation.<\/span><\/p><\/blockquote>\n

Having put forth the pros and cons of the approach, let us continue with our discussion on how to use NIF<\/strong><\/em>.<\/p>\n

The integration with the “foreign”<\/strong><\/em> language happens through NIF<\/strong><\/em> (Native Implemented Functions<\/strong><\/em>). So, if the “foreign”<\/strong><\/em> language supports “C”<\/strong><\/em> bindings, then it is possible to integrate it with Elixir<\/strong><\/em>.<\/p>\n

The official Erlang NIF<\/strong><\/em><\/a> tutorial is here.\u00a0 <\/span>And this<\/strong><\/em><\/a>\u00a0is another nice article on NIF<\/strong><\/em>.\u00a0<\/span><\/p>\n

Today’s focus is on learning how to call functions written in Lisp<\/strong><\/em> (specifically, LispWorks<\/strong> Lisp<\/strong><\/em> on Windows<\/strong><\/em> platform).<\/p>\n

The following diagram shows how the integration works.\u00a0<\/span><\/p>\n

\"Elixir-Lisp<\/a><\/p>\n

Step-1: Build the Lisp DLL<\/h3>\n

The functionality that we want to use from Lisp<\/strong><\/em> must be available as “exported”<\/strong><\/em> functions in a DLL.<\/p>\n

In an earlier article<\/strong><\/em><\/a>, I described the procedure to create a DLL of exported functions from LispWorks<\/strong> Lisp<\/strong><\/em>. You may find it useful to review that.<\/p>\n

Here is the Lisp<\/strong><\/em> code that exports two functions:<\/p>\n

1) Function that adds two integers<\/span><\/p>\n

2) Function that takes a string representing Lisp code and evaluates that code. For simplicity, I am assuming that the Lisp code returns an integer and not an arbitrary S-expression.<\/span><\/p><\/blockquote>\n

\"Lisp<\/a>
Lisp Functions<\/strong><\/figcaption><\/figure>\n

Step-2: Implement the NIF Layer in C Language<\/h3>\n

We need an intermediate NIF<\/strong><\/em> layer to marshall the parameters and return values between Elixir<\/strong><\/em> and Lisp<\/strong><\/em> code.<\/p>\n

The following is the first part of the NIF<\/strong><\/em> layer.<\/p>\n

\"C<\/a>
Glue Code in C<\/strong><\/figcaption><\/figure>\n

The function \u201clisp_init_nif\u201d<\/strong><\/em> initializes the Lisp<\/strong><\/em> environment from the DLL. The second function \u201clisp_quit_nif\u201d<\/strong><\/em> is used to ensure that the Lisp<\/strong><\/em> environment is shutdown properly when not required anymore. Later on, we will see how these are used in Elixir<\/strong><\/em>.<\/p>\n

The two main functions are shown below:<\/p>\n

\"C<\/a>
C Code (Contd.)<\/strong><\/figcaption><\/figure>\n

As you can guess, the two functions “lisp_add_nif”<\/strong><\/em> and “lisp_eval_nif”<\/strong><\/em> provide the required mapping between Elixir<\/strong><\/em> and the corresponding Lisp<\/strong><\/em> function parameters as well as the return values.<\/p>\n

The array \u201cnif_funcs\u201d<\/strong><\/em> defined at the end sets up the mapping between all the Elixir<\/strong><\/em> and NIF<\/strong><\/em> functions.<\/p>\n

Now that the functions are defined, we have to create a DLL. Here is how we use the Visual Studio<\/strong><\/em> command line tool to generate the DLL:<\/p>\n

cl\u00a0 <\/span>-I\u00a0 <\/span>“G:\\Program Files\\erl10.3\\usr\\include”\u00a0 <\/span>-LD -MD -Fe: lisp_nif.dll lisp_nif.c<\/span>\u00a0<\/span><\/p><\/blockquote>\n

Remember that this must be run from the Developer command prompt<\/strong><\/em>.<\/p>\n

Step-3: Load the Native Functions in Elixir<\/h3>\n

The final step is to define the appropriate Module<\/strong><\/em> in Elixir<\/strong><\/em> and load the NIF<\/strong><\/em>. The hook \u201c@load\u201d<\/strong><\/em> helps here. Here is the code for our example:<\/p>\n

\"Elixir<\/a>
Elixir Loader<\/strong><\/figcaption><\/figure>\n

A brief explanation may be useful here. Our Lisp<\/strong><\/em> function \u201ceval\u201d<\/strong><\/em> takes a string of S-expressions<\/strong><\/em> and returns an integer<\/strong><\/em>. The correct way to call this from Elixir<\/strong><\/em> is to pass a character list, for example, \u2018(+ 10 20)\u2019<\/strong><\/em>. But someone might pass a double-quoted string literal instead. To handle this correctly, I have defined the function \u201cexec\u201d<\/strong><\/em> with two argument types. One takes a double-quoted string and converts it into a character list before passing it to \u201ceval\u201d<\/strong><\/em>. The other passes the argument directly to \u201ceval\u201d<\/strong><\/em>.\u00a0This is just a convenience.<\/span><\/p>\n

Here is a session in IEX<\/strong><\/em>:<\/p>\n

\"Using<\/a>
Using the Lisp Functions<\/strong><\/figcaption><\/figure>\n

First, we compile and load the NIF<\/strong><\/em>. The call \u201cLisp.init\u201d<\/strong><\/em> initializes the Lisp<\/strong><\/em> environment by properly loading the function entry points. \u201cLisp.exec\u201d<\/strong><\/em> and \u201cLisp.eval\u201d<\/strong><\/em> are then used to evaluate various Lisp<\/strong><\/em> expressions. Take note of the complex multi-line \u201cflet\u201d<\/strong><\/em> expression and how it is evaluated correctly.<\/p>\n

When we do not require the Lisp<\/strong><\/em> environment anymore, it is a good idea to call \u201cLisp.quit\u201d<\/strong><\/em>.<\/p>\n

The brief interactive session in IEX<\/strong><\/em> demonstrates that the integration between Elixir<\/strong><\/em> and Lisp<\/strong><\/em> works as expected. Hopefully, you understood the steps involved in the process.<\/p>\n

For the record, I used LispWorks 7.1.1<\/strong> 64-bit Enterprise Edition for Windows<\/strong><\/em> and Visual Studio 2019 Professional<\/strong> <\/em>(version 16.6.4) for today\u2019s experiment. Elixir<\/strong><\/em> version is 1.10.3 for Windows<\/strong><\/em>.<\/p>\n

Here<\/strong><\/em><\/a>\u00a0is the source code used in the example.\u00a0<\/span><\/p>\n

Have a great weekend!<\/p>\n","protected":false},"excerpt":{"rendered":"

In the last article\u00a0I showed how we can simulate the idea of Lisp’s “closure” in Elixir. Today, I would like to demonstrate how we can call Lisp functions from Elixir using the NIF interface. What is the need to integrate Elixir with another language? I can think of two reasons: 1) We have a library […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"advanced_seo_description":"","jetpack_seo_html_title":"","jetpack_seo_noindex":false,"jetpack_post_was_ever_published":false,"_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2}},"categories":[242,18,17],"tags":[243,19,245],"class_list":["post-2057","post","type-post","status-publish","format-standard","hentry","category-elixir","category-lisp","category-programming","tag-elixir","tag-lisp","tag-nif"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-xb","jetpack-related-posts":[{"id":2071,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/08\/01\/elixir-wrapping-lisp-calls-in-a-macro\/","url_meta":{"origin":2057,"position":0},"title":"Elixir: Wrapping Lisp Calls in a Macro","author":"admin","date":"August 1, 2020","format":false,"excerpt":"In the last article, I showed how to make calls to Lisp functions from Elixir. We followed this pattern: 1) Initialize the Lisp environment by calling Lisp.init 2) Call Lisp functions as needed 3) Free the Lisp environment by calling Lisp.quit Using the powerful macro programming capabilities of Elixir, we\u2026","rel":"","context":"In "Elixir"","block_context":{"text":"Elixir","link":"https:\/\/www.rangakrish.com\/index.php\/category\/elixir\/"},"img":{"alt_text":"Sample Session","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/08\/Session.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/08\/Session.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/08\/Session.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/08\/Session.jpg?resize=700%2C400&ssl=1 2x"},"classes":[]},{"id":2042,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/07\/05\/closure-in-lisp-vs-elixir\/","url_meta":{"origin":2057,"position":1},"title":"Closure in Lisp vs Elixir","author":"admin","date":"July 5, 2020","format":false,"excerpt":"I started learning Elixir\u00a0a week ago. Although this has been at the top of my To-do list for quite a while, I couldn't take it up due to other commitments.\u00a0 I love Elixir. It is a great functional programming language. Having programmed in Lisp for a long time, I immediately\u2026","rel":"","context":"In "Elixir"","block_context":{"text":"Elixir","link":"https:\/\/www.rangakrish.com\/index.php\/category\/elixir\/"},"img":{"alt_text":"Program Output","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/elixir-output2.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/elixir-output2.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/elixir-output2.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/elixir-output2.jpg?resize=700%2C400&ssl=1 2x"},"classes":[]},{"id":2084,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/08\/16\/pattern-matching-comparing-elixir-and-mathematica\/","url_meta":{"origin":2057,"position":2},"title":"Pattern Matching: Comparing Elixir and Mathematica","author":"admin","date":"August 16, 2020","format":false,"excerpt":"One of the things I like about Elixir\u00a0is its support for patterns at the core language level, not through library functions as in most other languages. This contributes to writing cleaner code, in my opinion. \u00a0 Another environment that I am familiar with, namely Mathematica, boasts of (arguably) the most\u2026","rel":"","context":"In "Elixir"","block_context":{"text":"Elixir","link":"https:\/\/www.rangakrish.com\/index.php\/category\/elixir\/"},"img":{"alt_text":"Symbolic Expressions","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/08\/pattern-mm.png?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/08\/pattern-mm.png?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/08\/pattern-mm.png?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":2645,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/12\/25\/calling-lisp-functions-from-d-language\/","url_meta":{"origin":2057,"position":3},"title":"Calling Lisp Functions from D Language","author":"admin","date":"December 25, 2021","format":false,"excerpt":"After exploring \"newLisp\" in the past few posts, I would like to start looking at the \"D Programming Language\"\u00a0(DLang). DLang\u00a0has been around since 2001. It was originally created by Walter Bright and later Andrei Alexandrescu joined the team in 2007. The main inspiration for DLang was C++, although it uses\u2026","rel":"","context":"In "D Language"","block_context":{"text":"D Language","link":"https:\/\/www.rangakrish.com\/index.php\/category\/d-language\/"},"img":{"alt_text":"Lisp Function Called from D","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/12\/Lisp-300x107.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/12\/Lisp-300x107.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/12\/Lisp-300x107.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":3035,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/03\/05\/julia-defining-functions-dynamically\/","url_meta":{"origin":2057,"position":4},"title":"Julia: Defining Functions Dynamically","author":"admin","date":"March 5, 2023","format":false,"excerpt":"One of the widely discussed features of Julia is its support for metaprogramming. This feature makes it possible to generate and inspect the code at runtime. In essence, metaprogramming blurs the distinction between code and data. When used carefully, it can contribute to good code. Of course, Julia is not\u2026","rel":"","context":"In "Julia"","block_context":{"text":"Julia","link":"https:\/\/www.rangakrish.com\/index.php\/category\/julia\/"},"img":{"alt_text":"Defining A Function Dynamically","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/03\/Example1-300x195.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/03\/Example1-300x195.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/03\/Example1-300x195.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":963,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/06\/24\/calling-go-functions-from-lisp-part-2\/","url_meta":{"origin":2057,"position":5},"title":"Calling Go Functions from Lisp – Part 2","author":"admin","date":"June 24, 2018","format":false,"excerpt":"In my earlier article Calling Go Functions from Lisp, I explained the steps for making calls to Go functions from another language, specifically LispWorks Lisp. Today, I want to give a slightly more\u00a0 interesting example showing the use of Go channels\u00a0through exported functions. Go is widely admired for its native\u2026","rel":"","context":"In "Golang"","block_context":{"text":"Golang","link":"https:\/\/www.rangakrish.com\/index.php\/category\/golang\/"},"img":{"alt_text":"Go Functions","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/Go-Functions.png?resize=350%2C200","width":350,"height":200},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/2057","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/comments?post=2057"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/2057\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=2057"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=2057"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=2057"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}