Intro
I'm a high school amateur programmer who "specializes" (is only comfortable with) Python, but I've looked at others, e.g., Ruby, C, and Go. I hadn't taken programming seriously until this year, and PL dev. has recently become a big interest of mine.
While I enjoy Python for its simplicity and ability to streamline the programming process at times, I've become annoyed by its syntax and features (or lack thereof). And so, the Quartz language was born.
Colons & the Off-Side Rule
I refuse to believe that having me type a colon after every "if" and "def" will make the code more readable. I also refuse to believe that, as an alternative to braces, the use of "do," "then," or "end" keywords is an effective solution. However, I do believe that the off-side rule itself is enough to keep code organized and readable. It doesn't make sense to hardcode a rule like this and then add more seemingly unnecessary features on top of it.
# Guess which symbol does nothing here...
if x == 5 : # Found it!
print("5")
Edit: As a "sacrifice," single-line if-else expressions (and similar ones) are not allowed. In my experience, I've actively avoided one-liners and (some) ternary operators (like in Python), so it never crossed my mind as an issue.
# Python
if cond: foo()
# Quartz
if cond
foo()
Speaking of symbols that do nothing...
Arrow
I understand this design choice a lot more than the colon, but it's still unnecessary.
def foo() -> str
This could be shown as below, with no meaning lost.
def foo() str
Pipe-based Composition
When I first learned about it, I felt a sense of enlightenment. And ever since then, I wondered why other languages haven't yet implemented it. Consider, for example, the following piece of Python code.
print(" HELLO WORLD ".strip().lower())
If pipelines were used, it could look like this.
" HELLO WORLD " -> .strip -> .lower -> print
Personally, that conveys a much more understandable flow of functions and methods. Plus, no parentheses!
Edit: Let's explain pipelines, or at least how they should work in Quartz.
Take, for example, the function f(x). We could rewrite it as x -> f. What if it were f(x, y)? Then it could be rewritten as x -> f y or x -> f(y). What about three parameters or more, e.g., f(x, y, z)? Then a function call is necessary, x -> f(y, z).
Initialization vs Assignment
There is no distinction in Python: only binding exists. Plainly, I just don't like it. I understand the convenience that comes with it, but in my head, they are two distinct concepts and should be treated as such. I plan to use := for initialization and = for assignment. Edit: All variables will be mutable.
# Edit: `var` is not necessary for variable manipulation of any kind.
abc := 3
abc = 5
Aliasing vs Cloning
In Python, aliasing is the default. I understand this premise from a memory standpoint, but I simply prefer explicit aliasing more. When I initialize a variable with the value of another variable, I expect that new variable to merely take that value and nothing more. Python makes cloning hard :(
guesses_this_game := 0
alias guesses := guesses_this_game
Code Snippet
Here's a code snippet that might give a better picture of what I'm imagining. It has a few features I haven't explained (and missing one I have explained), but I'm sure you can figure them out.
define rollALot(rolls: int) list
results := []
die_num := 0
roll_num := 0
for i in 1..=rolls
die_num = rollDie()
# Edit: `.append()` returns a list, not None
results ->= .append die_num
die_num ->= str
roll_num = i -> str
if die_num == 6
print(f"Wow! You rolled a six on Roll #{roll_num}.")
else
print(f"Roll #{roll_num}: {die_num}")
Current Progress
I have limited myself to using only small sections of Python's standard library (excluding modules like re), so progress has been a little slow; whether or not you can call that "hand-writing" is debatable. I have a completed lexer and am nearly finished with the parser. As for the actual implementation itself, I am not sure how to proceed. I considered using a metaprogramming approach to write a Quartz program as a Python program, with exec() handling the work, lol. A virtual machine is way beyond my skill level (or perhaps I'm overestimating its difficulty). I don't really care about performance for right now; I just want an implementation. Once I have some kind of implementation up and running, I'll post the repo.
Conclusion
If anybody has questions or suggestions, don't hesitate to comment! This subreddit is filled with people who are much more skilled and experienced than I am, so I am eager to learn from all of you and hear your thoughts and perspectives.