Author Topic: [Tutorial]Achieving Decent Functional Programming in Axe DEPRECATED (Read 5411 times)

Ashbad · « **on:** June 16, 2011, 01:55:59 pm »

NOTE BY AUTHOR: this tutorial is now outdated. You can still use everything here since it's all valid Axe 1.0.0 code, but since 1.0.0 support for better functional programminng has been added. I rebooted this tutorial and covered everything in new notation here: http://ourl.ca/12120

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: [Select]

sub(ADD,5,5)
If A = 10
   Disp "Lol"
End

Lbl ADD
  r2 + r1 -> A
Return

This can be simply improved like so:

Code: [Select]

If sub(ADD,5,5) = 10
  Disp "Lol"
End

Lbl ADD
  r2 + r1
Return

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: [Select]

Lbl PRC:r1+3:Return
If sub(PRC,rand^4 -> A) = 6
  Disp "'tis 6"
Else
  Disp "No, it's actually",sub(PRC,A) >Dec
End

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: [Select]

If sub(PCV,ºA) = 5
  Disp "THIS IS 5."
End

Lbl PCV .The proc for attaching
  {r1}r + 5 -> {r1}r
Return

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: [Select]

If sub(CA) = 5
  Disp "THIS IS 5."
End

Lbl CA .Call A
  sub(PCV,ºA)
Return
Lbl PCV
  {r1}r + 5 -> {r1}r
Return

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

Code: [Select]

If sub(CA) = 5
  Disp "THIS IS 5."
End

Lbl CA
  {ºA}r + 5 -> {ºA}r
Return

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: [Select]

Data(5,6,2,1,0) -> Str1
sub(MAP,Str1)

Lbl MAP
  For(A,0,length(r1))
    {r1+A} + 5 -> {r1+A}
  End
Return

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

Code: [Select]

Data(5,6,2,1) -> Str1
sub(MAP,Str1,4)

Lbl MAP
  For(A,0,r2)
    {r1+A} + 5 -> {r1+A}
  End
Return

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: [Select]

Data(1,2,3,0) -> Str1
L1 -> P . Pointer to result array
sub(FLD,Str1,P)

Lbl FLD
  For(A,0,length(r1))
    {r1+A} + 5 -> {r2+A}
  End
Return

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

Code: [Select]

Data(1,2,3,0) -> Str1
L1 -> P . Pointer to output array
sub(FLD,Str1,P)

Lbl FLD
  For(A,0,length(r1))
    {r1+A} + 5 -> {r1+A}
    If {r1+A} = 10
      1 -> {r2 + A}
    Else
      0 -> {r2 + A}
    End
  End
Return

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: [Select]

Data(1,2,2,1,1,3,0) -> Str1
L1 -> P
sub(FLT,Str1,P)

Lbl FLT
  0 -> B
  For(A,0,length(r1))
    If A*({r1+A}=1}
      -> {r2+B}
      B++
    End
  End
Return

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: [Select]

Data(1,2,2,1,1,3,0) -> Str1
L1 -> P
Disp "Size of array: ",sub(FLT,Str1,A) >Dec

Lbl FLT
  0 -> B
  For(A,0,length(r1))
    If A*({r1+A}=1}
      -> {r2+B}
      B++
    End
  End
  B
Return

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: [Select]

Data(1,2,1,2,3,1) -> Str1
sub(MRF,Str1) -> P
Disp {P+2} >Dec," Passing elements found, which are at indices: ",i
For(A,0,{P}r)
  Disp {{P}r+A} >Dec,", "
End

Lbl MRF
  ... CALL MALLOC COMMAND
      AND DELEGATE SOME 
      MEMORY AND GIVE A 
      POINTER IN P ...
  0 -> B
  For(A,0,length(r1))
    If A*({r1+A}=1}
      -> {P+B}
      B++
    End
  End
  ... CALL MALLOC COMMAND 
     AND DELEGATE SPACE THAT
     IS B BYTES LONG, POINTED TO
     BY Q ...
  P -> {Q}r . Load P into first two bytes
  B -> {Q+2} . Load length int 3rd byte
  Q . Return pointer to return array
Return

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

~~

aeTIos · « **Reply #1 on:** June 16, 2011, 03:28:27 pm »

great. just great. Well done.

yrinfish · « **Reply #2 on:** June 16, 2011, 05:08:24 pm »

Wow. The only thing is that I don't understand lambdas anymore...
WIKIIIII

More please!!

Ashbad · « **Reply #3 on:** June 16, 2011, 06:51:54 pm »

Glad you like it, and yrinfish I would be glad to point you to some resources for learning how lambdas work if you want

With that being said, I think I'll add some more onto this tomorrow morning or late tonight.

AngelFish · « **Reply #4 on:** June 16, 2011, 07:01:32 pm »

Quote

Guide to using Axe to its full functional form

I'm not saying your guide isn't useful (+1), but Axe is a procedural/imperative language, not a functional one. Saying that it has a "full functional form" is kind of misleading. It's more accurate to say that you can synthesize other paradigms from imperative languages.

Ashbad · « **Reply #5 on:** June 16, 2011, 08:42:48 pm »

That's true

but since it can be used in primitive functional forms, and since most people don't even take note of them, or even know you can use things like that, I wanted to inform

however, I agree, I should change that opening line.

I have now added a ton more to this tutorial, covering more higher level functional aspects:

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: [Select]

Data(5,6,2,1,0) -> Str1
sub(MAP,Str1)

Lbl MAP
  For(A,0,length(r1))
    {r1+A} + 5 -> {r1+A}
  End
Return

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

Code: [Select]

Data(5,6,2,1) -> Str1
sub(MAP,Str1,4)

Lbl MAP
  For(A,0,r2)
    {r1+A} + 5 -> {r1+A}
  End
Return

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: [Select]

Data(1,2,3,0) -> Str1
L1 -> P . Pointer to result array
sub(FLD,Str1,P)

Lbl FLD
  For(A,0,length(r1))
    {r1+A} + 5 -> {r2+A}
  End
Return

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

Code: [Select]

Data(1,2,3,0) -> Str1
L1 -> P . Pointer to output array
sub(FLD,Str1,P)

Lbl FLD
  For(A,0,length(r1))
    {r1+A} + 5 -> {r1+A}
    If {r1+A} = 10
      1 -> {r2 + A}
    Else
      0 -> {r2 + A}
    End
  End
Return

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: [Select]

Data(1,2,2,1,1,3,0) -> Str1
L1 -> P
sub(FLT,Str1,P)

Lbl FLT
  0 -> B
  For(A,0,length(r1))
    If A*({r1+A}=1}
      -> {r2+B}
      B++
    End
  End
Return

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: [Select]

Data(1,2,2,1,1,3,0) -> Str1
L1 -> P
Disp "Size of array: ",sub(FLT,Str1,A) >Dec

Lbl FLT
  0 -> B
  For(A,0,length(r1))
    If A*({r1+A}=1}
      -> {r2+B}
      B++
    End
  End
  B
Return

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: [Select]

Data(1,2,1,2,3,1) -> Str1
sub(MRF,Str1) -> P
Disp {P+2} >Dec," Passing elements found, which are at indices: ",i
For(A,0,{P}r)
  Disp {{P}r+A} >Dec,", "
End

Lbl MRF
  ... CALL MALLOC COMMAND
      AND DELEGATE SOME 
      MEMORY AND GIVE A 
      POINTER IN P ...
  0 -> B
  For(A,0,length(r1))
    If A*({r1+A}=1}
      -> {P+B}
      B++
    End
  End
  ... CALL MALLOC COMMAND 
     AND DELEGATE SPACE THAT
     IS B BYTES LONG, POINTED TO
     BY Q ...
  P -> {Q}r . Load P into first two bytes
  B -> {Q+2} . Load length int 3rd byte
  Q . Return pointer to return array
Return

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!

nemo · « **Reply #6 on:** June 16, 2011, 09:27:14 pm »

Quote from: Ashbad on June 16, 2011, 08:42:48 pm

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:

implementing mapping, folding and filtering in Axe isn't very efficient though. The power behind those three functions is that they are higher order, which isn't possible in Axe (i.e. you can't pass a function as a parameter). for example, say you want to make 3 separate functions. one that add 5 to every element of a list, one that takes the square root of every element and one that divides each element by 3. in a functional programming language, you would have one function called map, and then three functions, add5(x), sqrt(x), and div3(x). then you'd call map with the parameters of each function and a list. technically you can "map" in Axe, but without the advantages of mapping in functional programming, which IMHO defeats the purpose.

it would be pretty cool to see higher order functions in Axe though.

Ashbad · « **Reply #7 on:** June 16, 2011, 09:34:27 pm »

That's true, but you could technically pass those parameters through with certain tricks, which I guess I could show tomorrow when I get back from school. They aren't very efficient in many cases, but they allow for some doing things in Axe that can't normally be done with non-functional constraints.

Quigibo · « **Reply #8 on:** June 16, 2011, 09:40:16 pm »

High order functions will be possible in Axe 1.0.0, and will be an interesting paradigm change. That will probably be THE biggest change from the betas. However, I'm still not sure if they will be recursively nestable yet, where the parameters can be backed up to the stack, but its still pretty damn useful.

ralphdspam · « **Reply #9 on:** June 16, 2011, 11:10:57 pm »

Looking forward to that.

Ashbad · « **Reply #10 on:** July 14, 2011, 10:20:40 am »

Let it be known this tutorial is deprecated and I'll be posting an updated and expanded version tonight, covering all topics here in more depth with new 1.0.1 notation.

ztrumpet · « **Reply #11 on:** July 14, 2011, 10:46:09 am »

That's awesome, Ashbad. After the contest (when I want to learn 1.0.1) I'm certainly going to give this a read-though or two; I would like to learn lambdas and I believe this is the perfect tutorial for that. Thanks!

Author Topic: [Tutorial]Achieving Decent Functional Programming in Axe DEPRECATED (Read 5411 times)

Ashbad

[Tutorial]Achieving Decent Functional Programming in Axe DEPRECATED

aeTIos

Re: Functional Axe

yrinfish

Re: Functional Axe

Ashbad

Re: Functional Axe

AngelFish

Re: Functional Axe

Ashbad

Re: Functional Axe

nemo

Re: Functional Axe

Ashbad

Re: [Tutorial]Achieving Decent Functional Programming in Axe

Quigibo

Re: [Tutorial]Achieving Decent Functional Programming in Axe

ralphdspam

Re: [Tutorial]Achieving Decent Functional Programming in Axe

Ashbad

Re: [Tutorial]Achieving Decent Functional Programming in Axe

ztrumpet

Re: [Tutorial]Achieving Decent Functional Programming in Axe DEPRECATED