Faça uma assinatura de tipo longa

23

Desafio

Encontre uma expressão, no máximo 100 bytes, com a assinatura de tipo mais longa.

Regras

  • Qualquer idioma digitado estaticamente com inferência de tipo é permitido
  • O tipo deve ser não ambíguo, mas pode incluir tipos sem instâncias definidas. Por exemplo Num [a]e Eq [a]são permitidos, mesmo sem uma instância definida
  • Nenhuma importação além do mínimo necessário para compilar um programa com STDIN / STDOUT
  • Tipos infinitos não são permitidos
  • Se uma resposta tiver mais de uma expressão, apenas uma poderá contribuir para a pontuação. Por exemplo, embora a assinatura do tipo de composição seja (.) :: (b -> c) -> (a -> b) -> a -> c, com uma pontuação de 20, a resposta com 25 cópias de (.)\nteria uma pontuação de 20, e não 500
  • A expressão deve ter no máximo 100 bytes
  • A pontuação é o número de caracteres na assinatura do tipo, excluindo o nome da função e qualquer espaço em branco. Por exemplo, f :: (a -> b) -> a -> bteria uma pontuação de 12
  • A pontuação mais alta vence!

Exemplos

Embora outros idiomas sejam permitidos, os seguintes exemplos estão em 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
fonte
Relacionado . Eu achava que havia um engano quase exato, mas não o encontrei.
Peter Taylor
2
Eu suspeito que um idioma com digitação dependente possa fazer uma assinatura de tipo com o comprimento de qualquer número de lata de computação.
xnor 12/02
@xnor Como os sistemas de tipos em si podem estar completos ( stackoverflow.com/a/4047732/5154287 ), acho que se torna mais um problema de castor ocupado. Devo editar as tags?
Michael Klein

Respostas:

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 aplicativo fdobra aproximadamente a assinatura de tipo, transformando a assinatura de tipo Tem (T,T). Por exemplo, a composição quádrupla f.f.f.f$0tem o tipo

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

Cada linha quadruplica o número de aplicações de f, dando 4^9 = 2^18no final. Portanto, a assinatura do tipo tem tamanho da ordem de 2^(2^18).

xnor
fonte
2
A abordagem clássica, mas acho que os parâmetros podem ser melhor ajustados. Especificamente, acho que f x=(x,x,x), ao custo de um n.na última linha, obtemos a pontuação ideal para essa estrutura geral.
Peter Taylor
Eu não sei Haskell, para que eu pudesse estar fora da base aqui, mas vou salientar que 4 ^ (4 ^ 4) é inferior a 3 ^ (4 ^ 5)
Sparr
Tenho certeza que o quarto n.será maior. 2^18vs, a 3 * (2^16)menos que eu tenha cometido um erro ao calcular a exponenciação original: 2^(4^9)vs3^((4^8)*3)
Draco18s 12/02/16
Não, @PeterTaylor está correto: 2 ^ (4 ^ 9) = 16 ^ (4 ^ 8) <27 ^ (4 ^ 8) = 3 ^ (4 ^ 8 ⋅ 3).
Anders Kaseorg
(,)(ou (,,)) pode ser usado para salvar alguns bytes e melhorar a pontuação usando mais ns.
ბიმო
11

Java, pontuação 17301488

Requer o método <T>java.util.Map<T,T>f(T t){return null;}, que foi contado no limite de 100 bytes.

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

A assinatura do tipo em tempo de compilação disso deve corresponder a isso.

SuperJedi224
fonte
Hmm. como lambdas são permitidas, isso provavelmente obteria uma pontuação mais alta
somente ASCII
10

Haskell com extensões, 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)

Experimente online!

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

Muito obrigado a Ørjan Johansen, que percebeu que fazer o construtor de números naturais infixar e construir os argumentos um pouco diferentemente salvou dois bytes, abrindo espaço suficiente para outra iteração de #.

Obviamente, o verificador de tipos desistirá de tentar verificar este programa. Para ter uma idéia geral de como seria a assinatura (se ela fosse pequena o suficiente para caber no universo observável), tente o tamanho bem menor.

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

Explicação

A #família de tipos está intimamente relacionada à função Ackermann – Péter , comumente escrita A , mas #cresce consideravelmente mais rápido. A função Ackermann – Péter é definida

A(0,n)=n+1

A(m,0)=A(m1,1) quandom>0

A(m,n)=A(m1,A(m,n1))m,n>0

#B

B(0,n)=n+1

B(m,0)=B(m1,m)m>0

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

AB(m,n)A(m,n)mn

Aqui calculamos uma representação unária de

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

A(6,0)

A definição dos números naturais,, (?)é um pouco fora do padrão. Para economizar espaço, usamos (?)como um tipo de número natural (no nível do tipo) e um tipo de proxy (no nível do termo).

Acredito que TypeFamiliesou (de maneira mais detalhada e ofuscada) FunctionalDependenciessão necessários para obter a computação em nível de tipo necessária para alcançar tipos verdadeiramente grandes. UndecidableInstancesé necessário para solucionar a verificação de terminação muito primitiva de Haskell. As outras extensões são necessárias apenas para compactar o código no pequeno espaço disponível.

dfeuer
fonte
Mais um#Z
Ørjan Johansen 14/03
@ ØrjanJohansen, empilhar Zs na frente é melhor do que começar com S(S Z)#S Zo mesmo?
dfeuer 15/03
De qualquer forma, o extra #Zno final é bem-vindo.
dfeuer 15/03
1
É exatamente o mesmo valor, mas salva um byte e altera o tipo de dados para ?salvar o outro, deixando espaço para o extra #Z.
Ørjan Johansen
1
Enquanto você estava editando pela primeira vez, descobri que A(m,1)nunca era maior que A(A(m,0),0)e estava prestes a comentar sobre isso, mas então você acabou de otimizar até o ponto em que as opções eram iguais. (Também m+1nunca é maior que A(m,0).)
Ørjan Johansen 15/03
9

Haskell, 9 · 2 663552 - 3 ( ± 1,02 · 10 199750 )

Uma pequena ("pequena") melhoria em relação a 5n2 262144 + 5 do xnor . Isso é 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

Como funciona

Nós temos

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

e assim por diante, com o comprimento aproximadamente dobrando para cada um (:). A expressão fornecida o.o.ofunciona (:).(:).(:).….(:)com 2 · 4 6 · 3 4 = 663552 cópias de (:).

Haskell com FlexibleContextse NoMonomorphismRestriction, (200 · 4 331776 + 75 · 331776 + 16) / 9 ± 2,53 · 10 199750

Uma pequena melhoria em relação ao 12 · 2 663552 + 9 · 663552 - 4 × 1,36 · 10 199750 do Bubbler , que também se baseia nessas extensões. A redação do desafio sugere que pode ser bom confiar neles ("Por exemplo, Num [a]e Eq [a]são permitidos, mesmo sem uma instância definida"); Não tenho certeza. Isso é 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

Como funciona

Nós temos

-(/).(:) :: (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 assim por diante, com o comprimento quadruplicando para cada um (/).(:). A expressão dada -o.o.ofunciona -(/).(:).(/).(:).….(/).(:)com 4 6 · 3 4 = 331776 cópias de (/).(:).

Anders Kaseorg
fonte
7

Haskell, 12 · 2 663552 + 9 · 663552 - 4

Mais uma pequena melhoria em relação à resposta 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

Como 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

Apenas alterei a composição da função (.)para divisão fracionária (/). A Fractional xparte na assinatura da função explode junto com a parte principal, resultando em um multiplicador constante um pouco maior.

Bubbler
fonte
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 tem a assinatura:

int(*)(int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,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
fonte
1
979 33554438 58640620148060 isso parece uma entrada ridícula do OEIS. possivelmente as maiores mudanças de magnitude que eu já vi em uma entrada do PPCG sendo refinadas.
Sparr
5

C ++ 11, não-concorrente

Eu mal consigo obter isso abaixo de 100 bytes, mas é tão próximo que achei que poderia postá-lo de qualquer maneira, na esperança de que alguém visse uma otimização.

Este é o prólogo, custando 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)

E a expressão, 9 bytes:

A<9>::T()

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

Dobrar praticamente toda vez que o número aumenta.

orlp
fonte
Eu me lembro que havia algumas versões muito antigas (pré-padrão?) Do C ++ que usavam a palavra-chave em classvez de typename. Gostaria de saber se existe um compilador por aí em algum lugar que ainda suporta esse fraseado para compatibilidade com versões anteriores?
4

C #, 363

Expressão:

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

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

Experimente online!

Somente ASCII
fonte
1

Go 1.0 sem reflect, 98

Os tipos Go 1.x são definidos estaticamente. Aqui está minha primeira tentativa:

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

Parque infantil On the Go :

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

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

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

Vá 1.9 usando aliases 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{}

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

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

Vá 1 usando reflect, 65532

um limite no pacotereflect para o tamanho dos nomes dos tipos:len(name) <= 1<<16-1

Consegui alcançar um nome de tipo de 65532 bytes até agora com este bloco:

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

Código completo no playground 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 é contado.

dolmen
fonte
inválida, a reflectimportação precisaria ser contada
somente ASCII
3403?
somente ASCII
3685
somente ASCII
65535
somente 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

Explicação:

Estamos definindo uma função f, computando um tipo f (0) é apenas o tipo de unidade, enquanto f (S (n)) calcula o tipo de igualdade aplicado ao argumento da função "hypered" por si só e f aplicado a n . A última linha basicamente é uma função que espera um valor de um tipo como (27 = (4 = (2 = (1 = ())))))) (para n = 4).

Exemplo Simples

f 3 = (27 = (4 = (2 = (1 = ()))))
Mega Man
fonte
1
Realmente não conheço Idris, mas acho que isso pode falhar em um detalhe técnico: você deve maximizar o tamanho da assinatura de tipo de uma expressão, não o tamanho de seu valor. A assinatura de tipo da sua expressão final não é justa :Type?
Ørjan Johansen
O que você quer dizer com número incontestável ? Eu não estou familiarizado com hyper; você poderia explicar?
dfeuer 25/03
@ ØrjanJohansen Ah, sim, apenas consertei isso e apliquei mais algumas alterações
Mega Man
1
(0) A explicação parece um pouco demorada. (1) Agora são apenas 98 bytes. (2) Como o primeiro argumento de hyperé amplificado enormemente mais do que o resto, acho que você deseja que todos / a maioria desses 99s sejam 9s. (3) Assumindo os $trabalhos de Idris como os de Haskell, o conjunto externo de parênteses depois f$é redundante. (4) Você poderia abreviar hyperou isso exigiria uma assinatura de tipo?
Ørjan Johansen
1
@dfeuer pt.wikipedia.org/wiki/Hiperoperação ( A definição de Idris é uma tradução direta.)
Ørjan Johansen 25/03
0

Haskell, 782

Expressão:

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

Assinatura 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
Somente ASCII
fonte
Torna-se 1814 caracteres com ghc 8.0.2, como o tipo de sumentão é(Num a, Foldable t) => t a -> a
Mathieu CAROFF
0

Ceilão, 38843546786070481 (~ 4 · 10 16 )

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

São 49 tuplas aninhadas, com uma tupla vazia mais interna. O nome abreviado desse tipo é realmente o mesmo que o valor nesse caso, mas o nome totalmente expandido é muito mais longo.

O compilador Ceylon está funcionando para sempre ao tentar compilar isso (o compilador ainda estava em execução após 180 minutos) - vou ter que tentar calcular o tamanho do tipo teórico.

O problema aqui é que um tipo de tupla de um elemento [X]é realmente representado no sistema de tipos do Ceilão como Tuple<X, X, []>(o primeiro parâmetro é um supertipo para todos os tipos de elementos, o segundo é o tipo do primeiro elemento e o terceiro o tipo de todos, exceto os primeiros elementos , que aqui é uma tupla vazia (o emptyobjeto, a instância única que satisfaz a interface Empty)).

Então []é empty, [[]]é Tuple<[], [], []>= Tuple<empty, empty, empty>, [[[]]]é Tuple<[[]], [[]], []>= Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []>. E o nome completo inclui os nomes dos pacotes, portanto, temos 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>apenas três níveis. E nós queremos ir para 50.

Com ceylon.language::empty22 caracteres e cada um ceylon.language::Tuple<?,?,ceylon.language::empty>adiciona 47 a duas vezes o resultado da etapa anterior, obtemos f(1) = 22, e f(n) = 2 · f(n-1) + 47. Isso simplifica f(n) = 69 · 2^(n - 1) - 47e a inserção de 50 fornece 38843546786070481. É claro que isso é muito maior do que o que caberia na memória do meu computador (8,10 9 bytes).

Obviamente, o compilador pode ser inteligente e não tentar ter o nome do tipo inteiro na memória até que seu nome seja solicitado.

Aqui está o programa completo tentando imprimir o tipo:

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

C # (compilador interativo do Visual C #) , 99 bytes, pontuação 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))))))))))))))))))))))))

Experimente online!

Saídas

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]]]]]]]]]]]]]]]]]]]]]]]]
Modalidade de ignorância
fonte