Compound data type
From Rosetta Code
You are encouraged to solve this task according to the task description, using any language you may know.
Data Structure
This illustrates a data structure, a means of storing data within a program.
Create a compound data type Point(x,y).
A compound data type is one that holds multiple independent values. See also Enumeration.
[edit] ActionScript
package
{
public class Point
{
public var x:Number;
public var y:Number;
public function Point(x:Number, y:Number)
{
this.x = x;
this.y = y;
}
}
}
[edit] Ada
[edit] 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.
type Point is tagged record
X : Integer := 0;
Y : Integer := 0;
end record;
[edit] Record Type
Ada record types are not extensible through inheritance. Without the reserved word tagged the record does not belong to an inheritance hierarchy.
type Point is record
X : Integer := 0;
Y : Integer := 0;
end record;
[edit] 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.
type Person (Gender : Gender_Type) is record
Name : Name_String;
Age : Natural;
Weight : Float;
Case Gender is
when Male =>
Beard_Length : Float;
when Female =>
null;
end case;
end record;
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.
[edit] ALGOL 68
[edit] Tagged Type
ALGOL 68 has only tagged-union/discriminants. And the tagging was strictly done by the type (MODE) of the members.
MODE UNIONX = UNION(
STRUCT(REAL r, INT i),
INT,
REAL,
STRUCT(INT ii),
STRUCT(REAL rr),
STRUCT([]REAL r)
);
To extract the apropriate member of a UNION a conformity-clause has to be used.
UNIONX data := 6.6;
CASE data IN
(INT i): printf(($"r: "gl$,i)),
(REAL r): printf(($"r: "gl$,r)),
(STRUCT(REAL r, INT i) s): printf(($"r&i: "2(g)l$,s)),
(STRUCT([]REAL r) s): printf(($"r: "n(UPB r OF s)(g)l$,s))
OUT
printf($"Other cases"l$)
ESAC;
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, except maybe in certain special cases.
[edit] Record Type
ALGOL 68 record types are not extensible through inheritance but they may be part of a larger STRUCT composition.
MODE POINT = STRUCT(
INT x,
INT y
);
[edit] 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.
MODE PERSON = STRUCT(
STRING name,
REAL age,
REAL weight,
UNION (
STRUCT (REAL beard length),
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.
[edit] AmigaE
OBJECT point
x, y
ENDOBJECT
PROC main()
DEF pt:PTR TO point,
NEW pt
pt.x := 10.4
pt.y := 3.14
END pt
ENDPROC
[edit] AutoHotkey
Works with: AutoHotkey_L monkeypatched example.
point := Object()
point.x := 1
point.y := 0
[edit] AWK
As usual, arrays are the only data type more complex than a number or a string. Having to use quotes around constant strings as element selectors:
p["x"]=10
p["y"]=42
[edit] BASIC
Works with: QBasic Works with: PowerBASIC
TYPE Point
x AS INTEGER
y AS INTEGER
END TYPE
[edit] C
typedef struct Point
{
int x;
int y;
} Point;
[edit] C++
struct Point
{
int x;
int y;
};
It is also possible to add a constructor (this allows the use of Point(x, y) in expressions):
struct Point
{
int x;
int y;
Point(int ax, int ay): x(ax), y(ax) {}
};
Point can also be parametrized on the coordinate type:
template<typename Coordinate> struct point
{
Coordinate x, y;
};
// A point with integer coordinates
Point<int> point1 = { 3, 5 };
// a point with floating point coordinates
Point<float> point2 = { 1.7, 3.6 };
Of course, a constructor can be added in this case as well.
[edit] C#
struct Point
{
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
[edit] Clean
[edit] Record type
:: Point = { x :: Int, y :: Int }
[edit] Parameterized Algebraic type
:: Point a = Point a a // usage: (Point Int)
[edit] Synonym type
:: Point :== (Int, Int)
[edit] Clojure
(defrecord Point [x y])
This defines a datatype with constructor Point. and accessors :x and :y :
(def p (Point. 0 1))
(assert (= 0 (:x p)))
(assert (= 1 (:y p)))
[edit] D
A struct, it can be inizialized with a Point(x, y) syntax:
struct Point { int x, y; }
It can also be parametrized on the coordinate type:
struct Point(T) { T x, y; }
// A point with integer coordinates
auto p1 = Point!(int)(3, 5);
// a point with floating point coordinates
auto p1 = Point!(float)(3, 5);
There are also other ways to initialize them. The D language also supports tuples.
[edit] Common Lisp
(defstruct point x y)
[edit] E
def makePoint(x, y) {
def point {
to getX() { return x }
to getY() { return y }
}
return point
}
[edit] Factor
TUPLE: point x y ;
[edit] Forth
There is no standard structure syntax in Forth, but it is easy to define words for creating and accessing data structures.
: pt>x ( point -- x ) ;
: 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 !
.pt \ 6 7
Works with: GNU Forth version 0.6.2 Some Forths have mechanisms for declaring complex structures. For example, GNU Forth uses this syntax:
struct
cell% field pt>x
cell% field pt>y
end-struct point%
[edit] Fortran
In ISO Fortran 90 or later, use a TYPE declaration, "constructor" syntax, and field delimiter syntax:
program typedemo
type rational ! Type declaration
integer :: numerator
integer :: denominator
end type rational
type( rational ), parameter :: zero = rational( 0, 1 ) ! Variables initialized
type( rational ), parameter :: one = rational( 1, 1 ) ! by constructor syntax
type( rational ), parameter :: half = rational( 1, 2 )
integer :: n, halfd, halfn
type( rational ) :: &
one_over_n(20) = (/ (rational( 1, n ), n = 1, 20) /) ! Array initialized with
! constructor inside
! implied-do array initializer
integer :: oon_denoms(20)
halfd = half%denominator ! field access with "%" delimiter
halfn = half%numerator
oon_denoms = one_over_n%denominator ! Access denominator field in every
! rational array element & store
end program typedemo ! as integer array
[edit] F#
See the OCaml section as well. Here we create a list of points and print them out.
type Point = { x : int; y : int }
let points = [
{x = 1; y = 1};
{x = 5; y = 5} ]
Seq.iter (fun p -> printfn "%d,%d" p.x p.y) points
[edit] Haskell
[edit] Algebraic Data Type
See algebraic data type. The different options ("Empty", "Leaf", "Node") are called constructors, and is associated with 0 or more arguments with the declared types.
data Tree = Empty
| Leaf Int
| Node Tree Tree
deriving (Eq, Show)
t1 = Node (Leaf 1) (Node (Leaf 2) (Leaf 3))
[edit] Tagged Type
This is special case of algebraic data type above with only one constructor.
data Point = Point Integer Integer
instance Show Point where
show (Point x y) = "("++(show x)++","++(show y)++")"
p = Point 6 7
[edit] Record Type
Entries in an algebraic data type constructor can be given field names.
data Point = Point { x :: Integer, y :: Integer }
deriving (Eq, Show)
The deriving clause here provides default instances for equality and conversion to string.
Different equivalent ways of constructing a point:
p = Point 2 3
p' = Point { x=4, y=5 }
The field name is also a function that extracts the field value out of the record
x p' -- evaluates to 4
[edit] Tuple Type
You can make a tuple literal by using a comma-delimited list surrounded by parentheses, without needing to declare the type first:
p = (2,3)
The type of p is (Int, Int), using the same comma-delimited list syntax as the literal.
[edit] Discriminated Type
Just an algebraic data type with multiple constructors being records
data Person =
Male { name :: String, age :: Integer, weight :: Double,
beard_length :: Double }
| Female { name :: String, age :: Integer, weight :: Double }
deriving (Eq, Show)
Note that the field names may be identical in alternatives.
[edit] Icon and Unicon
[edit] Icon
record Point(x,y)
[edit] Unicon
This Icon solution works in Unicon.
[edit] IDL
point = {x: 6 , y: 0 }
point.y = 7
print, point
;=> { 6 7}
[edit] 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:
NB. Create a "Point" class
coclass'Point'
NB. Define its constuctor
create =: 3 : 0
'X Y' =: y
)
NB. Instantiate an instance (i.e. an object)
cocurrent 'base'
P =: 10 20 conew 'Point'
NB. Interrogate its members
X__P
10
Y__P
20
[edit] Java
We use a class:
public class Point
{
public int x, y;
public Point() { this(0); }
public Point(int x0) { this(x0,0); }
public Point(int x0, int y0) { x = x0; y = y0; }
public static void main(String args[])
{
Point point = new Point(1,2);
System.out.println("x = " + point.x );
System.out.println("y = " + point.y );
}
}
[edit] JavaScript
var point = {x : 1, y : 2};
[edit] JSON
{"x":1,"y":2}
[edit] Logo
In Logo, a point is represented by a list of two numbers. For example, this will draw a triangle:
setpos [100 100] setpos [100 0] setpos [0 0]
show pos ; [0 0]
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:
until [(first mousepos) < 0] [ifelse button? [pendown] [penup] setpos mousepos]
[edit] Lua
[edit] Simple Table
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}
c = {
x = a.x + b.x;
y = a.y + b.y
}
print(a.x, a.y) --> 1 2
print(c.x, c.y) --> 4 6
[edit] 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
local pointPrototype = {} -- prototype declaration
function pointPrototype:getX() return x end -- public method
function pointPrototype:getY() return y end -- public method
function pointPrototype:getXY() return x, y end -- public method
function pointPrototype:type() return "point" end -- public method
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 x and y (see usage example). The pointPrototype:type method could be used to extend the original type function available in Lua:
local oldtype = type; -- store original type function
function type(v)
local vType = oldtype(v)
if (vType=="table" and v.type) then
return v:type() -- bypass original type function if possible
else
return vType
end--if vType=="table"
end--type
The usage of metatable cPoint which stores the behavior of the pointPrototype 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
return newPoint(
op1:getX()+op2:getX(),
op1:getY()+op2:getY())
end--if type(op1)
end--cPoint.__add
function cPoint.__sub(op1, op2) -- subtract the x and y components
if (type(op1)=="point" and type(op2)=="point") then
return newPoint(
op1:getX()-op2:getX(),
op1:getY()-op2:getY())
end--if type(op1)
end--cPoint.__sub
Usage example:
a = newPoint(1, 2)
b = newPoint(3, 4)
c = a + b -- using __add behaviour
print(a:getXY()) --> 1 2
print(type(a)) --> point
print(c:getXY()) --> 4 6
print((a-b):getXY()) --> -2 -2 -- using __sub behaviour
[edit] MAXScript
Point is a built-in object type in MAX, so...
struct myPoint (x, y)
newPoint = myPoint x:3 y:4
In practice however, you'd use MAX's built in Point2 type
newPoint = Point2 3 4
[edit] Modula-3
TYPE Point = RECORD
x, y: INTEGER;
END;
Usage:
VAR point: Point;
...
point := Point{3, 4};
or
point := Point{x := 3, y := 4};
[edit] Objeck
Classes are used for compound data types.
class Point {
@x : Int;
@y : Int;
New() {
@x := 0;
@y := 0;
}
New(x : Int, y : Int) {
@x := x;
@y := y;
}
New(p : Point) {
@x := p->GetX();
@y := p->GetY();
}
method : public : GetX() ~ Int {
return @x;
}
method : public : GetY() ~ Int {
return @y;
}
method : public : SetX(x : Int) ~ Nil {
@x := x;
}
method : public : SetY(y : Int) ~ Nil {
@y := y;
}
}
[edit] OCaml
[edit] Algebraic Data Type
See algebraic data type. The different options ("Empty", "Leaf", "Node") are called constructors, and is associated with 0 or 1 arguments with the declared types; multiple arguments are handled with tuples.
type tree = Empty
| Leaf of int
| Node of tree * tree
let t1 = Node (Leaf 1, Node (Leaf 2, Leaf 3))
[edit] Record Type
type point = { x : int; y : int }
How to construct a point:
let p = { x = 4; y = 5 }
You can use the dot (".") to access fields.
p.x (* evaluates to 4 *)
Fields can be optionally declared to be mutable:
type mutable_point = { mutable x2 : int; mutable y2 : int }
Then they can be assigned using the assignment operator "<-"
let p2 = { x2 = 4; y2 = 5 } in
p2.x2 <- 6;
p2 (* evaluates to { x2 = 6; y2 = 5 } *)
[edit] 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:
let p = (2,3)
The type of p is a product (indicated by *) of the types of the components:
# let p = (2,3);; val p : int * int = (2, 3)
[edit] 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.
def temp-table point
field x as int
field y as int
.
Another option would be a simple class.
[edit] Oz
A point can be represented by using a record value:
P = point(x:1 y:2)
Now we can access the components by name: P.x and P.y Often such values are deconstructed by pattern matching:
case P of point(x:X y:Y) then
{Show X}
{Show Y}
end
[edit] Pascal
type point = record
x, y: integer;
end;
[edit] Perl
[edit] Array
my @point = (3, 8);
[edit] Hash
my %point = (
x => 3,
y => 8
);
[edit] Class instance
package Point;
use strict;
use base 'Class::Struct'
x => '$',
y => '$',
;
my $point = Point->new(x => 3, y => 8);
[edit] Perl 6
Works with: Rakudo version #24 "Seoul"
[edit] Array
my @point = 3, 8;
[edit] Hash
my %point = x => 3, y => 8;
[edit] Class instance
class Point { has $.x is rw; has $.y is rw; }
my Point $point .= new(x => 3, y => 8);
[edit] PHP
# Using pack/unpack
$point = pack("ii", 1, 2);
$u = unpack("ix/iy", $point);
echo $x;
echo $y;
list($x,$y) = unpack("ii", $point);
echo $x;
echo $y;
# Using array
$point = array('x' => 1, 'y' => 2);
list($x, $y) = $point;
echo $x, ' ', $y, "\n";
# or simply:
echo $point['x'], ' ', $point['y'], "\n";
# Using class
class Point {
function __construct($x, $y) { $this->x = $x; $this->y = $y; }
function __tostring() { return $this->x . ' ' . $this->y . "\n"; }
}
$point = new Point(1, 2);
echo $point; # will call __tostring() in later releases of PHP 5.2; before that, it won't work so good.
[edit] PicoLisp
(class +Point)
(dm T (X Y)
(=: x X)
(=: y Y) )
(setq P (new '(+Point) 3 4))
(show P)
Output:
$52717735311266 (+Point) y 4 x 3
[edit] PL/I
define structure
1 point,
2 x float,
2 y float;
[edit] Pop11
uses objectclass;
define :class Point;
slot x = 0;
slot y = 0;
enddefine;
[edit] PureBasic
Basic structuresare implemented as;
Structure MyPoint
X.i
Y.i
EndStructure
If needed StructureUnion can be used to optimize the structures
Structure MyFileDate
name.s
StructureUnion
Date_as_txt.s
Date_in_Ticks.l
EndStructureUnion
EndStructure
[edit] Python
The simplest way it to use a tuple, or a list if it should be mutable:
X, Y = 0, 1
p = (3, 4)
p = [3, 4]
print p[X]
If needed, you can use class:
class Point:
def __init__(self, x=0, y=0):
self.x = x
self.y = y
p = Point()
print p.x
One could also simply instantiate a generic object and "monkeypatch" it:
class MyObject(object): pass
point = MyObject()
point.x, point.y = 0, 1
# objects directly instantiated from "object()" cannot be "monkey patched"
# however this can generally be done to it's subclasses
[edit] Named Tuples
As of Python 2.6 one can use the collections.namedtuple factory to create classes which associate field names with elements of a tuple. This allows one to perform all normal operations on the contained tuples (access by indices or slices, packing and unpacking) while also allowing elements to be accessed by name.
>>> from collections import namedtuple
>>> help(namedtuple)
Help on function namedtuple in module collections:
namedtuple(typename, field_names, verbose=False)
Returns a new subclass of tuple with named fields.
>>> Point = namedtuple('Point', 'x y')
>>> Point.__doc__ # docstring for the new class
'Point(x, y)'
>>> p = Point(11, y=22) # instantiate with positional args or keywords
>>> p[0] + p[1] # indexable like a plain tuple
33
>>> x, y = p # unpack like a regular tuple
>>> x, y
(11, 22)
>>> p.x + p.y # fields also accessable by name
33
>>> d = p._asdict() # convert to a dictionary
>>> d['x']
11
>>> Point(**d) # convert from a dictionary
Point(x=11, y=22)
>>> p._replace(x=100) # _replace() is like str.replace() but targets named fields
Point(x=100, y=22)
>>>
[edit] R
R uses the list data type for compound data.
mypoint <- list(x=3.4, y=6.7)
# $x
# [1] 3.4
# $y
# [1] 6.7
mypoint$x # 3.4
list(a=1:10, b="abc", c=runif(10), d=list(e=1L, f=TRUE))
# $a
# [1] 1 2 3 4 5 6 7 8 9 10
# $b
# [1] "abc"
# $c
# [1] 0.64862897 0.73669435 0.11138945 0.10408015 0.46843836 0.32351247
# [7] 0.20528914 0.78512472 0.06139691 0.76937113
# $d
# $d$e
# [1] 1
# $d$f
# [1] TRUE
[edit] Ruby
Point = Struct.new(:x,:y)
p = Point.new(6,7)
p.y=3
puts p
=> #<struct Point x=6, y=3>
[edit] Scheme
Using SRFI 9:
(define-record-type point
(make-point x y)
point?
(x point-x)
(y point-y))
[edit] SIMPOL
The point type is pre-defined in [SIMPOL], so we will call this mypoint.
type mypoint
embed
integer x
integer y
end type
The embed keyword is used here as a toggle to indicate that all following properties are embedded in the type. The other toggle is reference, which only places a reference to an object in the type, but the reference assigned before the property can be used. These keywords can also be placed on the same line, but then they only apply to that line of the type definition.
A type in [SIMPOL] can be just a container of values and other structures, but it can also include methods. These are implemented outside the type definition, but must be part of the same compiled unit.
type mypoint
embed
integer x
integer y
end type
function mypoint.new(mypoint me, integer x, integer y)
me.x = x
me.y = y
end function me
[edit] SNOBOL4
data('point(x,y)')
p1 = point(10,20)
p2 = point(10,40)
output = "Point 1 (" x(p1) "," y(p1) ")"
output = "Point 2 (" x(p2) "," y(p2) ")"
end
[edit] Standard ML
[edit] Algebraic Data Type
See algebraic data type. The different options ("Empty", "Leaf", "Node") are called constructors, and is associated with 0 or 1 arguments with the declared types; multiple arguments are handled with tuples.
datatype tree = Empty
| Leaf of int
| Node of tree * tree
val t1 = Node (Leaf 1, Node (Leaf 2, Leaf 3))
[edit] Tuple Type
You can make a tuple literal by using a comma-delimited list surrounded by parentheses, without needing to declare the type first:
val p = (2,3)
The type of p is a product (indicated by *) of the types of the components:
- val p = (2,3); val p = (2,3) : int * int
You can extract elements of the tuple using the #N syntax:
- #2 p; val it = 3 : int
The #2 above extracts the second field of its argument.
[edit] Record Type
Records are like tuples but with field names.
You can make a record literal by using a comma-delimited list of key = value pairs surrounded by curly braces, without needing to declare the type first:
val p = { x = 4, y = 5 }
The type of p is a comma-delimited list of key:type pairs of the types of the fields:
- val p = { x = 4, y = 5 };
val p = {x=4,y=5} : {x:int, y:int}
You can extract elements of the tuple using the #name syntax:
- #y p; val it = 5 : int
The #y above extracts the field named "y" of its argument.
[edit] Tcl
This appears to be a sub-functionality of a proper associative array:
array set point {x 4 y 5}
set point(y) 7
puts "Point is {$point(x),$point(y)}"
# => Point is {4,7}
[edit] TI-89 BASIC
TI-89 BASIC does not have user-defined data structures. The specific example of a point is best handled by using the built-in vectors or complex numbers.
[edit] Ursala
A record type with two untyped fields named x and y can be declared like this.
point :: x y
A constant instance of the record can be declared like this.
p = point[x: 'foo',y: 'bar']
A function returning a value of this type can be defined like this,
f = point$[x: g,y: h]
where g and h are functions. Then f(p) would evaluate to
point[x: g(p),y: h(p)] for a given argument p. Accessing the fields of
a record can be done like this.
t = ~x p
u = ~y p
where p is any expression of the defined type. A real application wouldn't be written
this way because pairs of values (x,y) are a common idiom.
[edit] Visual Basic .NET
[edit] Simple Structures
This shows a structure in its simpest form.
Structure Simple_Point
Public X, Y As Integer
End Structure
[edit] Immutable Structures
In Visual Basic, mutable strucutures are difficult to use properly and should only be used when performance measurements warrant it. The rest of the time, immutable structures should be used. Below is the same structure seen before, but in an immutable form.
Structure Immutable_Point
Private m_X As Integer
Private m_Y As Integer
Public Sub New(ByVal x As Integer, ByVal y As Integer)
m_X = x
m_Y = y
End Sub
Public ReadOnly Property X() As Integer
Get
Return m_X
End Get
End Property
Public ReadOnly Property Y() As Integer
Get
Return m_Y
End Get
End Property
End Structure
[edit] XSLT
Data types in XSLT are expressed as XML nodes. Members of a node can be either attributes or child nodes. Access to data is via XPath expressions.
[edit] Attributes
Attributes are often used for simple values. This is how a point might be represented in SVG, for example.
<point x="20" y="30"/>
<!-- context is a point node. The '@' prefix selects named attributes of the current node. -->
<fo:block>Point = <xsl:value-of select="@x"/>, <xsl:value-of select="@y"/></fo:block>
[edit] Children
More complex, multivariate, and nested data structures can be represented using child nodes.
<circle>
<point>
<x>20</x>
<y>30</y>
</point>
<radius>10</radius>
</circle>
<!-- context is a circle node. Children are accessed using a path-like notation (hence the name "XPath"). -->
<fo:block>Circle center = <xsl:value-of select="point/x"/>, <xsl:value-of select="point/y"/></fo:block>
