# New Ticket Created by grond...@yahoo.fr
# Please include the string: [perl #128010]
# in the subject line of all future correspondence about this issue.
# https://rt.perl.org/Ticket/Display.html?id=128010 >
In file A.pm6 :unit class A ; our sub f {}
In file B.pm6 :unit role B ;
As a status update: This behaves differently now.
$ perl6-m -e 'role Foo[::T] { has T @.a = [T] }; class Bar {}; say
Foo[Bar].new.a[0]'
Type check failed in assignment to '@!a'; expected 'Bar' but got 'Array'
in method REIFY at src/gen/m-CORE.setting:9935
in method reify at
instantiation failure.
* masak submits rakudobug
# New Ticket Created by Carl Mäsak
# Please include the string: [perl #57228]
# in the subject line of all future correspondence about this issue.
# URL: http://rt.perl.org/rt3/Ticket/Display.html?id=57228
Whereas
$ perl6 -e 'class A {}; my A $a .= new; 1'
$ perl6 -e 'class A {}; my A $a =
# New Ticket Created by Allison Randal
# Please include the string: [perl #41266]
# in the subject line of all future correspondence about this issue.
# URL: http://rt.perl.org/rt3/Ticket/Display.html?id=41266
Consider object instantiation as a method call on a class object, rather
than
the string: [perl #41266]
# in the subject line of all future correspondence about this issue.
# URL: http://rt.perl.org/rt3/Ticket/Display.html?id=41266
Consider object instantiation as a method call on a class object, rather
than an opcode on a type ID.
$P0 = get_class HLLClass
$P1
Hi all,
Here's an experiment I worked on yesterday to make creating objects a little
easier from PIR. The MakeObject library allows you to create an object by
passing its name (or, more usefully, a Key PMC) and a set of named arguments
to the initializer.
It then calls the class's BUILDALL()
On Tuesday 10 October 2006 12:23, Leopold Toetsch wrote:
PPS: new opcode variant count is 20 now.
I can imagine that we just have these:
new P0, .Class # plain form
new P0, .Class, args
new P0, [class], args
Is args a PMC (Hash) or a list of named arguments? Creating
have with object instantiation.
PPS: new opcode variant count is 20 now.
I can imagine that we just have these:
new P0, .Class # plain form
new P0, .Class, args
new P0, [class], args
leo
Am Dienstag, 10. Oktober 2006 21:32 schrieb chromatic:
new P0, [class], args
Is args a PMC (Hash) or a list of named arguments? Creating a Hash for
every initializer is a real bummer in PIR.
As said, args ought to be everything conforming to current calling
conventions.
o = new
At 11:27 AM +0200 9/3/04, Leopold Toetsch wrote:
Dan Sugalski [EMAIL PROTECTED] wrote:
At 12:16 PM +0200 8/31/04, Leopold Toetsch wrote:
Pclass = getclass, Foo
Pobjnew = Pclass.__new(args) # Pnew is an OUT argument
and that be special-cased to call VTABLE_new according to calling
Dan Sugalski [EMAIL PROTECTED] wrote:
At 11:27 AM +0200 9/3/04, Leopold Toetsch wrote:
Dan Sugalski [EMAIL PROTECTED] wrote:
At 12:16 PM +0200 8/31/04, Leopold Toetsch wrote:
Pclass = getclass, Foo
Pobjnew = Pclass.__new(args) # Pnew is an OUT argument
and that be special-cased to
Dan Sugalski [EMAIL PROTECTED] wrote:
At 12:16 PM +0200 8/31/04, Leopold Toetsch wrote:
Pclass = getclass, Foo
Pobjnew = Pclass.__new(args) # Pnew is an OUT argument
and that be special-cased to call VTABLE_new according to calling
conventions.
Still don't like __new, but otherwise
Dan Sugalski [EMAIL PROTECTED] wrote:
Add a vtable slot to the PMC vtable inv_init (or something like that,
the name's not that big a deal),
vtable-new and __new?
... define it as an invokable method
taking parameters as the current calling conventions, and be done
with it. Basically we
At 12:16 PM +0200 8/31/04, Leopold Toetsch wrote:
Dan Sugalski [EMAIL PROTECTED] wrote:
Add a vtable slot to the PMC vtable inv_init (or something like that,
the name's not that big a deal),
vtable-new and __new?
Those are a little too similarly named. We should have something more
distinct,
The current scheme of PMC instantiation works mostly fine for scalars
and other simple types, but it's a bit limited. It allows only one
initializer (see init_pmc in docs/pdds/pdd02_vtables.pod).
Further PMC and real object instantiation shouldn't differ in syntax.
Here is a summary what we
[EMAIL PROTECTED] (Aaron Sherman) writes:
my $x = Some::Module::That::Defines::A::Class.AUTOLOAD.new(blah);
Wow, that's pretty amazing... uh... I think I'd just prefer to do it
the old fashioned way. If my suggestion was really that horrific, I
withdraw the question.
These days, to me,
I was thinking about the case where you use a module, only to define a
class that you then instantiate like this:
use Some::Module::That::Defines::A::Class;
our Some::Module::That::Defines::A::Class $foo := new;
and I keep thinking that that's too redundant. It's not so much that
Aaron Sherman skribis 2004-08-23 12:53 (-0400):
use Some::Module::That::Defines::A::Class;
our Some::Module::That::Defines::A::Class $foo := new;
and I keep thinking that that's too redundant
(...)
So, I was wondering about a synonym, like:
uses
So, I was wondering about a synonym, like:
uses Some::Module::That::Defines::A::Class $foo;
Well if the long name is the problem:
use Some::Module::That::Defines::A::Class as Foo;
my Foo $obj .= new;
# OR #
require Some::Module::That::Defines::A::Class;
import
Aaron Sherman wrote:
I was thinking about the case where you use a module, only to define a
class that you then instantiate like this:
use Some::Module::That::Defines::A::Class;
our Some::Module::That::Defines::A::Class $foo := new;
and I keep thinking that that's too redundant.
Hello,
Aaron Sherman wrote:
I was thinking about the case where you use a module, only to define a
class that you then instantiate like this:
[ snip ]
So, I was wondering about a synonym, like:
uses Some::Module::That::Defines::A::Class $foo;
is $foo implicitely declared as our or my (or
At Mon, 23 Aug 2004 15:51:00 -0400,
[EMAIL PROTECTED] (Aaron Sherman) wrote:
On Mon, 2004-08-23 at 15:19, Paul Seamons wrote:
So, I was wondering about a synonym, like:
uses Some::Module::That::Defines::A::Class $foo;
Well if the long name is the problem:
use
Sean O'Rourke [EMAIL PROTECTED] wrote in message
news:[EMAIL PROTECTED]
my $x = (use Some::Module::That::Defines::A::Class).new(blah);
how about some variation on
my $x = Some::Module::That::Defines::A::Class.AUTOLOAD.new(blah);
Dave.
Dave Whipp wrote:
Sean O'Rourke [EMAIL PROTECTED] wrote in message
news:[EMAIL PROTECTED]
my $x = (use Some::Module::That::Defines::A::Class).new(blah);
how about some variation on
my $x = Some::Module::That::Defines::A::Class.AUTOLOAD.new(blah);
Wow, that's pretty amazing... uh...
After thinking about this a bit, it became glaringly obvious that the
right way to instantiate an object for class Foo is to do:
new P5, .Foo
Or whatever the constant value assigned to the Foo class upon its creation
is. When a class is created, it should be assigned a number, and for most
Dan Sugalski [EMAIL PROTECTED] wrote:
After thinking about this a bit, it became glaringly obvious that the
right way to instantiate an object for class Foo is to do:
new P5, .Foo
Or whatever the constant value assigned to the Foo class upon its creation
is. When a class is created, it
On Tue, 21 Oct 2003, Leopold Toetsch wrote:
Dan Sugalski [EMAIL PROTECTED] wrote:
After thinking about this a bit, it became glaringly obvious that the
right way to instantiate an object for class Foo is to do:
new P5, .Foo
Or whatever the constant value assigned to the Foo class
To: [EMAIL PROTECTED] (Dan Sugalski)
cc: [EMAIL PROTECTED]
Subject:Re: Object instantiation
Dan Sugalski [EMAIL PROTECTED] wrote:
After thinking about this a bit, it became glaringly obvious that the
right way to instantiate an object for class Foo is to do:
new P5
On Oct 21, 2003, at 7:14 AM, Dan Sugalski wrote:
After thinking about this a bit, it became glaringly obvious that the
right way to instantiate an object for class Foo is to do:
new P5, .Foo
Or whatever the constant value assigned to the Foo class upon its
creation
is. When a class is
If memory serves me right, Dan Sugalski wrote:
It's possible to just go ahead and do it *all* at runtime, and have
no compile time component at all--just a series of newclass,
addparent, addattribute ops, assuming those are the op names we go
with. Classes just get created at code
Well, we can make objects and we can call methods on objects (at
least the interface is specified, if not actually implemented) but
actually building classes to make objects out of is still
unspecified. So, time to remedy that, after which I hope we can build
at least a simple ParrotObject
Dan Sugalski wrote:
Well, we can make objects and we can call methods on objects (at least
the interface is specified, if not actually implemented) but actually
building classes to make objects out of is still unspecified. So, time
to remedy that, after which I hope we can build at least a
Dan Sugalski wrote:
The issue is metadata. How do you declare a class' inheritance
hierarchy, its interfaces, its attributes, and its type? (At the very
least, there's probably more) I can see the following .
1) A class subclasses a single parent.
2) A class subclasses a single parent and adds
On Fri, 11 Oct 2002 14:05:30 -0700, Michael Lazzaro wrote:
Maybe postfix ! on a class name means to autoinstantiate an object of
the named class only if/when first accessed:
our FancyCache $cache; # declare, but leave undef
our FancyCache! $cache;
On Thursday, October 10, 2002, at 05:11 PM, Larry Wall wrote:
my MyClass $obj = .new;
snip
my new MyClass $obj;
Thanks for the clarification. I like those two OK, personally. If I
were chained to one of those, I wouldn't chew my leg off.
Tying it together with the other thread
$obj is MyClass;
:
: should declare a variable of type MyClass. (You're right, it shouldn't
: autoviv.) So what's the simplest syntax for typing + instantiation,
: together? Dunno, maybe
:
: my $obj is MyClass .= new;
:
: is it, but still I'm hoping for an alternative that is easier
37 matches
Mail list logo
