Be concise.
Be useful.
All contributions dictatorially edited by webmasters to match personal tastes.
Please do not paste any copyright violating material.
Please try to avoid dependencies to third-party libraries and frameworks.
- Ada
- C
- Caml
- Clojure
- Clojure
- C++
- C#
- C#
- C#
- D
- D
- Dart
- Dart
- Elixir
- Elixir
- Erlang
- Erlang
- Erlang
- Fortran
- Fortran
- Go
- Groovy
- Haskell
- Haskell
- JS
- JS
- Java
- Java
- Java
- Java
- Kotlin
- Lisp
- Lua
- Obj-C
- PHP
- Pascal
- Perl
- Perl
- Python
- Python
- Python
- Python
- Python
- Ruby
- Rust
- Rust
- Scala
- Scheme
- Smalltalk
- VB
type Point is
record
X : Float;
Y : Float;
end record;typedef struct {
double x;
double y;
} Point;type point = {
x: float;
y: float;
}[x y](vector-of :double x y)Creates a vector containing the values x and y, unboxed internally
struct Point{
double x;
double y;
};record Point(double x, double y);If heap allocation isn't a problem, and a named type is needed, then the record syntax can be used to define a class with minimal boilerplate
struct Point
{
public double x;
public double y;
};A struct avoids heap allocation, which can be important in many applications that are doing extensive calculations on x/y coordinates.
(double x, double y)The simplest form in C# is a tuple.
struct Point{
double x;
double y;
}
Structs are value types.
class Point
{
float x;
float y;
}Classes are reference types.
class Point {
double x, y;
}class Point {
double x, y;
Point(this.x, this.y);
}With constructor, which you will almost always have.
p = [ x: 1.122, y: 7.45 ]
{x, y}
defmodule Point do
defstruct x: 0.0, y: 0.0
endthe tuple does the trick but a type is best implemented by a struct which is a module
N.B. the types of x and y can change
N.B. the types of x and y can change
PointAsATuple = {X, Y}.-module(points).
-export([new/2, x/1, y/1]).
-opaque point() :: #{x => float(), y => float()}.
-export_type([point/0]).
-spec new(float(), float()) -> point().
new(X, Y) -> #{x => X, y => Y}.
-spec x(point()) -> float().
x(#{x := X}) -> X.
-spec y(point()) -> float().
y(#{y := Y}) -> Y.to use this module from somewhere else you do stuff like...
Point = points:new(X, Y),
X = points:x(Point),
Y = points:y(Point).
Point = points:new(X, Y),
X = points:x(Point),
Y = points:y(Point).
PointAsAMap = #{x => X, y => Y}.type point
real :: x
real :: y
end type pointmodule x
type point
real :: x, y
end type point
end module x
type Point struct {
x, y float64
}class Point{
double x
double y
}data Point = Point
{ x :: Double
, y :: Double
} deriving (Eq, Ord, Show, Read)This version contains a deriving statement at the end which automatically writes the equality, ordering, and to and from string functions for this type.
data Point = Point
{ x :: Double
, y :: Double
}var p = { x: 1.122, y: 7.45 };Types are implicit. Just initialize a variable.
const point = { x: 1, y: 2 };class Point{
double x;
double y;
}record Point<T extends Number>(T x, T y) {}class Point { double x, y; }public record Point(double x, double y) { }Java 17
(defstruct point
(x 0.0d0 :type double-float)
(y 0.0d0 :type double-float))point = { x = 123, y = 456 }typedef struct {
double x,y;
} NSPoint;Precisely same as plain C; the NSPoint struct actually is part of the Foundation API used in most ObjC environments
class Point
{
/** @var float */
public $x = 0.0;
/** @var float */
public $y = 0.0;
}Type
TPoint = Record
x : Double;
y : Double;
End;Pascal uses unit math to define type float.
You can use one of Pascal's floating point types directly (being type single or type double), depending on which precision is required.
You can use one of Pascal's floating point types directly (being type single or type double), depending on which precision is required.
my $point = { x => 1, y => 2 };In a hash, members are named.
No need to declare a type beforehand.
No need to declare a type beforehand.
my $point = [ 1.5, 6.3 ];This array uses indices 0, 1 to hold x, y.
No need to declare a type beforehand.
For lists, perl prefers using arrays (over using hashes).
No need to declare a type beforehand.
For lists, perl prefers using arrays (over using hashes).
point = {'x': 1.2, 'y': 3.4}class Point:
def __init__(self, x, y):
self.x, self.y = x, ypoint = dict(x=1.2, y=3.4)Point = Struct.new(:x, :y)Instantiate like this : Point.new(1.0,1.0)
struct Point(f64, f64);struct Point {
x: f64,
y: f64,
}case class Point(x: Float, y: Float)(define (make-point x y)
(cons x y))
(define (point-x p)
(car p))
(define (point-y p)
(cdr p))Object subclass: #Point
instanceVariableNames: 'x y'
classVariableNames: ''
poolDictionaries: ''
category: 'Graphics-Primitives'This is an existing class. Instances are created as 3@4
Structure Point
Public x As Double
Public y As Double
End Structure