Strange, that's my objection to type declarations.
Is objectively less readable than
def marketDataService = new Factory<MarketDataService<Stock>>()
And even the latter is not the best.
def MyClass(marketDataService){
this.marketDataService = marketDataService
It's imho the most readable. If the name is self describing and there are unit tests that prove that I'm receiving the correct type I cannot care less about the type itself.
type expression =
| Number of float
| Add of expression * expression
| Subtract of expression * expression
| Multiply of expression * expression
| Divide of expression * expression
let rec eval expr =
match expr with
| Number n -> n
| Add (expr1, expr2) -> (eval expr1) +. (eval expr2)
| Subtract (expr1, expr2) -> (eval expr1) -. (eval expr2)
| Multiply (expr1, expr2) -> (eval expr1) *. (eval expr2)
| Divide (expr1, expr2) -> (eval expr1) /. (eval expr2)
janvitek.github.io/events/PBD13/slides/JeffFoster.pdf
They apparently changed their focus to gathering type information at runtime and using it to do interesting stuff, like this recent Hummingbird research.
By the way, I think it might be possible to implement autocompletion based on that runtime information they collect.
There are a lot of rudimentary "caveman completion" packages available for Ruby coding, but nobody has ever written a good "intellisense" feature for Ruby, where "good" means something on the level of, say, Xcode's "CodeSense" auto-completion for Objective-C or Swift, or JetBrains IDEA's support for Java.
I work in Xcode a lot, but I also maintain a couple Rails apps at work. A few times a year, I get so aggravated I spend an afternoon googling the state of the art in code completion for Ruby, and trying out various editors and IDEs.
JetBrains RubyMine is consistently the best, but it is far, far inferior to Xcode in this regard. It suggests methods but not the one I am looking for, or it suggests inappropriate methods that would cause an error, etc. It can't always jump to the definition of something, or tell me all the places the method I am currently editing is called from.
Xcode has a lot of things I could complain about, but the code completion, finding caller/callees, jump to definition/counterpart... all that stuff is incomparably better than it is for Ruby in any editor I have ever seen.
And of course it is — it is incredibly hard and complicated to do a complete or even mostly-complete job of it with Ruby code. There are just too many ways to metaprogram and too little information available to the editor to make it a straightforward task.
1. No compile-time type checking.
2. No autocomplete / intellisense in IDEs (you can try but it's never very good).