{"id":2815,"date":"2022-05-29T10:38:41","date_gmt":"2022-05-29T05:08:41","guid":{"rendered":"https:\/\/www.rangakrish.com\/?p=2815"},"modified":"2022-05-29T10:38:41","modified_gmt":"2022-05-29T05:08:41","slug":"setting-up-function-hooks-in-lisp","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2022\/05\/29\/setting-up-function-hooks-in-lisp\/","title":{"rendered":"Setting Up Function Hooks in Lisp"},"content":{"rendered":"

Lisp<\/strong><\/em> is known to be a highly dynamic language, where functions are first-class<\/strong><\/em>\u00a0objects. It is possible to define and undefine functions on the fly as well as attach hooks<\/strong><\/em> to existing functions. These are in addition to the ability to pass functions as parameters to other functions and returning a function as the result of a function call.<\/p>\n

This article will explore some of these ideas in detail.<\/p>\n

Getting the Function Object from Symbol<\/h4>\n

Let us start with a basic example:<\/p>\n

\"Function<\/a>
Function Example<\/strong><\/figcaption><\/figure>\n

Our “<\/strong>bar”<\/strong><\/em> function takes two arguments and returns their sum. With this definition in place, we can get a handle to the function in many ways:<\/p>\n

\"Getting<\/a>
Getting A Handle to the Function<\/strong><\/figcaption><\/figure>\n

As you can infer,\u00a0“#’bar”<\/strong><\/em> is actually a shortcut for the other two ways to get the function object.<\/p>\n

How can we confirm that all three mean the same thing?<\/p>\n

\"Confirming<\/a>
Checking the Type<\/strong><\/figcaption><\/figure>\n

And here is another check:<\/p>\n

\"Confirming<\/a>
Confirming Equivalence<\/strong><\/figcaption><\/figure>\n

What the above show is that given a symbol, it is possible to get the function definition associated with that symbol (provided the function is defined).<\/p>\n

Changing the Function Definition Dynamically<\/h4>\n

Lisp<\/strong><\/em> allows us to change any function definition at runtime. In our example, we can easily change the definition of “bar”<\/strong><\/em> shown earlier:<\/p>\n

\"Changing<\/a>
Changing Function Definition<\/strong><\/figcaption><\/figure>\n

It is that simple. Of course, the old definition is lost now.<\/p>\n

Defining “before” and “after” Hooks\u00a0<\/span><\/h4>\n

Changing the function definition at runtime is not common, although it is possible. However, many times, we might want to call a different function before and after the primary function is called. This can be useful in tracing the program flow, for example. How to do that?<\/p>\n

Here is a naive<\/strong><\/em>\u00a0implementation:<\/p>\n

\"Managing<\/a>
Managing Function Hooks<\/strong><\/figcaption><\/figure>\n

The set-function-hooks<\/strong>\u00a0<\/em>function uses a Hashtable<\/strong><\/em> to remember the original definition of the given a function and replace that definition with a function that applies the “before”<\/strong><\/em> and “after”<\/strong><\/em> functions appropriately while invoking the actual function. The remove-function-hooks<\/strong><\/em> function restores the original definition saved in the hashtable and removes the hashtable entry.<\/p>\n

Here is an interaction showing how this works:<\/p>\n

\"Function<\/a>
Function Hook Example<\/strong><\/figcaption><\/figure>\n

The reason why the given code is naive<\/strong><\/em>\u00a0is because it allows only a single set of “before”<\/strong><\/em> and “after”<\/strong><\/em> functions to be attached. One can easily extend the logic to handle the general case.<\/p>\n

Interestingly, Common Lisp<\/strong><\/em> already supports method combination<\/strong><\/em>, allowing us to attach “before<\/strong>“<\/strong><\/em>, “after”<\/strong><\/em> and “around”<\/strong><\/em> auxiliary methods to primary methods. You can go through my article on Aspect-Oriented Programming in Lisp<\/strong><\/em><\/a>\u00a0to see how this is done. Note that this is applicable only for methods<\/strong><\/em>\u00a0and not for regular functions.<\/p>\n

Defadvice Feature<\/h4>\n

LispWorks<\/strong><\/em><\/a> has a much richer way of attaching advice<\/strong><\/em>, i.e. executable code, to a function. It is possible to execute multiple auxiliary code “before”<\/strong><\/em>, “after”<\/strong><\/em>, or “around”<\/strong><\/em> a function. This permits arbitrary action(s) to be carried out in the context of a given function, method or macro.<\/p>\n

Here is an example session:<\/p>\n

\"Defadvice<\/a>
Defadvice Example<\/strong><\/figcaption><\/figure>\n

The primary “foo”<\/strong><\/em> function doubles the argument. The “around”<\/strong><\/em> advice calls the original function and then adds 100 to the returned result. That is why we get 300 as the result when we call (foo 100)<\/strong><\/em>.\u00a0<\/span><\/p>\n

How to “undefine” a Function?<\/h4>\n

Common Lisp allows us to unbind<\/strong><\/em>\u00a0(i.e. “undefine”<\/strong><\/em>) an existing function. Here is a sample session showing how this works:<\/p>\n

\"Undefining<\/a>
Undefining a Function<\/strong><\/figcaption><\/figure>\n

That concludes our discussion on function hooks in Lisp<\/strong><\/em>. How you found the article useful. The sample code is available here<\/strong><\/em><\/a>.<\/p>\n

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

Lisp is known to be a highly dynamic language, where functions are first-class\u00a0objects. It is possible to define and undefine functions on the fly as well as attach hooks to existing functions. These are in addition to the ability to pass functions as parameters to other functions and returning a function as the result of […]<\/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":[18,17],"tags":[324,323,19],"class_list":["post-2815","post","type-post","status-publish","format-standard","hentry","category-lisp","category-programming","tag-defadvice","tag-function-hooks","tag-lisp"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-Jp","jetpack-related-posts":[{"id":3017,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/02\/16\/calling-external-dll-functions-from-julia\/","url_meta":{"origin":2815,"position":0},"title":"Calling External DLL Functions from Julia","author":"admin","date":"February 16, 2023","format":false,"excerpt":"Julia supports calling external functions, especially those written in \u201cC\u201d language. As Julia documentation says, such calls do not involve any \u201cboilerplate\u201d code and hence are efficient. In today\u2019s article, I am going to show how to call functions defined in a DLL (Windows 64 bit). Instead of using direct\u2026","rel":"","context":"In "Julia"","block_context":{"text":"Julia","link":"https:\/\/www.rangakrish.com\/index.php\/category\/julia\/"},"img":{"alt_text":"The \"lispEval\" Function","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/02\/code-300x117.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/02\/code-300x117.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2023\/02\/code-300x117.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":2057,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/07\/19\/calling-lisp-functions-from-elixir\/","url_meta":{"origin":2815,"position":1},"title":"Calling Lisp Functions from Elixir","author":"admin","date":"July 19, 2020","format":false,"excerpt":"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:\u2026","rel":"","context":"In "Elixir"","block_context":{"text":"Elixir","link":"https:\/\/www.rangakrish.com\/index.php\/category\/elixir\/"},"img":{"alt_text":"Using the Lisp Functions","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=525%2C300&ssl=1 1.5x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2020\/07\/Session.jpg?resize=700%2C400&ssl=1 2x"},"classes":[]},{"id":944,"url":"https:\/\/www.rangakrish.com\/index.php\/2018\/06\/10\/calling-lisp-functions-from-go-language\/","url_meta":{"origin":2815,"position":2},"title":"Calling Lisp Functions from Go Language","author":"admin","date":"June 10, 2018","format":false,"excerpt":"In the previous post, we saw how to invoke a Go function from Lisp. In today's post, I would like to explain how to go in the other direction, namely, how to call Lisp functins from Go. There are two ways to do this. The first approach is to load\u2026","rel":"","context":"In "Golang"","block_context":{"text":"Golang","link":"https:\/\/www.rangakrish.com\/index.php\/category\/golang\/"},"img":{"alt_text":"Direct DLL Call","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/LispCall.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/LispCall.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2018\/06\/LispCall.png?resize=525%2C300 1.5x"},"classes":[]},{"id":1581,"url":"https:\/\/www.rangakrish.com\/index.php\/2019\/05\/19\/currying-in-mathematica\/","url_meta":{"origin":2815,"position":3},"title":"Currying in Mathematica","author":"admin","date":"May 19, 2019","format":false,"excerpt":"One of the more recent additions to the core Wolfram Language is the \u201cCurry\u201d function. It was introduced in Mathematica ver 11.3 and is still (as of ver 12.0) considered Experimental. In this post, I would like to go over this function briefly. Non-curried functions in Mathematica have to be\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"Lisp Currying Examples","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/05\/Lisp-Usage.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":2071,"url":"https:\/\/www.rangakrish.com\/index.php\/2020\/08\/01\/elixir-wrapping-lisp-calls-in-a-macro\/","url_meta":{"origin":2815,"position":4},"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":2645,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/12\/25\/calling-lisp-functions-from-d-language\/","url_meta":{"origin":2815,"position":5},"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":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/2815","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=2815"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/2815\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=2815"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=2815"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=2815"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}