![\"\"](\"http:\/\/dlang.org\/blog\/wp-content\/uploads\/2019\/03\/brain02.png\")
The D programming language provides advanced facilities for structuring programs logically, almost like Python or Ruby, but with high performance and the higher reliability of static typing and contract programming.<\/p>\nThe D programming language provides advanced facilities for structuring programs logically, almost like Python or Ruby, but with high performance and the higher reliability of static typing and contract programming.<\/p>\n
In this article, I will describe how to use D templates and mixins for memoization<\/em>, that is, to automatically remember a function (or property) result.<\/p>\n The first way is built straight into Phobos, the D standard library<\/a>, and is very easy to use:<\/p>\n Now the alias It\u2019s even possible to memoize a function with arguments:<\/p>\n This outputs:<\/p>\n You see that the calculations are not repeated again when the argument values are the same.<\/p>\n I\u2019ve found another way to memoize in D. It involves caching a property<\/em> of a Here is the source (you can also install it from https:\/\/github.com\/vporton\/memoize-dlang<\/a> for use in your programs):<\/p>\n It is used like this (with either structs or classes at your choice):<\/p>\n Then just:<\/p>\n Or you can specify the explicit name of the cached property:<\/p>\n turns into<\/p>\n That is, it sets The idea originates from the following Python code:<\/p>\n My way of memoization does not (yet) involve caching return values of functions with arguments.<\/p>\n Victor Porton is an open source developer, a math researcher, and a Christian writer. He earns his living as a programmer.<\/em><\/p>\n","protected":false},"excerpt":{"rendered":" The D programming language provides advanced facilities for structuring programs logically, almost like Python or Ruby, but with high performance and the higher reliability of static typing and contract programming. In this article, I will describe how to use D templates and mixins for memoization, that is, to automatically remember a function (or property) result. […]<\/p>\n","protected":false},"author":32,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[26,9],"tags":[],"_links":{"self":[{"href":"https:\/\/dlang.org\/blog\/wp-json\/wp\/v2\/posts\/2018"}],"collection":[{"href":"https:\/\/dlang.org\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dlang.org\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dlang.org\/blog\/wp-json\/wp\/v2\/users\/32"}],"replies":[{"embeddable":true,"href":"https:\/\/dlang.org\/blog\/wp-json\/wp\/v2\/comments?post=2018"}],"version-history":[{"count":3,"href":"https:\/\/dlang.org\/blog\/wp-json\/wp\/v2\/posts\/2018\/revisions"}],"predecessor-version":[{"id":2026,"href":"https:\/\/dlang.org\/blog\/wp-json\/wp\/v2\/posts\/2018\/revisions\/2026"}],"wp:attachment":[{"href":"https:\/\/dlang.org\/blog\/wp-json\/wp\/v2\/media?parent=2018"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dlang.org\/blog\/wp-json\/wp\/v2\/categories?post=2018"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dlang.org\/blog\/wp-json\/wp\/v2\/tags?post=2018"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}std.functional.memoize<\/code> from the standard library<\/h3>\nimport std.functional;\r\nimport std.stdio;\r\n\r\nfloat doCalculations() {\r\n writeln(\"Doing calculations.\");\r\n return -1.7; \/\/ the value of the calculations\r\n}\r\n\r\n\/\/ Apply the template \u201cmemoize\u201d to the function doCalculations():\r\nalias doCalculationsOnce = memoize!doCalculations;<\/pre>\ndoCalculationsOnce()<\/code> does the same as doCalculations()<\/code>, but the calculations are done only once (if we call doCalculationsOnce()<\/code> then \u201cDoing calculations.\u201d would be printed only once). This is useful for long slow calculations and in some other situations (like to create only a single window on the screen). That is memoization.<\/p>\nfloat doCalculations2(float arg1, float arg2) {\r\n writeln(\"Doing calculations.\");\r\n return arg1 + arg2; \/\/ the value of the calculations\r\n}\r\n\r\n\/\/ Apply the template \u201cmemoize\u201d to the function doCalculations2():\r\nalias doCalculationsOnce2 = memoize!doCalculations2;\r\n\r\nvoid main(string[] args)\r\n{\r\n writeln(doCalculationsOnce2(1.0, 1.2));\r\n writeln(doCalculationsOnce2(1.0, 1.3));\r\n writeln(doCalculationsOnce2(1.0, 1.3));\r\n}<\/pre>\nDoing calculations.\r\n2.2\r\nDoing calculations.\r\n2.3\r\n2.3<\/pre>\n
Memoizing
struct<\/code> or class<\/code> properties<\/h3>\nstruct<\/code> or class<\/code>. Properties are zero-argument (for reading) or one-argument (for writing) member functions (or sometimes two-argument non-member functions) and differ only in syntax. I deemed it more elegant to cache a property of a struct or class rather than to cache a member function\u2019s return value. My code can easily be changed to memoize a member function instead of a property, but you can always convert zero-argument member functions into a property, so why bother?<\/p>\nmodule memoize;\r\n\r\nmixin template CachedProperty(string name, string baseName = '_' ~ name) {\r\n mixin(\"private typeof(\" ~ baseName ~ \") \" ~ name ~ \"Cache;\");\r\n mixin(\"private bool \" ~ name ~ \"IsCached = false;\");\r\n mixin(\"@property typeof(\" ~ baseName ~ \") \" ~ name ~ \"() {\\n\" ~\r\n \"if (\" ~ name ~ \"IsCached\" ~ \") return \" ~ name ~ \"Cache;\\n\" ~\r\n name ~ \"IsCached = true;\\n\" ~\r\n \"return \" ~ name ~ \"Cache = \" ~ baseName ~ \";\\n\" ~\r\n '}');\r\n}<\/pre>\nimport memoize;\r\n\r\nstruct S {\r\n @property float _x() { return 1.5; }\r\n mixin CachedProperty!\"x\";\r\n}<\/pre>\nS s;\r\nassert(s.x == 1.5);<\/pre>\n
import memoize;\r\n\r\nstruct S {\r\n @property float _x() { return 1.5; }\r\n mixin CachedProperty!(\"x\", \"_x\");\r\n}<\/pre>\nCachedProperty<\/code> is a template mixin<\/a>. Template mixins insert the declarations of the template body directly into the current context. In this case, the template body is composed of string mixins<\/a>. As you can guess, a string mixin generates code at compile time from strings. So,<\/p>\nstruct S {\r\n @property float _x() { return 1.5; }\r\n mixin CachedProperty!\"x\";\r\n}<\/pre>\nstruct S {\r\n @property float _x() { return 1.5; }\r\n private typeof(_x) xCache;\r\n private bool xIsCached = false;\r\n @property typeof(_x) x() {\r\n if (xIsCached) return xCache;\r\n xIsCached = true;\r\n return xCache = _x;\r\n }\r\n}<\/pre>\nxCache<\/code> to _x<\/code> unless xIsCached<\/code> and also sets xIsCached<\/code> to true<\/code> when retrieving x<\/code>.<\/p>\nclass cached_property(object):\r\n \"\"\"A version of @property which caches the value. On access, it calls the\r\n underlying function and sets the value in `__dict__` so future accesses\r\n will not re-call the property.\r\n \"\"\"\r\n def __init__(self, f):\r\n self._fname = f.__name__\r\n self._f = f\r\n\r\n def __get__(self, obj, owner):\r\n assert obj is not None, 'call {} on an instance'.format(self._fname)\r\n ret = obj.__dict__[self._fname] = self._f(obj)\r\n return ret<\/pre>\n
\n