Jämförelse av programmeringsspråk (algebraisk datatyp)
Den här artikeln jämför syntaxen för att definiera och instansiera en algebraisk datatyp (ADT), ibland även kallad en taggad union , i olika programmeringsspråk .
Exempel på algebraiska datatyper
Ceylon
I Ceylon kan en ADT definieras med:
abstrakt klass Träd () av tom | Nod { } objekt tomt förlänger Träd () {} final class Nod ( delat heltalsvärde , delat träd vänster , delat träd höger ) utökar träd () {}
Och instansierat som:
0 värde myTree = Nod ( 42 , Nod ( , tom , tom ), tom );
Rena
I Clean kan en ADT definieras med:
:: Träd = Tomt | Nod Int Tree Tree
Och instansierat som:
0 myTree = Nod 42 ( Node Empty Empty ) Tom
Coq
I Coq kan en ADT definieras med:
Induktivt träd : Typ := | tomt : träd | nod : nat -> träd -> träd -> träd .
Och instansierat som:
0 Definition my_tree := nod 42 ( nod tom tom ) tom .
C++
I C++ kan en ADT definieras med:
struct Empty final {}; struct Node final { int värde ; std :: unik_ptr < std :: variant < Tom , Nod >> vänster ; std :: unik_ptr < std :: variant < Tom , Nod >> höger ; }; använder Tree = std :: variant < Empty , Node > ;
Och instansierat som:
0
Tree myTree { Node { 42 , std :: make_unique < Tree > ( Node { , std :: make_unique < Tree > (), std :: make_unique < Tree > () }), std :: make_unique < Tree > () } };
Alm
I Elm kan en ADT definieras med:
typ Träd = Tom | Nod Int Tree Tree
Och instansierat som:
0 myTree = Nod 42 ( Node Empty Empty ) Tom
F#
I F# kan en ADT definieras med:
typ Träd = | Tom | Nod av int * Träd * Träd
Och instansierat som:
0 låt myTree = Node ( 42 , Nod ( , Empty , Empty ), Empty )
F*
I F* kan en ADT definieras med:
typ träd = | Tom : träd | Nod : värde : nat -> vänster : träd -> höger : träd -> träd
Och instansierat som:
0 let my_tree = Nod 42 ( Node Empty Empty ) Empty
Gratis Pascal
I Free Pascal kan en ADT definieras med:
typ TTreeKind = ( tkEmpty , tkNode ) ; PTree = ^ TTree ; TTree = rekordfall FKind : TTreeKind of tkEmpty : ( ) ; tkNode : ( FValue : Heltal ; FLeft , FRight : PTree ; ) ; slut ;
Och instansierat som:
0
var MyTree : PTree ; börja nytt ( MyTree ) ; MyTree ^. FKind := tkNode ; MyTree ^. FVärde := 42 ; ny ( MyTree ^. FLeft ) ; MyTree ^. FLvänster ^. FKind := tkNode ; MyTree ^. FLvänster ^. FVärde := ; new ( MyTree ^. FLeft ^. FLeft ) ; MyTree ^. FLvänster ^. FLvänster ^. FKind := tkEmpty ; ny ( MyTree ^. FLeft ^. FRight ) ; MyTree ^. FLvänster ^. JÄTTE ^. FKind := tkEmpty ; ny ( MyTree ^. FRight ) ; MyTree ^. JÄTTE ^. FKind := tkEmpty ; slut .
Haskell
I Haskell kan en ADT definieras med:
dataträd = Tomt | _ Nod Int Tree Tree
Och instansierat som:
0 myTree = Nod 42 ( Node Empty Empty ) Tom
Haxe
I Haxe kan en ADT definieras med:
enum Träd { Tom ; Nod ( värde : Int , vänster : Träd , höger : Träd ); }
Och instansierat som:
0 var myTree = Node ( 42 , Nod ( , Empty , Empty ), Empty );
Hoppas
I Hope kan en ADT definieras med:
dataträd == tom ++ nod ( num # träd # träd ) ;
Och instansierat som:
dec mytree : träd; --- mytree <= nod (42, nod (0, tom, tom), tom);Idris
I Idris kan en ADT definieras med:
dataträd = Tomt | _ Node Nat Tree Tree
Och instansierat som:
0 myTree : Träd myTree = Nod 42 ( Node Empty Empty ) Empty
Java
I Java kan en ADT definieras med:
förseglat gränssnitt Träd { post Tom () implementerar Tree {} post Nod ( int värde , Träd vänster , Träd höger ) implementerar Träd {} }
Och instansierat som:
0
var myTree = nytt träd . Nod ( 42 , nytt träd . Nod ( , nytt träd . Tomt (), nytt träd . Tomt ()), nytt träd . Tomt () );
Julia
I Julia kan en ADT definieras med:
struct Empty end struct Node värde :: Int left :: Union { Empty , Node } right :: Union { Empty , Node } end const Tree = Union { Empty , Node }
Och instansierat som:
0 mytree = Nod ( 42 , Nod ( , Tom (), Tom ()), Tom ())
Kotlin
I Kotlin kan en ADT definieras med:
förseglad klass Träd { objekt Tomt : Träd ( ) dataklass Nod ( val värde : Int , val vänster : Träd , val höger : Träd ) : Träd ( ) }
Och instansierat som:
0
val myTree = Träd . Nod ( 42 , Träd . Nod ( , Träd . Tom , Träd . Tom ), Träd . Tom , )
Limbo
I Limbo kan en ADT definieras med:
Träd : adt { pick { Empty => Nod => värde : int ; vänster : ref Träd ; höger : ref Träd ; } };
Och instansierat som:
0
myTree := ref Träd . Nod ( 42 , ref Träd . Nod ( , ref Träd . Tom (), ref Träd . Tom ()), ref Träd . Tom () );
Merkurius
I Merkurius kan en ADT definieras med:
:- skriv träd ---> tomt; nod(int, träd, träd).Och instansierat som:
:- func mitt_träd = träd. mitt_träd = nod(42, nod(0, tom, tom), tom).Miranda
I Miranda kan en ADT definieras med:
träd ::= Tom | Nod num träd träd
Och instansierat som:
0 my_tree = Nod 42 ( Node Empty Empty ) Tom
Nemerle
I Nemerle kan en ADT definieras med:
variant Träd { | Tom | Nod { värde : int ; vänster : Träd ; höger : Träd ; } }
Och instansierat som:
0
def myTree = Träd . Nod ( 42 , Träd . Nod ( , Träd . Tom (), Träd . Tom ()), Träd . Tom (), );
Nim
I Nim kan en ADT definieras med:
typ TreeKind = enum tkEmpty tkNode Träd = ref TreeObj TreeObj = objektcasetyp : TreeKind av tkEmpty : kassera tkNode : värde : int vänster , höger : Träd _ _ _
Och instansierat som:
0
låt myTree = Träd ( typ : tkNode , värde : 42 , vänster : Träd ( typ : tkNode , värde : , vänster : Träd ( typ : tkEmpty ), höger : Träd ( typ : tkEmpty )), höger : Träd ( snäll : tkEmpty ))
OCaml
I OCaml kan en ADT definieras med:
typ träd = | Tom | Nod för int * träd * träd
Och instansierat som:
0 låt mitt_träd = Nod ( 42 , Nod ( , Empty , Empty ), Empty )
Opa
I Opa kan en ADT definieras med:
skriv träd = { tomt } eller { nod , int värde , träd vänster , träd höger }
Och instansierat som:
mitt_träd = { nod , värde : 42 , vänster : { nod, värde: 0, vänster: { tomt }, höger: { tomt } } , höger : { tomt } }
OpenCog
I OpenCog kan en ADT definieras med:
PureScript
I PureScript kan en ADT definieras med:
dataträd = Tomt | _ Nod Int Tree Tree
Och instansierat som:
0 myTree = Nod 42 ( Node Empty Empty ) Tom
Racket
I Typed Racket kan en ADT definieras med:
( struct Empty ()) ( struct Node ([ värde : Heltal ] [ vänster : Träd ] [ höger : Träd ])) ( definiera träd ( U Tom Node ))
Och instansierat som:
0 ( definiera mitt träd ( Nod 42 ( Nod ( Tom ) ( Tom )) ( Tom )))
Anledning
Anledning
I Reason kan en ADT definieras med:
typ Träd = | Tom | Nod ( int , Träd , Träd );
Och instansierat som:
0 let myTree = Node ( 42 , Node ( , Empty , Empty ), Empty );
Reskript
I ReScript kan en ADT definieras med:
skriv rec Tree = | Tom | Nod ( int , träd , träd )
Och instansierat som:
0 låt myTree = Node ( 42 , Nod ( , Empty , Empty ), Empty )
Rost
I Rust kan en ADT definieras med:
enum Tree { Empty , Node ( i32 , Box < Tree > , Box < Tree > ), }
Och instansierat som:
0
låt mitt_träd = Träd :: Nod ( 42 , Box :: ny ( Träd :: Nod ( , Box :: ny ( Träd :: Tom ), Box :: ny ( Träd :: Tom )), Box :: ny ( Träd :: Tom ), );
Scala
Scala 2
I Scala 2 kan en ADT definieras med: [ citat behövs ]
förseglad abstrakt klass Träd sträcker sig Produkt med serialiserbart objekt Träd { final case object Empty extends Träd slutlig case class Node ( värde : Int , vänster : Träd , höger : Träd ) sträcker sig Träd }
Och instansierat som:
0
val myTree = Träd . Nod ( 42 , Träd . Nod ( , Träd . Tom , Träd . Tom ), Träd . Tom )
Scala 3
I Scala 3 kan en ADT definieras med:
enum Träd : case Tom case Nod ( värde : Int , vänster : Träd , höger : Träd )
Och instansierat som:
0
val myTree = Träd . Nod ( 42 , Träd . Nod ( , Träd . Tom , Träd . Tom ), Träd . Tom )
Standard ML
I Standard ML kan en ADT definieras med:
datatypträd = TOM | _ NOD för int * träd * träd
Och instansierat som:
0 val myTree = NOD ( 42 , NOD ( , EMPTY , EMPTY ), EMPTY )
Snabb
I Swift kan en ADT definieras med:
enum Tree { case tom indirekt case nod ( Int , Tree , Tree ) }
Och instansierat som:
0 låt myTree : Träd = . nod ( 42 , . nod ( , . tom , . tom ), . tom )
TypeScript
I TypeScript kan en ADT definieras med:
typ Träd = | { typ : "tom" } | { kind : "nod" ; värde : antal ; vänster : Träd ; höger : Träd };
Och instansierat som:
0
const myTree : Träd = { typ : "nod" , värde : 42 , vänster : { typ : "nod" , värde : , vänster : { typ : "tom" }, höger : { typ : "tom" }, }, höger : { snäll : "tom" }, };
Visuell prolog
I Visual Prolog kan en ADT definieras med:
domänträd = tomt ; _ nod ( heltal , träd , träd ).
Och instansierat som:
0 konstanter mitt_träd : träd = nod ( 42 , nod ( , tom , tom ), tom ).