Latest posts tagged with #StaticTyping on Bluesky
Static typing in Ruby remains contentious. While RBS is a step, some feel it dilutes Ruby's simplicity. Alternatives like Sorbet & `low_type` are explored, highlighting the community's struggle to balance flexibility with robust type checking. #StaticTyping 3/6
Python's static analysis gets a boost with mypy-pure and mypy-raise, adding purity checks and exception handling to type hints. Developers can catch side effects and runtime errors earlier. #Python #StaticTyping
Not all static type systems are equal. Rust's ownership model and traits offer superior safety and expressiveness compared to languages like Java or C++, providing deeper guarantees against common pitfalls. #StaticTyping 4/5
![type Signal<T extends object> = T & {
onChange: (callback: Callback<T>) => () => void;
} & {
[K in keyof T as `on${Capitalize<string & K>}Change`]: (callback: (value: T[K], oldValue: T[K]) => void) => () => void;
} & {
[K in keyof T as `${string & K}AsSignal`]: T[K] extends object ? Signal<T[K]> : Signal<{value: T[K]}>;
}](https://cdn.bsky.app/img/feed_thumbnail/plain/did:plc:4vkspshcmybopmi5jufsce6b/bafkreigvhu4tfvzf2istwdfow6mu4gtmjvbtbigj25q6tdhinzvfq6pmjm)
type Signal<T extends object> = T & { onChange: (callback: Callback<T>) => () => void; } & { [K in keyof T as `on${Capitalize<string & K>}Change`]: (callback: (value: T[K], oldValue: T[K]) => void) => () => void; } & { [K in keyof T as `${string & K}AsSignal`]: T[K] extends object ? Signal<T[K]> : Signal<{value: T[K]}>; }
Mapped types: transform generic object keys into new types using key mapping and template literals. Recursively create new signatures per object key. Enables scalable, type-safe contracts at the type level. (see image)
#TypeScript #StaticTyping #MappedTypes
A major driver for Teal is the need for better maintainability and refactoring in larger Lua projects, especially in game development. Static types are seen as crucial for managing complexity beyond a certain scale. #StaticTyping 2/6
Conversely, many believe gradual typing can improve safety & scalability in Ruby without forcing a full static paradigm shift or sacrificing the language's beloved productivity. #StaticTyping 6/6
