프로그래밍 언어 비교(대칭 데이터 유형)

Comparison of programming languages (algebraic data type)
비교 요인
프로그래밍 언어의
개인별 비교
언어들

이 문서에서는 다양한 프로그래밍 언어로 태그 부착 결합이라고도 하는 대수 데이터 유형(ADT)을 정의하고 인스턴스화하기 위한 구문을 비교합니다.

대수 데이터 유형의 예

실론

상세 정보:실론(프로그래밍 언어)

실론에서 ADT는 다음과 [1]같이 정의될 수 있다.

추상적인 학급 트리()     의 빈   노드 {}  물건 빈     확장 트리() {}  최종 학급 노드(공유했습니다. 정수 값, 공유했습니다. 트리 왼쪽, 공유했습니다. 트리 맞다)     확장 트리() {}

인스턴스화:

가치 마이트리 = 노드(42, 노드(0, 빈, 빈), 빈);

깨끗한

상세 정보:클린(프로그래밍 언어)

Clean에서 ADT는 다음과 [2]같이 정의할 수 있습니다.

:: 트리   = 빈     노드 내부 트리 트리

인스턴스화:

마이트리 = 노드 42 (노드 0 빈 빈) 빈

동작

상세 정보:동작

Coq에서 ADT는 다음과 [3]같이 정의할 수 있습니다.

귀납적 트리 : 유형 :=   빈 : 트리   노드 : 내트 -> 트리 -> 트리 -> 트리.

인스턴스화:

정의. 마이 트리 := 노드 42 (노드 0 빈 빈) 빈.

C++

상세 정보:C++

C++ 에서는,[4] ADT 는 다음과 같이 정의할 수 있습니다.

구조 빈 최종 {};  구조 노드 최종 {     인트 가치;     표준::unique_ptr< >표준::변종< >빈, 노드>> 왼쪽;     표준::unique_ptr< >표준::변종< >빈, 노드>> 맞다; };  사용. 트리 = 표준::변종< >빈, 노드>;

인스턴스화:

트리 마이트리 { 노드{     42,     표준::make_filengths< >트리>(노드{         0,         표준::make_filengths< >트리>(),         표준::make_filengths< >트리>()     }),     표준::make_filengths< >트리>() } };

느릅나무

상세 정보:Elm(프로그래밍 언어)

Elm에서는 ADT를 다음과 [5]같이 정의할 수 있습니다.

유형 트리   = 빈     노드 내부 트리 트리

인스턴스화:

마이트리 = 노드 42 (노드 0 빈 빈) 빈

F#

상세 정보:F Sharp(프로그래밍 언어)

F#에서 ADT는 다음과 [6]같이 정의할 수 있습니다.

유형 트리 =       빈       노드 의 인트 * 트리 * 트리

인스턴스화:

허락하다 마이트리 = 노드(42, 노드(0, 빈, 빈), 빈)

F*

상세정보 : F* (프로그래밍 언어)

F*에서 ADT는 다음과 [7]같이 정의할 수 있습니다.

유형 트리 =     빈 : 트리     노드 : 가치:내트 -> 왼쪽:트리 -> 맞다:트리 -> 트리

인스턴스화:

허락하다 마이 트리 = 노드 42 (노드 0 빈 빈) 빈

프리 파스칼

상세 정보:프리 파스칼

Free Pascal에서 ADT는 다음과 [8]같이 정의할 수 있습니다.

유형   TTreeKind = (tk비움, tk노드);    PTree = ^트리;    트리 = 기록.     사례. FKind: TTreeKind 의       tk비움: ();       tk노드: (         동작: 정수;         플라이트, 프라이트: PTree;       );   끝.;

인스턴스화:

변화하다   마이트리: PTree;  시작한다.   신규(마이트리);   마이트리^.FKind := tk노드;   마이트리^.동작 := 42;   신규(마이트리^.플라이트);   마이트리^.플라이트^.FKind := tk노드;   마이트리^.플라이트^.동작 := 0;   신규(마이트리^.플라이트^.플라이트);   마이트리^.플라이트^.플라이트^.FKind := tk비움;   신규(마이트리^.플라이트^.프라이트);   마이트리^.플라이트^.프라이트^.FKind := tk비움;   신규(마이트리^.프라이트);   마이트리^.프라이트^.FKind := tk비움; 끝..

하스켈

상세 정보:Haskell(프로그래밍 언어)

Haskell에서는 ADT를 다음과 [9]같이 정의할 수 있습니다.

데이터. 트리     = 빈       노드 내부 트리 트리

인스턴스화:

마이트리 = 노드 42 (노드 0 빈 빈) 빈

Haxe

상세 정보:Haxe

Haxe에서는 ADT를 다음과 [10]같이 정의할 수 있습니다.

열거하다 트리 {  빈;  노드(가치:내부, 왼쪽:트리, 맞다:트리); }

인스턴스화:

var myTree = Node(42, Node(0, Empty, Empty, Empty), Empty;

바라다

상세 정보:Hope(프로그래밍 언어)

희망에서 ADT는 다음과 [11]같이 정의할 수 있습니다.

데이터. 트리 == 빈           ++ 노드 (숫자 # 트리 # 트리);

인스턴스화:

dec mytree : 트리; --- mytree <= 노드(42, 노드(0, 빈, 빈), 빈);

이드리스

상세 정보:Idris(프로그래밍 언어)

Idris에서 ADT는 다음과 [12]같이 정의할 수 있습니다.

데이터. 트리     = 빈       노드 내트 트리 트리

인스턴스화:

myTree : 트리 myTree = 노드 42(노드 0이 비어 있음) 비어 있음

자바

상세정보 : Java (프로그래밍 언어)

Java에서는 ADT를 다음과 같이 [13]정의할 수 있습니다.

밀봉된 인터페이스 트리 {     기록. 빈() 용구 트리 {}     기록. 노드(인트 가치, 트리 왼쪽, 트리 맞다) 용구 트리 {} }

인스턴스화:

변화하다 마이트리 = 신규 트리.노드(     42,     신규 트리.노드(0, 신규 트리.빈(), 신규 트리.빈()),     신규 트리.빈() );

줄리아.

상세정보 : Julia (프로그래밍 언어)

Julia에서 ADT는 다음과 [14]같이 정의할 수 있습니다.

구조 빈 끝.  구조 노드     가치::내부     왼쪽::유니언{빈, 노드}     맞다::유니언{빈, 노드} 끝.  컨스턴트 트리 = 유니언{빈, 노드}

인스턴스화:

마이트리 = 노드(42, 노드(0, 빈(), 빈()), 빈())

코틀린

상세정보 : Kotlin (프로그래밍 언어)

Kotlin에서는 ADT를 다음과 [15]같이 정의할 수 있습니다.

밀봉된 학급 트리 {     물건 빈 : 트리()     데이터. 학급 노드(값 가치: 내부, 값 왼쪽: 트리, 값 맞다: 트리) : 트리() }

인스턴스화:

값 마이트리 = 트리.노드(     42,     트리.노드(0, 트리.빈, 트리.빈),     트리.빈, )

림보

상세정보 : 림보(프로그래밍 언어)

림보에서는 ADT를 다음과 [16]같이 정의할 수 있습니다.

트리: 애드 {  고르다 {  빈 =>  노드 =>   가치: 인트;   왼쪽: 레퍼런스 트리;   맞다: 레퍼런스 트리;  } };

인스턴스화:

마이트리 := 레퍼런스 

                                    신라 골스 초보미용사
                                2021/04/01                            .노드(  42,  레퍼런스 트리.노드(0, 레퍼런스 트리.빈(), 레퍼런스 트리.빈()),  레퍼런스 트리.빈() );

수성.

상세 정보:Mercury(프로그래밍 언어)

수성에서는 ADT를 다음과 [17]같이 정의할 수 있습니다.

:- type tree ---> empty ;노드(int, tree, tree).

인스턴스화:

:- func my_tree = 트리.my_tree = node(42, node(0, empty, empty), empty.

미란다

상세 정보:미란다(프로그래밍 언어)

미란다에서 ADT는 다음과 [18]같이 정의할 수 있다.

트리 ::=     빈       노드 숫자 트리 트리

인스턴스화:

마이 트리 = 노드 42 (노드 0 빈 빈) 빈

네메루

상세 정보:네메루

Nemerle에서는 ADT를 다음과 [19]같이 정의할 수 있습니다.

변종 트리 {       빈       노드 {         가치: 인트;         왼쪽: 트리;         맞다: 트리;     } }

인스턴스화:

방어하다 마이트리 = 트리.노드(     42,     트리.노드(0, 트리.빈(), 트리.빈()),     트리.빈(), );

님

상세 정보:Nim(프로그래밍 언어)

Nim에서는 ADT를 다음과 [20]같이 정의할 수 있습니다.

유형   Tree Kind = 열거하다     tk비움     tk노드    트리 = 레퍼런스 트리 오브지    트리 오브지 = 물건     사례. 친절한: Tree Kind     의 tk비움:       폐기하다     의 tk노드:       가치: 인트       왼쪽, 맞다: 트리

인스턴스화:

허락하다 마이트리 = 트리(친절한: tk노드, 가치: 42,                   왼쪽: 트리(친절한: tk노드, 가치: 0,                              왼쪽: 트리(친절한: tk비움),                              맞다: 트리(친절한: tk비움)),                   맞다: 트리(친절한: tk비움))

OCaml

상세정보 : OCaml

OCaml에서는 ADT를 다음과 [21]같이 정의할 수 있습니다.

유형 트리 =     빈     노드 의 인트 * 트리 * 트리

인스턴스화:

허락하다 마이 트리 = 노드 (42, 노드 (0, 빈, 빈), 빈)

오파

상세 정보:Opa(프로그래밍 언어)

Opa에서 ADT는 다음과 [22]같이 정의할 수 있습니다.

tree = { empty } 또는 { node, int 값, 트리 왼쪽, 트리 오른쪽}을(를) 입력합니다.

인스턴스화:

my_tree = { node, 값: 42, 왼쪽: { node, 값: 0, 왼쪽: { empty }, 오른쪽: { empty } }

오픈코그

상세 정보:오픈코그

OpenCog에서는 ADT를 다음과 [23]같이 정의할 수 있습니다.

PureScript

상세 정보:PureScript

PureScript에서는 ADT를 다음과 [24]같이 정의할 수 있습니다.

데이터. 트리   = 빈     노드 내부 트리 트리

인스턴스화:

마이트리 = 노드 42 (노드 0 빈 빈) 빈

라켓

상세 정보:라켓(프로그래밍 언어)

타입드 라켓에서 ADT는 다음과 [25]같이 정의할 수 있습니다.

(구조 빈 ()) (구조 노드 ([가치 : 정수] [왼쪽 : 트리] [맞다 : 트리])) (정의형 트리 (U 빈 노드))

인스턴스화:

(정의하다 마이트리 (노드 42 (노드 0 (빈) (빈)) (빈)))

이유

상세 정보:이유(프로그래밍 언어)

이유

「이유」에서는, ADT [26]를 다음과 같이 정의할 수 있습니다.

유형 트리 =     빈     노드(인트, 트리, 트리);

인스턴스화:

허락하다 마이트리 = 노드(42, 노드(0, 빈, 빈), 빈);

재스크립트

ReScript에서 ADT는 다음과 [27]같이 정의할 수 있습니다.

유형 인식하다 트리 =     빈     노드(인트, 트리, 트리)

인스턴스화:

허락하다 마이트리 = 노드(42, 노드(0, 빈, 빈), 빈)

녹

상세 정보:러스트(프로그래밍 언어)

Rust에서 ADT는 다음과 [28]같이 정의할 수 있습니다.

열거하다 트리 {     빈,     노드(i32, 박스< >트리>, 박스< >트리>), }

인스턴스화:

let my_tree = 트리:: Node ( 42 , Box : : : new ( 트리::Node(0, 박스::new(트리:: Empty, 박스::new(트리:: Empty), 박스::new(트리:: 공백), );

스칼라

상세정보 : Scala (프로그래밍 언어)

스칼라 2

Scala 2에서는 ADT를 다음과 [citation needed]같이 정의할 수 있습니다.

밀봉된 추상적인 학급 트리 확장 제품. 와 함께 시리얼화 가능  물건 트리 {   최종 사례. 물건 빈 확장 트리   최종 사례. 학급 노드(가치: 내부, 왼쪽: 트리, 맞다: 트리)       확장 트리 }

인스턴스화:

값 마이트리 = 트리.노드(   42,   트리.노드(0, 트리.빈, 트리.빈),   트리.빈 )

스칼라 3

Scala 3에서는 ADT를 다음과 같이 [29]정의할 수 있습니다.

열거하다 트리:   사례. 빈   사례. 노드(가치: 내부, 왼쪽: 트리, 맞다: 트리)

인스턴스화:

값 마이트리 = 트리.노드(   42,   트리.노드(0, 트리.빈, 트리.빈),   트리.빈 )

표준 ML

상세 정보:표준 ML

표준 ML에서 ADT는 다음과 [30]같이 정의할 수 있습니다.

데이터형 트리 =     빈     노드 의 인트 * 트리 * 트리

인스턴스화:

값 마이트리 = 노드 (42, 노드 (0, 빈, 빈), 빈)

재빠르다

상세 정보:Swift(프로그래밍 언어)

Swift에서는 ADT를 다음과 [31]같이 정의할 수 있습니다.

열거하다 트리 {     사례. 빈     간접적인 사례. 노드(내부, 트리, 트리) }

인스턴스화:

허락하다 마이트리: 트리 = .노드(42, .노드(0, .빈, .빈), .빈)

타입 스크립트

상세 정보:타입 스크립트

TypeScript에서 ADT는 다음과 [32]같이 정의할 수 있습니다.

트리 = { cind: "empty" } { cind: "node"; 값: 숫자; 왼쪽:트리(오른쪽):트리 };

인스턴스화:

const myTree:트리 = { 종류: "노드", 값: 42, 왼쪽: { 종류: "노드", 값: 0, 왼쪽: { 종류: "빈" }, 오른쪽: { 종류: "빈" }, 오른쪽: { 종류: "빈" }, 오른쪽: { 종류: "빈" };

비주얼 프롤로그

상세 정보:비주얼 프롤로그

Visual Prolog에서 ADT는 다음과 [33]같이 정의할 수 있습니다.

도메인     트리 = 빈; 노드(정수, 트리, 트리).

인스턴스화:

상수     마이 트리 : 트리 = 노드(42, 노드(0, 빈, 빈), 빈).

레퍼런스

  1. ^ "Eclipse Ceylon: Union, intersection, and enumerated types". ceylon-lang.org. Retrieved 2021-11-29.
  2. ^ "Clean 2.2 Ref Man". clean.cs.ru.nl. Retrieved 2021-11-29.
  3. ^ "Inductive types and recursive functions — Coq 8.14.1 documentation". coq.inria.fr. Retrieved 2021-11-30.
  4. ^ "std::variant - cppreference.com". en.cppreference.com. Retrieved 2021-12-04.
  5. ^ "Custom Types · An Introduction to Elm". guide.elm-lang.org. Retrieved 2021-11-29.
  6. ^ cartermp. "Discriminated Unions - F#". docs.microsoft.com. Retrieved 2021-11-29.
  7. ^ "Inductive types and pattern matching — Proof-Oriented Programming in F* documentation". www.fstar-lang.org. Retrieved 2021-12-06.
  8. ^ "Record types". www.freepascal.org. Retrieved 2021-12-05.
  9. ^ "4 Declarations and Bindings". www.haskell.org. Retrieved 2021-12-07.
  10. ^ "Enum Instance". Haxe - The Cross-platform Toolkit. Retrieved 2021-11-29.
  11. ^ "Defining your own data types". 2011-08-10. Archived from the original on 2011-08-10. Retrieved 2021-12-03.
  12. ^ "Types and Functions — Idris2 0.0 documentation". idris2.readthedocs.io. Retrieved 2021-11-30.
  13. ^ "JEP 409: Sealed Classes". openjdk.java.net. Retrieved 2021-12-05.
  14. ^ "Types · The Julia Language". docs.julialang.org. Retrieved 2021-12-03.
  15. ^ "Sealed classes Kotlin". Kotlin Help. Retrieved 2021-11-29.
  16. ^ Stanley-Marbell, Phillip (2003). Inferno Programming with Limbo. Wiley. pp. 67–71. ISBN 978-0470843529.
  17. ^ "The Mercury Language Reference Manual: Discriminated unions". www.mercurylang.org. Retrieved 2021-12-07.
  18. ^ "An Overview of Miranda". www.cs.kent.ac.uk. Retrieved 2021-12-04.
  19. ^ "Basic Variants · rsdn/nemerle Wiki". GitHub. Retrieved 2021-12-03.
  20. ^ "Nim Manual". nim-lang.org. Retrieved 2021-11-29.
  21. ^ "OCaml - The OCaml language". ocaml.org. Retrieved 2021-12-07.
  22. ^ "The type system · MLstate/opalang Wiki". GitHub. Retrieved 2021-12-07.
  23. ^ "Type constructor - OpenCog". wiki.opencog.org. Retrieved 2021-12-07.
  24. ^ purescript/documentation, PureScript, 2021-11-24, retrieved 2021-11-30
  25. ^ "2 Beginning Typed Racket". docs.racket-lang.org. Retrieved 2021-12-04.
  26. ^ "Variants · Reason". reasonml.github.io. Retrieved 2021-11-30.
  27. ^ "Variant ReScript Language Manual". ReScript Documentation. Retrieved 2021-11-30.
  28. ^ "enum - Rust". doc.rust-lang.org. Retrieved 2021-11-29.
  29. ^ "Algebraic Data Types". Scala Documentation. Retrieved 2021-11-29.
  30. ^ "Defining datatypes". homepages.inf.ed.ac.uk. Retrieved 2021-12-01.
  31. ^ "Enumerations — The Swift Programming Language (Swift 5.5)". docs.swift.org. Retrieved 2021-11-29.
  32. ^ "Documentation - TypeScript for Functional Programmers". www.typescriptlang.org. Retrieved 2021-11-29.
  33. ^ "Language Reference/Domains - wiki.visual-prolog.com". wiki.visual-prolog.com. Retrieved 2021-12-07.