Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

`where` in function definitions in julia-0.6

Tags:

julia

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}) 

?

like image 285
Michael K. Borregaard Avatar asked Jan 30 '17 08:01

Michael K. Borregaard


People also ask

How is Julia function defined?

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.

What is the type of 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.


1 Answers

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:

  • The syntax used to define a method always matches the syntax used to call it.
  • The F{T} syntax always refers to the type F with parameter T.
  • Type parameters are always introduced by 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.

like image 61
StefanKarpinski Avatar answered Sep 23 '22 17:09

StefanKarpinski