Reto

Encuentre una expresión, como máximo de 100 bytes de longitud, con la firma de tipo más larga.

Reglas

• Se permite cualquier idioma escrito estáticamente con inferencia de tipos.
• El tipo no debe ser ambiguo, pero de lo contrario puede incluir tipos sin instancias definidas. Por ejemplo Num [a]yEq [a] están permitidos, incluso sin una instancia definida
• No hay importaciones aparte del mínimo requerido para compilar un programa con STDIN / STDOUT
• No se permiten tipos infinitos.
• Si una respuesta tiene más de una expresión, solo una puede contribuir a la puntuación. Por ejemplo, aunque la firma tipo de composición es (.) :: (b -> c) -> (a -> b) -> a -> c, con una puntuación de 20, la respuesta con 25 copias (.)\ntendría una puntuación de 20, no 500
• La expresión debe ser, como máximo, 100 bytes.
• La puntuación es el número de caracteres en la firma de tipo, excluyendo el nombre de la función y cualquier espacio en blanco. Por ejemplo, f :: (a -> b) -> a -> btendría una puntuación de 12
• ¡El puntaje más alto gana!

Ejemplos

Aunque se permiten otros idiomas, los siguientes ejemplos están en 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

Cada aplicación de faproximadamente el doble de la firma de tipo transformando la firma de tipo Ta (T,T). Por ejemplo, la composición cuádruple f.f.f.f$0tiene tipo

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

Cada línea cuadruplica el número de aplicaciones de f, dando 4^9 = 2^18al final. Entonces, la firma de tipo tiene un tamaño del orden de 2^(2^18).

Java, puntaje 17301488

Requiere el método <T>java.util.Map<T,T>f(T t){return null;}, que se ha contado para el límite de 100 bytes.

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

La firma de tipo de tiempo de compilación de esto debería coincidir con esto.

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

Pruébalo en línea!

Requiere -XDataKinds, -XPolyKinds, -XTypeOperators, -XUndecidableInstances, y -XTypeFamilies.

Muchas gracias a Ørjan Johansen, quien se dio cuenta de que hacer que el constructor de números naturales se infija y construir los argumentos de manera un poco diferente ahorró dos bytes, dejando suficiente espacio para otra iteración de #.

Obviamente, el verificador de tipos dejará de intentar verificar este programa. Para tener una idea general de cómo se vería la firma (si fuera lo suficientemente pequeña como para caber en el universo observable), pruebe el más pequeño

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

Explicación

La #familia tipográfica está estrechamente relacionada con la función Ackermann – Péter , comúnmente escrita como $A$ , pero #crece considerablemente más rápido. Se define la función Ackermann – Péter.

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

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

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

#, por otro lado, podemos llamar a $B$ y escribir

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

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

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

Solo el segundo caso es diferente. La prueba de terminación es idéntica a la estándar para $A$ , y debe quedar claro que $B(m,n) \ge A(m,n)$ para todo $m$ y $n$ .

Aquí calculamos una representación unaria de

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

Por cálculo directo, $B(B(B(B(0,0),0),0),0)=220$ , entonces

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

Tenga en cuenta que $A(A(A(A(0,0),0),0),0)$ es solo $5$ , por lo que hemos mejorado un poco para comenzar. No tengo una idea muy clara de cuánto más rápido crece $B$ que $A$ , pero teniendo en cuenta cómo procede el cálculo, es probable que crezca mucho más rápido.

El número de dígitos incluso en $A(6,0)$ es demasiado grande para expresarse prácticamente en decimal, así que esto es ... bastante ridículamente grande.

La definición de los números naturales (?), es un poco no estándar. Para ahorrar espacio, utilizamos (?)tanto un tipo de número natural (en el nivel de tipo) como un tipo de proxy (en el nivel de término).

Creo que uno TypeFamilieso (de manera más vergonzosa y ofuscada) FunctionalDependenciesson necesarios para obtener el cálculo de nivel de tipo requerido para alcanzar tipos realmente grandes. UndecidableInstanceses necesario para evitar la comprobación de terminación muy primitiva de Haskell. Las otras extensiones solo son necesarias para comprimir el código en el pequeño espacio disponible.

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

Una mejora pequeña ("pequeña") sobre los 5⋅2 ²⁶²¹⁴⁴ + 5 de xnor . Esto es 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

Cómo funciona

Tenemos

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

y así sucesivamente, con una longitud que se duplica aproximadamente para cada uno (:). La expresión dada o.o.ofunciona (:).(:).(:).….(:)con 2 · 4 ⁶ · 3 ⁴ = 663552 copias de(:) .

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

Una pequeña mejora con respecto a Bubbler's 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 - 4 ≈ 1.36 · 10 ¹⁹⁹⁷⁵⁰ , que también se basa en estas extensiones. La redacción del desafío sugiere que podría estar bien confiar en ellos ("Por ejemplo, Num [a]y Eq [a]están permitidos, incluso sin una instancia definida"); No estoy seguro. Esto es 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

Cómo funciona

Tenemos

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

y así sucesivamente, con la longitud aproximadamente cuadruplicando para cada uno (/).(:). La expresión dada -o.o.ofunciona -(/).(:).(/).(:).….(/).(:)con 4 ⁶ · 3 ⁴ = 331776 copias de (/).(:).

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

Otra pequeña mejora sobre la respuesta de 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

Cómo funciona

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

Acaba de cambiar la composición de la función (.)a la división fraccional (/). La Fractional xparte en la firma de la función explota junto con la parte principal, dando un multiplicador constante ligeramente más 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 tiene 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, no competitivo

Yo apenas no puedo conseguir esto bajo 100 bytes, pero está tan cerca que pensé que podría publicar de todos modos, con la esperanza de que alguien ve a una optimización.

Este es el prólogo, que cuesta 93 bytes:

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

Y la expresión, 9 bytes:

A<9>::T()

Para ilustrar:

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

Aproximadamente doblando cada vez que aumenta el número.

C #, 363

Expresión:

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

Firma de tipo:

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

Pruébalo en línea!

Ir 1.0 sin reflect, 98

Los tipos Go 1.x están definidos estáticamente. Aquí está mi primer intento:

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

En el patio de juegos Go :

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

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

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

Ir 1.9 usando alias de 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{}

En el patio de juegos 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)
}

Resultado:

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

Ir 1 usando reflect, 65532

Hay un límite en el paquetereflect sobre la longitud de los nombres de tipo:len(name) <= 1<<16-1

Hasta ahora he podido alcanzar un nombre de tipo de 65532 bytes con este bloque:

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

Código completo en el patio de juegos 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

Explicación:

Estamos definiendo una función f, calcular un tipo f (0) es solo el tipo de unidad, mientras que f (S (n)) calcula el tipo de igualdad aplicado al argumento de la función "hipered" por sí mismo y a f aplicado a n . La última línea es básicamente una función que espera un valor de un tipo como (27 = (4 = (2 = (1 = ()))))) (para n = 4).

Ejemplo simple

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

Haskell, 782

Expresión:

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

Firma de tipo:

:: (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

Ceilán, 38843546786070481 (~ 4 · 10 ¹⁶ )

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

Son 49 tuplas anidadas, con una tupla vacía en el interior. El nombre corto de este tipo es en realidad el mismo que el valor en este caso, pero el nombre completamente expandido es mucho más largo.

El compilador de Ceilán funciona para siempre al intentar compilar esto (el compilador seguía ejecutándose después de 180 minutos). Tendré que intentar calcular la longitud de tipo teórica.

El problema aquí es que un tipo de tupla de un elemento [X]está realmente representado en el sistema de tipos de Ceylon como Tuple<X, X, []>(el primer parámetro es un supertipo para todos los tipos de elementos, el segundo es el tipo del primer elemento y el tercero el tipo de todos excepto los primeros elementos) , que aquí es una tupla vacía (el emptyobjeto, la instancia única que satisface la interfazEmpty )).

Entonces []es empty, [[]]es Tuple<[], [], []>= Tuple<empty, empty, empty>, [[[]]]es Tuple<[[]], [[]], []>= Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []>. Y el nombre completo incluye los nombres de los paquetes, por lo que en realidad 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 tenemos tres niveles. Y queremos ir a los 50.

Como ceylon.language::emptytiene 22 caracteres de largo, y cada uno ceylon.language::Tuple<?,?,ceylon.language::empty>agrega 47 al doble del resultado del paso anterior, obtenemos f(1) = 22, y f(n) = 2 · f(n-1) + 47. Esto se simplifica f(n) = 69 · 2^(n - 1) - 47, y al ingresar 50 nos da 38843546786070481. Por supuesto, esto es mucho más grande de lo que cabría en la memoria de mi computadora (8 · 10 ⁹ bytes).

Por supuesto, el compilador podría ser inteligente y no tratar de tener el nombre completo del tipo en la memoria hasta que se solicite su nombre.

Aquí está el programa completo tratando de imprimir el tipo:

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

C # (compilador interactivo de Visual C #) , 99 bytes, puntaje 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))))))))))))))))))))))))

Pruébalo en línea!

Salidas

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