diff options
Diffstat (limited to 'comp/lucas-standen-NEA/overview')
| -rw-r--r-- | comp/lucas-standen-NEA/overview | 302 |
1 files changed, 302 insertions, 0 deletions
diff --git a/comp/lucas-standen-NEA/overview b/comp/lucas-standen-NEA/overview new file mode 100644 index 0000000..5f7904e --- /dev/null +++ b/comp/lucas-standen-NEA/overview @@ -0,0 +1,302 @@ +CS course work project + +zippy - a high level functional programing language + +zippy will be an interpreted language designed to replace C in higher level use +C is used largely to write most of the unix desktop, however c can be difficult +when writing larger programs, and is missing moddern features like oop or +functional patterns (higher order functions) + +requirents: + - must be human readable, even a non programmer should be able to figure + out what a program is doing + - faster than competion, other languages that have tried to slot into + this position like python are far to slow, and thus it must be faster + - low runtime overhead, the interpreter should be small, it shouldn't + force the developer to think about how the interpreter works to use it + efficently + - have moddern tools, a pkg manager and enviroment manager, making it + easy to develop for + - needs to support c libarys + +language info + +zippy will use function programming as a primary solution, however also support +simple oop, with classes (no inheritence) +its syntax will be comparable to lisp, with prolific use of "()" +it will need a stdlib, which can be taken from C's stdlib + +types: + + char - just like a c char + i32 - 32 bit signed int + f32 - 32 bit signed float + u32 - unsigned 32 bit int + i16- 16 bit signed int + u16 - 16 bit unsigned int + bool - TRUE/FALSE + + + arrays: + + arrays can be created like so + (let arr[]:char "hello there") + (let arr[]:i32 1 2 3) + + all arrays are linked lists of there data type + their size is not fixed + + you can get, or set the value of an array at a specific index using + arr[index] + + strings: + + strings are arrays of chars + a string can be defined by a litteral like so + "hello world" - this is the same as 'h' 'e' 'l'.... + because this is represented as a linked list there is no need to have a + NULL terminator like in c, the end of the string is jus the point where the + linked list has no more nodes + +comments: + + comments can be writen like so + ! this is a comment + +indentation and spacing: + + indentation and new lines arent at all necesary + any new lines will be converted to spaces, and tabs will be removed + the only place that needs spaces is when calling a function and giving its args + +scopes: + + () can be placed anywhere, and anything that is in them is in there own scope + as soon as the bracket is closed, any variables defined in the scope + will be deleted + any scope inherets all variables and functions from the scope that contains it + code writen in the main body of the file can be imagined like so + ( + ... + ... + ... + your code + ... + ... + ... + ) + however that level of indentation is not needed + + this can be helpful if you want to have two scopes with different imports + ( + (import z) + ( + (import x) + ! anything writen here has access to libary x and z + ) + ( + (import y) + ! anything writen here has access to libary y and z + ) + ! anything writen here has access to libary z + ) + +libarys: + + libarys are similar to header files in c + when imported the user can use any function contained within the file + + it would be good practice to put your libary in a struct to avoid functions with the + same names coming from 2 libarys, however its not needed + +errors: + + errors would be + +keywords: + + (defun arg1:type arg2:type returnType + ... + ... + ... + ) + defines a function, can be done anywhere in the program, all functions + must return a value, return type and arguments must be known at runtime + + returns the function that can be asigned with let + + (return VALUE) + returns VALUE from a function, VALUE must be of the same tupe as returnType + in defun + + (for x a b function) + + runs the function inside the loop, x will be increment by 1 each iteration and + it will have a starting value of a running until it reaches b (inclusive) + x cant be changed in any way other than the for loop + x, a, b are all of type i32 + + (while condtion function) + + runs all code inside the loop until the condion is not TRUE + condition must be a bool (TRUE/FALSE) + + (let name:type value) + + assign value to variable name, this will create the variable if it doesn't already + exist, and overwrite it if it does + names type must be defined by type + + (const name:type value) + + same as let but creates an imutable variable + + (import libary) + + searches the libary dir and imports the libary to the current project + libary can also be a specific path if it starts with / or ./ or ../ + + (struct name + ... + ... + ... + (defun init arg1:type type + ... + ... + ... + ) + (defun deinit arg1:type type + ... + ... + ... + ) + ) + + structs can be used as a custom data type + creates a struct/class called name, functions called init will be ran when an + object is created + when deinit is called the code init will be ran, then the object will be deleted + if deinit is not defined it can still be called to delete the instace of the class + + you can create a struct like so: + (let mystruct:name (name.init arg1 arg2)) + + you can call a method attached to an instace of a struct like this: + (mystruct.method arg1 arg2) + + and to destroy it you can just use this: + (mystruct.deinit arg1 arg2) + + structs can be recursive + eg: + (struct node + (defun init next:node + (let next:node next) + ) + ) + + a struct can have default values + eg: + (struct person + (let age:i32 50) + (let name[]:char "john doe") + ... + ... + ... + ) + + this will make the struct have default values + + overall in simple terms structs are just like c structs but they can contain + functions + + (symbol arg1:type arg2:type returntype location) + + returns a function that can be called. the function is retrieved from a .o file + which can be writen in C, the args, should be the args that the function takes in + and there types + the interpreter will try to convert data to the equal type in C, however this may need + to be done manually + the location should be a string which is is the file path to the .o file + + (if condition + ... + ... + ... + )(elif condition + ... + ... + ... + )(else + ... + ... + ... + ) + + simple if statment, if condition is TRUE run the code inside, elif runs if the condition in it + is TRUE and if the previous has not been TRUE + else will run if nothing else is TRUE + + (cast TYPE variable) + + returns a variable casted to type TYPE, if type is function, will return a function with no args + that returns the variable value in its starting type + + conditions: + (= a b) returns TRUE if a is equal to be (works with arrays) + (!= a b) returns TRUE if a is not equal to be (works with arrays) + (> a b) returns TRUE if a > b (does not work with arrays) + (< a b) returns TRUE if a < b (does not work with arrays) + (>= a b) returns TRUE if a >= b (does not work with arrays) + (<= a b) returns TRUE if a <= b (does not work with arrays) + (! a) returns TRUE if a is FALSE (only works on bools) + (| a b) returns TRUE if a or b are TRUE (only works on bools) + (& a b) returns TRUE if a and b are TRUE (only works on bools) + (^ a b) returns TRUE if a xor b is true (only works on bools) + + all these are just functions that can be used to assign values + eg: + (let mybool:bool (= a b)) + ! mybool will be TRUE if a = b + + mathmatical operations: + zippy uses reverse polish notation + (+ a b) returns a + b + (- a b) returns a - b + (* a b) returns a * b + (/ a b) returns a / b, whole number eg: (/ 7 3) = 2 + (/. a b) returns a / b, floating point number eg: (/. 7 3) = 2.5 + (% a b) returns the remander of (/ a b) + (** a b) returns a ^ b + + +sample code + (let fib:function (defun num:i32 i32 + (if (< num 2) + (return num) + ) + (else + (return (+ (fib (- num 1)) (fib (- num 2)) )) + ) + ) + ) + (let a:i32 (fib 5)) + ! returns the 5th fib number + +stdlib: + (import io) + io contains a few types + they are: + (io.file) + io contains many io related functions + they are: + + (io.write "hello %s\n" name) ! this is very similar to printf in C + (let input:char[] (io.read)) + + (let file:io.file (io.open path[]:char "method")) + + (io.fwrite file:io.file "hello %s" name) + (let file[]:char (io.fread file:io.file)) + (let line[]:char (io.freadline file:io.file lineno:i32)) + |