Porównanie języków programowania (algebraiczny typ danych)
W tym artykule porównano składnię definiowania i tworzenia wystąpień algebraicznego typu danych (ADT), czasami określanego również jako unia tagowana , w różnych językach programowania .
Przykłady algebraicznych typów danych
Cejlon
Na Cejlonie ADT można zdefiniować za pomocą:
Klasa abstrakcyjna Drzewo ( ) pustych | Węzeł {} obiekt pusty extends Tree () {} final class Node ( shared Integer val , shared Tree left , share Tree right ) extends Tree () {}
I utworzone jako:
0 wartość myTree = Node ( 42 , Node ( , pusty , pusty ), pusty );
Czysty
W Clean ADT można zdefiniować za pomocą:
:: Drzewo = Puste | Węzeł Int Drzewo Drzewo
I utworzone jako:
0 myTree = Węzeł 42 ( węzeł pusty pusty ) pusty
Coq
W Coq ADT można zdefiniować za pomocą:
Drzewo indukcyjne : Typ := | pusty : drzewo | węzeł : nat -> drzewo -> drzewo -> drzewo .
I utworzone jako:
0 Definicja my_tree := węzeł 42 ( węzeł pusty pusty ) pusty .
C++
W C++ ADT można zdefiniować za pomocą:
struct Pusty finał {}; struct Node final { int value ; std :: unique_ptr < std :: wariant < pusty , węzeł >> lewy ; std :: unique_ptr < std :: wariant < Pusty , Węzeł >> w prawo ; }; używając Tree = std :: wariant < Pusty , Węzeł > ;
I utworzone jako:
0
Drzewo myTree { Node { 42 , std :: make_unique < Tree > ( Node { , std :: make_unique < Tree > (), std :: make_unique < Tree > () }), std :: make_unique < Tree > () } };
Wiąz
W Elm ADT można zdefiniować za pomocą:
wpisz Drzewo = Puste | Węzeł Int Drzewo Drzewo
I utworzone jako:
0 myTree = Węzeł 42 ( węzeł pusty pusty ) pusty
F#
W języku F# ADT można zdefiniować za pomocą:
wpisz Drzewo = | Pusty | Węzeł typu int * Drzewo * Drzewo
I utworzone jako:
0 niech myTree = Node ( 42 , Node ( , Pusty , Pusty ), Pusty )
F*
W F* ADT można zdefiniować za pomocą:
wpisz drzewo = | Puste : drzewo | Węzeł : wartość : nat -> lewo : drzewo -> prawo : drzewo -> drzewo
I utworzone jako:
0 niech my_tree = Node 42 ( Node Empty Empty ) Pusty
Wolny Pascal
We Free Pascalu ADT można zdefiniować za pomocą:
wpisz TTreeKind = ( tkEmpty , tkNode ) ; PTree = ^ TTree ; TTree = przypadek rekordu FKind : TTreeKind of tkEmpty : () ; tkNode : ( FValue : Integer ; FLeft , Fright : PTree ; ) ; koniec ;
I utworzone jako:
0
var Moje Drzewo : PTree ; rozpocznij nowe ( Moje drzewo ) ; Moje drzewo ^. FKind := tkNode ; Moje drzewo ^. Fwartość := 42 ; nowy ( Moje drzewo ^ .FLeft ) ; Moje drzewo ^. W lewo ^. FKind := tkNode ; Moje drzewo ^. W lewo ^. FWartość := ; nowy ( MojeDrzewo ^ .FLeft ^ .FLeft ) ; Moje drzewo ^. W lewo ^. W lewo ^. FKind := tkEmpty ; nowy ( MyTree ^. FLeft ^. Fright ) ; Moje drzewo ^. W lewo ^. PRZESTRZEŃ ^. FKind := tkEmpty ; nowy ( MyTree ^ .FRight ) ; Moje drzewo ^. PRZESTRZEŃ ^. FKind := tkEmpty ; koniec .
Haskella
W Haskell ADT można zdefiniować za pomocą:
Drzewo danych = Puste | Węzeł Int Drzewo Drzewo
I utworzone jako:
0 myTree = Węzeł 42 ( węzeł pusty pusty ) pusty
Haxe
W Haxe ADT można zdefiniować za pomocą:
enum Drzewo { Puste ; Węzeł ( wartość : Int , lewo : Drzewo , prawo : Drzewo ); }
I utworzone jako:
0 var myTree = Węzeł ( 42 , Węzeł ( , Pusty , Pusty ), Pusty );
Mieć nadzieję
W Hope ADT można zdefiniować za pomocą:
drzewo danych == pusty węzeł ++ ( numer # drzewo # drzewo );
I utworzone jako:
dec mytree : drzewo; --- mojedrzewo <= węzeł (42, węzeł (0, pusty, pusty), pusty);Idrys
W Idris ADT można zdefiniować za pomocą:
Drzewo danych = Puste | Węzeł Nat Drzewo Drzewo
I utworzone jako:
0 myTree : Tree myTree = Węzeł 42 ( węzeł pusty pusty ) pusty
Jawa
W Javie ADT można zdefiniować za pomocą:
uszczelniony interfejs Drzewo { rekord Pusty () implementuje Drzewo {} rekord Węzeł ( wartość int , Drzewo po lewej , Drzewo po prawej ) implementuje Drzewo {} }
I utworzone jako:
0
var mojeDrzewo = nowe Drzewo . Węzeł ( 42 , nowe drzewo . Węzeł ( , nowe drzewo . Puste (), nowe drzewo . Puste ()), nowe drzewo . Puste () );
Julia
W Julii ADT można zdefiniować za pomocą:
struct Empty end struct Node value :: Int left :: Union { Empty , Node } right :: Union { Empty , Node } end const Tree = Union { Empty , Node }
I utworzone jako:
0 mytree = Węzeł ( 42 , Węzeł ( , Pusty (), Pusty ()), Pusty ())
Kotlin
W Kotlinie ADT można zdefiniować za pomocą:
klasa zapieczętowana Drzewo { obiekt Pusty : Drzewo () klasa danych Węzeł ( wartość val : Int , val left : Tree , val right : Tree ) : Tree () }
I utworzone jako:
0
val myTree = Drzewo . Węzeł ( 42 , Drzewo . Węzeł ( , Drzewo . Pusty , Drzewo . Pusty ), Drzewo . Pusty , )
Otchłań
W Limbo ADT można zdefiniować za pomocą:
Drzewo : adt { pick { Pusty => Węzeł => wartość : int ; po lewej : ref Drzewo ; po prawej : ref Drzewo ; } };
I utworzone jako:
0
myTree := ref Drzewo . Węzeł ( 42 , ref Drzewo . Węzeł ( , ref Drzewo . Pusty (), ref Drzewo . Pusty ()), ref Drzewo . Pusty () );
Rtęć
W Merkurym ADT można zdefiniować za pomocą:
:- wpisz drzewo ---> puste ; węzeł(int, drzewo, drzewo).I utworzone jako:
:- funkcja moje_drzewo = drzewo. my_tree = node(42, node(0, pusty, pusty), pusty).Mirando
W Mirandzie ADT można zdefiniować za pomocą:
drzewo ::= Puste | Węzeł num drzewo drzewo
I utworzone jako:
0 my_tree = Węzeł 42 ( węzeł pusty pusty ) pusty
Nemerle
W Nemerle ADT można zdefiniować za pomocą:
wariant Drzewo { | Pusty | węzeł { wartość : int ; po lewej : Drzewo ; po prawej : Drzewo ; } }
I utworzone jako:
0
def myTree = Drzewo . Węzeł ( 42 , Drzewo . Węzeł ( , Drzewo . Pusty (), Drzewo . Pusty ()), Drzewo . Pusty (), );
Nim
W Nim ADT można zdefiniować za pomocą:
type TreeKind = enum tkEmpty tkNode Tree = ref TreeObj TreeObj = obiekt case kind : TreeKind of tkEmpty : odrzuć tkNode : value : int left , right : Tree _
I utworzone jako:
0
niech myTree = Tree ( rodzaj : tkNode , wartość : 42 , lewy : Drzewo ( rodzaj : tkNode , wartość :, lewy : Drzewo ( rodzaj : tkEmpty ), prawy : Drzewo ( rodzaj : tkEmpty ) ), prawy : Drzewo ( rodzaj : tkEmpty ) ))
OCaml
W OCaml ADT można zdefiniować za pomocą:
wpisz drzewo = | Pusty | Węzeł typu int * tree * tree
I utworzone jako:
0 niech moje_drzewo = Węzeł ( 42 , Węzeł ( , Pusty , Pusty ), Pusty )
Opa
W Opa ADT można zdefiniować za pomocą:
wpisz drzewo = { puste } lub { węzeł , wartość int , lewe drzewo , prawe drzewo }
I utworzone jako:
moje_drzewo = { węzeł , wartość : 42 , lewy : { węzeł, wartość: 0, lewy: { pusty}, prawy: { pusty} } , prawy : { pusty} }
OpenCog
W OpenCog ADT można zdefiniować za pomocą:
PureScript
W PureScript ADT można zdefiniować za pomocą:
Drzewo danych = Puste | Węzeł Int Drzewo Drzewo
I utworzone jako:
0 myTree = Węzeł 42 ( węzeł pusty pusty ) pusty
Rakieta
W Typed Racket, ADT można zdefiniować za pomocą:
( struct Empty ()) ( struct Node ([ value : Integer ] [ left : Tree ] [ right : Tree ])) ( zdefiniuj-type Tree ( U Empty Node ))
I utworzone jako:
0 ( zdefiniuj moje drzewo ( Węzeł 42 ( Węzeł ( Pusty ) ( Pusty )) ( Pusty )))
Powód
Powód
W Reason ADT można zdefiniować za pomocą:
wpisz Drzewo = | Pusty | Węzeł ( int , drzewo , drzewo );
I utworzone jako:
0 niech myTree = Węzeł ( 42 , Węzeł ( , Pusty , Pusty ), Pusty );
Reskrypt
W ReScript ADT można zdefiniować za pomocą:
wpisz rec Drzewo = | Pusty | Węzeł ( int , Drzewo , Drzewo )
I utworzone jako:
0 niech myTree = Node ( 42 , Node ( , Pusty , Pusty ), Pusty )
Rdza
W Rust ADT można zdefiniować za pomocą:
enum Drzewo { Pusty , Węzeł ( i32 , Pole < Drzewo > , Pole < Drzewo > ), }
I utworzone jako:
0
niech my_tree = Tree :: Node ( 42 , Box :: new ( Tree :: Node ( , Box :: new ( Tree :: Empty ), Box :: new ( Tree :: Empty )), Box :: new ( Tree :: Pusty ), );
Scala
Skala 2
W Scali 2 ADT można zdefiniować za pomocą: [ potrzebne źródło ]
Sealed abstract class Tree extends Product with Serializable object Tree { final case object Empty extends Tree final case class Node ( value : Int , left : Tree , right : Tree ) extends Tree }
I utworzone jako:
0
val myTree = Drzewo . Węzeł ( 42 , Drzewo . Węzeł ( , Drzewo . Pusty , Drzewo . Pusty ), Drzewo . Pusty )
Skala 3
W Scali 3 ADT można zdefiniować za pomocą:
enum Drzewo : sprawa Pusta sprawa Węzeł ( wartość : Int , po lewej : Drzewo , po prawej : Drzewo )
I utworzone jako:
0
val myTree = Drzewo . Węzeł ( 42 , Drzewo . Węzeł ( , Drzewo . Pusty , Drzewo . Pusty ), Drzewo . Pusty )
standardowy ML
W standardowym ML ADT można zdefiniować za pomocą:
drzewo typów danych = PUSTY | WĘZEŁ typu int * drzewo * drzewo
I utworzone jako:
0 val myTree = WĘZEŁ ( 42 , WĘZEŁ ( , PUSTY , PUSTY ), PUSTY )
Szybki
W Swift ADT można zdefiniować za pomocą:
enum Tree { case pusty pośredni przypadek node ( Int , Tree , Tree ) }
I utworzone jako:
0 niech myTree : Tree = . węzeł ( 42 , . węzeł ( , . pusty , . pusty ), . pusty )
Maszynopis
W TypeScript ADT można zdefiniować za pomocą:
wpisz Drzewo = | { rodzaj : "pusty" } | { rodzaj : "węzeł" ; wartość : liczba ; po lewej : Drzewo ; po prawej : Drzewo };
I utworzone jako:
0
const myTree : Tree = { rodzaj : "węzeł" , wartość : 42 , left : { rodzaj : "węzeł" , wartość :, left : { rodzaj : "pusty" }, right : { rodzaj : "pusty" } , }, po prawej : { rodzaj : "pusty" }, };
Prolog wizualny
W Visual Prolog ADT można zdefiniować za pomocą:
drzewo domen = puste ; węzeł ( liczba całkowita , drzewo , drzewo ).
I utworzone jako:
0 stałe my_tree : tree = node ( 42 , node ( , pusty , pusty ), pusty ).