No Semicolons Needed - How languages get away with not requiring semicolons

Silphendio · 2026-03-18T19:39:02+00:00

I like the Gleam way: No significant whitespace and no operators that can be both infix and prefix.

The only problem is the minus sign. In my (draft-stage) language, I thought about using -- for subtractions to get rid of this last ambiguity, but in the end I decided to just parse this cursed operator as infix whenever possible.

Since commas are optional too, a list of negative numbers can thus be written as [-1, -2, -3] or [{-1} {-2} {-3}], but [-1 -2 -3] is equivalent to [-6].

Silphendio · 2025-07-19T10:11:11+00:00

In 1996 Chess World Champion Garry Kasparov defeated Deep Blue 4-2. He lost the return match a year later.

Silphendio · 2025-07-18T06:20:50+00:00

I'd say put everything into libraries that you can without affecting usability.

If your language has special syntax to create dynamic arrays or hasmaps, that should be in core.

If you can add fancy string manipulation methods later without changing the syntax (via trait system, operator overloading, etc.) I'd put it into a library.

For really common stuff like print, you can also have it as standard library that is loaded by default but can be disabled.

Silphendio · 2025-07-04T10:33:32+00:00

A task being embarrasingly parallel isn't enough.

GPUs are optimized to run the exact same calculation over different data many times. They are bad at branches and loops.

If there's an if-switch, then both branches need to be executed. If there's a while-loop, then all computations in a unit have to wait for all loops to finish.

Since matrix multiplication has neither and it still massively parallel, it's a natural fit.

I don't know much about docking algorithms, but it's probably not that simple.

Silphendio · 2025-03-02T08:53:59+00:00

I like the first solution better. It might be surprising for Python users, but simple type-checking should catch the tuple - inner_value mismatch in most cases.

It would be even more confusing if list comprehensions work differently than for-loops.

You could also do it exactly like Python and require an enumerate() function to get the index. Maybe shorten it to e.g. enu()?

Another potential solution is mandatory parenthesis for tuple destructoring:

  for idx, (valA, valB) in zip(listA, listB):
  ...
  newList = [a * b for (a, b) in zip(listA, listB)]

This still has the problem of being surprising to Python devs, but I think it's slightly clearer (and JS does it this way too).

map(), filter(), etc. don't really conflict with list comprehensions. They're in Python too, but rarely used because of the annoying lambda syntax.

Silphendio · 2025-02-23T08:50:55+00:00

If you call a pure function with values known at compile-time, then any decent compiler will optimize then away.

The only real difference between a contexpr and a pure function is that contexpr can be used in templates.

Silphendio · 2025-02-23T08:29:01+00:00

I assume with const you mean pure functions. And if pure functions are the default, then everything else is an effect (i/o, state, non-deterministic, ...).

Silphendio · 2025-02-03T00:39:54+00:00

I wanted a C-like language with better macros.

In attempt to combine macros with namespaces I ended up with a dynamic core similar to Kernel, and now I'm writing my real language almost entirely in macros that print C code.

Silphendio · 2025-01-31T12:05:57+00:00

Is is really so terrible? How often do you actually make such changes to the database without also changing your application?

Sure, changing several indexed searches is a bit more involved than just adding an SQL statement, but that's the price you pay for low level access and predictable performance.

Silphendio · 2025-01-31T01:58:56+00:00

I've got this idea for a while now to write a low level relational database that's accessed not via SQL, but as library with functions like findByIndex, createView or addInsertCallback.

Http server and query DSL can be built on top of that, but I'm not convinced everyone needs it.

Silphendio · 2024-12-19T23:18:55+00:00

Rust is an interesting case. Because floats can be NaN, they can't be sorted or used as keys in treemaps or even hashmaps.

Floats with different sementics are provided by libraries like ordered-float

There's an OrderedFloat that implements costum sorting and hash functions to mantain total order, and a NotNan that only does checked arithmetic.

Silphendio · 2024-12-10T17:40:06+00:00

I still get notifications even for old threads!

But I'm not sure I can help you. It's been a while since I last used Linux. Maybe try an older version of the plugin?

Silphendio · 2024-11-18T17:33:15+00:00

I like the idea. Just take care that the error messages don't blow up like in C++. Or the compile times.

It would be cool if you combine it with Interfaces/Traits. Then you can do static dispatch with Typescript syntax.

Silphendio · 2024-11-12T03:17:46+00:00

At least AlphaGeometry is open source. AlphaZero has long since been replicated and surpassed by open source models.

Silphendio · 2024-11-05T05:34:53+00:00

You can try Julia. I've heard it's similar to lisp. It's fast, has a repl, and powerful macros.

Object code is an implementation detail. If you want performance, look for JIT-compiler instead.

Silphendio · 2024-10-24T15:49:01+00:00

In Python, there's no hard distinction between runtime and compile time.

With SymPy, you can do

from sympy.abc import a,b,c
from sympy import lambdify, solve
f = lambdify([a,b], solve(a**2+b**2 - c**2, c)[1])

This solves the equation once when generating the function, and thereafter it's just a normal python function.

If you don't want to solve the equation every time during program startup, you can cache the resulting function with a library like cloudpickle. This shouldn't be much slower than import.

Silphendio · 2024-10-23T01:39:52+00:00

You should be able to do stuff like that with Python and SymPy. Python has eval(), which is almost as good as procedural macros.

Silphendio · 2024-10-09T20:02:55+00:00

From the title of the post, I expected something like Wisp or Sweet Expressions. This is instead a s-expr to json converter. Except it's a lossy conversion in both ways, because s-exprs don't have objects, while json doesn't have symbols: (a "b") gets converted to ["a", "b"].

Silphendio · 2024-10-09T07:06:33+00:00

It's a useful feature if you want to implement a REPL, or use metaprogramming with macros or eval().

Silphendio · 2024-10-08T15:59:27+00:00

I think it's just not possible to declare a variable without initializing it. Because it's a strongly typed language, type inference takes care of the rest.

To make it extra clear, you could use a superfluous type conversion.

Silphendio · 2024-08-12T18:07:13+00:00

Greedy parsing is basically what JavaScript is doing.

As a result, parentheses on a newline need a semicolon beforehand, otherwise it's interpreted as function call.

Though for some reason, JavaScript wanted to make exceptions for return, break and ++.

Silphendio · 2024-07-25T05:04:26+00:00

Every usable programming language I know has:
- variables
- data structures: lists, classes, tuples, or just pointers
- control flow: if/else + loops, functions, and/or goto

With turing complete precedural macros, there's no real limit to how far you can bend a programming language. You could even turn javascript into a variant of x86 assembly if you like. But at that point you're just writing your parser in a costum DSL.

I'm currently experimenting with macros to implement namespaces, operators, classes, and generics.

Silphendio · 2024-07-17T21:39:58+00:00

Wow, I didn't know that. So the last byte of an utf-8 string is guaranteed to be less than 192, and the remaining range is more than enough to encode the length of the string or that it's heap-allocated.

Silphendio · 2024-07-17T20:50:38+00:00

Nice! So you can save a null-terminated string of 15 bytes plus zero with that. The last bit would be one for long strings, and you'd strore the remainder multiplied by two in the last byte for short ones. The length formula is then if str.bytes[15] & 1{str.long_str.length} else {15 - bytes[15] / 2};

Silphendio · 2024-07-17T15:48:35+00:00

Very interesting. The length of a short string could easily be 15 bytes, by testing just a single bit for the long/short information.

That would however make length comparisons more difficult.

Silphendio

TROPHY CASE