README: bump for 0.3.0.0 alpha

Author: uditkarode

README.md

@@ -8,23 +8,29 @@
 
 (print "this is my programming language, axolotl")
 
-(defun get-count [(argument-for-no-reason: int)] {
-  (+i argument-for-no-reason 1)
+(defun get-given-count [(argument-for-no-reason: int)] {
+  (+ argument-for-no-reason 1)
 })
 
 (def text1 "If I have ")
+(def text2 " apples to everyone, i'll be left with ")
 
-(defun arbitrary-function [(initial: int) (text2: string)] {
+(defun arbitrary-function [(initial: int)] {
   (print "expressions are written in braces")
   (print "and the last value is returned!")
-  (print (str text1 (+i initial 2) " apples and I give " (get-count 2) text2 (/f (+i initial 2) (get-count 4)) " apples!"))
+  (print (str text1 (+ initial 2) " apples and I give " (get-given-count 2) text2 (/ (+ initial 2) (get-given-count 4)) " apples!"))
   420
 })
 
-(def initial 37)
-(def t2 " apples to everyone, i'll be left with ")
+(defun variadic-example [(ability: string) &(more: string)] {
+  (print "Axolotl can also do " ability)
+  (print "Here are the remaining arguments: " more)
+})
+
+(def initial-val 37)
 
-(print (arbitrary-function initial t2))
+(print (arbitrary-function initial-val))
+(variadic-example "variadic functions!" "abcd" "efgh" "ijkl" "mnop")
 ```
 _Outputs:_
 ```
@@ -34,6 +40,8 @@ expressions are written in braces
 and the last value is returned!
 If I have 39 apples and I give 3 apples to everyone, i'll be left with 7.8 apples!
 420
+Axolotl can also do variadic functions!
+Here are the remaining arguments: ["efgh","ijkl","mnop"]
 ```
 
 # Syntax Guide
@@ -43,10 +51,9 @@ Files can be run using `axl` -- `axl run program.axl`
 
 ## Comments
 Single line comments start with `;` and multi-line comments start and end with `#|` and `|#` respectively.
-Note that as of 0.1.0.0 alpha, there's a parsing bug when a comment is the first thing in an axl file.
 
 ## Calling Functions
-Since axolotl is lisp-like, functions are called using `(function-name arg1 arg2 ...)` instead of `functionName(arg1, arg2, ...)` that many other languages use.
+Since axolotl is lisp-like, functions are called using `(function-name arg1 arg2 ...)` instead of `functionName(arg1, arg2, ...)`.
 
 ## Variables
 Variables can be declared using the `def` function, where the first argument is the name of the variable (optionally typed) and the second argument is the value to assign to it:
@@ -57,7 +64,7 @@ Variables can be declared using the `def` function, where the first argument is
 (def (name2: string) "paul") ;; creates a variable 'name2' with the value "paul"
 (print name " and " name2 " are friends") ;; cody and paul are friends
 ```
-Variables are accessible in their immediate scope **after** they are defined, and are immutable; as of 0.1.0.0 alpha there's no way to mutate them, though something is planned.
+Variables are accessible in their immediate scope **after** they are defined, and are immutable; as of 0.3.0.0 alpha there's no way to mutate them, though something is planned.
 
 ## Functions
 Functions can be defined using the `defun` function, where the first argument is the name of the function (optionally typed), the second argument is an array of arguments to it (which must be manually typed), and the third argument is the set of expressions to evaluate inside braces (this creates a new scope that includes all the defined variables above the function definition, and the arguments to it:
@@ -73,13 +80,20 @@ Functions can be defined using the `defun` function, where the first argument is
 
 ## Mathematical Functions
 Only the operators +, -, * and / are available for now, each is a function that can take any number of arguments.
-As of 0.1.0.0 alpha, there are two versions of these operators - one that returns an integer, and one that returns a float.
+
+There are two versions of these operators - one that returns an integer, and one that returns a float.
 The integer version rounds the result if it gets a float, and the float version converts to float if it gets an int.
 If you want the integer version, append `i` to the function name, and if you want the float version, append `f` to the function name.
+
+By default, if there's a float value in the arguments, the float variant will be used in case of +, -, *.
+For division, the float variant will always be used by default.
+
 For example,
 ```clojure
 (print (+i 2 4.95)) ;; 7
+(print (+ 2 5)) ;; 7 -- since there's no float in the arguments, it automatically uses the float variant
 (print (+f 2 4.95)) ;; 6.95
+(print (+ 2 4.95)) ;; 6.95 -- since there's a float in the arguments, it automatically uses the float variant
 
 (print (-i 2 4.95)) ;; -3
 (print (-f 2 4.95)) ;; -2.95
@@ -92,7 +106,7 @@ For example,
 ```
 
 # Utility Functions
-As of 0.1.0.0 alpha, there's only two utility functions - `str` and `print`
+As of 0.3.0.0 alpha, there's only two utility functions - `str` and `print`
 ```clojure
 ;; str can be used to concatenate any number of arguments of any data type to form a string
 ;; print prints the arguments it gets to stdout with a newline