Compound data type: Difference between revisions

Content added Content deleted

Inline

Revision as of 12:45, 14 August 2009

Create a compound data type Point(x,y).

A compound data type is one that holds multiple independent values. See also Enumeration.

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. <lang ada>type Point is tagged record

  X : Integer := 0;
  Y : Integer := 0;

end record;</lang>

Record Type

Ada record types are not extensible through inheritance. Without the reserved word tagged the record does not belong to an inheritance hierarchy. <lang ada>type Point is record

  X : Integer := 0;
  Y : Integer := 0;

end record;</lang>

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. <lang ada>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;</lang> 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.

ALGOL 68

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.

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
);

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.

AmigaE

<lang 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</lang>

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: <lang awk> p["x"]=10

p["y"]=42</lang>

BASIC

Works with: QuickBasic version 4.5

Works with: PB version 7.1

TYPE Point
  x AS INTEGER
  y AS INTEGER
END TYPE

C

Works with: GCC

Works with: MSVC

Works with: BCC

Works with: Watcom

Libraries: Standard

<lang c>typedef struct Point {

 int x;
 int y;

} Point;</lang>

C++

<lang cpp>struct Point {

 int x;
 int y;

};</lang>

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

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

};</lang>

Point can also be parametrized on the coordinate type: <lang cpp>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 };</lang> Of course, a constructor can be added in this case as well.

C#

<lang csharp>struct Point {

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

}</lang>

Clean

Record type

:: Point = { x :: Int, y :: Int }

Parameterized Algebraic type

:: Point a = Point a a  // usage: (Point Int)

Synonym type

:: Point :== (Int, Int)

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.

Common Lisp

<lang lisp>(defstruct point x y)</lang>

E

def makePoint(x, y) {
    def point {
        to getX() { return x }
        to getY() { return y }
    }
    return point
}

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%

Fortran

In ISO Fortran 90 or later, use a TYPE declaration, "constructor" syntax, and field delimiter syntax: <lang fortran> 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</lang>

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

Haskell

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))

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

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

Tuple Type

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 p is (Int, Int), using the same comma-delimited list syntax as the literal.

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.

IDL

point = {x: 6 , y: 0 } 
point.y = 7
print, point
;=> {       6       7}

Java

We use a class: <lang java>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 );
 }

}</lang>

JavaScript

<lang javascript>var point = new Object(); point.x = 1; point.y = 2;</lang>

JSON

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

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]

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

Modula-3

<lang modula3>TYPE Point = RECORD

 x, y: INTEGER;

END;</lang>

Usage:

VAR point: Point;
...
point := Point{3, 4};

or

point := Point{x := 3, y := 4};

OCaml

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.

<lang ocaml>type tree = Empty

         | Leaf of int
         | Node of tree * tree

let t1 = Node (Leaf 1, Node (Leaf 2, Leaf 3))</lang>

Record Type

<lang ocaml>type point = { x : int; y : int }</lang>

How to construct a point:

You can use the dot (".") to access fields. <lang ocaml>p.x (* evaluates to 4 *)</lang>

Fields can be optionally declared to be mutable: <lang ocaml>type mutable_point = { mutable x2 : int; mutable y2 : int }</lang>

Then they can be assigned using the assignment operator "<-" <lang ocaml>let p2 = { x2 = 4; y2 = 5 } in

 p2.x2 <- 6;
 p2 (* evaluates to { x2 = 6; y2 = 5 } *)</lang>

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 p is a product (indicated by *) of the types of the components:

# let p = (2,3);;
val p : int * int = (2, 3)

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.

Pascal

<lang pascal>type point = record

             x, y: integer;
            end;</lang>

Perl

Works with: Perl version 5.x

This is a hash (associative array), but accomplishes the task. <lang perl>my %point = (

  x => 3,
  y => 8

);</lang>

PHP

<lang 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;</lang>

<lang php># Using array $point = array('x' => 1, 'y' => 2);

list($x, $y) = $point; echo $x, ' ', $y, "\n";

or simply:

echo $point['x'], ' ', $point['y'], "\n";</lang>

<lang php># 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.</lang>

Pop11

uses objectclass;
define :class Point;
   slot x = 0;
   slot y = 0;
enddefine;

Python

The simplest way it to use a tuple, or a list if it should be mutable: <lang python>X, Y = 0, 1 p = (3, 4) p = [3, 4]

print p[X]</lang>

If needed, you can use class:

<lang python>class Point:

   def __init__(self, x=0, y=0):
       self.x = x
       self.y = y

p = Point() print p.x</lang>

One could also simply instantiate a generic object and "monkeypatch" it:

<lang python> 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

</lang>

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.

<lang python>>>> 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)

>>> </lang>

R

R uses the list data type for compound data. <lang R>

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

</lang>

Ruby

<lang ruby>Point = Struct.new(:x,:y) p = Point.new(6,7) p.y=3 puts p => #<struct Point x=6, y=3></lang>

Scheme

Using SRFI 9: <lang scheme>(define-record-type point

   (make-point x y)
   point?
   (x point-x)
   (y point-y))</lang>

Standard ML

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.

<lang sml>datatype tree = Empty

             | Leaf of int
             | Node of tree * tree

val t1 = Node (Leaf 1, Node (Leaf 2, Leaf 3))</lang>

Tuple Type

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 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.

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:

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.

Tcl

This appears to be a sub-functionality of a proper associative array: <lang tcl>array set point {x 4 y 5} set point(y) 7 puts "Point is {$point(x),$point(y)}"

=> Point is {4,7}</lang>

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.

Visual Basic .NET

Simple Structures

This shows a structure in its simpest form.

Structure Simple_Point
   Public X, Y As Integer
End Structure

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

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.

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>

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>

@@ Line 646: / Line 646: @@
 puts "Point is {$point(x),$point(y)}"
 # => Point is {4,7}</lang>
+=={{header|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.
 =={{header|Visual Basic .NET}}==