{"id":2722,"date":"2022-03-06T09:37:54","date_gmt":"2022-03-06T04:07:54","guid":{"rendered":"https:\/\/www.rangakrish.com\/?p=2722"},"modified":"2022-03-06T09:37:54","modified_gmt":"2022-03-06T04:07:54","slug":"lazy-parameter-evaluation-in-d-language","status":"publish","type":"post","link":"https:\/\/www.rangakrish.com\/index.php\/2022\/03\/06\/lazy-parameter-evaluation-in-d-language\/","title":{"rendered":"Lazy Parameter Evaluation in D Language"},"content":{"rendered":"

Languages such as C\/<\/strong>C++<\/strong><\/em> and Java<\/strong><\/em> follow an\u00a0“eager”<\/strong><\/em> argument evaluation approach, where function arguments are evaluated before the function is entered. Of course, there are idioms and tricks that one can use to force “lazy”<\/strong><\/em> evaluation. The primary benefit of “lazy”<\/strong><\/em> parameter evaluation is that the parameter is evaluated only when it is used and this can improve efficiency. D<\/strong><\/em> language supports both “eager”<\/strong><\/em> and “lazy”<\/strong><\/em> parameter evaluations.<\/p>\n

Here is a simple D<\/strong><\/em> program to show “eager”<\/strong><\/em> parameter evaluation:<\/p>\n

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

 <\/p>\n

If you study the function “fooBar”<\/em><\/strong>, it takes a boolean first parameter along with two integer params. Based on the value of the first param, it uses one of the other two params (not both) inside the body for computing its result.<\/p>\n

Now look at the program output:<\/p>\n

\"Eager<\/a>
Eager Evaluation Result<\/strong><\/figcaption><\/figure>\n

We see that both<\/strong><\/em> the functions are evaluated in each case. This is not surprising. Because by default, D<\/strong><\/em> language (like C, C++, Java<\/strong><\/em>) uses “eager evaluation<\/strong><\/em>“, when the “fooBar”<\/strong><\/em> function is called, both the second and third parameters are evaluated apriori<\/strong><\/em>, even though only one is actually used inside the function. One might argue that it is “wasteful”<\/strong><\/em> to call the other function that is not used in the result computation, especially if the calculation is “costly”<\/strong><\/em>.<\/p>\n

The solution lies in “lazy”<\/strong><\/em> parameter evaluation. Here is the modified “fooBar”<\/strong><\/em> function:<\/p>\n

\"Declaring<\/a>
Declaring Lazy Parameters<\/strong><\/figcaption><\/figure>\n

I have added the extra qualifier “lazy”<\/strong><\/em> to the second and third parameters of “fooBar”<\/strong><\/em>. This forces the D<\/strong><\/em> compiler to evaluate the argument(s) only at the point of use<\/strong><\/em>, not apriori. This is confirmed by the output from the program.<\/p>\n

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

Nice, isn’t it? There is a catch, though. While the positive aspect of declaring an argument as “lazy”<\/strong><\/em> is that the compiler evaluates it only when it is required, the negative side of it is that the compiler evaluates it “every”<\/strong><\/em> time it needs the parameter.<\/p>\n

Let us modify our “fooBar”<\/strong><\/em> function slightly:<\/p>\n

\"Multiple<\/a>
Multiple References to Lazy Param<\/strong><\/figcaption><\/figure>\n

The change, as you would have noticed, is that I am using the “<\/strong>lazy”<\/strong><\/em> parameters twice in each expression just to prove a point. When we run the program now, this is what we get:<\/p>\n

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

Clearly, this is not what we want! Our decision to declare the parameters as “lazy”<\/strong><\/em> in the first place was to avoid unnecessary computation, but now the objective is lost!<\/p>\n

So what is the way out? Simple really. We can evaluate the “lazy”<\/strong><\/em> parameter once and assign it to a different local variable and then use that local variable whenever we need the original parameter later in the function. This is shown below.<\/p>\n

\"Caching<\/a>
Caching the Parameter<\/strong><\/figcaption><\/figure>\n

And here is the program output after the change:<\/p>\n

\"Output<\/a>
Output After Caching<\/strong><\/figcaption><\/figure>\n

That solves our problem! We now have the benefit of “lazy”<\/strong><\/em> parameter evaluation, at the same time avoiding multiple evaluations of that parameter. Ideally, the compiler should cache the result of the first evaluation and use it subsequently, but we can live with that limitation.<\/p>\n

You can download the sample D<\/strong><\/em> program here<\/strong><\/em><\/a>.<\/p>\n

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

Languages such as C\/C++ and Java follow an\u00a0“eager” argument evaluation approach, where function arguments are evaluated before the function is entered. Of course, there are idioms and tricks that one can use to force “lazy” evaluation. The primary benefit of “lazy” parameter evaluation is that the parameter is evaluated only when it is used and […]<\/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":[302,17],"tags":[304,311],"class_list":["post-2722","post","type-post","status-publish","format-standard","hentry","category-d-language","category-programming","tag-d-language","tag-lazy-parameter-evaluation"],"jetpack_publicize_connections":[],"jetpack_featured_media_url":"","jetpack_sharing_enabled":true,"jetpack_shortlink":"https:\/\/wp.me\/p9OLnF-HU","jetpack-related-posts":[{"id":2668,"url":"https:\/\/www.rangakrish.com\/index.php\/2022\/01\/23\/template-mixins-in-d-programming-language\/","url_meta":{"origin":2722,"position":0},"title":"Template Mixins in D Programming Language","author":"admin","date":"January 23, 2022","format":false,"excerpt":"When I heard the name Mixin\u00a0for the first time in the context of Dlang, I imagined it would be something similar to the mixins\u00a0of Common Lisp, but I was completely wrong!\u00a0 Mixins are a very interesting feature of D language. They allow code to be \"injected\" into the source at\u2026","rel":"","context":"In "D Language"","block_context":{"text":"D Language","link":"https:\/\/www.rangakrish.com\/index.php\/category\/d-language\/"},"img":{"alt_text":"Simple Template Mixin","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/01\/Defn-300x98.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":1560,"url":"https:\/\/www.rangakrish.com\/index.php\/2019\/05\/05\/python-integration-in-mathematica-12\/","url_meta":{"origin":2722,"position":1},"title":"Python Integration in Mathematica 12","author":"admin","date":"May 5, 2019","format":false,"excerpt":"Mathematica has had Python support since ver 11.2 through ExternalEvaluate[]. In ver 11.3 it was possible to input Python expression in a cell by beginning with \u201c>\u201d character. The good news is that Mathematica 12 has significantly enhanced this integration. Python Cells Let us start with the simplest way to\u2026","rel":"","context":"In "Mathematica"","block_context":{"text":"Mathematica","link":"https:\/\/www.rangakrish.com\/index.php\/category\/mathematica\/"},"img":{"alt_text":"Function References","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/05\/External-Evaluate-4.png?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/05\/External-Evaluate-4.png?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2019\/05\/External-Evaluate-4.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":2722,"position":2},"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":2975,"url":"https:\/\/www.rangakrish.com\/index.php\/2022\/12\/25\/stdtie\/","url_meta":{"origin":2722,"position":3},"title":"Std::tie","author":"admin","date":"December 25, 2022","format":false,"excerpt":"std::tuple is a widely used abstraction in C++ and has been around since C++11. It is a generalization of std::pair. std::tie is convenient when we want to create a tuple of lvalue references to existing variables. It is a function template commonly used to unpack a tuple into individual objects.\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"std::tie Example","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/12\/Example1-300x142.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/12\/Example1-300x142.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2022\/12\/Example1-300x142.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]},{"id":2540,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/09\/19\/c-20-concepts\/","url_meta":{"origin":2722,"position":4},"title":"C++ 20: Concepts","author":"admin","date":"September 19, 2021","format":false,"excerpt":"Concepts, introduced in C++20, are predicates that act as contraints on template parameters. As you would expect, the nice thing is that the constraint checking happens as part of template instantiation at compile time and not at run time! Since templates can have type as well as non-type parameters, Concepts\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Constraint on Type","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/09\/Example1-300x213.jpg?resize=350%2C200&ssl=1","width":350,"height":200},"classes":[]},{"id":2433,"url":"https:\/\/www.rangakrish.com\/index.php\/2021\/06\/06\/getting-to-know-visual-prolog-10\/","url_meta":{"origin":2722,"position":5},"title":"Getting to Know Visual Prolog 10","author":"admin","date":"June 6, 2021","format":false,"excerpt":"Visual Prolog\u00a0has its roots in Turbo Prolog, which was popularized by Borland in the mid 1980s. It is developed and supported by PDC A\/S, Denmark. So how is Visual Prolog different from other Prolog implementations out there, for example, SWI-Prolog or Sicstus Prolog? Here are the key differences: 1) It\u2026","rel":"","context":"In "C++"","block_context":{"text":"C++","link":"https:\/\/www.rangakrish.com\/index.php\/category\/c\/"},"img":{"alt_text":"Visual Prolog Project","src":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/06\/Project-300x183.jpg?resize=350%2C200&ssl=1","width":350,"height":200,"srcset":"https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/06\/Project-300x183.jpg?resize=350%2C200&ssl=1 1x, https:\/\/i0.wp.com\/www.rangakrish.com\/wp-content\/uploads\/2021\/06\/Project-300x183.jpg?resize=525%2C300&ssl=1 1.5x"},"classes":[]}],"_links":{"self":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/2722","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=2722"}],"version-history":[{"count":0,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/posts\/2722\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/media?parent=2722"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/categories?post=2722"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.rangakrish.com\/index.php\/wp-json\/wp\/v2\/tags?post=2722"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}