I am trying to understand the new type system in Julia v0.6, based on reading the release notes.
Can anyone tell me what
inv(M::Matrix{T}) where T <: AbstractFloat
gives me which is different from using the classic
inv{T<:AbstractFloat}(M::Matrix{T})
?
The basic syntax for defining functions in Julia is: julia> function f(x,y) x + y end f (generic function with 1 method) This function accepts two arguments x and y and returns the value of the last expression evaluated, which is x + y . There is a second, more terse syntax for defining a function in Julia.
Every function in Julia is a generic function. A generic function is conceptually a single function, but consists of many definitions, or methods. The methods of a generic function are stored in a method table. Method tables (type MethodTable ) are associated with TypeName s.
The new syntax means the same thing but can be used in more circumstances and can express more constructs and eliminates a number of conceptual ambiguities, especially surrounding parametric constructors. The old syntax will be deprecated in 0.6 and some of the old syntax will be reclaimed with different meaning in 1.0. Fundamentally, the problem with F{T}(args...)
is that the F{T}
part is conceptually ambiguous – the parser knows what it means, but it's often confusing to humans:
In isolation F{T}
means the parametric type F
with type parameter T
.
Followed by parens, not as part of a method definition, F{T}(args...)
means to apply the type F{T}
to the arguments args...
as a function, typically constructing an instance of the type F{T}
.
Followed by parens and equals, i.e. as part of a method definition as in F{T}(args...) = expr
, it means to define a method for F
as a function, with type parameters T
formal arguments args...
and definition expr
.
In particular, there is no syntax for either of these:
Adding a method to F{T}
for the concrete value of T
in the current scope.
Adding a method to F{T}
for each parametric value T
.
This situation causes constructor syntax in Julia 0.5 and prior to be more confusing and unintuitive than necessary. In Julia 1.0 type parameters and constructors will be both more intuitive and consistent, following these principles:
F{T}
syntax always refers to the type F
with parameter T
.where
clauses.There will be a more detailed explanation of the changes when 0.6 comes out, probably in a blog post on highlights of the 0.6 release.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With