<h2>klaupacius</h2>
<p>A language so inspired by lisps, forths and array languages that it resembles none of these.</p>
<p>A combinator-based, concatenative, tacit lisp with automatic memory management, immutability, partial application, some church encodings, without variables or lambdas, where everything is a function.</p>
+ <p><a href="repl">repl</a> <a href="https://git.eli173.com/?p=klapaucius">src</a></p>
+ <p>more documentation: <a href="builtins.html">builtins</a></p>
<!-- note: maybe a picture or something here instead of just space? -->
<div id="setting_out">
<h3>Setting Out</h3>
<p>This language emerged as a result of thinking about computing on stack machines. I wanted to spawn some sort of convergence of lisp-like and forth-like languages, I wanted to take the point-free style one gets in forths, and bring it into something with a structure based more upon s-expressions. It's a take on stack-based programming, but where we work from the other direction in a sense.</p>
<p>To demonstrate, let's break down something simple, like <code>(+ 4 5)</code>. If one has some experience with other lisps, this code might appear pretty obvious, and even without that experience, if one were to look at a plus, a four, and a five arranged like so, one might guess that this program adds four and five, returning <code>9</code>. And yes, that's exactly what happens, but understanding how we get there sheds light on how we can understand this language. It's already been stated that everything is a function, but it might be helpful to think of everything as a monadic function, a function that takes only one argument (which generally holds true, save for a particularly exciting and useful exception). But isn't the above-mentioned <code>+</code> a function that takes two values? Sort of! In this case, it is reasonable to think of <code>+</code> as a function that takes one argument <span class="italic">n</span>, and returns another function, which takes one argument <span class="italic">m</span> and returns <span class="italic">n + m</span>. Breaking this down a bit further reveals some aspects of the underlying system.</p>
- <p>How might we think about <code>+</code> being a monadic function that returns a function? Well let's start by breaking our example into 'simpler' pieces. Let's start with just <code>(+)</code>. If we type that into our <a href="link to repl plz TODO">repl</a> and hit enter, we get <code>_512</code> in return. What is this? You're right to ask. Things prefixed with an underscore like that are just how internal operations are printed, the underscore followed by a numeric value, here 512 corresponds to our plus. So let's call this function now. Type in <code>(+ 4)</code>, and you get <code>_512</code> in return. The same thing? What happened to the 4? I promise it's still in there, it's just printed like that to not overwhelm the output when dealing with more complicated matters. You can even get the four back out, doing <code>getargs (+ 4)</code> returns a list of arguments applied to any builtin operation (here, we'd get <code>(4)</code>).</p>
+ <p>How might we think about <code>+</code> being a monadic function that returns a function? Well let's start by breaking our example into 'simpler' pieces. Let's start with just <code>(+)</code>. If we type that into our <a href="repl">repl</a> and hit enter, we get <code>_512</code> in return. What is this? You're right to ask. Things prefixed with an underscore like that are just how internal operations are printed, the underscore followed by a numeric value, here 512 corresponds to our plus. So let's call this function now. Type in <code>(+ 4)</code>, and you get <code>_512</code> in return. The same thing? What happened to the 4? I promise it's still in there, it's just printed like that to not overwhelm the output when dealing with more complicated matters. You can even get the four back out, doing <code>getargs (+ 4)</code> returns a list of arguments applied to any builtin operation (here, we'd get <code>(4)</code>).</p>
<p>So, if you're still with me, now we have a nice new function <code>(+ 4)</code>. Let's call this function now. Give it <code>((+ 4) 5)</code>, and indeed you'll get a <code>9</code> in return! When it's parenthesized this way, I feel it's easier to understand that <code>(+ 4)</code> is itself a function, and can be applied to a number to get the sum of that number and four. So now is there a difference between <code>((+ 4) 5)</code> and <code>(+ 4 5)</code>? Practically speaking they're the same. When the interpreter evaluates a statement like <code>(a b c d)</code>, it takes <code>a</code> and <code>b</code> off the top of the list, appplies <code>a</code> to <code>b</code>, and sticks that (let's call it <code>ab</code>) to the beginning of the list and starts over again. So <code>(a b c d)</code> becomes <code>(ab c d)</code> which in turn becomes <code>(abc d)</code>, which goes to <code>(abcd)</code>, and now since there aren't any more arguments, it drops the parenthesis giving us <code>abcd</code>. This gives us a decent amount of leeway with the use of parenthesis in a way that's different from other lisps. The expressions
<pre>(+ 4 5)
((+ 4) 5)
home / projects / klapaucius / commitdiff