Newbie questions about Pliant

Newbie questions about Pliant

generic types

get exception 11 when trying to add to
List attribute in a generic type
Message posted by borisreitman on 2001/11/25 07:50:21
I think I am not allocating memory correctly, but I tried
it with 'new' and still got an error. What the correct way to do this ?

========
module "/pliant/language/unsafe.pli"  

type X
  field List:X list
  field Int foo

type Y
  void

X maybe Y

gvar X x y z

x list += y
x list += z

gvar Y xx yy zz  
xx foo := 5
console "Foo works: foo = " xx:foo eol

xx list += yy # generates exception 11  !!!



Message posted by maybe Patrice Ossona de Mendez on 2001/11/25 11:06:45
First, "maybe" means that we claim that any call on an object with type Y
should work if the waited argument if of type X. It is not a kind of subclassing
and it won't work properly if type Y somehow includes the fields of X as its
first fields, or functions on X object are sufficiently smart.

Thus, the code:

gvar Y xx
xx foo := 5 

will poke a "5" on the memory after the Y object xx.

Second, Lists includes all the datas of the elements and don't keep objects headers
(which allow runtime type checking). So, in a List:X, you can only put X objects.

Altogather, here is a sample that shows what can be done:

#
#
module "/pliant/language/unsafe.pli"      # Lists are unsafe
module "/pliant/language/compiler.pli"    # To get the 'name' method on types.

# "Interface" type

type X
   field List:(Link:X) list # the list keep 'links' to the objects.
                            # so that they remain objects.
   field Int foo

# "Implementation" type
 
type Y
   field List:(Link:X) list
   field Int foo
   field Int something_else
 
X maybe Y

# objects are global variables and datas created by "new"
 
gvar X x y z  # 4 objects of type X

gvar Link:X py :> y # get links on them
gvar Link:X pz :> z
 
x list += py # add the links to the list of x
x list += pz
 
gvar Y xx yy zz # 3 objects of type Y

method a set_foo i
  arg X a
  a foo := i

xx set_foo 5 # we use a method defined for X arg on a Y object.
console "Foo works: foo = " xx:foo eol

gvar Link:X pxx :> xx # links on an object of type Y considered
                      # as an object of type X

x list += pxx  # add it to the list of x
 

# Sample "generic" method. generic methods are kinds of "device drivers".
# A default implementation is defined for the "interface" type with keyword
# "generic"; each implementation defines its own method to call if different
# from the general case defined for the interface.


method a show_my_type # default method to call on X objects and implementations
  arg X a
  generic
  console "I am X" eol
 
method a show_my_type # special method to call when the object has type Y
  arg Y a
  console "I am Y" eol
 
# Here is a simple method to show the types of the elements in the list of
# an object of type X.

method a show_list
  arg X a
  each v a:list
    # first method: get the runtime type through pliant "low level" machinery:
    # we get the address of the object, ask for the runtime type (entry_type)
    # and then for the name of the obtained type

    console "Element of type " entry_type:(addressof v):name eol

    # second method: we use generic method "show_my_type" defined above

    v show_my_type
 
x show_list