But yeah I REALLY wish the Julia guys can come up with a nice way of dealing with Nullable.
But I actually don't miss the `object.method()` notation. I find it is so much more straightforward to compose things functionally when everything is a plain function. I feel methods just adds complexity to a language. For readability I tend to use the form `x |> f |> g |> h` if I need to make it easier to read a call like `h(g(f(x)))`.
I agree completion is a bit nicer with `object.method()` but function completion works quite well in the REPL and Juno. I use `methodswith()` to locate relevant functions for a type.
In some ways I think it is actually easier to deal with than in Swift, as Swift base classes have so many methods you can't find the stuff you are interested in quickly.
I have kind of wanted Swift to be the solution for everything, but I see that the API design philosophy for Swift makes it difficult to turn it into a language which is as nice for data science as Julia. There is no focus on making stuff like matrix classes, multidimensional arrays, shell integration etc.
Also I don't quite like that Swift ties me so much to an IDE. Writing Swift code with a plain text editor and a REPL isn't as nice as doing it with Julia.
- Writing code with Nullables is cumbersome and verbose compared to Swift.
- The object.method() notation is sometimes more readable, especially in more complex expression. Plus, in an IDE it works well with completion.
- The ordering of types in a file matters.
- Overall, Swift code looks a tiny bit more readable, cleaner.
- No interfaces.