Series: Examples, Questions
I have restarted my effort to make a new programming language that fits the way I like things. I haven’t pushed any code yet, but I have made a lot of progress in my head to understand what I want.
Here are some random examples that might get across some of the ways I am thinking:
// You code using general types like "Int" but you can set what // they really are in the code (usually at the beginning), so // if you plan to use native ints in the production code, it's // a good idea to use: Int = CheckedNativeInt; // while in dev, since it will crash at runtime if you overflow. // Then, in production when you're sure you have no errors, // switch to an unchecked one: Int = NativeInt; // But, if you prefer correctness over efficiency, you can use // mathematical integer that never overflows: Int = ArbitrarySizeInt; // Variables are immutable by default, so: Int x = 4; x = 3; // this is a compile error // But this is OK Mutable(Int) y = 6; y = y + x; // Notice that you can call functions that return types that you // then use, like Mutable(Int) here. // Generally, code can run at either compile time or run time. // Code to do with types has to run at compile time. // By default, other code runs at run time, but you can force // it to run early if you want to. // A main method looks like this - you get hold of e.g. stdout through // a World instance - I try to avoid any global functions like print, or // global variables like sys.stdout. Auto main = {:(World world)->Int //... }; // (Although note that Int, String etc. actually are global variables, // which is a bit annoying) // I wish the main method were simpler-looking. The only saving grace // is that for simple examples you don't need a main method - // Pepper3 just calculates the expression you provide in your file and // prints it out. // Expressions in curly brackets are lambda functions, so: {3}; // is a function taking no arguments, returning 3, and: {:(Int x) x * 2 }; // is a function that doubles a value. Obviously, we can tie functions to names: Auto dbl = {:(Int x) x * 2 }; // Meaning we can call dbl like this: dbl(4); // Auto is a magic word to say ("use type inference"), so // this is equivalent to the above: fn([Int]->Int) dbl = {:(Int x) x * 2 }; // Because {} makes an anon function, things like "for" can be // functions instead of keywords. for(range(3), {:(Int x) world.stdout.println(to(String)(x)); }); // As far as possible, Pepper3 will only contain assignment statements: String s = "xx"; // and expressions containing function calls and operators: dbl(3) + 6; // This means we can make our own constructs like a different type of // for loop, which would need a new keyword in some languages: Auto parallel_for = import(multiprocess.parallel_for);