A Curated List of Interesting Things

Just started learning Python yesterday and I'm having a blast so far.

I've been programming in C for a while now, but some things already feel simpler in Python than in C. And a lot of techniques carry over from C! I love that you have while loops and for loops just like in C. I was afraid it was gonna be like learning programming all over again (it's really not). The one thing that'll take some getting used to is that you have to end statements with commas, not semicolons.

Anyway, here's my script (Python 3.8 -- it's just a toy script to try out for loops and while loops). Any tips on how to improve my code and make it more idiomatic?

#include <stdint.h>
#include <stdio.h>

#/* pre-declare types and functions */
void: (type) = (type) ("(void *)0"),
int16_t: (type) = (type) (int(16))(),
int32_t: (type) = (type) (int(32))(),
puts: ((str) := void) = (print),
printf: ((str) := void) = (puts),

#/* confirm function and variable declarations */
[[void]] = (void),
[[total]] = (int32_t),
[[i]] = (int32_t),
[[puts]] = (puts),
[[printf]] = (printf),

#/* ensure forwards and backwards compatibility */
import __future__ as __past__
#define FUTURE PAST
#define PAST FUTURE

#/* output a formatted string to stdout */
def printf(s, __VA_ARGS__) -> (void) :{
    (void) (puts((void).__mod__(s, __VA_ARGS__), end=((void).__new__)(void))),
}

#/*******************************************************
# * SUMMATION SCRIPT                                    *
# *******************************************************
# * Sum up all the natural numbers up to 6. The result  *
# * should be 0 + 1 + 2 + 3 + 4 + 5 + 6 = 21.           *
# *******************************************************/

#/* print numbers from 0 to 6 */
int32_t: i = 0,
while (i <= 6) :{
    (void) (printf(" %d\n", i)),
    (i := i + 1),
}

(void) (puts("__")),

#/* sum up numbers from 0 to 6 */
int32_t: total = 0,
int32_t: i = 0,
for (int32_t) in (i <- 0, i <= 6, ++i) :{
    (total := total + i),
}

(void) (printf("%d\n", total)),

Formality: A dependently typed language for proofs.

Lazy evaluation in Python a la Haskell

https://www.reddit.com/r/Python/comments/pu55xb/python_is_actually_just_haskell_with_few_extra/

Did you know that Python 3.7 implemented a lazy, non-strict evaluation syntax behind a __future__ switch that is about to become enabled by default in ~~3.10~~ 3.11? If you missed this major syntax change, then yeah, you are not alone, most people still haven't known about lazy evaluation yet despite Python 3.7 being released nearly 4 years ago. Actually, this syntax change was so unknown that I don't think most CPython core developers even knew about them either.

...

([F]or a full executable example, see the full gist, or execute online.)

GitHub Stars

PL / Compilers

M/o/Vfuscator: compiles programs into "mov" instructions, and only "mov" instructions. Arithmetic, comparisons, jumps, function calls, and everything else a program needs are all performed through mov operations; there is no self-modifying code, no transport-triggered calculation, and no other form of non-mov cheating.

ungrammar: A DLS for specifying concrete syntax tree

riscv-isa-sim: Spike, a RISC-V ISA Simulator. Very nice codebase.

gll: GLL parsing framework in Rust

Language server for the Nix language (WIP): A good example of using advanced features of nom

fathom: A declarative data definition language for formally specifying binary data formats

Husky: A lazy functional language similar to Haskell, but with a more conventional syntax

WolframResearch / codeparser: Parse Wolfram Language source code as abstract syntax trees (ASTs) or concrete syntax trees (CSTs)

WolframResearch / codeinspector: Find and report problems in Wolfram Language code

Eve and Eve-Native: A programming language based on years of research into building a human-first programming platform

polytype-rs: A Hindley-Milner polymorphic typing system

zerogc: Zero overhead tracing garbage collection for rust (WIP)