Guide to using Functional Paradigmal patterns in Axe

Hello, today I would like to share some things I noticed you can do with Axe to use it in a more high-level functional way. This tutorial assumes you don't know how higher level functional concepts work and walks you through all of them step by step. Axe has limited support for functions, many think, but that's pretty far from the truth. You just can't know all of them from reading a documentation, some of them are either more of reactions that the compiler would do based on its function, or with the help of a little inline assembly. Here are a few things that when used with your program, can make it flow much better and in some cases achieve things that couldn't be done normally with built in features.


Returning Values

This is one of the more simpler concepts that you can draw from functional Axe programming. Basically, when you return a value from a function, you're simply just letting the process of that function represent a value. That value is determined by the function, which does arithmetic and possibly even further computational things to obtain that value. Let's start with this non-functional code for example:


Code:


This can be simply improved like so:


Code:


This is a decent optimization in size, and speed. Plus, you have no need to store the answer value from ADD into a variable, we can just use the call to ADD itself as a value. Why does this work like this? Because HL, the assembly register, is like the Ans with BASIC but with Axe. The parser puts all expressions that were just parsed into HL, so that's why "r2 + r1" returned 10 into HL, which was then used by the calling If statement.


Simple Variable-Attachment Lambdas

What is a Lambda statement? Essentially, it's the most value-like function attainable. It is literally a stand-in for a real value that it returns. Lambdas are very useful in functional programming, but are harder to use in Axe. They come in two forms: Normals, and Procs. I'll start with procs, since Normals are usually attached to a variable (easy to do in HLLs, not easy in Axe, procs are easier to use in straight-up axe). Since they can literally stand into a part of a program in any place, here is an example of a Proc'd expression:


Code:


As you can see, a Proc in Axe is literally just a subroutine used in place of a value exclusively. While that may not be super-useful with small things, it saves a lot of space with constant expression checking, though the speed will generally take a toll so minor that it really woudln't matter.


Normals

Normals can be achieved by attaching a Proc to a variable, so that whenever the variable is accessed its value depends on input parameters. Here is one way of doing so, where you can actually get the value of a variable but in Normallic form using variable indirection and a simple proc:
º

Code:


This Lambda follows Normallic form, but it doesn't completely attach itself to a variable. To do that so it's variable specific, you can do this:


Code:


An alternative to that, where you only use one routine to do both, but it only applies to one:


Code:



Mapping and Folding

Mapping and folding in Functional programming basically are functions that apply to all members of an Array, List, etc.  Basically, they loop and fix all numbers one by one until the end of array or the specified length has been reached.  An example:


Code:


This above method applies this map to a zero terminated array.  To d the same with length termination is a simple difference:


Code:



Folding is almost the same, but it fills in more of the place of a value-function than a performance one.  Basically, a Fold is a Map that returns values in the form of any type of object, either in a fixed array leaving the original the same, or even outputting a list of return values in array form afterwards so a programmer can see if certain conditions were met.  Examples:

Fixing an array without being destructive, by outputting results to a result array:


Code:



Fixing and checking to see if fixed elements are 10, and output results to an output array: 


Code:



Filters

Filters are the next type of higher level functional forms.  Filters are simply "checkers" that see if an array has certain elements that fulfill a certain expressional requirement, and returns either the element contents or indices to the passing elements.  In many cases with axe, due to limited functional properties already, returning indices is better since you can have more detail on the elements and can do more operations on them, while still being able easily reproduce the exact value of the passing elements.  A thing to remember with filter outputs though -- usually, the output for the filter will be an array less than or equal to the size of the inout array -- though in rare cases, with certain passing requirements or double looping checks, they can be larger.  But, with the output of filters being so variant in size you need to either take precautions to make sure that if zero is a passing value, you must return the length of the output array.  You must also be sure you have error checking for no-match conditions.  Anyways, examples:

This code filters the array to see if the elements are equal to 1, and returns indices to the passing elements:


Code:


To return a size of the output array, you can just return B value-style since we're already sure that the output pointer is defined already, you can change it to this:


Code:



Returning multiple arguments

Let's say you want to make a Filter function that assumes that you want the output array to be placed somewhere in memory assigned by the equivalent of a malloc() command.  You can return multiple arguments by simply packing all of the returned values into an array of unorganized members.  You then return the pointer to that array, and the calling expression can unpack it as needed.  Example:


Code:



That covers a lot of functional programming in Axe for now, but there can always be more added.  If you have anything to contribute to this set of functional ideals, please post them, and help the effort to bring the Functional Paradigm to Axe a reality by informing others Thanks!



~~Thanks for reading, more coming! Feel free to ask Q&C's, or ask for more content I can add ~~

So that first one is similar to the C++ function call, with a return value?

Code:

I know this has no purpose, but it helps me correlate languages with other languages.

Yeah, it's like that, except you don't do the addition, thing, but in general same exact concept. Returning values is the building block of all functional programming, as most if not all higher order ideals include it or expand upon its functionality in some way, shape, or form.

This is rather informative, Ashbad. How many other tutorials do you have planned to post?

I plan to add them perpetually, and might even do a few more simple ones like Lambda currying/decurrying tonight, and possibly a few more ones in the future, which would apply higher order ideals to manually made Structures

Well, if you have more in mind, I think I might set up an Axe specific subforum, to help keep things a bit more organized.

Oh, you meant a totally difference non-functional tutorial? Yeah, I'm planning a few more in the next week or so, like a crude OOP implementation, making/using unions, advanced array manipulation, and more

Just so long as it is Axe specific stuff, that is what I was hinting at :p