On Wed, 2016-03-23 at 16:48, kunal singh <ks250...@gmail.com> wrote:
> *the code works!!*
> I know that number== basic
> But the adding methods to number makes it ,from execution point of view ,
> an inherited class
But those methods can be called through basic as well as number and
basic are identical:
julia> m = basic(4.5)
basic("I am Function C from number via number's outer constructor")
>
> 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 <ks25...@gmail.com> 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 <maur...@runbox.com> 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 <ks25...@gmail.com>
>>>>> 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 <
>>>>> ks25...@gmail.com>
>>>>> > 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
>>>>>
>>>>
>>>>
