Herausforderung

Suchen Sie einen höchstens 100 Byte langen Ausdruck mit der längsten Typensignatur.

Regeln

• Jede statisch typisierte Sprache mit Typinferenz ist zulässig
• Der Typ muss nicht mehrdeutig sein, kann aber ansonsten Typen ohne definierte Instanzen enthalten. Zum Beispiel Num [a]und Eq [a]sind erlaubt, auch ohne definierte Instanz
• Keine anderen Importe als das zum Kompilieren eines Programms mit STDIN / STDOUT erforderliche Minimum
• Unendliche Typen sind nicht erlaubt
• Wenn eine Antwort mehr als einen Ausdruck enthält, kann nur einer zur Bewertung beitragen. Obwohl die Typensignatur der Komposition (.) :: (b -> c) -> (a -> b) -> a -> ceine Punktzahl von 20 aufweist, hätte die Antwort mit 25 Kopien von (.)\nbeispielsweise eine Punktzahl von 20 und nicht von 500
• Der Ausdruck darf höchstens 100 Bytes umfassen
• Die Punktzahl gibt die Anzahl der Zeichen in der Typensignatur ohne den Namen der Funktion und Leerzeichen an. Zum Beispiel f :: (a -> b) -> a -> bhätte eine Punktzahl von 12
• Die höchste Punktzahl gewinnt!

Beispiele

Obwohl andere Sprachen zulässig sind, befinden sich die folgenden Beispiele in 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

Bei jeder Anwendung wird die fTypensignatur ungefähr verdoppelt, indem die Typensignatur Tin umgewandelt wird (T,T). Zum Beispiel hat die vierfache Zusammensetzung f.f.f.f$0einen Typ

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

Jede Zeile vervierfacht die Anzahl der Bewerbungen fund gibt 4^9 = 2^18am Ende an. Die Typensignatur hat also eine Größe in der Größenordnung von 2^(2^18).

Java, Punktzahl 17301488

Erfordert die Methode <T>java.util.Map<T,T>f(T t){return null;}, die auf das 100-Byte-Limit angerechnet wurde.

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

Die Signatur dieses Typs zur Kompilierungszeit sollte mit dieser übereinstimmen .

Haskell mit Erweiterungen, $\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)

Probieren Sie es online!

Erfordert -XDataKinds, -XPolyKinds, -XTypeOperators, -XUndecidableInstances, und -XTypeFamilies.

Vielen Dank an Ørjan Johansen, der erkannt hat, dass durch das Einfügen des natürlichen Zahlenkonstruktors und das etwas andere Bilden der Argumente zwei Bytes gespart wurden und gerade genug Platz für eine weitere Iteration von #.

Offensichtlich gibt die Typprüfung den Versuch auf, dieses Programm zu prüfen. Um einen allgemeinen Eindruck davon zu bekommen, wie die Signatur aussehen würde (wenn sie klein genug wäre, um in das beobachtbare Universum zu passen), probieren Sie die viel kleinere aus

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

Erläuterung

Die #Typfamilie ist eng mit der Ackermann-Péter-Funktion verwandt , die üblicherweise als $A$ wird, #wächst jedoch erheblich schneller. Die Ackermann-Péter-Funktion ist definiert

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

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

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

#Andererseits können wir $B$ aufrufen und schreiben

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

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

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

Nur der zweite Fall ist anders. Der Abschlussnachweis ist identisch mit dem Standardnachweis für $A$ , und es sollte klar sein, dass $B(m,n) \ge A(m,n)$ für alle $m$ und $n$ .

Hier berechnen wir eine unäre Darstellung von

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

Durch direkte Berechnung wird $B(B(B(B(0,0),0),0),0)=220$ , so

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

Man beachte , dass $A(A(A(A(0,0),0),0),0)$ ist nur$5$ , so dass wirDinge ein gutes Stück gestoßen haben aus zu starten. Ich habe keine klare Vorstellung davon, wie viel schneller$B$ wächst als$A$ , aber wenn man bedenkt, wie die Berechnung abläuft, ist es wahrscheinlich, dass esviel schnellerwächst.

Die Anzahl der Stellen in einem geraden $A(6,0)$ ist zu groß, um praktisch als Dezimalzahl ausgedrückt zu werden. Das ist also ... ziemlich lächerlich.

Die Definition der natürlichen Zahlen (?)ist etwas ungewöhnlich. Um Platz zu sparen, verwenden wir (?)sowohl einen natürlichen Zahlentyp (auf Typebene) als auch einen Proxy-Typ (auf Begriffsebene).

Ich glaube, dass entweder TypeFamiliesoder (ausführlicher und verschleierter) FunctionalDependenciesnotwendig sind, um die Berechnung auf Typebene zu erhalten, die erforderlich ist, um wirklich große Typen zu erreichen. UndecidableInstanceswird benötigt, um die sehr primitive Terminierungsprüfung von Haskell zu umgehen. Die anderen Erweiterungen werden nur benötigt, um den Code auf den kleinen verfügbaren Platz zu komprimieren.

Haskell, 9,2 ^663552-3 (≈ 1,02 · 10 ¹⁹⁹⁷⁵⁰ )

Eine kleine Verbesserung gegenüber xnors 5⋅2 ²⁶²¹⁴⁴ + 5 . Das sind 99 Bytes.

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

Wie es funktioniert

Wir haben

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

und so weiter, wobei sich die Länge für jeden ungefähr verdoppelt (:). Der angegebene Ausdruck o.o.ofunktioniert (:).(:).(:).….(:)mit 2 · 4 ⁶ · 3 ⁴ = 663552 Kopien von (:).

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

Eine kleine Verbesserung gegenüber Bubbler's 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 - 4 · 1,36 · 10 ¹⁹⁹⁷⁵⁰ , die ebenfalls auf diesen Erweiterungen beruht. Der Wortlaut der Herausforderung legt nahe, dass es in Ordnung sein könnte, sich auf sie zu verlassen („Zum BeispielNum [a]undEq [a]erlaubt, auch ohne definierte Instanz“). Ich bin mir nicht sicher. Das sind 100 Bytes.

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

Wie es funktioniert

Wir haben

-(/).(:) :: (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]]]

und so weiter, wobei sich die Länge für jedes ungefähr vervierfacht (/).(:). Der angegebene Ausdruck -o.o.ofunktioniert -(/).(:).(/).(:).….(/).(:)mit 4 ⁶ · 3 ⁴ = 331776 Kopien von (/).(:).

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

Noch eine kleine Verbesserung gegenüber Anders Kaseorgs Antwort .

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

Wie es funktioniert

(/) -- 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

Gerade geänderte Funktionszusammensetzung (.) in Bruchteilung(/) . Der Fractional xTeil in der Funktionssignatur explodiert zusammen mit dem Hauptteil und ergibt einen etwas höheren konstanten Multiplikator.

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 hat die Unterschrift:

int(*)(int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,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, nicht konkurrierend

Ich kaum kann es unter 100 Bytes bringen, aber es ist so nah, dass ich dachte, ich könnte es trotzdem posten, in der Hoffnung, dass jemand eine Optimierung entdeckt.

Dies ist der Prolog, der 93 Bytes kostet:

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

Und der Ausdruck, 9 Bytes:

A<9>::T()

Um zu veranschaulichen:

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

Jedes Mal, wenn die Zahl zunimmt, wird sie ungefähr verdoppelt.

C #, 363

Ausdruck:

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=""}}}}}}}}}}}}}}

Typ Unterschrift:

<>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]]]]]]]]]]]]]]

Probieren Sie es online!

Gehen Sie 1.0 ohne reflect98

Go 1.x-Typen sind statisch definiert. Hier ist mein erster Versuch:

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

Auf dem Go-Spielplatz :

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

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

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

Go 1.9 mit Typ-Aliasnamen, 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{}

Auf dem Go-Spielplatz :

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

Ergebnis:

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

Gehe 1 mit reflect , 65532

Es gibt eine Grenze im Paketreflect von der Länge der Typennamen:len(name) <= 1<<16-1

Bisher konnte ich mit diesem Block einen Typnamen von 65532 Bytes erreichen:

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

Vollständiger Code auf dem Go-Spielplatz :

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,> hyper (hyper (hyper (hyper (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

Erläuterung:

Wir definieren eine Funktion f, wobei die Berechnung eines Typs f (0) nur der Einheitentyp ist, während f (S (n)) den Gleichheitstyp berechnet, der auf das Funktionsargument angewendet wird, das von sich aus "hypered" ist, und auf f, das auf n angewendet wird . Die letzte Zeile ist im Grunde eine Funktion, die einen Wert eines Typs wie (27 = (4 = (2 = (1 = ())))) (für n = 4) erwartet.

Einfaches Beispiel

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

Haskell, 782

Ausdruck:

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

Typ Unterschrift:

:: (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 ¹⁶ )

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

Dies sind 49 verschachtelte Ein-Tupel mit einem leeren Tupel im Innersten. Der Kurzname dieses Typs entspricht in diesem Fall dem Wert, der vollständig erweiterte Name ist jedoch viel länger.

Der Ceylon-Compiler arbeitet ununterbrochen, wenn er versucht, dies zu kompilieren (der Compiler lief noch nach 180 Minuten). Ich muss versuchen, die theoretische Typlänge zu berechnen.

Das Problem hierbei ist, dass ein Ein-Element-Tupel-Typ [X]in Ceylons Typsystem tatsächlich dargestellt wird als Tuple<X, X, []>(der erste Parameter ist ein Supertyp für alle Elementtypen, der zweite ist der Typ des ersten Elements und der dritte der Typ aller mit Ausnahme der ersten Elemente Dies ist hier ein leeres Tupel (das emptyObjekt, die einzelne Instanz, die die Schnittstelle erfüllt Empty).

So []ist empty, [[]]ist Tuple<[], [], []>= Tuple<empty, empty, empty>, [[[]]]ist Tuple<[[]], [[]], []>= Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []>. Und der vollständige Name enthält die Paketnamen, so dass wir eigentlich ceylon.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>nur für drei Ebenen haben. Und wir wollen zu 50 gehen.

Da ceylon.language::empty22 Zeichen lang sind und jedes ceylon.language::Tuple<?,?,ceylon.language::empty>47 zu dem doppelten Ergebnis des vorherigen Schritts addiert, erhalten wir f(1) = 22und f(n) = 2 · f(n-1) + 47. Dies vereinfacht sich f(n) = 69 · 2^(n - 1) - 47, und die Eingabe von 50 ergibt 38843546786070481. Natürlich ist dies viel größer als das, was in den Speicher meines Computers passen würde (8 · 10 ⁹ Bytes).

Natürlich könnte der Compiler klug sein und nicht versuchen, den gesamten Typnamen im Speicher zu haben, bis sein Name angefordert wird.

Hier ist das vollständige Programm, das versucht, den Typ zu drucken:

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, Score 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))))))))))))))))))))))))

Probieren Sie es online!

Ausgänge

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]]]]]]]]]]]]]]]]]]]]]]]]