*the code works!!*
I know that number== basic
But the adding methods to number makes it ,from execution point of view ,
an inherited class
On Wednesday, March 23, 2016 at 7:25:16 PM UTC+5:30, Stefan Karpinski wrote:
>
> Doing
>
> typealias B Union{A}
>
> makes B the same as A. Is this code meant to work today or is this
> something you're proposing should work?
>
> On Wednesday, March 23, 2016, kunal singh <[email protected]> wrote:
>
>> Hi,
>>
>> I wrote a sample code which explains how inheritance can be done in Julia
>> Let me explain what the code is about
>> There is a Base Class : basic
>> it contains two functions A and B
>>
>> Then there is number class which inherits from basic
>> and number has its own Function C
>> So number has in total three Functions A, B and C
>>
>> there is integer class which inherits from number
>> and integer has its own Function D
>> So integer has in total Four Functions A, B, C and D
>>
>> So what my code will be doing : I will be entering each class and
>> printing all the function available in the particular class
>>
>> type basic
>> x::AbstractString
>> function basic()
>> z = new()
>> return z
>> end
>>
>> function basic(p::AbstractString) # Defining Function A
>> z = new(p)
>> return z
>> end
>> end
>>
>> function basic(p::Int) #Defining Function B
>> z = basic()
>> z.x = "I am Function B from basic via outer constructor"
>> return z
>> end
>>
>> println("Entering basic")
>> println("Calling Function A...")
>> m = basic("I am Function A from basic via inner constructor")
>> println(m.x)
>>
>> println("Calling Function B...")
>> m = basic(0)
>> println(m.x)
>>
>>
>> typealias number Union{basic}
>>
>> function number(p::Float64) # Defining Function C
>> z = basic()
>> z.x = "I am Function C from number via number's outer constructor"
>> return z
>> end
>>
>> println("number inherits basic ")
>> println("Entering number")
>>
>> println("Calling Function A...")
>> m = number("I am Function A of basic via basic's inner constructor")
>> println(m.x)
>>
>> println("Calling Function B...")
>> m = number(10)
>> println(m.x)
>>
>> println("Calling Function C...")
>> m = number(4.5)
>> println(m.x)
>>
>>
>> typealias integer Union{number}
>>
>> println("integer inherits number ")
>> println("Entering integer")
>>
>> println("Calling Function A...")
>> m = number("I am Function A of basic via basic's inner constructor")
>> println(m.x)
>>
>> println("Calling Function B...")
>> m = number(10)
>> println(m.x)
>>
>> println("integer inherits number Calling Function C...")
>> m = integer(5.6)
>> println(m.x)
>>
>> function integer(p::Float64) #Defining Function D
>> z = basic()
>> z.x = "I am Function D from integer via integer's outer constructor"
>> return z
>> end
>>
>> println("Calling Function D...")
>> m = integer(5.6)
>> println(m.x)
>>
>>
>>
>> On Tuesday, March 22, 2016 at 11:01:25 PM UTC+5:30, Stefan Karpinski
>> wrote:
>>>
>>> Read through the julia-dev thread I linked to – this is addressed in
>>> depth there.
>>>
>>> On Tue, Mar 22, 2016 at 12:55 PM, Mauro <[email protected]> wrote:
>>>
>>>> > By the way isn't type Basic in my code a composite type?
>>>>
>>>> Basic is defined both as `type` and as `abstract` which will error.
>>>>
>>>> > So is there any way of inheritance among composite types ?
>>>>
>>>> No.
>>>>
>>>> > Also is there any libraries which I can refer to which uses extensive
>>>> > inheritance?
>>>> >
>>>> > In C++ we can easily inherit classes ? Why don't we have such ease in
>>>> Julia ?
>>>>
>>>> Because Julia is designed this way. Because with the ease also comes
>>>> pain.
>>>>
>>>> > On Tuesday, March 22, 2016 at 9:20:19 PM UTC+5:30, Stefan Karpinski
>>>> wrote:
>>>> >
>>>> > Have a read on this oldish thread:
>>>> https://groups.google.com/forum/#!topic/
>>>> > julia-dev/eA4VkFAD-yQ. Still applies today.
>>>> >
>>>> > On Tue, Mar 22, 2016 at 11:30 AM, kunal singh <[email protected]>
>>>> wrote:
>>>> >
>>>> >
>>>> >
>>>> > On Tuesday, March 22, 2016 at 8:43:50 PM UTC+5:30, Mauro
>>>> wrote:
>>>> >
>>>> > > Hi Mauro ,
>>>> > >
>>>> > > Can you show me any example ?
>>>> > > I am a beginner in Julia. It would of great help for me.
>>>> >
>>>> > In Julia the number types are defined here:
>>>> > https://github.com/JuliaLang/julia/blob/
>>>> > fdbcdf78bf0106e609a8d83b9e896d2d11bae594/base/boot.jl#L156
>>>> >
>>>> > So there are the abstract types:
>>>> >
>>>> > abstract Number
>>>> > abstract Real <: Number
>>>> > abstract AbstractFloat <: Real
>>>> > abstract Integer <: Real
>>>> > abstract Signed <: Integer
>>>> > abstract Unsigned <: Integer
>>>> >
>>>> > and then there are concrete subtypes. For example a few
>>>> integer
>>>> > types:
>>>> >
>>>> > bitstype 8 Bool <: Integer
>>>> > bitstype 64 Int64 <: Signed
>>>> > bitstype 64 UInt64 <: Unsigned
>>>> >
>>>> >
>>>> > > On Tuesday, March 22, 2016 at 8:01:47 PM UTC+5:30,
>>>> Mauro wrote:
>>>> > >
>>>> > > You can only inherit from abstract types. Also, first
>>>> > defining
>>>> > >
>>>> > > type number
>>>> > > ...
>>>> > > end
>>>> > >
>>>> > > and then
>>>> > >
>>>> > > abstract number
>>>> > >
>>>> > > is not possible. It cannot be both abstract and
>>>> concrete.
>>>> > (Also note
>>>> > > that types are by convention Captialized).
>>>> > >
>>>> > > So build your hierarchy only with abstract types and
>>>> make
>>>> > concrete types
>>>> > > of some of the abstract ones.
>>>> >
>>>> > Can you explain this point please ?
>>>> > > On Tue, 2016-03-22 at 15:26, kunal singh <
>>>> [email protected]>
>>>> > wrote:
>>>> > > > So basically there is a type called Basic defined as
>>>> > follows
>>>> > > >
>>>> > > > type Basic
>>>> > > > ptr::Ptr{Void}
>>>> > > > function Basic()
>>>> > > > z = new(C_NULL)
>>>> > > > ccall((:basic_new_stack, :libsymengine), Void, (Ptr
>>>> > {Basic}, ), &z)
>>>> > > > finalizer(z, basic_free)
>>>> > > > return z
>>>> > > > end
>>>> > > > end
>>>> > > >
>>>> > > > Now I want to create a hierarchy: integer(not
>>>> Integer)<
>>>> > number(not
>>>> > > Number) <
>>>> > > > Basic
>>>> > > >
>>>> > > > But in Julia, we cannot inherit from concrete type
>>>> So what
>>>> > should I Do??
>>>> > > >
>>>> > > > Here's My approach
>>>> > > >
>>>> > > > abstract Basic
>>>> > > >
>>>> > > > type number <: Basic
>>>> > > > ptr::Ptr{Void}
>>>> > > > function number()
>>>> > > > z = new(C_NULL)
>>>> > > > ccall((:basic_new_stack, :libsymengine), Void, (Ptr
>>>> > {Basic}, ), &z)
>>>> > > > finalizer(z, basic_free)
>>>> > > > return z
>>>> > > > end
>>>> > > > end
>>>> > > >
>>>> > > > abstract number
>>>> > > >
>>>> > > > type integer <: number
>>>> > > > ptr::Ptr{Void}
>>>> > > > function integer()
>>>> > > > z = new(C_NULL)
>>>> > > > ccall((:basic_new_stack, :libsymengine), Void, (Ptr
>>>> > {Basic}, ), &z)
>>>> > > > finalizer(z, basic_free)
>>>> > > > return z
>>>> > > > end
>>>> > > > end
>>>> > > >
>>>> > > >
>>>> > > > Please tell me if I am wrong ?
>>>> > > > Need help from
>>>>
>>>
>>>
