Crea una firma di tipo lungo


23

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

Correlato . Pensavo che ci fosse un duplicato quasi esatto, ma non l'ho trovato.
Peter Taylor,

2
Ho il sospetto che una lingua con la digitazione dipendente possa fare una firma del tipo della lunghezza di qualsiasi numero di può calcolare.
xnor

@xnor Dato che i sistemi di tipi stessi potrebbero essere completi ( stackoverflow.com/a/4047732/5154287 ), immagino che allora diventi più un problema di castori. Devo modificare i tag?
Michael Klein,

Risposte:


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

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


2
L'approccio classico, ma penso che i parametri possano essere sintonizzati meglio. In particolare, penso che f x=(x,x,x)al costo di uno n.nell'ultima riga dia il punteggio ottimale per questa struttura generale.
Peter Taylor,

Non conosco Haskell, quindi potrei essere fuori base qui, ma farò notare che 4 ^ (4 ^ 4) è inferiore a 3 ^ (4 ^ 5)
Sparr,

Abbastanza sicuro che il 4 ° n.sarà più grande. 2^18vs a 3 * (2^16)meno che non abbia fatto un errore nel calcolo dell'espiazione originale: 2^(4^9)vs.3^((4^8)*3)
Draco18s

No, @PeterTaylor è corretto: 2 ^ (4 ^ 9) = 16 ^ (4 ^ 8) <27 ^ (4 ^ 8) = 3 ^ (4 ^ 8 ⋅ 3).
Anders Kaseorg,

(,)(o (,,)) può essere usato per salvare alcuni byte e migliorare il punteggio usando più ns.
ბიმო

11

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.


hmm. dato che i lambda sono ammessi, questo otterrebbe probabilmente un punteggio più alto
solo ASCII il

10

Haskell con estensioni, 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(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

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

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.



@ ØrjanJohansen, impilare Zs davanti è meglio che iniziare S(S Z)#S Z, o lo stesso?
Dfeuer

Ad ogni modo, il supplemento #Zalla fine è il benvenuto.
Dfeuer

1
È lo stesso valore esatto, ma salva un byte e modificando il tipo di dati per ?salvare l'altro, lasciando spazio per l'extra #Z.
Ørjan Johansen,

1
Mentre stavi modificando per la prima volta, ho scoperto che A(m,1)non è mai stato più grande di A(A(m,0),0), e stavo per commentarlo, ma poi ti sei appena ottimizzato al punto in cui le opzioni erano uguali. (Inoltre m+1non è mai più grande di A(m,0).)
Ørjan Johansen

9

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

Un piccolo ("piccolo") miglioramento rispetto a 5⋅2 262144 + 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 6 · 3 4 = 663552 copie di (:).

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

Un piccolo miglioramento rispetto a 12 · 2 663552 + 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 6 · 3 4 = 331.776 copie di (/).(:).


7

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


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

1
979 33554438 58640620148060 sembra una voce ridicola dell'OEIS. forse i più grandi cambiamenti di grandezza che abbia mai visto in una voce PPCG sono stati perfezionati.
Sparr,


5

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.


Mi sembra di ricordare che esistessero alcune versioni molto vecchie (pre-standard?) Di C ++ che utilizzavano la parola chiave classanziché typename. Mi chiedo se c'è un compilatore là fuori che supporti ancora quel fraseggio per compatibilità con le versioni precedenti?

4

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!


1

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


Note: x:=non viene mai conteggiato.


non valido, l' reflectimportazione dovrebbe essere contata
solo ASCII il




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

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

1
Non conosco davvero Idris, ma penso che questo potrebbe non funzionare a causa di un tecnicismo: dovresti massimizzare la lunghezza della firma del tipo di un'espressione, non la lunghezza del suo valore. La firma del tipo della tua espressione finale non è solo :Type?
Ørjan Johansen

Cosa intendi con un numero inestimabile ? Non ho familiarità hyper; potresti spiegare?
dfeuer

@ ØrjanJohansen Oh sì, l'ho appena risolto e applicato alcune altre modifiche
Mega Man

1
(0) La spiegazione sembra in ritardo. (1) Adesso sono solo 98 byte. (2) Poiché il primo argomento di hyperviene amplificato enormemente più degli altri, penso che tu voglia che tutti / la maggior parte di quelli 99siano 9. (3) Supponendo che le $opere di Idris come quelle di Haskell, l'insieme esterno di parentesi f$sia ridondante. (4) Potresti abbreviare hypero richiederebbe una firma del tipo?
Ørjan Johansen,


0

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

Diventa 1814 personaggi con ghc 8.0.2, come il tipo di sumallora è(Num a, Foldable t) => t a -> a
Mathieu CAROFF

0

Ceylon, 38843546786070481 (~ 4 · 10 16 )

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

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

0

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]]]]]]]]]]]]]]]]]]]]]]]]
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.