Sfida

Trova un'espressione, lunga al massimo 100 byte, con la firma del tipo più lungo.

Regole

• È consentita qualsiasi lingua tipicamente statica con inferenza di tipo
• Il tipo deve essere non ambiguo, ma in caso contrario può includere tipi senza istanze definite. Ad esempio Num [a]e Eq [a]sono consentiti, anche senza un'istanza definita
• Nessuna importazione oltre al minimo richiesto per compilare un programma con STDIN / STDOUT
• I tipi infiniti non sono ammessi
• Se una risposta ha più di un'espressione, solo una può contribuire al punteggio. Ad esempio, sebbene la firma del tipo di composizione sia (.) :: (b -> c) -> (a -> b) -> a -> c, con un punteggio di 20, la risposta con 25 copie di (.)\navrebbe un punteggio di 20, non di 500
• L'espressione deve essere al massimo di 100 byte
• Il punteggio è il numero di caratteri nella firma del tipo, escluso il nome della funzione e qualsiasi spazio bianco. Ad esempio, f :: (a -> b) -> a -> bavrebbe un punteggio di 12
• Il punteggio più alto vince!

Esempi

Sebbene siano consentite altre lingue, i seguenti esempi sono 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

Ogni applicazione fraddoppia approssimativamente la firma del tipo trasformando la firma del tipo Tin (T,T). Ad esempio, la composizione quadrupla f.f.f.f$0ha tipo

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

Ogni riga quadruplica il numero di applicazioni di f, dando 4^9 = 2^18alla fine. Quindi, la firma del tipo ha dimensione dell'ordine di 2^(2^18).

Java, punteggio 17301488

Richiede il metodo <T>java.util.Map<T,T>f(T t){return null;}, che è stato conteggiato per il limite di 100 byte.

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

La firma del tipo in fase di compilazione deve corrispondere a questa.

Haskell con estensioni, $\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)

Provalo online!

Richiede -XDataKinds, -XPolyKinds, -XTypeOperators, -XUndecidableInstances, e -XTypeFamilies.

Mille grazie a Ørjan Johansen, che si è reso conto che rendere il costruttore del numero naturale inficiare e costruire gli argomenti in modo leggermente diverso ha salvato due byte, facendo abbastanza spazio per un'altra iterazione di #.

Ovviamente, il controllo del tipo smetterà di provare a controllare questo programma. Per avere un'idea generale di come sarebbe la firma (se fosse abbastanza piccola da adattarsi all'universo osservabile), prova il più piccolo

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

Spiegazione

La #famiglia di tipi è strettamente correlata alla funzione di Ackermann – Péter , comunemente scritta $A$ , ma #cresce notevolmente più velocemente. La funzione Ackermann – Péter è definita

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

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

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

#$B$

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

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

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

$A$$B(m,n) \ge A(m,n)$$m$$n$

Qui calcoliamo una rappresentazione unaria di

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

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

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

$A(A(A(A(0,0),0),0),0)$$5$$B$$A$

$A(6,0)$

La definizione dei numeri naturali (?), è un po 'non standard. Per risparmiare spazio, utilizziamo (?)sia un tipo di numero naturale (a livello di tipo) sia un tipo di proxy (a livello di termine).

Credo che sia necessario TypeFamilieso (in modo più verbale e offuscato) FunctionalDependenciesper ottenere il calcolo a livello di tipo richiesto per raggiungere tipi veramente grandi. UndecidableInstancesè necessario per aggirare il controllo di terminazione molto primitivo di Haskell. Le altre estensioni sono necessarie solo per comprimere il codice nel piccolo spazio disponibile.

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

Un piccolo ("piccolo") miglioramento rispetto a 5⋅2 ²⁶²¹⁴⁴ + 5 di xnor . Questo è di 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

Come funziona

abbiamo

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

e così via, con la lunghezza che raddoppia approssimativamente per ciascuno (:). L'espressione data o.o.ofunziona (:).(:).(:).….(:)con 2 · 4 ⁶ · 3 ⁴ = 663552 copie di (:).

Haskell con FlexibleContextse NoMonomorphismRestriction, (200 · 4 ³³¹⁷⁷⁶ + 75 · 331776 + 16) / 9 ≈ 2.53 · 10 ¹⁹⁹⁷⁵⁰

Un piccolo miglioramento rispetto a 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 - 4 ≈ 1.36 · 10 ^{199750 di} Bubbler , che si basa anche su queste estensioni. La formulazione del tipo di sfida suggerisce che potrebbe essere giusto fare affidamento su di essi ("Ad esempio Num [a]e Eq [a]sono consentiti, anche senza un'istanza definita"); Non ne sono sicuro. Questo è di 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

Come funziona

abbiamo

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

e così via, con la lunghezza circa quadruplicata per ciascuno (/).(:). La data espressione -o.o.ofunziona a -(/).(:).(/).(:).….(/).(:)con 4 ⁶ · 3 ⁴ = 331.776 copie di (/).(:).

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

Ancora un altro piccolo miglioramento rispetto alla risposta di 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

Come funziona

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

Ho appena cambiato la composizione della funzione (.)in divisione frazionaria (/). La Fractional xparte nella firma della funzione esplode insieme alla parte principale, dando un moltiplicatore costante leggermente più alto.

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 ha la firma:

int(*)(int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,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, non competitivo

A malapena non riesco a ottenere questo sotto i 100 byte, ma è così vicino che ho pensato di poterlo pubblicare comunque, nella speranza che qualcuno individuasse un'ottimizzazione.

Questo è il prologo, che costa 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)

E l'espressione, 9 byte:

A<9>::T()

Illustrare:

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

Raddoppiando approssimativamente ogni volta che il numero aumenta.

C #, 363

Espressione:

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

Digitare la firma:

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

Provalo online!

Vai 1.0 senza reflect, 98

I tipi Go 1.x sono definiti staticamente. Ecco il mio primo tentativo:

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

Parco giochi On the Go :

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

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

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

Vai 1.9 usando alias di tipo, 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{}

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

Risultato:

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

Vai 1 utilizzando reflect, 65532

Esiste un limite nel pacchettoreflect sulla lunghezza dei nomi dei tipi:len(name) <= 1<<16-1

Finora sono riuscito a raggiungere un nome tipo di 65532 byte con questo blocco:

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

Codice completo nel parco giochi 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,> 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

Spiegazione:

Stiamo definendo una funzione f, calcolare un tipo f (0) è solo il tipo di unità, mentre f (S (n)) calcola il tipo di uguaglianza applicato all'argomento della funzione "hypered" da solo e f applicato a n . L'ultima riga è sostanzialmente una funzione che prevede un valore di un tipo come (27 = (4 = (2 = (1 = ()))))) (per n = 4).

Esempio semplice

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

Haskell, 782

Espressione:

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

Digitare la firma:

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

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

Si tratta di 49 tuple annidate, con una tupla vuota più interna. Il nome breve di questo tipo è in realtà lo stesso del valore in questo caso, ma il nome completamente espanso è molto più lungo.

Il compilatore Ceylon funziona per sempre quando si tenta di compilare questo (il compilatore era ancora in esecuzione dopo 180 minuti) - Dovrò provare a calcolare la lunghezza teorica del tipo.

Il problema qui è che un tipo di tupla a un elemento [X]è effettivamente rappresentato nel sistema di tipi di Ceylon comeTuple<X, X, []> (il primo parametro è un supertipo per tutti i tipi di elementi, il secondo è il tipo del primo elemento e il terzo il tipo di tutti tranne i primi elementi , che è qui una tupla vuota (l' emptyoggetto, la singola istanza che soddisfa l'interfaccia Empty)).

Quindi []è empty, [[]]è Tuple<[], [], []>= Tuple<empty, empty, empty>,[[[]]] è Tuple<[[]], [[]], []>=Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []> . E il nome completo include i nomi dei pacchetti, quindi in realtà abbiamo 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>solo tre livelli. E vogliamo andare al 50.

Dato che ceylon.language::emptyè lungo 22 caratteri, ognuno ceylon.language::Tuple<?,?,ceylon.language::empty>aggiunge 47 al doppio del risultato del passaggio precedente, otteniamo f(1) = 22ef(n) = 2 · f(n-1) + 47 . Questo semplifica f(n) = 69 · 2^(n - 1) - 47e l'immissione di 50 ci dà 38843546786070481. Naturalmente, questo è molto più grande di quello che si adatterebbe nella memoria del mio computer (8 · 10 ⁹ byte).

Naturalmente, il compilatore potrebbe essere intelligente e non tentare di avere l'intero nome del tipo in memoria fino a quando non viene richiesto il nome.

Ecco il programma completo che prova a stampare il tipo:

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

C # (compilatore interattivo Visual C #) , 99 byte, punteggio 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))))))))))))))))))))))))

Provalo online!

Uscite

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