Nanoscript

Nanoscript is a minimalist programming language crafted entirely from scratch using pure Python without relying on external libraries like ply or pybison.

Features

• Arithmetic Expression Evaluation

  Evaluate numeric expressions like `4 * (3 + 2 - (3 % 4))`, etc
  

• Variables

   - Syntax : Use the `let` and `const` to define variables.
  - Assignment: Currently supports numbers and arithmetic expressions.
  - Scoping: Support global and function scoping
  

  // Exampleconsta=5;letb=10;letx=y=x=12;b=5;// worksa=10;// throws an errorconstc;// throws an errorleta=12;// throws an error

• Objects, Nested Objects and Accessors

   - Syntax : Similar to JS objects, use curly braces `{}`
  - Assignment : Currently supports only numbers and arithmetic expressions
  - Scoping : Every property inside the object belongs to the object and are scoped to it
  - Accessors : Use the dot operator (.) to access properties inside an object. For nested properties, see the example below
  

  // Exampleletobj={a : 32,b : 39+23-5*4%2nested : {foo : {bar : 1}}};a=b+15// throws : Cannot resolve b as it does not existobj.a=obj.b+15// this is valid// accessing nested propertiesobj.nested.foo.bar=2

• Global and User Defined Functions

   - Syntax : - Use the `fn` keyword to create user defined function. - Use the `make_native_fn` macro to create global methods. See `create_global_env()` method in `runtime/environment.py`
  - Note :
  - `return` statement is yet to be implemented. In the current implementation, the last statement / expr in the function declaration is returned
  

  fnadd(x,y){constres=x+y;res// res is returned}leta=add(10,2);

• Nested Functions and Nested Call Expressions :

   - Syntax : Just like the normal function, use the `fn` keyword and create functions within functions
  - Scoping : Inner functions have access to outer function's scope but not vice-versa. See the example below to understand better about scoping
  

  letres;// A. this is in global scopeleta;// A. this is in global scopeletb;// A. this is in global scopefncalc(x,y){letres;// B. this is in the 'calc' function's scopefnadd(x,y){constVAL=1;res=x+y// refers to B.res}fnsub(x,y){res=x-y// refers to B.res}res={// refers to Ba : add(x,y),b : sub(add(x,y),10)}// throws : Cannot resolve VAL as it does not exist print(VAL)}// refers to A (although, in this case the program terminates // since we are accessing VAL from outer scope)print(res)

Some Notes On Grammar

• Order of precedence :

  
  lower in the tree or the call stack has the highest precedence
  | Stmt (lowest)
  | Expr | VariableDecl
  | AssignmentExpr
  | ObjectExpr
  | AdditiveExpr
  | MultiplicativeExpr
  | CallExpr
  | MemberExpr
  v PrimaryExpr (highest)
  more precedence = further down the tree
  so, additive calls multiplicative. multiplicative calls primary. similarly, assignment calls object expression, and so on
  At any level of the stack described above, the expr that the parser currently points at will always :
  - return something or
  - call itself or
  - call an expr that has a lower precedence
  - call an expr that has a one level higher precedence
  At no point, an expr calls another expr that has more than one level of precedence difference. It always passes through the above order. So, for example :
  VariableDecl can not directly call PrimaryExpr or say
  AdditiveExpr can not directly call MemberExpr
  Technically speaking, this would be the grammar of this language at this point :
  Stmt := Expr | VariableDecl
  Expr := AssignmentExpr
  AssignmentExpr := AssignmentExpr | ObjectExpr
  ObjectExpr := Expr | AdditiveExpr
  AdditiveExpr := MultiplicativeExpr
  MultiplicativeExpr := PrimaryExpr
  

• Note :

   - The grammar created here is based on the parser implementation.
  - Ideally, it would the other way around - we write the rules and code a 'meta program' to auto-generate the parser file. For the time being, this is what we will be working with the former.
  - This is bound to change in the future.
  

Getting Started

To dive into Nanoscript, simply clone this repository and start experimenting with the language.

To execute your Nanoscript code use the provided REPL .

git clone https://github.com/Vishvam10/NanoScript
cd src
python repl.py

License

This project is licensed under the MIT License - see the LICENSE file for details.

Acknowledgements

Big thanks to @tlaceby for initiating the guide-to-interpreter series. I absolutely loved it 💛. Your work inspired me to create a Python port, building upon your foundation, with the hope of making it even better.