{"id":3675,"date":"2025-04-24T15:00:33","date_gmt":"2025-04-24T09:30:33","guid":{"rendered":"https:\/\/www.rangakrish.com\/?p=3675"},"modified":"2025-04-24T15:00:33","modified_gmt":"2025-04-24T09:30:33","slug":"interfaces-without-inheritance-comparing-c-and-common-lisp","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2025\/04\/24\/interfaces-without-inheritance-comparing-c-and-common-lisp\/","title":{"rendered":"Interfaces Without Inheritance: Comparing C++ and Common Lisp"},"content":{"rendered":"

Clean interface design is a crucial aspect of software engineering since it enables code flexibility, reuse, and maintainability. Developers who prefer an object-oriented approach typically rely on inheritance to define the interface and thus establish type relationships. While this can lead to a good design if approached carefully, detractors of OOP point out that this can result in rigid hierarchies, and when multiple inheritance is used, it might lead to the infamous \u201cdiamond problem\u201d<\/strong><\/em>.<\/p>\n

Experienced C++ developers know that it is possible to define interface compatibility without necessarily resorting to inheritance. For example, \u201cConcepts\u201d<\/strong><\/em><\/a>\u00a0introduced in C++20<\/strong><\/em> offer an elegant, static, compile-time solution to this requirement. Common Lisp<\/strong><\/em>, being a dynamic language with support for advanced metaprogramming capabilities, allows us to model this use case differently. In this article, I would like to take a simple example, implement it using C++20 Concept<\/strong><\/em> and then show its corresponding (closest) Lisp<\/strong><\/em> implementation.<\/p>\n

Take the example of two shapes, a Rectangle<\/strong><\/em> and a Circle<\/strong><\/em>. The common OOP approach uses inheritance, perhaps starting with an abstract base class called \u201cShape\u201d<\/strong><\/em> and then publicly deriving Rectangle<\/strong><\/em> and Circle<\/strong><\/em> from it, and then overriding the appropriate methods. This typically involves dynamic binding.<\/p>\n

Another approach, which is our focus today, uses C++20 \u201cConcept\u201d<\/strong><\/em> to model these classes but without using inheritance.<\/p>\n

\"Rectangle<\/a>
Rectangle and Circle Defined<\/strong><\/figcaption><\/figure>\n

These classes are not derived from a common base class. Note also that I have defined the class \u201cLocality\u201d<\/strong><\/em> with the \u201carea()\u201d<\/strong><\/em> member function returning a \u201cstring\u201d<\/strong><\/em> instead of a numeric value.<\/p>\n

Let us now define our \u201cShape\u201d<\/strong> Concept<\/strong><\/em>:<\/p>\n

\"Shape<\/a>
Shape Concept<\/strong><\/figcaption><\/figure>\n

Thus \u201cShape\u201d<\/strong><\/em> is a generic predicate<\/strong><\/em> that checks if the given type has an \u201carea()\u201d<\/strong><\/em> member function taking no parameter and returning a numeric value (that can be converted to a double).\u00a0<\/span><\/p>\n

To show how this is used, I have defined a \u201cprintArea()\u201d<\/strong><\/em> function that takes argument conforming to a \u201cShape\u201d<\/strong><\/em> and then prints its area.<\/p>\n

Here is the \u201cmain()\u201d<\/strong><\/em> function:<\/p>\n

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

When the last two lines are commented out, here is the program output:<\/p>\n

\"Program<\/a>
Program Output<\/strong><\/figcaption><\/figure>\n

If the last two lines are uncommented, the compiler generates error messages as expected:<\/p>\n

\"Compiler<\/a>
Compiler Error Message<\/strong><\/figcaption><\/figure>\n

The reason is obvious. These functions take arguments that do not satisfy the \u201cShape\u201d<\/strong><\/em> constraint. Note carefully that even though \u201cLocality\u201d<\/strong><\/em> defines a member function called \u201carea()\u201d<\/strong><\/em>, it does not fully satisfy the constraint since it does not return a numeric value.<\/p>\n

Let us now look at the Lisp<\/strong><\/em> implementation. As I said earlier, Lisp<\/strong><\/em> is different from C++<\/strong><\/em> in that it is a dynamically typed language, so the checks are done at run time<\/strong><\/em>, not at compile time. We can issue directives to the compiler regarding types, optimization, safety, etc., but these are implementation dependent.<\/p>\n

Here are the \u201crectangle\u201d<\/strong><\/em> and \u201ccircle\u201d<\/strong><\/em> classes:<\/p>\n

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

Next we define methods for calculating \u201carea\u201d<\/strong><\/em> for different objects:<\/p>\n

\"Defining<\/a>
Defining Generic Methods<\/strong><\/figcaption><\/figure>\n

Note the default \u201carea\u201d<\/strong><\/em> method that returns zero. This method will normally be called when there is no other specific method that matches the call point.<\/p>\n

Below we define the nearest equivalent of our C++ \u201cConcept\u201d<\/strong><\/em> definition. The \u201cshape-p\u201d<\/strong><\/em> method returns True<\/strong><\/em> if and only if there is a matching<\/strong><\/em> \u201carea\u201d<\/strong><\/em> method for the object passed as argument.<\/p>\n

\"The<\/a>
The Shape Constraint in Lisp<\/strong><\/figcaption><\/figure>\n

Next we define \u201cprint-area\u201d<\/strong><\/em> function that prints the area of the given object. Note the \u201cdeclaim\u201d<\/strong><\/em> declaration before the method as a compiler directive<\/strong><\/em>. It states that the \u201cprint-area\u201d<\/strong><\/em> function takes a \u201cshape\u201d- <\/strong><\/em>conforming object and returns anything. Also note the call to \u201ccheck-type\u201d<\/strong><\/em> in the method to forcibly<\/strong><\/em> check the type compatibility.<\/p>\n

\"The<\/a>
The print-area Method<\/strong><\/figcaption><\/figure>\n

We then call \u201cprint-area\u201d<\/strong><\/em> on a \u201crectangle\u201d<\/strong><\/em> object as well as a \u201ccircle\u201d<\/strong><\/em> object and these work fine because there is a corresponding \u201carea\u201d<\/strong><\/em> method. However, the last commented expression is illegal and it will trigger a runtime error.<\/p>\n

Here is the actual output:<\/p>\n

\"Lisp<\/a>
Lisp Program Output<\/strong><\/figcaption><\/figure>\n

This example is an attempt to show that C++20 Concepts<\/strong><\/em> can be simulated in a dynamic language such as Lisp<\/strong><\/em>. It is not intended to compare languages otherwise.<\/p>\n

The C++<\/strong><\/em> program was tested in Visual Studio Professional (64 bit) ver 17.13.5<\/strong><\/em>. The Lisp<\/strong> program was tested in LispWorks Enterprise (64 bit) ver 8.0.1<\/strong><\/em> as well as in Allegro CL Enterprise Edition (64 bit) ver 11.0.<\/strong><\/em><\/p>\n

You can download the C++<\/strong><\/em><\/a>\u00a0code and Lisp<\/strong><\/em><\/a>\u00a0code.<\/p>\n

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

Clean interface design is a crucial aspect of software engineering since it enables code flexibility, reuse, and maintainability. Developers who prefer an object-oriented approach typically rely on inheritance to define the interface and thus establish type relationships. While this can lead to a good design if approached carefully, detractors of OOP point out that this […]<\/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_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},"jetpack_post_was_ever_published":false},"categories":[49,18],"tags":[293,420,110],"class_list":["post-3675","post","type-post","status-publish","format-standard","hentry","category-c","category-lisp","tag-c-20","tag-c20-concept","tag-common-lisp"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-Xh","jetpack-related-posts":[{"id":4012,"url":"https:\/\/www.rangakrish.com\/index.php\/2026\/01\/01\/common-lisp-metaobject-protocol-classes-are-just-objects\/","url_meta":{"origin":3675,"position":0},"title":"Common Lisp Metaobject Protocol: Classes are Just Objects!","author":"admin","date":"January 1, 2026","format":false,"excerpt":"In today\u2019s popular languages such as C++, Java, Golang, Rust, Python, etc., classes are fixed constructs defined by the language. They have a definite syntax that can\u2019t be changed while programming. We are all used to this of course. But what makes Common Lisp stand out is that in that\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"A Simple Class","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2026\/01\/code1-300x42.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":2351,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/03\/14\/calling-c-methods-from-lispworks-lisp-part-2\/","url_meta":{"origin":3675,"position":1},"title":"Calling C# Methods from LispWorks Lisp – Part 2","author":"admin","date":"March 14, 2021","format":false,"excerpt":"In the last article, I showed how we can invoke C# methods from LispWorks Enterprise Edition, through the COM\/Automation interface. That approach relied on invoking the Automation methods dynamically, without depending on the Type library (*.tlb).\u00a0 In this article, I will discuss the other approach, which uses the Type library.\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"C# Code","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/03\/Code2-236x300.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/03\/Code2-236x300.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/03\/Code2-236x300.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":2334,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/02\/28\/calling-c-methods-from-lispworks-lisp-through-com-interface\/","url_meta":{"origin":3675,"position":2},"title":"Calling C# Methods from LispWorks Lisp through COM Interface","author":"admin","date":"February 28, 2021","format":false,"excerpt":"In an earlier article, I showed how to invoke C# methods from Sicstus Prolog. Today, I would like to detail the steps for doing the same from LispWorks Lisp. LispWorks Enterprise Edition comes budled with support for COM and Automation. This is what we will be using. What this means\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"The COM Server in C#","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/02\/C-Code-300x267.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":2935,"url":"https:\/\/www.rangakrish.com\/index.php\/2022\/11\/07\/why-learn-c\/","url_meta":{"origin":3675,"position":3},"title":"Why Learn C++","author":"admin","date":"November 7, 2022","format":false,"excerpt":"This is the third and the last article in the series \u201cWhy Learn Language-XYZ?\u201d. I talked about Prolog and Lisp earlier. The present article is on C++. Once you have gained reasonable proficiency with Prolog and Lisp, you are ready to learn C++! In my view, C++ is a complex\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"","src":"","width":0,"height":0},"classes":[]},{"id":617,"url":"https:\/\/www.rangakrish.com\/index.php\/2017\/09\/13\/reuse-of-grammars-through-inheritance\/","url_meta":{"origin":3675,"position":4},"title":"Reuse of Grammars Through Inheritance","author":"admin","date":"September 13, 2017","format":false,"excerpt":"We are familiar with the advantages of class inheritance in object-oriented languages such as C++, C#, Java, and Python. The ability to reuse functionality via inheritance allows us to express our software design optimally, without having to write redundant code. iLangGen encourages the reuse of grammars by supporting Grammar Inheritance,\u2026","rel":"","context":"In "LISP"","block_context":{"text":"LISP","link":"https:\/\/www.rangakrish.com\/index.php\/category\/lisp\/"},"img":{"alt_text":"Simple Grammar","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/09\/image1.png?resize=350%2C200","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/09\/image1.png?resize=350%2C200 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2017\/09\/image1.png?resize=525%2C300 1.5x"},"classes":[]},{"id":3017,"url":"https:\/\/www.rangakrish.com\/index.php\/2023\/02\/16\/calling-external-dll-functions-from-julia\/","url_meta":{"origin":3675,"position":5},"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":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/3675","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=3675"}],"version-history":[{"count":4,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/3675\/revisions"}],"predecessor-version":[{"id":3689,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/3675\/revisions\/3689"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=3675"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=3675"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=3675"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}