Types:
a :: Int varname :: Type
Assignment: a = b varname = varname or literal (or expression)
Declaring a variable and not using it should only give errors on release build
Expression Syntax:
The operator should be added between the operands
1 + 2 # 3
a :: Int b :: Int a + b # anything
Extended expressions are possible too a :: Int a = b + c + 3 + e
Negation operator will negate the variable a :: Int b :: Int a = -3 b = -a # 3
Functions should first be given a Type and Parameter types (This can be on any line) Sum :: Int <- |Int| Sum([]) # In case of an emtpy array return 0 (or null) end Sum(x) #If given a variable it assumes you want to actualy use it for logic sum :: Int x.foreach |i| sum += i end end
This allows for pattern matching in PandahV2 When there is a function that takes multiple parameters and you don't need all of them for the logic you can use an _ to say you don't care Move :: Void <- Bool, Int # Can Move, Speed Move(false,_)
end Move(true, speed) @x += speed #do logic with the given parameter end
As seen in the previous function. different variables should get different prefixes. Private: no prefix Public: if an instance variable use @ if a class variable use $ (Static or global)
This is dont so one could type in 1 character to see all the variables that belong to an instance (in a reasonalbly good ide)
Pandah uses Classes to represent basic data in this way:
class Animal name :: String Move :: Int <- Bool, Int
end
Pandah prefers to have all the variable names on the top so one could quickly look at what a class can do. Actual Logic should happen further down the class structure. (this is not yet forced) Pandah also strives to support higher order functions (means: passing functions as parameters)
FindSpeed :: Int <- String Move :: Int <- Bool, Int <- String #Can Move, findSpeed
Move(true, function) function(@name) end
#logic Move(true, FindSpeed)
A "Hello Pandah" in Pandah would look like this:
class Greeter Greet :: Void <- Void
Greet() do Print("Hello World") end end
greeter :: Greeter #Gives type greeter = Greeter.new() #Calls constructor greeter.Greet() #Calls Greet function
Pandah also has a build-in unit test framework. It works like this Anywhere in code (Preferably at the end of any class you are testing) you can add a Test function like this
[RUN] myAnimal.Move(true, 1) [TEST] @x == 1
As you can see the testing is based on prefixes which tell the framework what to do. Other prefixes are
[RESET] myAnimal = Animal.new() #Resets the variables (Runs before every [RUN] Prefix)
Like some other languages Pandah starts globally (not within any class or method) This makes it easier to write quick snippets of code without having a whole class structure ready.
Pandah can use blocks as arguments Blocks are made by putting & before the type that the block wants. for example &Int (a block of code that does something with an int)
Blocks can be used for iterative functions like this
10.Times() do |i| print i end
What this code does is call the Times function. this function takes a block of type Int. In this case the block is "print i". i is an iterator given by the times function. To give a block a variable to use can be done using the yield keyword. the yield keyword runs the given block. This is what the Times function would look like
Times :: Void <- &Int Times(block) while i < this block(i++) end end
As you can see it uses this to know when to stop. This is because the function was called on an Int. It also has a block parameter. this parameter is a function that runs the given block. the parameters of this block will be used in the block. There is no pattern matching in blocks.
TODO: Rethink Constructor calling (new Animal and Animal.new are both meh) Think some more
program : declaration* EOF declaration : vardecl | methoddecl | statement ; methoddecl : IDENTIFIER "::" TYPE "<-" (TYPE) (("," TYPE)* )? vardecl : IDENTIFIER "::" TYPE ; statement : expression ; block : DO statement END | "{" statement "}" ; assignment : IDENTIFIER "=" expression ; expression : logic | assignment ; logic : equality ( ( "||" | "&&" ) equality)* ; equality : comparison ( ( "!=" | "==" ) comparison )* ; comparison : addition ( ( ">" | ">=" | "<" | "<=" ) addition )* ; addition : multiplication ( ( "-" | "+" ) multiplication )* ; multiplication : unary ( ( "/" | "" | "%" ) unary ) ; unary : ( "!" | "-" ) unary | primary ; primary : NUMBER | STRING | IDENTIFIER | "false" | "true" | "null" | "(" expression ")" ; while : "while" expression "do" declaration* "end"