Tantangan

Temukan ekspresi, paling panjang 100 byte, dengan tipe tanda tangan terpanjang.

Aturan

• Setiap bahasa yang diketik secara statis dengan inferensi tipe diperbolehkan
• Jenisnya harus non-ambigu, tetapi selain itu dapat menyertakan jenis tanpa instans yang ditentukan. Misalnya Num [a]dan Eq [a]diizinkan, bahkan tanpa instance yang ditentukan
• Tidak ada impor selain dari minimum yang diperlukan untuk mengkompilasi program dengan STDIN / STDOUT
• Jenis yang tidak terbatas tidak diperbolehkan
• Jika jawaban memiliki lebih dari satu ekspresi, hanya satu yang dapat berkontribusi pada skor. Misalnya, meskipun jenis tanda tangan komposisi adalah (.) :: (b -> c) -> (a -> b) -> a -> c, memiliki skor 20, jawaban dengan 25 salinan (.)\nakan memiliki skor 20, bukan 500
• Ekspresi paling banyak harus 100 byte
• Skor adalah jumlah karakter dalam tipe tanda tangan, tidak termasuk nama fungsi dan spasi putih apa pun. Misalnya, f :: (a -> b) -> a -> bakan memiliki skor 12
• Skor tertinggi menang!

Contohnya

Meskipun bahasa lain diperbolehkan, contoh-contoh berikut ada di Haskell:

Score: 112
map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map.map
f :: (a -> b)
 -> [[[[[[[[[[[[[[[[[[[[[[[[[a]]]]]]]]]]]]]]]]]]]]]]]]]
 -> [[[[[[[[[[[[[[[[[[[[[[[[[b]]]]]]]]]]]]]]]]]]]]]]]]]    

Score: 240
(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.).(.)
f :: (b->c)->(a->a1->a2->a3->a4->a5->a6->a7->a8->a9->a10->a11->a12->a13->a14->a15->a16->a17->a18->a19->a20->a21->a22->a23->a24->b)->a1->a2->a3->a4->a5->a6->a7->a8->a9->a10->a11->a12->a13->a14->a15->a16->a17->a18->a19->a20->a21->a22->a23->a24->c

Score: 313
foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl$foldl(.)
f :: (Foldable t, Foldable t1, Foldable t2, Foldable t3, Foldable t4,
  Foldable t5, Foldable t6, Foldable t7, Foldable t8, Foldable t9,
  Foldable t10, Foldable t11, Foldable t12, Foldable t13,
  Foldable t14, Foldable t15) =>
 (b -> c)
 -> t (t1 (t2 (t3 (t4 (t5 (t6 (t7 (t8 (t9 (t10 (t11 (t12 (t13 (t14 (t15 (b
 -> b))))))))))))))))
 -> b
 -> c

Score: 538
lex.show.foldl1.mapM.traverse.sum.mapM.sum.traverse.(.).mapM.scanl.zipWith3((.traverse).(.traverse))
 (Num
    (a -> ([[c]] -> t3 [[a1 -> f b]]) -> [[c]] -> t3 [[a1 -> f b]]),
  Num
    (([[c]] -> t3 [[a1 -> f b]])
     -> t1 (t2 ([[c]] -> t3 [[a1 -> f b]]))
     -> [[c]]
     -> t3 [[a1 -> f b]]),
  Show
    (t (t1 (t2 ([[c]] -> t3 [[a1 -> f b]])))
     -> t1 (t2 ([[c]] -> t3 [[a1 -> f b]]))),
  Applicative f, Foldable t,
  Foldable ((->) (t1 (t2 ([[c]] -> t3 [[a1 -> f b]])) -> a)),
  Foldable
    ((->) (([[c]] -> t3 [[a1 -> f b]]) -> a -> t3 [a1 -> f b])),
  Traversable t1, Traversable t2, Traversable t3, Traversable t4,
  Traversable t5,
  Traversable ((->) (t1 (t2 ([[c]] -> t3 [[a1 -> f b]])))),
  Traversable ((->) ([[c]] -> t3 [[a1 -> f b]]))) =>
 [(t5 (t4 a1) -> f (t5 (t4 b))) -> c -> a1 -> f b]
 -> [(String, String)]

Haskell, ~ 2 ^ (2 ^ 18)

f x=(x,x)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l.l
n=m.m.m.m
n.n.n.n$0

Setiap aplikasi secara fkasar menggandakan tanda tangan jenis dengan mentransformasikan tanda tangan tipe Tmenjadi (T,T). Misalnya, komposisi empat kali lipat f.f.f.f$0memiliki tipe

Num a => ((((a, a), (a, a)), ((a, a), (a, a))), (((a, a), (a, a)), ((a, a), (a, a))))

Setiap baris melipatgandakan jumlah aplikasi f, memberi 4^9 = 2^18di akhir. Jadi, tipe tanda tangan memiliki ukuran urutan 2^(2^18).

Jawa, skor 17301488

Membutuhkan metode <T>java.util.Map<T,T>f(T t){return null;}, yang telah dihitung menuju batas 100 byte.

f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(1)))))))))))))))))))

Jenis tanda tangan waktu kompilasi harus cocok dengan ini.

Haskell dengan ekstensi, $\ggg A(A(A(A(220,0),0),0),0)$

Z::Z#Z#Z#Z#Z#Z#Z#Z#Z?Z
data a?b=Z|S(a?b)
type family m#n where Z#n=S n;S m#Z=m#S m;S m#S n=m#(S m#n)

Cobalah online!

Membutuhkan -XDataKinds, -XPolyKinds, -XTypeOperators, -XUndecidableInstances, dan -XTypeFamilies.

Terima kasih banyak kepada Ørjan Johansen, yang menyadari bahwa membuat bilangan alami pembangun infiks dan membangun argumen sedikit berbeda menghemat dua byte, membuat cukup ruang untuk pengulangan lain #.

Jelas, pemeriksa tipe akan menyerah mencoba memeriksa program ini. Untuk mendapatkan gambaran umum tentang bagaimana tanda tangan itu akan terlihat (jika cukup kecil untuk muat di alam semesta yang dapat diamati), cobalah yang lebih kecil

Z::S(S Z)#Z?Z

Penjelasan

Keluarga #tipe terkait erat dengan fungsi Ackermann-Péter , umumnya ditulis $A$ , tetapi #tumbuh jauh lebih cepat. Fungsi Ackermann – Péter didefinisikan

$A(0,n)=n+1$

$A(m,0)=A(m-1,1)$ ketika$m > 0$

$A(m,n)=A(m-1, A(m, n-1))$ ketika$m, n > 0$

#, di sisi lain, kita dapat memanggil $B$ , dan menulis

$B(0,n)=n+1$

$B(m,0)=B(m-1,m)$ ketika$m > 0$

$B(m,n)=B(m-1, B(m, n-1))$ ketika$m,n > 0$

Hanya kasus kedua yang berbeda. Bukti terminasi identik dengan standar untuk $A$ , dan harus jelas bahwa $B(m,n) \ge A(m,n)$ untuk semua $m$ dan $n$ .

Di sini kita menghitung representasi unary dari

$r = B(B(B(B(B(B(B(B(0,0),0),0),0),0),0),0),0)$

Dengan perhitungan langsung, $B(B(B(B(0,0),0),0),0)=220$ , jadi

$r = B(B(B(B(220,0),0),0),0)$ .

Perhatikan bahwa $A(A(A(A(0,0),0),0),0)$ hanya $5$ , jadi kami telah memulai beberapa hal yang baik untuk memulai). Saya tidak memiliki kepekaan yang jelas tentang seberapa cepat $B$ tumbuh lebih cepat daripada $A$ , tetapi mengingat bagaimana kalkulasinya berlangsung, sepertinya akan tumbuh jauh lebih cepat.

Jumlah digit bahkan dalam $A(6,0)$ terlalu besar untuk diekspresikan secara praktis dalam desimal, jadi ini ... agak besar.

Definisi bilangan asli,, (?)agak tidak standar. Untuk menghemat ruang, kami menggunakan (?)keduanya sebagai tipe bilangan alami (pada level tipe) dan tipe proxy (pada level term).

Saya percaya bahwa salah satu TypeFamiliesatau (lebih secara verbal dan tidak jelas) FunctionalDependenciesdiperlukan untuk mendapatkan perhitungan tipe-tingkat yang diperlukan untuk mencapai tipe yang benar-benar besar. UndecidableInstancesdiperlukan untuk bekerja di sekitar pengecekan terminasi Haskell yang sangat primitif. Ekstensi lain hanya diperlukan untuk memampatkan kode ke dalam ruang kecil yang tersedia.

Haskell, 9 · 2 ⁶⁶³⁵⁵² - 3 (≈ 1.02 · 10 ¹⁹⁹⁷⁵⁰ )

Peningkatan kecil ("kecil") di atas xnor's 5⋅2 ²⁶²¹⁴⁴ + 5 . Ini adalah 99 byte.

f=(:).(:)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l
n=m.m.m
o=n.n.n
o.o.o

Bagaimana itu bekerja

Kita punya

(:)         :: a -> [a] -> [a]
(:).(:)     :: a -> [[a] -> [a]] -> [[a] -> [a]]
(:).(:).(:) :: a -> [[[a] -> [a]] -> [[a] -> [a]]] -> [[[a] -> [a]] -> [[a] -> [a]]]

dan seterusnya, dengan panjang kira-kira dua kali lipat untuk masing-masing (:). Ungkapan yang diberikan o.o.oberhasil (:).(:).(:).….(:)dengan 2 · 4 ⁶ · 3 ⁴ = 663552 salinan (:).

Haskell dengan FlexibleContextsdan NoMonomorphismRestriction, (200 · 4 ³³¹⁷⁷⁶ + 75 · 331776 + 16) / 9 ≈ 2,53 · 10 ¹⁹⁹⁷⁵⁰

Sebuah perbaikan kecil dibandingkan Bubbler's 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 - 4 ≈ 1,36 · 10 ¹⁹⁹⁷⁵⁰ , yang juga bergantung pada ekstensi ini. Kata-kata dari jenis tantangan menyarankan mungkin bergantung pada mereka ("Sebagai contoh Num [a]dan Eq [a]diizinkan, bahkan tanpa contoh yang ditentukan"); Saya tidak yakin. Ini adalah 100 byte.

f=(/).(:)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l
n=m.m.m
o=n.n.n
-o.o.o

Bagaimana itu bekerja

Kita punya

-(/).(:) :: (Fractional ([a] -> [a]), Num (a -> ([a] -> [a]) -> [a] -> [a])) => a -> ([a] -> [a]) -> [a] -> [a]
-(/).(:).(/).(:) :: (Fractional ([a] -> [a]), Fractional ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]), Num (a -> ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]])) => a -> ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]
-(/).(:).(/).(:).(/).(:) :: (Fractional ([a] -> [a]), Fractional ([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]), Fractional ([([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]), Num (a -> ([([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]) -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]])) => a -> ([([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]) -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]] -> [([([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]) -> [([a] -> [a]) -> [a] -> [a]] -> [([a] -> [a]) -> [a] -> [a]]]

dan seterusnya, dengan panjang kira-kira empat kali lipat untuk masing-masing (/).(:). Ungkapan yang diberikan -o.o.oberhasil -(/).(:).(/).(:).….(/).(:)dengan 4 ⁶ · 3 ⁴ = 331776 salinan (/).(:).

Haskell, 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 - 4

Namun peningkatan kecil lainnya atas jawaban Anders Kaseorg .

f=(/).(/)
g=f.f.f.f
h=g.g.g.g
i=h.h.h.h
j=i.i.i.i
k=j.j.j.j
l=k.k.k.k
m=l.l.l
n=m.m.m
o=n.n.n
o.o.o

Bagaimana itu bekerja

(/) -- score 27
   :: Fractional a => a -> a -> a
(/).(/) -- score 62
   :: (Fractional a, Fractional (a -> a)) => a -> (a -> a) -> a -> a
(/).(/).(/) -- score 119
   :: (Fractional a, Fractional (a -> a), Fractional ((a -> a) -> a -> a)) =>
      a -> ((a -> a) -> a -> a) -> (a -> a) -> a -> a
(/).(/).(/).(/) -- score 224
   :: (Fractional a, Fractional (a -> a),
       Fractional ((a -> a) -> a -> a),
       Fractional (((a -> a) -> a -> a) -> (a -> a) -> a -> a)) =>
      a
      -> (((a -> a) -> a -> a) -> (a -> a) -> a -> a)
      -> ((a -> a) -> a -> a)
      -> (a -> a)
      -> a
      -> a

Hanya mengubah komposisi fungsi (.)menjadi pembagian fraksional (/). Bagian Fractional xdalam tanda tangan fungsi meledak bersama dengan bagian utama, memberikan pengali konstan sedikit lebih tinggi.

C, 979

#define a int,int,int
#define b a,a,a,a
#define c b,b,b
#define d c,c,c
#define e d,d,d
int(*f)(e);

f memiliki tanda tangan:

int(*)(int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int)

C ++ 11, tidak bersaing

Saya hampir tidak bisa mendapatkan ini di bawah 100 byte, tetapi begitu dekat saya pikir saya mungkin mempostingnya, dengan harapan seseorang melihat optimasi.

Ini adalah prolog, dengan biaya 93 byte:

#define t(a,b,c)template<a>union A b{using T=c(*)(c);};
t(int N,,typename A<N-1>::T)t(,<0>,A)

Dan ungkapannya, 9 byte:

A<9>::T()

Menggambarkan:

Expr       Type
A<0>::T()  A<0> (*)(A<0>)
A<1>::T()  A<0> (*(*)(A<0> (*)(A<0>)))(A<0>)
A<2>::T()  A<0> (*(*(*)(A<0> (*(*)(A<0> (*)(A<0>)))(A<0>)))(A<0> (*)(A<0>)))(A<0>)

Menggandakan secara kasar setiap kali jumlahnya meningkat.

C #, 363

Ekspresi:

new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=new{a=""}}}}}}}}}}}}}}

Jenis tanda tangan:

<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[<>f__AnonymousType0#1`1[System.String]]]]]]]]]]]]]]

Cobalah online!

Go 1.0 tanpa reflect, 98

Tipe Go 1.x didefinisikan secara statis. Ini adalah percobaan pertama saya:

[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]string{}

Arena bermain On the Go :

package main;import "fmt"
func main() {

    x := [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]string{}

    fmt.Printf("%d %T\n", len(fmt.Sprintf("%T", x)), x)
}

Go 1.9 menggunakan alias type, 2389

type(I=interface{f();g()};S=struct{p,q,r,s,t,u,v,w,x,y,z I});map[S]map[S]map[S]map[S]map[S]map[S]S{}

Arena bermain On the Go :

package main;import("fmt";"strings")
func main() {

    type(I=interface{f();g()};S=struct{p,q,r,s,t,u,v,w,x,y,z I});x:=map[S]map[S]map[S]map[S]map[S]map[S]S{}

    fmt.Printf("%d %T\n", len(strings.Replace(fmt.Sprintf("%T", x), " ", "", -1)), x)
}

Hasil:

2389 map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]map[struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }]struct { p interface { main.f(); main.g() }; q interface { main.f(); main.g() }; r interface { main.f(); main.g() }; s interface { main.f(); main.g() }; t interface { main.f(); main.g() }; u interface { main.f(); main.g() }; v interface { main.f(); main.g() }; w interface { main.f(); main.g() }; x interface { main.f(); main.g() }; y interface { main.f(); main.g() }; z interface { main.f(); main.g() } }

Go 1 using reflect, 65532

Ada batas dalam paketreflect pada panjang nama jenis:len(name) <= 1<<16-1

Sejauh ini saya telah mencapai nama jenis 65532 byte dengan blok ini:

t:=reflect.TypeOf(0);u:=t;for i:=0;i<8191;i++{t=reflect.MapOf(u,t)};reflect.New(t).Interface()

Kode lengkap di taman bermain Go :

package main;import("fmt";"reflect")
func main() {

    t:=reflect.TypeOf(0);u:=t;for i:=0;i<8191;i++{t=reflect.MapOf(u,t)};x:=reflect.New(t).Interface()

    fmt.Printf("%d %T\n", len(fmt.Sprintf("%T", x)), x)
}

Idris,> hiper (hiper (hiper (hiper (999999999, 99, 99), 99,99), 99,99), 99,99)

f:Nat->Type
f Z=()
f(S n)=hyper n n n~=~f n
the$f$hyper(hyper(hyper(hyper 999999999 9 9) 9 9)9 9)9 9

Penjelasan:

Kami mendefinisikan fungsi f, menghitung tipe f (0) hanya tipe unit, sementara f (S (n)) menghitung tipe kesetaraan yang diterapkan pada argumen fungsi "hypered" dengan sendirinya dan ke f diterapkan ke n . Baris terakhir pada dasarnya adalah fungsi yang mengharapkan nilai tipe seperti (27 = (4 = (2 = (1 = () =))))) (untuk n = 4).

Contoh sederhana

f 3 = (27 = (4 = (2 = (1 = ()))))

Haskell, 782

Ekspresi:

sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum.sum

Jenis tanda tangan:

:: (Num [[[[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[[c]]]]]]]]]]]]]]], Num [[[[[[[[[[[[[[c]]]]]]]]]]]]]], Num [[[[[[[[[[[[[c]]]]]]]]]]]]], Num [[[[[[[[[[[[c]]]]]]]]]]]], Num [[[[[[[[[[[c]]]]]]]]]]], Num [[[[[[[[[[c]]]]]]]]]], Num [[[[[[[[[c]]]]]]]]], Num [[[[[[[[c]]]]]]]], Num [[[[[[[c]]]]]]], Num [[[[[[c]]]]]], Num [[[[[c]]]]], Num [[[[c]]]], Num [[[c]]], Num [[c]], Num [c], Num c) => [[[[[[[[[[[[[[[[[[[[[[[[[c]]]]]]]]]]]]]]]]]]]]]]]]] -> c

Ceylon, 38843546786070481 (~ 4 · 10 ¹⁶ )

[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]

Ini adalah 49 tupel bersarang, dengan tuple kosong paling dalam. Nama pendek jenis ini sebenarnya sama dengan nilai dalam kasus ini, tetapi nama yang diperluas sepenuhnya jauh lebih lama.

Kompiler Ceylon berfungsi selamanya ketika mencoba mengkompilasi ini (Kompilator masih berjalan setelah 180 menit) - Saya harus mencoba menghitung panjang jenis teoritis.

Masalahnya di sini adalah bahwa tipe satu elemen-tuple [X]sebenarnya diwakili dalam sistem tipe Ceylon karena Tuple<X, X, []>(parameter pertama adalah supertipe untuk semua jenis elemen, kedua adalah tipe elemen pertama, dan ketiga tipe semua kecuali elemen pertama) , yang di sini adalah tuple kosong ( emptyobjek, contoh tunggal yang memuaskan antarmukaEmpty )).

Begitu []juga empty, [[]]adalah Tuple<[], [], []>= Tuple<empty, empty, empty>, [[[]]]adalah Tuple<[[]], [[]], []>= Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []>. Dan nama lengkap termasuk nama paket, jadi sebenarnya sudahceylon.language::Tuple<ceylon.language::Tuple<ceylon.language::empty, ceylon.language::empty, ceylon.language::empty>, ceylon.language::Tuple<ceylon.language::empty, ceylon.language::empty, ceylon.language::empty>, ceylon.language::empty> hanya tiga level. Dan kami ingin pergi ke 50.

As ceylon.language::emptysepanjang 22 karakter, dan masing-masing ceylon.language::Tuple<?,?,ceylon.language::empty>menambahkan 47 hingga dua kali hasil dari langkah sebelumnya, kita dapatkan f(1) = 22, dan f(n) = 2 · f(n-1) + 47. Ini menyederhanakan f(n) = 69 · 2^(n - 1) - 47, dan memasuki 50 memberi kita 38843546786070481. Tentu saja, ini jauh lebih besar daripada apa yang akan muat dalam memori komputer saya (8 · 10 ⁹ byte).

Tentu saja, kompiler dapat menjadi pintar dan tidak mencoba untuk memiliki seluruh nama tipe dalam memori sampai namanya diminta.

Ini adalah program lengkap yang mencoba mencetak jenis:

import ceylon.language.meta {
    type
}
"Run the module `codegolf.signature71797`."
shared void run() {
    value x = [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]];
    print(type(x));
}

C # (Visual C # Interactive Compiler) , 99 byte, Skor 841

(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,(1,1,1))))))))))))))))))))))))

Cobalah online!

Keluaran

System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`2[System.Int32,System.ValueTuple`3[System.Int32,System.Int32,System.Int32]]]]]]]]]]]]]]]]]]]]]]]]