Compound data type: Difference between revisions

=={{header|11l}}==

Int x, y

F (x, y)

.x = x

=={{header|ACL2}}==

(x (:assert (rationalp x)))

(y (:assert (rationalp y))))

(assign p1 (update-point (@ p1) :x 3)) ; Update the x value

(point-x (@ p1))

{{out}}

NESASM3 syntax:

.rsset $0400 ; reserve memory storage starting at address $0400

point_x .rs MAX_POINT_OBJECTS ; reserve 64 bytes for x-coordinates

VASM syntax:

point_ram equ $0400

point_x equ point_ram

So, for example, let's say we want to load our third (zero-indexed) point variable and copy it to zero page RAM addresses $00 and $01. We would do the following:

point_ram equ $0400

STA $00

LDA point_y,x

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

DEFINE REALPTR="CARD"

PrintR(p2.rx) Print(",")

PrintR(p2.ry) Print(")")

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Compound_data_type.png Screenshot from Atari 8-bit computer]

=={{header|ActionScript}}==

{

public class Point

}

}

=={{header|Ada}}==

===Tagged Type===

Ada tagged types are extensible through inheritance. The reserved word ''tagged'' causes the compiler to create a tag for the type. The tag identifies the position of the type in an inheritance hierarchy.

X : Integer := 0;

Y : Integer := 0;

===Record Type===

Ada record types are not extensible through inheritance. Without the reserved word ''tagged'' the record does not belong to an inheritance hierarchy.

X : Integer := 0;

Y : Integer := 0;

====Parameterized Types====

An Ada record type can contain a discriminant. The discriminant is used to choose between internal structural representations. Parameterized types were introduced to Ada before tagged types. Inheritance is generally a cleaner solution to multiple representations than is a parameterized type.

Name : Name_String;

Age : Natural;

null;

end case;

In this case every person will have the attributes of gender, name, age, and weight. A person with a male gender will also have a beard length.

===Tagged Type===

ALGOL 68 has only tagged-union/discriminants. And the tagging was strictly done by the ''type'' (MODE) of the members.

STRUCT(REAL r, INT i),

INT,

STRUCT(REAL rr),

STRUCT([]REAL r)

To extract the apropriate member of a UNION a '''conformity-clause''' has to be used.

CASE data IN

(INT i): printf(($"r: "gl$,i)),

OUT

printf($"Other cases"l$)

The '''conformity-clause''' does mean that ALGOL 68 avoids the need for

[[duck typing]], but it also makes the tagged-union kinda tough to use,

ALGOL 68 record types are not extensible through inheritance but they

may be part of a larger STRUCT composition.

INT x,

INT y

====Parameterized Types====

An ALGOL 68 record type can contain a tagged-union/discriminant. The

tagged-union/discriminant is used to choose between internal structural

representations.

STRING name,

REAL age,

VOID

) gender details

In this case every PERSON will have the attributes of gender details, name, age,

and weight. A PERSON may or may not have a beard. The sex is implied by the tagging.

=={{header|ALGOL W}}==

% create the compound data type %

record Point( real x, y );

% access the fields of p - note Algol W uses x(p) where many languages would use p.x %

write( x(p), y(p) )

=={{header|AmigaE}}==

x, y

ENDOBJECT

pt.y := !3.14

END pt

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

iMagicNumber: .int 0xCCCCCCCD

=={{header|Arturo}}==

x: 10

y: 20

]

{{out}}

There are numerous ways to do this. The simplest is to use an "unboxed" tuple type:

If one insists both that the type be unique (as opposed to an alias for a tuple) and that the notation to create a point be '''Point (x, y)''', then the following works:

| Point of (t, t)

=={{header|AutoHotkey}}==

[[wp:Monkey_patch|monkeypatched]] example.

point.x := 1

point.y := 0

=={{header|AWK}}==

As usual, arrays are the only data type more complex than a number or a string.<br>

Use quotes around constant strings as element selectors:

p["x"]=10

p["y"]=42

for (i in p) print( i, ":", p[i] )

{{out}}

<pre>

=={{header|Axe}}==

Axe does not have language support for custom data structures. However, they can be implemented from scratch using memory directly.

r₂→{r₁}ʳ

r₃→{r₁+2}ʳ

r₁

To initialize a POINT at memory address L₁ with (x, y) = (5, 10):

The caller must ensure the buffer has enough free space to contain the object (in this case, 4 bytes).

{{works with|PowerBASIC}}

x AS INTEGER

y AS INTEGER

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

=={{header|Bracmat}}==

So we go object oriented and create a 'type' Point. We show that <code>x</code> and <code>y</code> are independent by changing the value of <code>x</code> and checking that <code>y</code> didn't change.

Bracmat does not have other typing systems than duck typing. The variable <code>Point</code> is not a class, but an object in its own right. The <code>new$</code> function creates a copy of <code>Point</code>.

= (x=)

(y=)

& 7:?(pt..x)

& out$(!(pt..x) !(pt..y))

{{out}}

<pre>3 4

=={{header|C}}==

{

int x;

int y;

=={{header|C sharp|C#}}==

{

public int x, y;

this.y = y;

}

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

{

int x;

int y;

It is also possible to add a constructor (this allows the use of <tt>Point(x, y)</tt> in expressions):

{

int x;

int y;

Point(int ax, int ay): x(ax), y(ax) {}

Point can also be parametrized on the coordinate type:

{

Coordinate x, y;

// a point with floating point coordinates

Of course, a constructor can be added in this case as well.

=={{header|Clean}}==

===Record type===

===Parameterized Algebraic type===

===Synonym type===

=={{header|Clojure}}==

This defines a datatype with constructor ''Point.'' and accessors '':x'' and '':y'' :

(assert (= 0 (:x p)))

=={{header|CLU}}==

Aside from this, they work the same way.

point = struct[x, y: int]

mutable_point = record[x, y: int]

% Initialization

p: point := point${x: 10, y: 20}

The fields can be accessed using the <code>.</code> syntax:

''Record''s, but not ''struct''s, allow updating the fields in the same way.

It should be noted that the special forms <code>p.x</code> and <code>mp.x := value</code>

are really only syntactic sugar, they are equivalent to the following method calls:

=={{header|COBOL}}==

01 Point.

05 x pic 9(3).

05 y pic 9(3).

=={{header|CoffeeScript}}==

# Lightweight JS objects (with CS sugar).

point =

console.log p1.distance_from # [Function]

console.log p1.distance_from p2 # 13

=={{header|Common Lisp}}==

In addition to defining the ''point'' data type, the defstruct macro also created constructor and accessor functions:

#S(POINT :X 0 :Y 0)

CL-USER> (setf b (make-point :x 5.5 :y #C(0 1))) ;Dynamic datatypes are the default

3

CL-USER> (point-y b)

=={{header|Crystal}}==

Crystal's structs work very similarly to objects, but are allocated on the stack instead of the heap, and passed by value instead of by reference. More potential caveats are noted in the [https://crystal-lang.org/reference/syntax_and_semantics/structs.html language reference].

getter x : T

getter y : T

end

=={{header|D}}==

// A normal POD struct

// (if it's nested and it's not static then it has a hidden

static assert(is(p6[0] == int));

static assert(p6[1] == 5);

=={{header|Delphi}}==

As defined in Types.pas:

X: Longint;

Y: Longint;

end;

=={{header|Diego}}==

add_struct(point)_arg(x,y);

with_point(point2)_arg(0.033,👣);

=={{header|E}}==

def point {

to getX() { return x }

}

return point

=={{header|EchoLisp}}==

(lib 'struct)

(struct Point (x y))

(Point 3 'albert)

❌ error: #number? : type-check failure : albert → 'Point:y'

=={{header|Ela}}==

Ela supports algebraic types:

Except of regular algebraic types, Ela also provides a support for open algebraic types - which can be extended any time with new constructors:

//Add new constructor to an existing type

=={{header|Elena}}==

{

prop int X;

Y := y

}

=={{header|Elixir}}==

...(1)> defstruct x: 0, y: 0

...(1)> end

10

iex(8)> py

=={{header|Elm}}==

--Compound Data type can hold multiple independent values

--In Elm data can be compounded using List, Tuple, Record

--Each time a new record is generated

--END

=={{header|Erlang}}==

-module(records_test).

-compile(export_all).

P2 = P1#point{x=3.0}, % creates a new point record with x set to 3.0, y is copied from P1

io:fwrite("X: ~f, Y: ~f~n",[P2#point.x,P2#point.y]).

=={{header|Euphoria}}==

{{works with|OpenEuphoria}}

enum x, y

printf(1,"x = %d, y = %3.3f\n",point)

printf(1,"x = %s, y = %3.3f\n",point)

{{out}}

<pre>

=={{header|F_Sharp|F#}}==

See the OCaml section as well. Here we create a list of points and print them out.

let points = [

{x = 5; y = 5} ]

=={{header|Factor}}==

=={{header|Fantom}}==

// define a class to contain the two fields

// accessors to get/set the field values are automatically generated

}

}

{{out}}

There is no standard structure syntax in Forth, but it is easy to define words for creating and accessing data structures.

: pt>y ( point -- y ) CELL+ ;

: .pt ( point -- ) dup pt>x @ . pt>y @ . ; \ or for this simple structure, 2@ . .

create point 6 , 0 ,

7 point pt>y !

{{works with|GNU Forth|0.6.2}}

Some Forths have mechanisms for declaring complex structures. For example, GNU Forth uses this syntax:

cell% field pt>x

cell% field pt>y

=={{header|Fortran}}==

In ISO Fortran 90 or later, use a TYPE declaration, "constructor" syntax, and field delimiter syntax:

type rational ! Type declaration

integer :: numerator

oon_denoms = one_over_n%denominator ! Access denominator field in every

! rational array element & store

=={{header|FreeBASIC}}==

Type Point

Print p.x, p.y

Print p2.x, p2.y

{{out}}

=={{header|Go}}==

x, y float64

}

=={{header|Groovy}}==

===Declaration===

int x

int y

Point(int x = 0, int y = 0) { this.x = x; this.y = y }

String toString() { "{x:${x}, y:${y}}" }

===Instantiation===

=====Direct=====

def p0 = new Point()

assert 0 == p0.x

def p2 = new Point(36)

assert 36 == p2.x

=====List-to-argument Substitution=====

There are several ways that a List can be substituted for constructor arguments via "type coercion" (casting).

def p4 = [36, -2] as Point

assert 36 == p4.x

Point p8 = [36]

assert 36 == p8.x

=====Map-to-property Substitution=====

There are several ways to construct an object using a map (or a comma-separated list of map entries) that substitutes entries for class properties. The process is properly (A) instantiation, followed by (B) property mapping. Because the instantiation is not tied to the mapping, it requires the existence of a no-argument constructor.

def p3 = new Point([x: 36, y: -2])

assert 36 == p3.x

Point p9 = [y:-2]

assert 0 == p9.x

=={{header|Haskell}}==

You can make a tuple literal by using a comma-delimited list surrounded by parentheses, without needing to declare the type first:

The type of <code>p</code> is <code>(Int, Int)</code>, using the same comma-delimited list syntax as the literal.

=={{header|Icon}} and {{header|Unicon}}==

=={{header|IDL}}==

point.y = 7

print, point

=={{header|J}}==

In a "real" J application, points would be represented by arrays of 2 (or N) numbers. None the less, sometimes objects (in the OO sense) are a better representation than arrays, so J supports them:

coclass'Point'

10

Y__P

=={{header|Java}}==

We use a class:

{

public int x, y;

System.out.println("y = " + point.y );

}

=={{header|JavaScript}}==

var point = {x : 1, y : 2};

}

}

=={{header|jq}}==

If the emphasis in the task description is on "type", then an alternative approach would be to include a "type" key, e.g.

Using this approach, one can distinguish between objects of type "Point" and those that happen to have keys named "x" and "y".

=={{header|JSON}}==

=={{header|Julia}}==

'''Define the type''':

x::T

y::T

The components of <code>Point</code> can be any sort of real number, though they do have to be of the same type.

'''Define a few simple operations for Point''':

Base.:-(u::Point) = Point(-u.x, -u.y)

Base.:+(u::Point, v::Point) = Point(u.x + v.x, u.y + v.y)

'''Have fun''':

@show a b c

@show a + b

@show a + b + c

@show a == b

{{out}}

=={{header|KonsolScript}}==

Point,

Number x,

Number y

Instanciate it with...

Var:Point point;

=={{header|Kotlin}}==

fun main(args: Array<String>) {

p.y = 4

println(p)

{{out}}

=={{header|Lambdatalk}}==

1) a pair

{def P {P.new 1 2}}

{A.last {R}}

-> 2

=={{header|Lasso}}==

In Lasso, a point could just be stored in the pair type. However, assuming we want to be able to access the points using the member methods [Point->x] and [Point->y], let's just create a type that inherits from the pair type:

parent pair

local(point) = Point(33, 42)

#point->x

{{out}}

Simply define a record in the LFE REPL (can also be used in include files, modules, etc.):

(defrecord point

x

y)

Creating points:

=={{header|Lingo}}==

Point and Vector types are built-in. A custom "MyPoint" type can be implemented like this:

property x

property y

me.y = py

return me

put p.x, p.y

Construction could also be simplified by using a global wrapper function:

on MyPoint (x, y)

return script("MyPoint").new(x, y)

put p.x, p.y

=={{header|Logo}}==

In Logo, a point is represented by a list of two numbers. For example, this will draw a triangle:

Access is via normal list operations like FIRST and BUTFIRST (BF). X is FIRST point, Y is LAST point. For example, a simple drawing program which exits if mouse X is negative:

=={{header|Lua}}==

Lua could use a simple table to store a compound data type Point(x, y):

a = {x = 1; y = 2}

b = {x = 3; y = 4}

print(a.x, a.y) --> 1 2

print(c.x, c.y) --> 4 6

==== Prototype Object ====

Furthermore, Lua could create a prototype object (OOP class emulation) to represent a compound data type Point(x, y) as the following:

cPoint = {} -- metatable (behaviour table)

function newPoint(x, y) -- constructor

return setmetatable(pointPrototype, cPoint) -- set behaviour and return the pointPrototype

end--newPoint

In the above example, the methods are declared inside the constructor so that they could access the closured values <code>x</code> and <code>y</code> (see usage example). The <code>pointPrototype:type</code> method could be used to extend the original <code>type</code> function available in Lua:

local oldtype = type; -- store original type function

function type(v)

end--if vType=="table"

end--type

The usage of metatable <code>cPoint</code> which stores the behavior of the <code>pointPrototype</code> enables additional behaviour to be added to the data type, such as:

function cPoint.__add(op1, op2) -- add the x and y components

if type(op1)=="point" and type(op2)=="point" then

end--if type(op1)

end--cPoint.__sub

Usage example:

a = newPoint(1, 2)

b = newPoint(3, 4)

print(c:getXY()) --> 4 6

print((a-b):getXY()) --> -2 -2 -- using __sub behaviour

=={{header|Maple}}==

Point:-x;

{{out}}

<pre>

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Expressions like point[x, y] can be used without defining.

Out[1]= point[2, 3]

In[3]:= a[[2]] = 4; a

Or you can just define a function.

Data will be stored as down values of the symbol ''p''.

=={{header|MATLAB}} / {{header|Octave}}==

Alternatively, coordinates can be also stored as vectors

=={{header|Maxima}}==

p: new(point)$

q: point(1, 2)$

=={{header|MAXScript}}==

Point is a built-in object type in MAX, so...

In practice however, you'd use MAX's built in Point2 type

=={{header|MiniScript}}==

Point.x = 0

=={{header|Modula-2}}==

x, y : INTEGER

Usage:

...

point.x := 12;

=={{header|Modula-3}}==

x, y: INTEGER;

Usage:

=={{header|NetRexx}}==

Like Java, NetRexx uses the <tt>class</tt> instruction to create compound types. Unlike Java; NetRexx provides keywords to automatically generate getters and setters for <tt>class</tt> properties and will automatically generate intermediate methods based on defaults provided in method prototypes.

options replace format comments java crossref symbols nobinary

res = 'X='getX()',Y='getY()

return res

{{out}}

<pre>

=={{header|Nim}}==

var p: Point = (12, 13)

=={{header|Oberon-2}}==

MODULE Point;

TYPE

END Point.

=={{header|Objeck}}==

Classes are used for compound data types.

class Point {

@x : Int;

}

}

=={{header|OCaml}}==

See [[wp:Algebraic_data_type|algebraic data type]]. The different options ("Empty", "Leaf", "Node") are called ''constructors'', and is associated with 0 or more arguments with the declared types; multiple arguments are declared with a syntax that looks like a tuple type, but it is not really a tuple.

| Leaf of int

| Node of tree * tree

===Record Type===

How to construct a point:

You can use the dot (".") to access fields.

Fields can be optionally declared to be mutable:

Then they can be assigned using the assignment operator "<-"

p2.x2 <- 6;

===Tuple Type===

You can make a tuple literal by using a comma-delimited list, optionally surrounded by parentheses, without needing to declare the type first:

The type of <code>p</code> is a product (indicated by <code>*</code>) of the types of the components:

Using a class :

=={{header|ooRexx}}==

ooRexx uses class for compound data types.

p = .point~new(3,4)

say "x =" p~x

::attribute x

::attribute y

=={{header|OpenEdge/Progress}}==

The temp-table is a in memory database table. So you can query sort and iterate it, but is the data structure that comes closest.

field x as int

field y as int

Another option would be a simple class.

=={{header|OxygenBasic}}==

'SHORT FORM

type point float x,y

print p.x " " p.y

=={{header|Oz}}==

A point can be represented by using a record value:

Now we can access the components by name: P.x and P.y

Often such values are deconstructed by pattern matching:

{Show X}

{Show Y}

=={{header|PARI/GP}}==

=={{header|Pascal}}==

x, y: integer;

=={{header|Perl}}==

===Array===

===Hash===

x => 3,

y => 8

===Class instance===

use strict;

;

=={{header|Phix}}==

===traditional user defined type===

The sequence is a natural compound data type. The following would be the same without the type point and declaring p as a sequence, apart from the run-time error. There would be no difficulty defining point to have a string and two atoms.

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

<span style="color: #008080;">enum</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span>

<span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">x</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span> <span style="color: #000080;font-style:italic;">-- fine</span>

<span style="color: #000000;">p</span><span style="color: #0000FF;">[</span><span style="color: #000000;">y</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"string"</span> <span style="color: #000080;font-style:italic;">-- run-time error (not pwa/p2js)</span>

{{out}}

<pre>

{{libheader|Phix/Class}}

You could also use a class (not pwa/p2js)

<span style="color: #008080;">class</span> <span style="color: #000000;">point</span>

<span style="color: #008080;">public</span> <span style="color: #004080;">atom</span> <span style="color: #000000;">x</span><span style="color: #0000FF;">,</span><span style="color: #000000;">y</span>

<span style="color: #000000;">p</span><span style="color: #0000FF;">.</span><span style="color: #000000;">x</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span> <span style="color: #000080;font-style:italic;">-- fine</span>

<span style="color: #000000;">p</span><span style="color: #0000FF;">.</span><span style="color: #000000;">y</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"string"</span> <span style="color: #000080;font-style:italic;">-- run-time error</span>

{{out}}

<pre>

=={{header|PHP}}==

$point = pack("ii", 1, 2);

list($x,$y) = unpack("ii", $point);

echo $x;