bicarbonato
I often see comparisons to languages like Python and Kotlin, but both encode far less information on their syntax because they don't have the same features as Rust, so there's no way for them to express the same semantics as rust.
Sure, you can make Rust look simpler by removing information, but at that point you're not just changing syntax, you're changing the language's semantics.
Is there any language that preserves the same level of type information while using a less "janky" syntax?
The thing is, inaction is not simply "not taking an action"; Inaction is taking active action of accepting the current solution.
> I doubt that the best proposals are so horrible for some people that they’d hold a grudge and leave Go.
But people may leave go if they constantly avoid fixing any of problems with the language. The more time passes, the more unhappy people become with the language. It will be a death by a thousand cuts.
I love go. But their constant denial do fix obvious problems is tiring.
Concepts fix implicit template requirements
> What about ranges?
Fix the bad iterators
> Auto
Fix the the overly long type names
> Move semantics
This is mostly necessary because of excessive copies that cpp does
> Consteval
Fix cases where constexpr couldn't do it at comptime
Kernel Threads (aka threads): OS-Level and preemptive.
Green Threads (aka lightweight threads, virtual threads or goroutines): User-level and preemptive.
Fibers: User-level (sometimes OS-level or offered as a OS library, like in Windows) and cooperative.
Coroutines: User-level and cooperative.
class BinOp:
def __init__(self, left, right, operator):
self.left = left
self.right = right
self.operator = operator
sum_of_ints = BinOp(left=1, right=1, operator='+')
match sum_of_ints:
case BinOp(left=int(left), right=int(right), operator='+'):
print(f'Summing int {left} + {right}')
case BinOp(left=str(left), right=str(right), operator='+'):
print(f'Concateneting strings {left} + {right}')
case _:
print('Don\'t know how to sum this')