I think providing a distinction between ordinary and pure functions has benefits and adds a little to certainty. Besides being sure that a branch of calls is referentially transparent I also nurture this idea of mobile code. And the first candidate for mobile code are pure functions, as you can run pure remote code with much less worry since there are no side effects. There is still a halting problem, but can be solve on interpreter level I think.
Imagine communicating with a map-filter-reduce server also written in Rye and instead of translating requests into it's query language you can just sent it your pure functions for map/filter/reduce and get the result.
The implementation is quite simple. All pure builtins have a Pure flag set and pure user functions can only call pure builtins or other pure functions.
I didn't like the idea, that interpreter would need to always check the flags of all builtins and functions when evaluating the pure function. I figured out a way that solves this with separate contexts (scopes).
Rye is very flexible with scopes (in rye called contexts). Scope is a first class value in Rye. You can for example create isolated context, use current context and/or combine and link contexts together as you see fit. Functions and blocks of code can then be ran in these constructed contexts, not just lexical/dynamic scopes like in most programming languages.
So we solve this simply by having an isolated context, where all pure functions and builtins get are defined also. And pure functions evaluate their code using this scope only.
This is a simple demonstration.
Next blogpost will be about what we can also do in with our definitional scopes, inspired by reading this well written blogpost.
Komentarji
Objavite komentar