Roadmap

Updated 560 Days AgoPublic

Actions

This is the wiki format of the Ratscript development roadmap. It should be kept in sync with the Ratscript Projects Workboard.

When coding in exit codes for Ratscript, follow the sysexits conventions as mentioned in Crafting Interpreters.

v 0.1

• Parsing/lexing via tree walk method.
• Command line console
  • Start with command line to enter text and print / return same text
    • Output cursor #>
  • Plug parser into command line script as functional
  • Eventually make a nicer gui interface? (Related but not in v0.1)
• Math functionality:
  • Parsing and tokenizing numbers. Use SIMPLExpress, not regex
    • First integer (int), then decimal (number)
  • Parsing and tokenizing basic math operators (+, -, *, /, %, ^, open and close () Keeping in mind that parenthesis will need to be parsed for all kinds of things, not just math.)
    • Include - as a negation, that is, to create a negative number; parse correctly compared to using as a subtractor
    • Include precedence/order of operations per the standard P[E][MD%][AS] (Parenthesis, Exponent, Multiplication, Division, Modulo, Addition, Subtraction)
      • 1 + 2 * 3 occurs as 1 + (2 * 3)
  • Display an error if it can't do these things
  • Display a result if it can

v 0.2

• Console read script file as well as accepting direct input
• Print Statement
  • Crafting Interpreters "bakes this in", rather than making it a core library function. How should we handle it?
  • If we find that we need to postpone working on print statements, shift to return statements
• Conditional statements:
  • Start with if, then include while, for, possibly switch
    • if statements should be simple to start, for example...

if 1 + 1 == 2
;  print("Magic!")
; # Alternatively, if we postpone print, return True
end

• Start with ==, then comparisons:
  • True/false logic (if !true == false)
  • less < than, less_than <= or_equal, greater > than, greater_than >= or_equal, exactly == equal, not != equal
  • not, or/and logic (if 1 + 1 == 2 or 1 + 1 == 3), (if 1 + 1 == 2 and 2 + 2 == 4)
  • is - type checking
• This will have to include handling the subordination operator ;

v 0.3

• Variable assignment (will need to include memory handling)
  • Start with integer (int), decimal (number), string
  • make - variable assignment
    • Type casting as <type> - worth including from the start, probably.
  • let - temporary variable
  • define - constant
  • Null variable
  • Note: ratscript/old/ folder has some memory handling stuff
• Verify consistency with mutability/immutability rules described in wiki
• Verify consistency with typecasting rules

Unprioritized milestones and breakdowns

• Conditionals, functions, etc, in general, terminated by end (anything with subordination)
• Line of code terminated by newline unless extended with ...
• Booleans
• Trileans
• String handling (presumably via pawlib and onestring?)
  • String concatenation folded into the + operator
  • String formatting (See Python f-string and/or %s syntax?)
• Switch statements if not handled in v 0.2
• Functions, function definition
  • If left untouched in v 0.2, return (automatically return non-value if no defined return)
• Further variable definitions - each data type will need some degree of its own memory assignment, etc. Some or all of this may end up in v0.3.
  • Collections
    • Array, list, linked list, queue, stack, dictionary, set....
  • Functional programming
    • Comprehensions (list, dictionary, set), lambdas, decorators, generators, and coroutines
• Other data types untouched in v 0.1-0.3 (bytes, float, vector, matrix, datetime, etc.)
• Tests
• Classes, class definition, inheritance
• Attributes
• Read/write to files
• try / catch statements
• with statements
• Error handling
• Standard Library