No surprise there since a Float64 is 8 bytes.
On Thursday, February 4, 2016 at 3:22:44 PM UTC-5, Christopher Alexander
wrote:
>
> That's interesting, I can reproduce that exactly. However, when I set the
> "a" attribute for A as being Float64, they are both size 8:
>
> abstract ABC
>
> immutable A2 <: ABC
> a::Float64
> end
>
> julia> bA2, bABC2 = B{A2}(A2(1)), B{ABC}(A2(2))
> (B{A2}(A2(1.0)),B{ABC}(A2(2.0)))
>
> julia> sizeof(bA2), sizeof(bABC2)
> (8,8)
>
>
>
>
>
> On Thursday, February 4, 2016 at 2:56:46 PM UTC-5, Josh Langsfeld wrote:
>>
>> I may be mistaken, but I think setting the type parameter to be abstract
>> is indeed the same as setting the field itself to be abstract. This snippet
>> is my evidence:
>>
>> julia> abstract ABC
>>
>> julia> immutable A <: ABC
>> a::Float32
>> end
>>
>> julia> type B{T<:ABC}
>> a::T
>> end
>>
>> julia> bA, bABC = B{A}(A(1)), B{ABC}(A(2))
>> (B{A}(A(1.0f0)),B{ABC}(A(2.0f0)))
>>
>> julia> sizeof(bA), sizeof(bABC)
>> (4,8)
>>
>> Even though both 'B' objects contain an 'A' immutable, bABC keeps it as a
>> pointer (size 8) whereas bA can directly unpack it into the definition.
>>
>>
>> On Thursday, February 4, 2016 at 1:59:17 PM UTC-5, Christopher Alexander
>> wrote:
>>>
>>> Oh cool! I was worried, since my call method was passing in the
>>> abstract type if none was specified (ie I wasn't setting a value for the
>>> param "a"), that it would just be the same as if I hadn't used a parametric
>>> type at all and just set the type of "a" to the abstract type.
>>>
>>> Thanks!
>>>
>>> Chris
>>>
>>> On Thursday, February 4, 2016 at 11:50:07 AM UTC-5, Kevin Squire wrote:
>>>>
>>>> No, `a` is the (concrete) type `T`, which is a subtype of `ABC` (and a
>>>> new type `B{T}` is created for each `T`). So you shouldn't lose
>>>> performance because of this.
>>>>
>>>> Cheers,
>>>> Kevin
>>>>
>>>> On Thu, Feb 4, 2016 at 8:10 AM, Christopher Alexander <
>>>> [email protected]> wrote:
>>>>
>>>>> Let's say I have the following types:
>>>>>
>>>>> abstract ABC
>>>>>
>>>>> type A <: ABC
>>>>> a::Float64
>>>>> end
>>>>>
>>>>> type B{T <: ABC}
>>>>> a::T
>>>>> end
>>>>>
>>>>> In some cases, I need for type "B" to be incompletely initialized so
>>>>> that I can define its parameter "a" later. I've found out that you can
>>>>> do
>>>>> something like this:
>>>>>
>>>>> type B{T <: ABC}
>>>>> a::T
>>>>>
>>>>> call(::Type{B}) = new{ABC}()
>>>>> end
>>>>>
>>>>> which then allows this:
>>>>>
>>>>> julia> myB = B()
>>>>> B{ABC}(#undef)
>>>>>
>>>>> My question is, I'm assuming you lose any of the performance gain by
>>>>> using the parametric type in this case because you are still using the
>>>>> abstract type "ABC" for the parameter "a" (even if you define it later
>>>>> with
>>>>> a concrete "A"). Is there a better way to do this?
>>>>>
>>>>> Thanks!
>>>>>
>>>>> Chris
>>>>>
>>>>
>>>>
