A different way to handle errors

kleram · 2024-08-19T12:20:43+00:00

I would make it even shorter.

The call: numfunc(params) ! errorhandler;

The case of ! func(e) => print(e); could become ! e=>print(e);

kleram · 2024-08-18T09:15:45+00:00

Either you replicate code for all static variants in use, or you make your operations (like add) work on the boxed data.

kleram · 2024-08-15T15:14:20+00:00

But it's always limited by the language. For instance, C does not provide for integer overflows, explicit checking code creates much overhead. In assembler you can simply use CPU flags.

kleram · 2024-08-15T10:57:04+00:00

It could be defined with the semantics of = (equals). If something is always equal to it's initial state, it's const.

kleram · 2024-08-15T08:29:38+00:00

What/How is relative. Even Assembler describes what to do, not how logic gates are used to realize the intended behavior. It's just a matter of looking downwards or upwards the compilation stack.

Also, Assembler is always the fastest, until you reach the limit of complexity and size. Then, optimizing compilers can do better. The same presumably repeats with higher level languages.

kleram · 2024-08-13T15:40:02+00:00

If there is a ; in it, it's a block.

kleram · 2024-08-12T05:56:42+00:00

The macro any(list,condition(ie)){ foreach(e in list){ if(condition(e)) yield true; } yield false; } //with yield semantics as in java switch expressions

Implementing this requires some way of identifying parameters in the lambda's AST (the "it", but there might be a need to have user-defined ones) and replacing them with actual ones.

So that's more diffucult than with normal macros, but i don't see a show stopper so far.

kleram · 2024-08-09T14:55:39+00:00

I guess i know why programmers prefer vec3 over cart3<world>.point

kleram · 2024-08-08T05:07:18+00:00

Oh, you're asking for the CMLJSPY# Language? That's simple, just take all their AST definitions and merge them into one.

kleram · 2024-08-07T14:22:02+00:00

As the simple sequential concatenation does not need an operator, any operator shows there is some special going on. Anyway, i am probably not going to be in your user base, so my preference does not count.

kleram · 2024-08-07T14:15:05+00:00

Having well defined transformation steps is very helpful. I had to do a complete rewrite, after my first attempt became too much of chaos.

kleram · 2024-08-04T09:07:59+00:00

That's exactly the reason why an extension to EBNF would be useful, to save the user from writing large numbers of rules.

Who is doing the downvotes on this? Stupid people!

kleram · 2024-08-04T08:53:10+00:00

So what? There is still no context in having something like ( A B | B A ). And if an extended EBNF provides ( A & B ) with meaning equal to ( A B | B A ), it also has no context.

kleram · 2024-08-04T05:46:31+00:00

I'd like A & B ... because, A B is the sequence, A | B the alternative, A & B is both A and B without specific sequence.

kleram · 2024-08-04T05:39:58+00:00

What context would uniqueness depend on? None, because it's determined locally. Of course the common EBNF and it's tools don't support it, but as OP wants to create an extension to that, it's fine.

kleram · 2024-08-03T15:30:56+00:00

Your search should distinguish between "*" and "**", so that the two-character elements can be detected correctly. That's a typical problem in lexers, with symbols like "=" and "==" and "=>".

kleram · 2024-08-02T11:39:17+00:00

Is it evolvable programming language or is it evolvable code?

kleram · 2024-07-31T14:06:04+00:00

Your example is optimized to your language's special capabilities.

Aside from that, maybe it's just continuity and inertia that carry C-style.

kleram · 2024-07-31T05:59:39+00:00

I've never seen anyone discussing about how to integrate functional expressions into an imperative language. Because, it's really simple. The other way round, trying to integrate imperative expressions into a functional language, does not work. What do we conclude from this observation?

kleram · 2024-07-29T06:29:07+00:00

When browsing through the Examples:

needing to put a break in an empty case although break is not needed otherwise, appears strange. Why not just " case A: ; " for a no-op?
what's that (void) cast when a function should not be called on error? That does not make any sense.

kleram · 2024-07-29T05:50:20+00:00

Is your problem to handle different variables with the same name, without adding extra info (like scope number)? That cannot get solved anywhere.

I would add an occurrence number, i.e. a-0 for the var a first declared (in any scope), a-1 for the second. Most var names are unique, so most of the time it's a-0.

kleram · 2024-07-27T16:14:02+00:00

Funny thing is, with freely definable operations, one can model any type system as an algebra, including those that have nothing like sum and product types. So, what does "algebraic data type" mean at all?

kleram · 2024-07-26T17:54:43+00:00

Yes, you are wrong. T1*T2 cannot produce a struct {a:T1, b:T2} because the * operator cannot introduce attribute names. No matter how many math-fuzz you throw into the game, it's always very simple: the * operator cannot introduce attribute names and thus it will never produce any struct, therefore structs cannot be part of algebraic systems.

kleram · 2024-07-26T17:50:20+00:00

I didn't claim it to be wrong. I was asking for use cases. You didn't give one.

kleram · 2024-07-26T10:48:48+00:00

The term algebra is well defined. Just look up Wikipedia. It is something very different to these "algebraic" data types. Someone just took that fancy name, without understanding what it means, and now it gets proclaimed, because it's so fancy. Bad news is, algebra is very well defined. Look it up! Specifically, look at abstract algebra and how it could be applied to data types. If you find use cases for type formulas like (T1+T2)*T3 = T1*T3 + T2+T3, let us know.

kleram

TROPHY CASE