> 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

Reply via email to