Buat tanda tangan tipe panjang

23

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)]
Michael Klein
sumber
Terkait . Saya memang berpikir ada penipuan yang hampir pasti, tapi saya belum menemukannya.
Peter Taylor
2
Saya menduga bahwa bahasa dengan pengetikan bergantung dapat membuat tanda tangan jenis dengan panjang berapa pun jumlah yang dapat dihitung.
xnor
@ xnor Karena sistem tipe itu sendiri mungkin turing lengkap ( stackoverflow.com/a/4047732/5154287 ), saya kira itu menjadi masalah berang-berang yang sibuk. Haruskah saya mengedit tag?
Michael Klein

Jawaban:

19

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).

Tidak
sumber
2
Pendekatan klasik, tapi saya pikir parameternya bisa lebih baik disetel. Secara khusus, saya berpikir bahwa f x=(x,x,x)dengan mengorbankan satu n.di baris terakhir memberikan skor optimal untuk struktur keseluruhan ini.
Peter Taylor
Saya tidak tahu Haskell, jadi saya mungkin tidak berada di markas di sini, tetapi saya akan tunjukkan bahwa 4 ^ (4 ^ 4) kurang dari 3 ^ (4 ^ 5)
Sparr
Cukup yakin 4th n.akan menjadi lebih besar. 2^18vs 3 * (2^16)kecuali saya membuat kesalahan menghitung eksponensial asli: 2^(4^9)vs3^((4^8)*3)
Draco18s
Tidak, @PeterTaylor benar: 2 ^ (4 ^ 9) = 16 ^ (4 ^ 8) <27 ^ (4 ^ 8) = 3 ^ (4 ^ 8 ⋅ 3).
Anders Kaseorg
(,)(atau (,,)) dapat digunakan untuk menyimpan beberapa byte dan meningkatkan skor dengan menggunakan lebih banyak ns.
ბიმო
11

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.

SuperJedi224
sumber
hmm karena lambda diizinkan, ini mungkin akan mendapatkan skor yang lebih tinggi
ASCII
10

Haskell dengan ekstensi, 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 SEBUAH , tetapi #tumbuh jauh lebih cepat. Fungsi Ackermann – Péter didefinisikan

SEBUAH(0,n)=n+1

SEBUAH(m,0)=SEBUAH(m-1,1) ketikam>0

SEBUAH(m,n)=SEBUAH(m-1,SEBUAH(m,n-1)) ketikam,n>0

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

B(0,n)=n+1

B(m,0)=B(m-1,m) ketikam>0

B(m,n)=B(m1,B(m,n1)) ketikam,n>0

Hanya kasus kedua yang berbeda. Bukti terminasi identik dengan standar untuk A , dan harus jelas bahwa B(m,n)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 SEBUAH(SEBUAH(SEBUAH(SEBUAH(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 SEBUAH , tetapi mengingat bagaimana kalkulasinya berlangsung, sepertinya akan tumbuh jauh lebih cepat.

Jumlah digit bahkan dalam SEBUAH(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.

dfeuer
sumber
Satu lagi#Z
Ørjan Johansen
@ ØrjanJohansen, apakah menumpuk Zdi depan lebih baik daripada memulainya S(S Z)#S Z, atau sama?
dfeuer
Either way, tambahan #Zdi akhir disambut.
dfeuer
1
Ini nilai yang sama persis tetapi menyimpan satu byte, dan mengubah tipe data untuk ?menyimpan yang lain, meninggalkan ruang untuk ekstra #Z.
Ørjan Johansen
1
Ketika Anda pertama kali mengedit, saya menemukan A(m,1)tidak pernah lebih besar dari A(A(m,0),0), dan akan berkomentar tentang itu, tapi kemudian Anda hanya dioptimalkan ke titik di mana opsi-opsi sama. (Juga m+1tidak pernah lebih besar dari A(m,0).)
Ørjan Johansen
9

Haskell, 9 · 2 663552 - 3 (≈ 1.02 · 10 199750 )

Peningkatan kecil ("kecil") di atas xnor's 5⋅2 262144 + 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 6 · 3 4 = 663552 salinan (:).

Haskell dengan FlexibleContextsdan NoMonomorphismRestriction, (200 · 4 331776 + 75 · 331776 + 16) / 9 ≈ 2,53 · 10 199750

Sebuah perbaikan kecil dibandingkan Bubbler's 12 · 2 663552 + 9 · 663552 - 4 ≈ 1,36 · 10 199750 , 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 6 · 3 4 = 331776 salinan (/).(:).

Anders Kaseorg
sumber
7

Haskell, 12 · 2 663552 + 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.

Bubbler
sumber
6

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)
LegionMammal978
sumber
1
979 33554438 58640620148060 ini terlihat seperti entri OEIS yang konyol. mungkin perubahan besarnya terbesar yang pernah saya lihat dalam entri PPCG sedang disempurnakan.
Sparr
5

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.

orlp
sumber
Sepertinya saya ingat ada beberapa versi C ++ yang sangat lama (pra-standar?) Yang menggunakan kata kunci classalih-alih typename. Saya bertanya-tanya apakah ada kompiler di luar sana yang masih mendukung ungkapan itu untuk kompatibilitas?
4

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!

Khusus ASCII
sumber
1

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)
}


Catatan: x:=tidak pernah dihitung.

dolmen
sumber
tidak valid, reflectimpor harus dihitung
ASCII
3403?
ASCII
3685
ASCII
65535
ASCII
1

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 = ()))))
Mega Man
sumber
1
Saya tidak benar - benar mengenal Idris, tetapi saya pikir ini mungkin gagal karena masalah teknis: Anda seharusnya memaksimalkan panjang tanda tangan jenis ekspresi, bukan panjang nilainya. Bukankah tipe tanda tangan dari ekspresi akhir Anda saja :Type?
Ørjan Johansen
Apa yang Anda maksud dengan sebuah uncomputable nomor ? Saya tidak terbiasa dengan itu hyper; bisakah kamu menjelaskan?
dfeuer
@ ØrjanJohansen Oh ya, baru saja memperbaikinya dan menerapkan beberapa perubahan lagi
Mega Man
1
(0) Penjelasan sepertinya agak tertinggal. (1) Ini baru 98 byte sekarang. (2) Karena argumen pertama hyperdiperkuat lebih dari yang lain, saya pikir Anda ingin semua / sebagian besar 99menjadi 9s. (3) Dengan asumsi $karya Idris seperti karya Haskell, tanda kurung luar setelahnya f$adalah mubazir. (4) Bisakah Anda menyingkat hyperatau apakah itu membutuhkan tanda tangan jenis itu sendiri?
Ørjan Johansen
1
@dfeuer en.wikipedia.org/wiki/Hyperoperation ( Definisi Idris adalah terjemahan langsung.)
Ørjan Johansen
0

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
Khusus ASCII
sumber
Menjadi 1814 karakter dengan ghc 8.0.2, karena jenisnya sumadalah(Num a, Foldable t) => t a -> a
Mathieu CAROFF
0

Ceylon, 38843546786070481 (~ 4 · 10 16 )

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

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 9 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));
}
Paŭlo Ebermann
sumber
0

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]]]]]]]]]]]]]]]]]]]]]]]]
Perwujudan Ketidaktahuan
sumber