Compound data type: Difference between revisions

{{Data structure}}

 

{{Template:See also lists}}

<br><br>

 

=={{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}}

3

T</pre>

 

=={{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|AmigaE}}==

x, y

ENDOBJECT

pt.y := !3.14

END pt

 

=={{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|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|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|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|Elixir}}==

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

...(1)> end

10

iex(8)> py

 

=={{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}}

</pre>

 

 

 

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'

 

create =: 3 : 0

'X Y' =: y

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}}==

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.

 

 

 

{{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}}

Point(x=3, y=4)

</pre>

 

=={{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|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|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|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

'FULL FORM

type point

float y

end type

 

=={{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}}==

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.

{{out}}

<pre>

point p is {107.5,3.375}

p[x]:107.5, p[y]:3.375

type check failure, p is {0,"string"}

</pre>

 

=={{header|PHP}}==

 

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

 

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

echo $x;

 

$point = array('x' => 1, 'y' => 2);

 

 

# or simply:

 

class Point {

function __construct($x, $y) { $this->x = $x; $this->y = $y; }

}

$point = new Point(1, 2);

 

=={{header|PicoLisp}}==

 

(dm T (X Y)

(setq P (new '(+Point) 3 4))

 

{{out}}

<pre>$52717735311266 (+Point)

y 4

x 3</pre>

 

=={{header|PL/I}}==

define structure

1 point,

 

 

 

=={{header|Pop11}}==

 

define :class Point;

slot x = 0;

slot y = 0;

 

=={{header|PowerShell}}==

{{works with|PowerShell|5}}

class Point {

[Int]$a

$p1.add()

$p2.mul()

<b>Output:</b>

<pre>

6

</pre>

 

=={{header|PureBasic}}==

 

A basic [http://www.purebasic.com/documentation/reference/structures.html structure] is implemented as;

x.i

y.i

 

=={{header|Python}}==

 

The simplest way it to use a tuple, or a list if it should be mutable:

p = (3, 4)

p = [3, 4]

 

 

If needed, you can use class:

 

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

self.x = x

 

p = Point()

 

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

 

point = MyObject()

point.x, point.y = 0, 1

# objects directly instantiated from "object()" cannot be "monkey patched"

 

=== Dictionary ===

Mutable. Can add keys (attributes)

 

 

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.

 

>>> help(namedtuple)

Help on function namedtuple in module collections:

Point(x=100, y=22)

 

 

=={{header|R}}==

R uses the list data type for compound data.

# $x

# [1] 3.4

# [1] 1

# $d$f

 

=={{header|Racket}}==

The most common method uses structures (similar to records):

 

#lang racket

(struct point (x y))

 

Alternatively, you can define a class:

 

#lang racket

(define point% ; classes are suffixed with % by convention

(super-new)

(init-field x y)))

 

=={{header|REXX}}==

y= 1.7

 

:: ---or---

y= 1/4e21

 

bpoint=point

 

 

=={{header|Ring}}==

see new point {x=10 y=20} class point x y

Output

x: 10.000000

y: 20.000000

 

=={{header|Ruby}}==

pt = Point.new(6,7)

puts pt.x #=> 6

pt.each_pair{|member, value| puts "#{member} : #{value}"}

#=> x : 2

 

=={{header|Rust}}==

 

====C-like struct====

struct Point<T> {

x: T,

let p = Point { x: 1.0, y: 2.5 }; // p is of type Point<f64>

println!("{}, {}", p.x, p.y);

 

====Tuple struct====

These are basically just named tuples.

fn main() {

let p = Point(1.0, 2.5);

println!("{},{}", p.0, p.1);

===Tuples===

let p = (0.0, 2.4);

println!("{},{}", p.0, p.1);

 

=={{header|Scala}}==

 

 

=={{header|Scheme}}==

Using [http://srfi.schemers.org/srfi-9/srfi-9.html SRFI 9]:

(make-point x y)

point?

(x point-x)

 

=={{header|Seed7}}==

var integer: x is 0;

var integer: y is 0;

 

=={{header|Shen}}==

X : number; Y : number;

====================

Pairs (distinct from cons cells) are also supported, in which case a point would be denoted by (number * number):

 

=={{header|Sidef}}==

var point = Point(1, 2);

 

=={{header|SIMPOL}}==

The <code>point</code> type is pre-defined in [SIMPOL], so we will call this mypoint.

 

embed

integer x

integer y

 

The <code>embed</code> keyword is used here as a toggle to indicate that all following properties are embedded in the type. The other toggle is <code>reference</code>, 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.

 

embed

integer x

me.x = x

me.y = y

 

=={{header|SNOBOL4}}==

 

p1 = point(10,20)

p2 = point(10,40)

output = "Point 1 (" x(p1) "," y(p1) ")"

output = "Point 2 (" x(p2) "," y(p2) ")"

 

=={{header|Standard ML}}==

See [[wp:Algebraic_data_type|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.

 

| Leaf of int

| Node of tree * tree

 

 

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

You can make a record literal by using a comma-delimited list of <code>key = value</code> pairs surrounded by curly braces, without needing to declare the type first:

 

 

The type of <code>p</code> is a comma-delimited list of <code>key:type</code> pairs of the types of the fields:

val it = 5 : int

The <code>#y</code> above extracts the field named "y" of its argument.

 

=={{header|Swift}}==

struct Point {

var x:Int

self.y = y

}

 

=={{header|Tcl}}==

This can be done using an associative array:

set point(y) 7

puts "Point is {$point(x),$point(y)}"

Or a dictionary:

{{works with|Tcl|8.5}}

dict set point y 7

Or an object:

{{works with|Tcl|8.6}}

variable x y

constructor {X Y} {set x $X;set y $Y}

Point create point 4 5

point y 7

 

=={{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|TXR}}==

In TXR Lisp, a structure type can be created:

 

 

If it is okay for the coordinates to be initialized to <tt>nil</tt>, it can be condensed to:

 

 

The <tt>nil</tt> denotes that a <tt>point</tt> has no supertype: it doesn't inherit from anything.

This structure type can then be instantiated using the <tt>new</tt> macro (not the only way):

 

(new point x 1) ;; -> #S(point x 1 y 0)

 

A structure can support optional by-order-of-arguments ("boa") construction by providing a "boa constructor". The <tt>defstruct</tt> syntactic sugar does this if a function-like syntax is used in place of the structure name:

 

 

The existing construction methods continue to work, but in addition, this is now possible:

 

 

Slot access syntax is supported. If variable <tt>p</tt> holds a point, then <tt>p.x</tt> designates the <tt>x</tt> slot, as a syntactic place which can be accessed and stored:

 

(inc p.x delta.x)

 

=={{header|UNIX Shell}}==

{{works with|ksh93}}

ksh93 allows you to define new compound types with the <tt>typeset -T</tt> command.

typeset x

typeset y

echo ${p.x} ${p.y}

Point q=(x=3 y=4)

{{out}}

<pre>( x=1 y=2 )

 

You can also declare compound variables "on the fly" without using a defined type:

point.x=5

point.y=6

echo $point

{{out}}

<pre>( x=5 y=6 )

=={{header|Ursala}}==

A record type with two untyped fields named <code>x</code> and <code>y</code> can be declared like this.

A constant instance of the record can be declared like this.

A function returning a value of this type can be defined like this,

where <code>g</code> and <code>h</code> are functions. Then <code>f(p)</code> would evaluate to

<code>point[x: g(p),y: h(p)]</code> for a given argument <code>p</code>. Accessing the fields of

a record can be done like this.

where <code>p</code> is any expression of the defined type. A real application wouldn't be written

this way because pairs of values <code>(x,y)</code> are a common idiom.

 

=={{header|Vim Script}}==

One cannot create new data types in Vim Script. A point could be represented by a dictionary:

 

return {"x": a:x, "y": a:y}

endfunction

 

echon "Point 1: x = " p1.x ", y = " p1.y "\n"

 

{{Out}}

=={{header|Visual Basic .NET}}==

 

 

Public X, Y As Integer

 

=== Immutable Structures ===

 

 

 

End Sub

 

 

 

 

=={{header|XSLT}}==

===Attributes===

Attributes are often used for simple values. This is how a point might be represented in SVG, for example.

 

<!-- context is a point node. The '@' prefix selects named attributes of the current node. -->

 

===Children===

More complex, multivariate, and nested data structures can be represented using child nodes.

<point>

<x>20</x>

</circle>

 

<fo:block>Circle center = <xsl:value-of select="point/x"/>, <xsl:value-of select="point/y"/></fo:block>

 

=={{header|zkl}}==

The OO solution:

fcn init(x,y){self.x=x.toFloat(); self.y=y.toFloat(); }

fcn toString{ "P(%f,%f)".fmt(x,y) }

//... __opEQ == etc

}

which can be pretty heavy weight. [read only] lists can work just as well:

 

{{omit from|bc}}

{{omit from|dc}}