thx
On Wednesday, October 7, 2015 at 4:55:01 AM UTC-4, Tomas Lycken wrote:
>
> Not sure what you’re asking, but if you want the *why* of this question,
> the reason is that I have an interface (of Interpolations.jl) that
> currently takes types (i.e. the argument type is Type{T}) as
> configuration flags. For flexibility, I want to switch to instances
> <https://github.com/tlycken/Interpolations.jl/pull/74> (i.e. argument
> type T), but at least for a while I also want existing functionality to
> be backwards compatible. To do that, I want to create forwards of the type
>
> foo{T}(::Type{T}) = foo(T())
>
> but Tuple{S,T}() isn’t possible for (and the flags can be combined,
> recursively, in tuples) so I needed a recursive solution to instantiate the
> tuples. construct_instance solves this problem
>
> julia> construct_instance(Tuple{S,T})
> (S(), T())
> julia> construct_instance(Tuple{S,Tuple{T, U, V}})
> (S(), (T(), U(), V()))
>
> This lets me get away with
>
> foo(::Type{T}) = foo(construct_instance(T))
> function foo(::T)
> # actual implementation
> end
>
> and keep exposing both methods in the API.
>
> // T
>
> On Tuesday, October 6, 2015 at 9:15:32 PM UTC+2, Jeffrey Sarnoff wrote:
>
> Would you show a simple example of the use, and defs for tuple, ntuple
> below?
>
> On Monday, October 5, 2015 at 5:42:17 AM UTC-4, Tomas Lycken wrote:
>
> Ha! It seems all I needed was a type-assertion at the end. Both of these
> work the way I want them to:
>
> construct_instance{T<:Tuple}(::Type{T}) = tuple([construct_instance(t) for t
> in T.parameters]...)::T
> construct_instance{T<:Tuple}(::Type{T}) = ntuple(i ->
> construct_instance(T.parameters[i]), length(T.parameters))::T
>
> // T
>
> On Monday, October 5, 2015 at 11:33:25 AM UTC+2, Tomas Lycken wrote:
>
> I managed to get rid of the list comprehension by using ntuple:
>
> construct_instance{T<:Tuple}(::Type{T}) = ntuple(i ->
> construct_instance(T.parameters[i]), length(T.parameters))
>
> However, this suffers from the same instability problem (because of the
> anonymous function?). I’ll keep trying, but I would gladly accept any
> advice on how to do this.
>
> // T
>
> On Monday, October 5, 2015 at 10:28:15 AM UTC+2, Tomas Lycken wrote:
>
> I’ve tried to do the following
>
> construct_instance{T}(::Type{T}) = T()
> construct_instance{T<:Tuple}(::Type{T}) = tuple([construct_instance(t) for t
> in T.parameters]...)
>
> as a way to dynamically and recursively create an instance of a tuple
> type. The tuple type might be nested, it might be any length > 0, and all
> (supported) non-tuple types in the hierarchy are leaf-types with an empty
> constructor defined.
>
> This works insofar as it gives me the tuple I want back, but it’s not type
> stable; the inferred return type is Tuple rather than T. I also tried
> wrapping it in convert(T, tuple(...)), but that only gave me e.g. Tuple{Any,
> Any} for a two-tuple type, which I assume is because type info is lost in
> the list comprehension.
>
> Is there a way to help type inference realize that it will get a T back,
> even when T is a tuple type?
>
> // T
>
>
>
>
>
>
> ...
