This is a prototype version of the CX Programming Language. At the moment, in order to create a program, the programmer needs to use the base language directly.
package main
import (
"fmt"
"github.com/skycoin/skycoin/src/cipher/encoder"
. "github.com/skycoin/cx/src/base"
)
func main() {
}
Start by creating a reference to the only currently supported primitive type i32.
i32 := MakeType("i32")
We will use the variable i32 when creating objects that require a type, like definitions and fields in structures. When executing a function which uses definitions of type i32, the base language will automatically recognize this primitive type.
Arguments that represent identifiers need to be of type ident. These identifiers will point to a value of certain type (like i32). This behaviour is similar to how Lisp handles symbols, and how symbols point to other data. When using languages constructed using the CX base language, this process should be transparent to the user. For the moment, let's create the type ident:
ident := MakeType("ident")
The last reference to a primitive that we need to make is to the addI32 function:
addI32 := MakeFunction("addI32")
which simply adds two arguments of type i32.
A function is created using a maker, which is, in this case, MakeFunction:
double := MakeFunction("double")
This function will take a number, will double it and then will return the result. Let's start with adding the input and the output:
double := MakeFunction("double").
AddInput(MakeParameter("num", i32)).
AddOutput(MakeParameter("", i32))
Adders are used to add objects to another object. In this case, AddInput and AddOutput were used to add an input parameter and an output parameter to the double function, respectively. Both of these adders require a parameter object, which is created by using the maker MakeParameter. The input parameter has the name "num" and is of type i32. The output is unnamed and is of type i32. In the CX base language, one can give the output a name or not. The output of a function will correspond to the name of the output parameter in the former case, or will be the value of the last expression in the function body in the latter. As this function will only require a single expression, an unnamed output is more convenient. Let's now add this expression:
double := MakeFunction("double").
AddInput(MakeParameter("num", i32)).
AddOutput(MakeParameter("", i32)).
AddExpression(MakeExpression(addI32).
AddArgument(MakeArgument(MakeValue("num"), ident)).
AddArgument(MakeArgument(MakeValue("num"), ident)))
The maker MakeExpression requires an operator to make an expression,
which is addI32 in this case. Without any arguments, this maker would
create this s-expression: (+). After adding twice the num
identifier to the expression, the s-expression would look like this:
(+ num num).
The double function could be represented by the following s-expression:
(defun double (num i32)
(+ num num))
If we want to call this function, and actually double a number with it, we can make another expression which uses double as its operator. But first, let's create a variable which holds the number 25:
num := encoder.SerializeAtomic(int32(25))
As values in CX are serialized to byte arrays, we used Skycoin's
cipher/encoder package to serialize the number. Now, to double this
number and print the value:
fmt.Println(
MakeExpression(double).
AddArgument(MakeArgument(&num, i32)).
Execute(mod.Definitions).Value)
In the next versions, a program should be executed as this
cxt.Execute() where cxt is the context holding references to
everything in a program. The program would run by executing a main()
function or by continuing executing the function and expression
in which it was paused at. For now, we need to create an expression
which uses double and the number we created as its argument, and
then call its Execute method. The execute method requires a
definitions array to act as its state.
By compiling and running the code above, this output should be printed:
&[50 0 0 0]
which is a seralized 50 int32.
An affordance of an object represents something that we can do to that
object. At the moment, CX can apply some basic affordances on its
objects, like adders and selectors. Adders were used in the
previous section, and these basically add objects to other objects
(like adding an input parameter to a function). Selectors change the
current object the program is acting on: for example,
SelectModule will change a context to work on a desired module,
which means that any call to AddFunction, AddStruct or
AddDefinition will add objects to this module.
Let's create a "root" object or context and call its GetAffordances
method:
cxt = MakeContext()
PrintAffordances(cxt.GetAffordances())
PrintAffordances is a function used for debugging affordances; it
just prints an affordance's description to the console. The code above
should give the following output:
AddModule mod26
This is telling us that the only affordance over our empty context is to add a module. If we decide to apply this affordance, the program will generate a unique, but not very descriptive, identifier (mod26 in this case). Let's apply this affordance:
cxt.GetAffordances()[0].ApplyAffordance()
Note that we had to state that we desire to apply affordance
0. Other functions should provide the logic to follow in order to
determine what affordance to apply. A FilterAffordances function is
provided, which receives a series of string keywords to filter the
descriptions of the provided affordances. For example:
FilterAffordances(cxt.GetAffordances(),
"AddExpression", "write")
this filter will return all the affordances which involve adding an expression with operators containing the "write" keyword.
After applying the affordance obtained above, if we make another call
to GetAffordances, we should get an output similar to this:
AddModule mod27
SelectModule mod26
It is now telling us that we can either add another module or select the previously created module. Let's now run the following code:
PrintAffordances(cxt.GetCurrentModule().GetAffordances())
We are using a getter called GetCurrentModule on our context to
obtain the active module, and then we get its affordances and print
them. The output should be similar to this:
AddDefinition def27 i32
AddFunction fn28
AddStruct strct29
This tells us that we can add a new definition of type i32, a function or a struct to the module. If we had more types (structs and more primitive types), the list of AddDefinitions would be longer (one for each available type in the current module, and for each imported module).
If we want to know the structure of a program (context), we can use
the function PrintProgram, which is a function that has been used
only for debugging purposes. By running cxt.PrintProgram(false), we
should get something like this:
Context
0.- Module: mod0
1.- Module: Math
Definitions
0.- Definition: def2 i32
1.- Definition: def3 Complex
2.- Definition: hugs i32
3.- Definition: items StdLib.Stream
4.- Definition: views i64
Structs
0.- Struct: Complex
1.- Struct: List
0.- Field: fld18 i32
1.- Field: fld23 List
Functions
0.- Function: fn5 (in16 StdLib.Stream, in17 StdLib.Stream, num1 i32, num2 i32) sum i32
1.- Function: fn10 (items StdLib.Stream)
0.- Expression: fn5(items StdLib.Stream, items StdLib.Stream, hugs i32, hugs i32)
2.- Module: StdLib
Structs
0.- Struct: Stream
Functions
0.- Function: fn14 ()
The false argument tells the function to not print the available
affordances for each object. Here is an example of this case:
Context
* 0.- AddModule mod26
* 1.- SelectModule mod0
* 2.- SelectModule Math
* 3.- SelectModule StdLib
* 4.- SelectFunction fn5
* 5.- SelectFunction fn10
* 6.- SelectStruct List
* 7.- SelectStruct Complex
* 8.- SelectExpression Line # 0
0.- Module: mod0
* 0.- AddDefinition def27 i32
* 1.- AddImport Math
* 2.- AddImport StdLib
* 3.- AddFunction fn28
* 4.- AddStruct strct29
1.- Module: Math
* 0.- AddDefinition def30 i32
* 1.- AddDefinition def31 List
* 2.- AddDefinition def32 Complex
* 3.- AddDefinition def33 StdLib.Stream
* 4.- AddImport mod0
* 5.- AddImport StdLib
* 6.- AddFunction fn34
* 7.- AddStruct strct35
Definitions
0.- Definition: def2 i32
1.- Definition: def3 List
2.- Definition: hugs i32
3.- Definition: items StdLib.Stream
4.- Definition: views i64
Structs
0.- Struct: List
* 0.- AddField fld36 i32
* 1.- AddField fld37 List
* 2.- AddField fld38 Complex
* 3.- AddField fld39 StdLib.Stream
0.- Field: fld18 i32
1.- Field: fld23 List
1.- Struct: Complex
* 0.- AddField fld40 i32
* 1.- AddField fld41 List
* 2.- AddField fld42 Complex
* 3.- AddField fld43 StdLib.Stream
Functions
0.- Function: fn5 (in16 StdLib.Stream, in17 StdLib.Stream, num1 i32, num2 i32) sum i32
* 0.- AddInput i32
* 1.- AddInput List
* 2.- AddInput Complex
* 3.- AddInput StdLib.Stream
* 4.- AddExpression fn10
* 5.- AddExpression StdLib.fn14
1.- Function: fn10 (items StdLib.Stream)
* 0.- AddInput i32
* 1.- AddInput List
* 2.- AddInput Complex
* 3.- AddInput StdLib.Stream
* 4.- AddOutput i32
* 5.- AddOutput List
* 6.- AddOutput Complex
* 7.- AddOutput StdLib.Stream
* 8.- AddExpression fn5
* 9.- AddExpression StdLib.fn14
0.- Expression: fn5(items StdLib.Stream, items StdLib.Stream, def2 i32, hugs i32)
2.- Module: StdLib
* 0.- AddDefinition def44 i32
* 1.- AddDefinition def45 Stream
* 2.- AddImport mod0
* 3.- AddImport Math
* 4.- AddFunction fn46
* 5.- AddStruct strct47
Structs
0.- Struct: Stream
* 0.- AddField fld48 i32
* 1.- AddField fld49 Stream
Functions
0.- Function: fn14 ()
* 0.- AddInput i32
* 1.- AddInput Stream
* 2.- AddOutput i32
* 3.- AddOutput Stream
A function which continually applies affordances to an empty program
is provided. This function, RandomProgram, receives a number that
represents how many affordances will be applied, and returns the
generated context. For example, by running
cxt := RandomProgram(100)
cxt.PrintProgram(false)
we get an output similar to this:
0.- Module: mod26
Definitions
0.- Definition: def27 i32
1.- Definition: def33 i32
2.- Definition: def39 i32
Functions
0.- Function: fn31 (in36 i32, in38 i32, in51 i32)
1.- Module: mod42
Definitions
0.- Definition: def113 mod42.strct89
1.- Definition: def119 strct89
2.- Definition: def135 mod42.strct89
3.- Definition: def142 mod42.strct48
4.- Definition: def63 strct48
5.- Definition: def75 i32
Structs
0.- Struct: strct48
0.- Field: fld54 strct48
1.- Field: fld57 strct48
2.- Field: fld59 i32
1.- Struct: strct89
0.- Field: fld94 mod42.strct89
1.- Field: fld99 mod42.strct89
2.- Field: fld128 strct89
Functions
0.- Function: fn44 (in49 strct48, in55 strct48, in58 strct48, in61 strct48, in66 strct48, in67 strct48, in68 strct48, in69 strct48, in95 mod42.strct48)
1.- Function: fn106 (in108 mod42.strct48, in116 mod42.strct89, in117 mod42.strct89, in138 mod42.strct89)
2.- Module: mod146
which sadly didn't add any expression to any function it created (so it wouldn't do anything if executed).