On Sat, Feb 6, 2016 at 5:52 AM, Uri Patish <uripat...@gmail.com> wrote:
> Hi Chris, thanks for weighing in ;)
>
> The solution you suggest is indeed a sound one, and one of my attempts at
> this issue was through parametric types and an enum instead of attributes
> like you suggest, e.g.,
>
> @enum TypeKind A=1 B=2
>
> type SomeType{T}
> value::Int
> end
>
> typealias TypeA SomeType{A}
> typealias TypeB SomeType{B}
>
> What I didn't like about this is solution is that only the types' names are
> parametric, but the types' bodies are exactly alike. In other words, it
> feels wrong to me to say that two types are different even though they are
> only different in the kind of instances they produce. Instances of types can
> be different in state, but if their structure is the same, then I feel that
> the best approach should indicate this by relying on a single type, and
> producing the different instances by overloading the constructor.
So for you, `type A a::Int end` and `type B a::Int end` shouldn't be
different type?
Your type alias approach won't work since there's no difference
between different names at all.
>
> BTW, going forward with the multiple types approach, the solution I found as
> most convenient is using a macro. This goes something like the following,
>
> macro sometype(typename, typevalue)
> quote
> type $(esc(typename))
> name::ASCIIString
> value::Int
> end
> $(esc(typename))(value::Int) = $(esc(typename))($typevalue, value)
> end
> end
>
> @sometype TypeA "A"
> @sometype TypeB "B"
>
> But I was hoping that maybe there was a solution using the single type
> approach.
>
> Uri
>
> On Friday, February 5, 2016 at 11:16:24 PM UTC+2, Uri Patish wrote:
>>
>> Hi,
>>
>> I was wondering what is the best way going about the following issue.
>> Suppose I have a type with few outer constructors which I name differently,
>> and I want Julia to recognize these functions as constructors of that type.
>> For example
>>
>> type SomeType <: SomeAbstract
>> name::ASCIIString
>> value::Int
>> end
>>
>> TypeA(value::Int) = SomeType("A", value)
>> TypeB(value::Int) = SomeType("B", value)
>>
>> In this case, I have two pseudo-types, TypeA and TypeB, which have the
>> same structure and are only different by their state. The problem with this
>> approach is that now TypeA and TypeB are functions and not datatypes, thus,
>> I cannot use operations defined on datetypes like checking for subtyping
>> (TypeA <: SomeAbstract), or overloading type construction using call.
>>
>> Clearly, I could have defined two types which have exactly the same
>> structure but this seems wrong to me as it involes code replication. Another
>> possible solution is to define a macro which defines the type and its outer
>> constructor, and I would call the macro to define TypeA and TypeB.
>> Nonetheless, I was wondering if there was a way to tell Julia that the
>> functions TypeA and TypeB are in fact constructors of SomeType. I'd be glag
>> to hear about other solutions as well.
>>
>> Uri
>>
>>
>
