[Enhancement] Distinguish keyword arguments from type annotations

[yhk1038]

Currently, there is no way to distinguish between keyword arguments and type annotations.

# Type annotation: parameter x has type String
def foo(x: String)
  x
end

# Keyword argument: parameter x has default value "default"
def foo(x: "default")
  x
end

Both syntaxes use the same param: value format, making it impossible to differentiate between them.

This requires syntax design review.

[pvcresin]

I would like to dare to make a proposal, acknowledging that it will involve significant syntactic changes.

Considering keyword arguments, how about making the method type syntax closer to RBS?

def foo(String positional, keyword: String)
  # ...
end

Currently, the policy seems to be to introduce types with syntax closer to TypeScript. However, since RBS is the official type definition language for Ruby, I thought that a similar syntax might reduce confusion.

Furthermore, if we align the syntax with RBS, it might be better to use -> for the method's return type instead of :.

def foo(String positional, keyword: String) -> String
  # ...
end

# rbs
def foo: (String positional, keyword: String) -> String

[yhk1038]

@pvcresin Thank you for your interesting and awesome idea!
I empathize with this concern and have given it serious thought.

However, I've decided to maintain the current approach for the following reasons:

1. Readability when defining complex types like union types
2. Introducing special policies for specific parts increases the learning curve
3. (Important) In the not-too-distant future, I want to add decorators. If i receive your proposal, there's potential for syntactic conflicts at that point.

On the other hand, I think the "keyword arguments" part can be solved quite simply.

# In general. -- position based arguments typing
def hello(name: String, level: Integer = 99)

hello("pvcresin")

The core idea is to wrap them in curly braces.

Keyword arguments

[1] Inline typing

def hello({ name: String, level: Integer = 99 })

hello(name: "pvcresin")

[2] Anonymous Interface typing

def hello({ name:, level: 99 }: { name: String, level?: Integer })

hello(name: "pvcresin")

[2+] Interface typing

interface Person
  name: String
  level?: Integer
end

def hello({ name:, level: 99 }: Person)

hello(name: "pvcresin")

[yhk1038]

I believe this issue still warrants further discussion.

Above, I proposed a solution for keyword arguments through new syntax, which has already been deployed. However, since the new principle "All Ruby code is T-Ruby code" has been accepted as valid, this issue needs to be revisited.

The related discussion is ongoing at #32