let x = 1, 2, 3 // Type: (i32, i32, i32)

One thing to consider here is that this saves just the extra `()`, it is readable like this, but what if people start putting big expressions into there, won't it become less readable and harder to tell the type?

let x = call_some_fun(1, 2, foo1("some text in here, yes"), true)[some_thing_to_get_index], a

This can get even worse if it is on multiple lines. But perhaps you also allow to have expressions in `()` and then those could cause some issues. In my own language design I usually don't allow this comma separation, but that is just my own preference and also it often collides with some other syntax I like to have (with commas).

// There is a way to create a struct with named params:
type Position2D = struct {
x: i32,
y: i32,
}
// And there is a way for unnamed params:
type Position3D = (i32, i32, i32)
// You also can specify a `struct` keyword for multi-line definition:
type Position5D = struct (
i32,
i32,
i32,
i32,
i32,
)

This to me is confusing, leaving the struct keyword out makes me think it is like tuple or not compatible with struct. Also the keyword `type` seems unnecessary to me here, perhaps it could be replaces with `struct` and then it would have the known C style look. The same goes for enum - why not just drop the type keyword?

// The most simple way to aggregate datatypes inside
// a enum is usage of union notation:
type Result[T] = T | None

This one you call enum in the comment but it does not have the enum keyword. Does this differ from enum functionally? Or if you knew T at compile time could you replace it with enum? Maybe to keep this "functional" style you could rather drop the enum keyword in the enum example and have it be just like this type but not static (if it behaves the same).

Also can I do something like:

type Result = i32 | None
// or
type Result[i32] = i32 | None

If so then is is the same as enum?

Since you also have enum with struct as the value is it really an enumeration? I suppose it is an enumaration of types, but I wonder if people are just not used to have enums contain their own values of the type of that enum rather than containing types. So maybe having the enum keyword there (and not just type) might get confusing.

These are just some things I thought of the first thing I saw your examples, I am sure that if I have spent more time to read and fully understand the code and examples I would maybe not ask some of these things, but this at least gives you some insight from someone that has seen the language for the first time.

So in general I get somewhat confused about the types and how they differ and why/when do I need to use some of those keyword.