Hacer una firma tipo larga

23

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)]
Michael Klein
fuente
Relacionados . Pensé que había un engaño casi exacto, pero no lo he encontrado.
Peter Taylor
2
Sospecho que un idioma con mecanografía dependiente puede hacer una firma de tipo de la longitud de cualquier cantidad de cómputo.
xnor
@xnor Como los sistemas de tipos pueden estar completos ( stackoverflow.com/a/4047732/5154287 ), supongo que se convierte en un problema de castores más ocupado. ¿Debo editar las etiquetas?
Michael Klein

Respuestas:

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

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

xnor
fuente
2
El enfoque clásico, pero creo que los parámetros se pueden ajustar mejor. Específicamente, creo que f x=(x,x,x)al costo de uno n.en la última línea da el puntaje óptimo para esta estructura general.
Peter Taylor
No conozco a Haskell, así que podría estar fuera de la base aquí, pero señalaré que 4 ^ (4 ^ 4) es menor que 3 ^ (4 ^ 5)
Sparr
Estoy bastante seguro de que el cuarto n.va a ser más grande. 2^18vs a 3 * (2^16)menos que haya cometido un error al calcular la exponenciación original: 2^(4^9)vs.3^((4^8)*3)
Draco18s
No, @PeterTaylor es correcto: 2 ^ (4 ^ 9) = 16 ^ (4 ^ 8) <27 ^ (4 ^ 8) = 3 ^ (4 ^ 8 ⋅ 3).
Anders Kaseorg
(,)(o (,,)) se puede usar para guardar algunos bytes y mejorar la puntuación usando más ns.
ბიმო
11

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.

SuperJedi224
fuente
hmm dado que las lambdas están permitidas, esto probablemente obtendría una puntuación más alta
solo ASCII el
10

Haskell con extensiones, 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 UNA , pero #crece considerablemente más rápido. Se define la función Ackermann – Péter.

UNA(0 0,norte)=norte+1

UNA(metro,0 0)=UNA(metro-1,1) cuandometro>0 0

UNA(metro,norte)=UNA(metro-1,UNA(metro,norte-1)) cuandometro,norte>0 0

#, por otro lado, podemos llamar a si y escribir

si(0 0,norte)=norte+1

si(metro,0 0)=si(metro-1,metro) cuandometro>0 0

si(metro,norte)=si(metro-1,si(metro,norte-1)) cuandometro,norte>0 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)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 UNA(UNA(UNA(UNA(0 0,0 0),0 0),0 0),0 0) es solo 5 5 , por lo que hemos mejorado un poco para comenzar. No tengo una idea muy clara de cuánto más rápido crece si que UNA , 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 UNA(6 6,0 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.

dfeuer
fuente
Uno más#Z
Ørjan Johansen
@ ØrjanJohansen, ¿está apilando Zs en la parte delantera mejor que comenzar S(S Z)#S Z, o lo mismo?
dfeuer
De cualquier manera, el extra #Zal final es bienvenido.
dfeuer
1
Es exactamente el mismo valor, pero guarda un byte y al cambiar el tipo de datos a ?otro, deja espacio para el extra #Z.
Ørjan Johansen
1
Cuando estaba editando por primera vez, descubrí que A(m,1)nunca era más grande A(A(m,0),0)y estaba a punto de comentarlo, pero luego se optimizó hasta el punto en que las opciones eran iguales. (También m+1nunca es más grande que A(m,0).)
Ørjan Johansen
9

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

Una mejora pequeña ("pequeña") sobre los 5⋅2 262144 + 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 6 · 3 4 = 663552 copias de(:) .

Haskell con FlexibleContextsy NoMonomorphismRestriction, (200 · 4 331776 + 75 · 331776 + 16) / 9 ≈ 2.53 · 10 199750

Una pequeña mejora con respecto a Bubbler's 12 · 2 663552 + 9 · 663552 - 4 ≈ 1.36 · 10 199750 , 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 6 · 3 4 = 331776 copias de (/).(:).

Anders Kaseorg
fuente
7

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

Bubbler
fuente
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 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)
LegionMammal978
fuente
1
979 33554438 58640620148060 esto parece una entrada OEIS ridícula. posiblemente los mayores cambios de magnitud que he visto en una entrada de PPCG que se está refinando.
Sparr
5

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.

orlp
fuente
Me parece recordar que hubo algunas versiones muy antiguas (¿pre-estándar?) De C ++ que usaban la palabra clave en classlugar de typename. Me pregunto si hay un compilador en algún lugar que aún sea compatible con esa redacción para la compatibilidad con versiones anteriores.
4

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!

Solo ASCII
fuente
1

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


Notas: x:=nunca se cuenta.

dolmen
fuente
no válido, la reflectimportación debería contarse
solo ASCII
3403?
Solo ASCII
3685
Solo ASCII
65535
Solo ASCII
1

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 = ()))))
Mega Man
fuente
1
Realmente no conozco a Idris, pero creo que esto puede fallar en un tecnicismo: se supone que debes maximizar la longitud de la firma de tipo de una expresión, no la longitud de su valor. ¿No es justo el tipo de firma de su expresión final :Type?
Ørjan Johansen
¿Qué quieres decir con un número inconfundible ? No estoy familiarizado con hyper; ¿Podrías explicar?
dfeuer
@ ØrjanJohansen Oh, sí, solo arreglé eso y apliqué algunos cambios más
Mega Man
1
(0) La explicación parece estar un poco retrasada. (1) Esto es solo 98 bytes ahora. (2) Dado que el primer argumento de hyperse amplifica enormemente más que el resto, creo que quiere que todos / la mayoría de esos 99s sean 9s. (3) Asumiendo que Idris $funciona como Haskell, el conjunto externo de paréntesis después f$es redundante. (4) ¿Podría abreviar hypero requeriría una firma de tipo en sí misma?
Ørjan Johansen
1
@dfeuer en.wikipedia.org/wiki/Hyperoperation ( La definición de Idris es una traducción directa.)
Ørjan Johansen
0

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
Solo ASCII
fuente
Se convierte en 1814 caracteres con ghc 8.0.2, como el tipo de sumentonces es(Num a, Foldable t) => t a -> a
Mathieu CAROFF
0

Ceilán, 38843546786070481 (~ 4 · 10 16 )

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

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

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]]]]]]]]]]]]]]]]]]]]]]]]
Encarnación de la ignorancia
fuente