ADT'ler, GADT'ler ve endüktif türler arasındaki fark nedir?

Herhangi biri arasındaki farkı açıklayabilir:

Cebirsel Veri Tipleri (oldukça aşina olduğum)
Genelleştirilmiş Cebirsel Veri Tipleri (onları genelleştiren nedir?)
Endüktif Tipler (örneğin, Coq)

(Özellikle endüktif tipler.) Teşekkürler.

— ninjagecko
kaynak

Yanıtlar:

Cebirsel veri türleri, türleri özyinelemeli olarak tanımlamanıza izin verir. Somut, veri tipine sahip olduğumuzu varsayalım

d a t a l i s t = N i l | C o n s o f N \times l i s t

$\mathsf{data\;list = Nil \;\;|\;\; Cons\;of\;\mathbb{N} \times list}$

Bunun anlamı ise tarafından üretilen küçük dizi ve operatörler. Bunu operatörünü tanımlayarak resmileştirebiliriz. $\mathsf{list}$ $\mathsf{Nil}$ $\mathsf{Cons}$ $F(X)$

F (X) == {N- ben l} \cup {C O n s (n, x) | n \in N- \land x \in X}

$F(X) == \{ \mathsf{Nil} \} \cup \{ \mathsf{Cons}(n, x) \;|\; n \in \mathbb{N} \land x \in X \}$

ve daha sonra tanımlama olarak $\mathsf{list}$

l ben s t = ⋃_{ben \in N-} F^{ben} (\emptyset)

$\mathsf{list} = \bigcup_{i \in \mathbb{N}} F^i(\emptyset)$

Bir genelleştirilmiş ADT türü tanımlarken ne olsun operatörü yinelemeli. Örneğin, aşağıdaki tür kurucuyu tanımlayabiliriz:

b u s h bir = L e bir f O f bir | N- e s t O f b u s h (bir x bir)

$\mathsf{bush}\;a = \mathsf{Leaf\;of\;}a \;\;|\;\; \mathsf{Nest\;of\;bush}(a \times a)$

Bu tür aracının bir unsuru bir demet olan uzunlukta s bazıları için parametre olarak her zaman için, yapıcı tür bağımsız değişkeni kendisi ile eşleştirilir. Böylece sabit bir nokta almak istediğimiz operatörü tanımlayabiliriz: $\mathsf{bush\;}a$ $a$ $2^n$ $n$ $\mathsf{Nest}$

F (R,) = λ X . {L e bir f (x) | x \in X} \cup {N- e s t (v) | v \in R, (X)}

$F(R) = \lambda X.\; \{ \mathsf{Leaf}(x) \;|\; x \in X\} \cup \{ \mathsf{Nest}(v) \;|\; v \in R(X) \}$

Coq'daki bir endüktif tip, esas olarak, tip operatörünün indekslerinin diğer tiplerle (örneğin Haskell'de olduğu gibi) sınırlı olmadığı, ancak tip teorisinin değerleriyle endekslenebildiği bir GADT'dir . Bu, uzunluk indeksli listeler için türler vermenizi sağlar, vb.

— Neel Krishnaswami
kaynak

Teşekkür ederim. Ancak bu, sadece "bağımlı tip" ile tamamen eşanlamlı olan "endüktif tip" anlamına gelmez mi?

— ninjagecko

@Neel: GADT bushdenilen türler hiç görmedim . Onları iç içe geçmiş veya normal olmayan türler olarak gördüm.

— jbapple

İç içe tipler, GADT'lerin özel bir durumudur. Bir GADT'nin kritik özelliği, basitçe, daha yüksek kalitede tekrarlayan bir tanım olmasıdır. (Rh'lerde yapılan değişiklikler temel olarak yapıcının bir bileşeni olarak tip eşitliği eklemek için sözdizimsel bir şekerdir.)

— Neel Krishnaswami

@ ninjagecko: "Endüktif tipler", yapıcının en sabit noktası olarak semantik verilen tiplerdir. Tüm türler bu şekilde tanımlanamaz (işlevler olamaz ve akışlar gibi sonsuz türleri de olamaz). Bağımlı türler, program terimlerinin kendilerinde oluşmasına izin veren türleri tanımlar (bu türler "bağımlı" olabilir). Coq bağımlı tip bir teori olduğundan, tanımlamanıza izin veren endüktif tipler de bağımlıdır. Ancak bağımlı olmayan tip teorileri de endüktif tipleri destekleyebilir ve bu endüktif tipler bağımlı olmayacaktır.

— Neel Krishnaswami

@NeelKrishnaswami: Türlerinin "ilk birkaç küçük" elementini sıralayarak cevabınızı netleştirecek kadar nazik misiniz bush a? Bu örnekte, öyle Nest Leaf(a) Leaf(a) Leaf(a) Leaf(a)ya Nest ((Nest Leaf(a) Leaf(a)) (Nest Leaf(a) Leaf(a)))setin gibi bir örnek?

— ninjagecko

Aşağıdaki gibi cebirsel veri türlerini göz önünde bulundurun:

data List a = Nil | Cons a (List a)

: Bir veri türü her yapıcı dönüş türleri hepsi aynı Nilve Consher iki dönüş List a. Yapıcıların farklı türler döndürmesine izin verirsek, bir GADT’miz var :

data Empty -- this is an empty data declaration; Empty has no constructors
data NonEmpty

data NullableList a t where
    Vacant :: NullableList a Empty
    Occupied :: a -> NullableList a b -> NullableList a NonEmpty

Occupiedtipe a -> NullableList a b -> NullableList a NonEmptysahipken Cons, tipe sahip a -> List a -> List a. Bunun NonEmptybir terim değil bir tür olduğunu not etmek önemlidir . Başka bir örnek:

data Zero
data Succ n

data SizedList a t where
    Alone :: SizedList a Zero
    WithFriends :: a -> SizedList a n -> SizedList a (Succ n)

Programlama dillerinde bağımlı türlere sahip indüktif türler, yapıcıların geri dönüş türlerinin, bağımsız değişkenlerin değerlerine (yalnızca türlerine değil) bağlı olmasını sağlar.

Inductive Parity := Even | Odd.

Definition flipParity (x:Parity) : Parity :=
  match x with
    | Even => Odd
    | Odd => Even
  end.

Fixpoint getParity (x:nat) : Parity :=
  match x with
    | 0 => Even
    | S n => flipParity (getParity n)
  end.

(*
A ParityNatList (Some P) is a list in which each member
is a natural number with parity P.
*)

Inductive ParityNatList : option Parity -> Type :=
  Nil : forall P, ParityNatList P
| Cons : forall (x:nat) (P:option Parity), 
  ParityNatList P -> ParityNatList 
  (match P, getParity x with
     | Some Even, Even => Some Even
     | Some Odd, Odd => Some Odd
     | _, _ => None
   end).

Bir not: GHC, değer yapıcılarını tip kurucuları olarak değerlendirmek için bir mekanizmaya sahiptir . Bu, Coq'un sahip olduğu bağımlı endüktif tiplerle aynı değildir, ancak GADT'lerin sözdizimsel yükünü biraz azaltır ve daha iyi hata mesajlarına yol açabilir.

— jbapple
kaynak

Teşekkür ederim. "Bağımlı tiplere sahip programlama dillerinde endüktif tipler" Peki, endüktif tip, bağımlı tipsiz bir dilde nasıl görünür ve endüktif olmayan (ama GADT benzeri) bağımlı tipler olabilir mi?

— ninjagecko