VList: Difference between revisions

Content added Content deleted
Line 933: Line 933:
{{trans|Kotlin}}
{{trans|Kotlin}}


⚫
<lang objeck>class vList<T:Stringify> {
Will refactor to use generic types.
⚫
@base : vSeg<T>;

⚫
<lang objeck>class vList {
⚫
@base : vSeg;
@offset : Int;
@offset : Int;


New() {}
New() {}


New(base : vSeg, offset : Int) {
New(base : vSeg<T>, offset : Int) {
@base := base;
@base := base;
@offset := offset;
@offset := offset;
}
}


New(base : vSeg) {
New(base : vSeg<T>) {
@base := base;
@base := base;
}
}


method : public : GetBase() ~ vSeg {
method : public : GetBase() ~ vSeg<T> {
return @base;
return @base;
}
}
Line 958: Line 956:
}
}


method : public : Cons(a : String) ~ vList {
method : public : Cons(a : T) ~ vList<T> {
if(@base = Nil) {
if(@base = Nil) {
return vList->New(vSeg->New(a));
return vList->New(vSeg->New(a)<T>)<T>;
}
}
else if(@offset = 0) {
else if(@offset = 0) {
l2 := @base->GetEle()->Size() * 2;
l2 := @base->GetEle()->Size() * 2;
ele := String->New[l2];
ele := T->New[l2];
ele[l2 - 1] := a;
ele[l2 - 1] := a;
return vList->New(vSeg->New(@base, ele), l2 - 1);
return vList->New(vSeg->New(@base, ele)<T>, l2 - 1)<T>;
}
}
else {
else {
Line 976: Line 974:
}
}


method : public : Cdr() ~ vList {
method : public : Cdr() ~ vList<T> {
if(@base = Nil) {
if(@base = Nil) {
return Nil;
return Nil;
Line 986: Line 984:
}
}
else {
else {
return vList->New(@base->GetNext(), 0);
return vList->New(@base->GetNext(), 0)<T>;
};
};
}
}


method : public : Index(i : Int) ~ String {
method : public : Index(i : Int) ~ T {
if(i >= 0) {
if(i >= 0) {
i += @offset;
i += @offset;
Line 1,021: Line 1,019:
r := "[";
r := "[";
ele := @base->GetEle();
ele := @base->GetEle();
r += ele[@offset];
r += ele[@offset]->ToString();
r += ' ';
r += ' ';


Line 1,030: Line 1,028:
while(<>done) {
while(<>done) {
for(i := offset; i < ele->Size(); i += 1;) {
for(i := offset; i < ele->Size(); i += 1;) {
r += ele[i];
r += ele[i]->ToString();
r += ' ';
r += ' ';
};
};
Line 1,074: Line 1,072:
}
}
class vSeg {
class vSeg<T:Stringify> {
@next : vSeg;
@next : vSeg<T>;
@ele : String[];
@ele : T[];


New(next : vSeg, ele : String[]) {
New(next : vSeg<T>, ele : T[]) {
@next := next;
@next := next;
@ele := ele;
@ele := ele;
}
}


New(s : String) {
New(s : T) {
@ele := String->New[1];
@ele := T->New[1];
@ele[0] := s;
@ele[0] := s;
}
}


method : public : GetNext() ~ vSeg {
method : public : GetNext() ~ vSeg<T> {
return @next;
return @next;
}
}


method : public : GetEle() ~ String[] {
method : public : GetEle() ~ T[] {
return @ele;
return @ele;
}
}
Line 1,099: Line 1,097:
class Test {
class Test {
function : Main(args : String[]) ~ Nil {
function : Main(args : String[]) ~ Nil {
v := vList->New();
v := vList->New()<String>;
"Zero value for type. empty vList: {$v}"->PrintLine();
"Zero value for type. empty vList: {$v}"->PrintLine();
v->PrintStructure();
v->PrintStructure();


for(a := '6'; a >= '1'; a -=1;) {
for(a := '6'; a >= '1'; a -=1;) {
v := v->Cons("{$a}");
v := v->Cons("{$a}")<String>;
};
};
"Demonstrate cons. 6 elements added: {$v}"->PrintLine();
"Demonstrate cons. 6 elements added: {$v}"->PrintLine();
v->PrintStructure();
v->PrintStructure();


v := v->Cdr();
v := v->Cdr()<String>;
Runtime->Assert(v <> Nil);
Runtime->Assert(v <> Nil);
"Demonstrate cdr. 1 element removed: {$v}"->PrintLine();
"Demonstrate cdr. 1 element removed: {$v}"->PrintLine();
Line 1,121: Line 1,120:
"Demonstrate element access. v[3] = {$e}"->PrintLine();
"Demonstrate element access. v[3] = {$e}"->PrintLine();


v := v->Cdr()->Cdr();
v := v->Cdr()<String>->Cdr()<String>;
Runtime->Assert(v <> Nil);
Runtime->Assert(v <> Nil);
"Demonstrate cdr. 2 elements removed: {$v}"->PrintLine();
"Demonstrate cdr. 2 elements removed: {$v}"->PrintLine();
Retrieved from "https://rosettacode.org/wiki/VList"