VList: Difference between revisions

=={{header|Applesoft BASIC}}==

1 FOR A = 6 TO 1 STEP - 1:A$ = STR$ (A): PRINT "CONS "A$": ";: GOSUB 10: GOSUB 50: NEXT A

2 GOSUB 30: PRINT "LENGTH: "L

REM PRINT ELEMENT WITH NEWLINE given A

{{out}}

<pre>

</pre>

=={{header|C}}==

#include <stdlib.h>

v_del(v);

return 0;

=={{header|C++}}==

{{trans|Go}}

#include <iostream>

#include <vector>

return 0;

}

{{out}}

<pre>

Two modules are provided - one for implementing and one for using VLists

MODULE RosettaVLists;

(** In 2002, Phil Bagwell published "Fast Functional Lists" which introduced VLists as alternatives to Functional Programming's

NEW(nilBase); nilBase.NewBlock(1, '*')

END RosettaVLists.

Interface extracted from implementation:

DEFINITION RosettaVLists;

END;

Module that uses previous module:

MODULE RosettaVListsUse;

END RosettaVListsUse.

Execute: ^Q RosettaVListsUse.Use

{{out}}

=={{header|D}}==

{{trans|C}}

import core.stdc.stdlib: malloc, free, abort;

v.free;

{{out}}

<pre>v.length = 10

=={{header|Go}}==

import "fmt"

fmt.Println("show cdr releasing segment. 2 elements removed:", v)

v.printStructure()

{{out}}

<pre>

A vlist preallocates storage in increasing powers of 2. The "head" of the vlist is in the last (largest) storage block. Here we define a class with methods <code>unshift</code> (which adds to the "head" of the vlist), <code>shift</code> (which removes from the "head" of the vlist), <code>size</code> (which tells us how many elements the vlist currently contains), and <code>get</code> (which retrieves the nth element from the vlist):

off=: 0

end.

r=. off{do current

Example use:

size__L''

0

555

size__L''

Caution: this is an accurate model of the vlist data structure but should not be used if performance is critical.

languages with slower arrays.

import Base.length, Base.string

testVList()

<pre>

zero value for type. empty VList: []

=={{header|Kotlin}}==

{{trans|Go}}

class VList<T : Any?> {

println("Demonstrating cdr method again, 2 more elements removed: $v")

v.printStructure()

{{out}}

=={{header|Nim}}==

{{trans|Go}}

VSeg[T] = ref object

v = v.cdr().cdr()

echo "Show cdr releasing segment. Two elements removed: ", v

{{out}}

{{trans|Kotlin}}

@base : vSeg<T>;

@offset : Int;

v->PrintStructure();

}

{{output}}

The ooRexx queue class is a vlist implementation.

Here are some examples of usage:

-- show how to use the queue class

q = .queue~of(1, 2, 3, 4)

say q[1] q[2] q[4]

{{out}}

<pre>

=={{header|Phix}}==

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">enum</span> <span style="color: #000000;">OFFSET</span><span style="color: #0000FF;">,</span> <span style="color: #000080;font-style:italic;">-- (first spare slot [0=none])</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

{{out}}

<pre>

{{trans|Go}}

{{trans|Kotlin}}

subset vEle of Any; # or Str

$v := $v.cdr.cdr;

say "show cdr releasing segment. 2 elements removed: ", $v;

{{out}}

<pre>zero value for type. empty vList: []

║ used. I.E.: 63.01 63.5 63.63 63.9 ║

╚════════════════════════════════════════════════════════════════════╝

/*could use instead: q = 1 2 3 4 */

call q 0, 1 2 3 4 /*populate the list with values 1 ── ►4*/

if j==ni then $=$ ! /*handle the "insert". */

end /*j*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

The Scala implementation shares a common root with the Clojure implementation, but is certainly not a port of it.</blockquote>

A quote of Martin Odersky, his co-worker Phil Bagwell† invented the VList.

val emptyVlist1 = Vector.empty[Int]

assert(addedVlist1(3) == 10, "Wrong element accesed.")

println("Successfully completed without errors.")

=={{header|Wren}}==

{{trans|Kotlin}}

construct new() {

_next = null

v = v.cdr().cdr()

System.print("Demonstrating cdr method again, 2 more elements removed: %(v)")

{{out}}