Faire une longue signature

23

Défi

Trouvez une expression, d'au plus 100 octets, avec la signature de type la plus longue.

Règles

  • Toute langue typée statiquement avec inférence de type est autorisée
  • Le type doit être non ambigu, mais peut autrement inclure des types sans instances définies. Par exemple Num [a]et Eq [a]sont autorisés, même sans instance définie
  • Aucune importation autre que le minimum requis pour compiler un programme avec STDIN / STDOUT
  • Les types infinis ne sont pas autorisés
  • Si une réponse a plus d'une expression, une seule peut contribuer au score. Par exemple, bien que le type de signature de la composition soit (.) :: (b -> c) -> (a -> b) -> a -> c, ayant un score de 20, la réponse avec 25 copies de (.)\naurait un score de 20, pas 500
  • L'expression doit être au maximum de 100 octets
  • Le score est le nombre de caractères dans la signature de type, à l'exclusion du nom de la fonction et des espaces. Par exemple, f :: (a -> b) -> a -> baurait un score de 12
  • Le score le plus élevé gagne!

Exemples

Bien que d'autres langues soient autorisées, les exemples suivants sont 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
la source
Connexes . Je pensais qu'il y avait une dupe presque exacte, mais je ne l'ai pas trouvée.
Peter Taylor
2
Je soupçonne qu'une langue avec une saisie dépendante peut faire une signature de type de la longueur d'un nombre quelconque de peut calculer.
xnor
@xnor Comme les systèmes de types eux-mêmes peuvent être complets ( stackoverflow.com/a/4047732/5154287 ), je suppose que cela devient alors un problème de castor très occupé. Dois-je modifier les balises?
Michael Klein

Réponses:

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

Chaque application fconsiste à doubler approximativement la signature de type en transformant la signature de type Ten (T,T). Par exemple, la composition quadruple f.f.f.f$0a le type

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

Chaque ligne quadruple le nombre d'applications de f, donnant 4^9 = 2^18à la fin. Ainsi, la signature de type a une taille de l'ordre de 2^(2^18).

xnor
la source
2
L'approche classique, mais je pense que les paramètres peuvent être mieux ajustés. Plus précisément, je pense qu'au f x=(x,x,x)prix d'un n.dans la dernière ligne donne le score optimal pour cette structure globale.
Peter Taylor
Je ne connais pas Haskell, donc je pourrais être hors de la base ici, mais je soulignerai que 4 ^ (4 ^ 4) est inférieur à 3 ^ (4 ^ 5)
Sparr
Je suis sûr que le 4e n.sera plus grand. 2^18vs 3 * (2^16)sauf si j'ai fait une erreur de calcul de l'exponentiation d'origine: 2^(4^9)vs3^((4^8)*3)
Draco18s
Non, @PeterTaylor est correct: 2 ^ (4 ^ 9) = 16 ^ (4 ^ 8) <27 ^ (4 ^ 8) = 3 ^ (4 ^ 8 ⋅ 3).
Anders Kaseorg
(,)(ou (,,)) peut être utilisé pour enregistrer certains octets et améliorer le score en utilisant plus de ns.
ბიმო
11

Java, score 17301488

Nécessite la méthode <T>java.util.Map<T,T>f(T t){return null;}, qui a été prise en compte dans la limite de 100 octets.

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

La signature de type à la compilation de ceci doit correspondre à ceci.

SuperJedi224
la source
hmm. puisque les lambdas sont autorisés, cela obtiendrait probablement un score plus élevé
ASCII uniquement
10

Haskell avec extensions, 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)

Essayez-le en ligne!

Nécessite -XDataKinds, -XPolyKinds, -XTypeOperators, -XUndecidableInstanceset -XTypeFamilies.

Un grand merci à Ørjan Johansen, qui a réalisé que rendre le constructeur de nombres naturels infixé et construire les arguments un peu différemment permettait d'économiser deux octets, ce qui laissait juste assez de place pour une autre itération de #.

De toute évidence, le vérificateur de type abandonnera la vérification de ce programme. Pour avoir une idée générale de ce à quoi ressemblerait la signature (si elle était suffisamment petite pour tenir dans l'univers observable), essayez la beaucoup plus petite

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

Explication

La #famille de types est étroitement liée à la fonction Ackermann – Péter , communément écrite A , mais #croît considérablement plus rapidement. La fonction Ackermann – Péter est définie

A(0,n)=n+1

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

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

#d'autre part, nous pouvons appeler B et écrire

B(0,n)=n+1

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

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

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

Ici, nous calculons une représentation unaire de

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

Par calcul direct, B(B(B(B(0,0),0),0),0)=220 , donc

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

A(A(A(A(0,0),0),0),0)5BA

A(6,0)

La définition des nombres naturels,, (?)est un peu non standard. Pour économiser de l'espace, nous utilisons (?)à la fois un type de nombre naturel (au niveau du type) et un type de proxy (au niveau du terme).

Je crois que l'un TypeFamiliesou l' autre (de façon plus verbeuse et plus obscure) FunctionalDependenciessont nécessaires pour obtenir le calcul de niveau requis pour atteindre des types vraiment grands. UndecidableInstancesest nécessaire pour contourner la vérification de terminaison très primitive de Haskell. Les autres extensions ne sont nécessaires que pour compresser le code dans le petit espace disponible.

dfeuer
la source
Un de plus#Z
Ørjan Johansen
@ ØrjanJohansen, est-il Zmieux de s'empiler à l'avant que de commencer S(S Z)#S Z, ou la même chose?
dfeuer
De toute façon, le supplément #Zà la fin est le bienvenu.
dfeuer
1
C'est exactement la même valeur mais enregistre un octet, et changer le type de données pour ?enregistrer l'autre, laissant de la place pour le supplément #Z.
Ørjan Johansen
1
Pendant que vous éditiez pour la première fois, j'ai découvert qu'il A(m,1)n'était jamais plus grand que A(A(m,0),0), et que j'étais sur le point de le remarquer, mais vous veniez juste d'optimiser au point où les options étaient égales. (Aussi m+1n'est jamais plus grand que A(m,0).)
Ørjan Johansen
9

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

Une petite ("petite") amélioration par rapport à 5⋅2 262144 + 5 de xnor . C'est 99 octets.

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

Comment ça marche

On a

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

et ainsi de suite, la longueur doublant à peu près pour chacun (:). L'expression donnée correspond o.o.oà (:).(:).(:).….(:)2 · 4 6 · 3 4 = 663552 copies de (:).

Haskell avec FlexibleContextset NoMonomorphismRestriction, (200 · 4 331776 + 75 · 331776 + 16) / 9 ≈ 2,53 · 10 199750

Une petite amélioration par rapport à Bubbler 12 · 2 663552 + 9 · 663552 - 4 ≈ 1,36 · 10 199750 , qui repose également sur ces extensions. Le libellé du défi suggère en quelque sorte qu'il pourrait être acceptable de se fier à eux («Par exemple Num [a]et Eq [a]sont autorisés, même sans une instance définie»); Je ne suis pas sûr. C'est 100 octets.

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

Comment ça marche

On a

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

et ainsi de suite, la longueur quadruplant à peu près pour chacun (/).(:). L'expression donnée correspond -o.o.oà -(/).(:).(/).(:).….(/).(:)4 6 · 3 4 = 331776 copies de (/).(:).

Anders Kaseorg
la source
7

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

Encore une petite amélioration par rapport à la réponse d'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

Comment ça marche

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

Je viens de changer la composition de la fonction (.)en division fractionnaire (/). La Fractional xpartie de la signature de fonction explose avec la partie principale, donnant un multiplicateur constant légèrement plus élevé.

Bubbler
la source
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 a la signature:

int(*)(int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,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
la source
1
979 33554438 58640620148060 cela ressemble à une entrée OEIS ridicule. peut-être les plus grands changements d'amplitude que j'ai jamais vus dans une entrée PPCG en cours de raffinement.
Sparr
@Sparr tu
cat
5

C ++ 11, non compétitif

Je n'arrive presque pas à obtenir moins de 100 octets, mais c'est si proche que je me suis dit que je pourrais le publier de toute façon, dans l'espoir que quelqu'un repère une optimisation.

Voici le prologue, qui coûte 93 octets:

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

Et l'expression, 9 octets:

A<9>::T()

Pour illustrer:

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

Doublement grossissant chaque fois que le nombre augmente.

orlp
la source
Il me semble que certaines versions très anciennes (pré-standard?) De C ++ utilisaient le mot-clé classplutôt que typename. Je me demande s'il y a un compilateur quelque part qui prend toujours en charge cette formulation pour une compatibilité descendante?
4

C #, 363

Expression:

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

Signature de type:

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

Essayez-le en ligne!

ASCII uniquement
la source
1

Go 1.0 sans reflect, 98

Les types Go 1.x sont définis statiquement. Voici mon premier essai:

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

Sur le terrain de jeu Go :

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

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

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

Go 1.9 à l'aide d'alias de type, 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{}

Sur le terrain de jeu 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)
}

Résultat:

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

Go 1 using reflect, 65532

Il y a une limite dans le packagereflect sur la longueur des noms de type:len(name) <= 1<<16-1

J'ai pu atteindre un nom de type de 65532 octets jusqu'à présent avec ce bloc:

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

Code complet sur le terrain de jeu 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)
}


Remarques: x:=n'est jamais compté.

dolmen
la source
invalide, l' reflectimportation devra être comptée
ASCII uniquement
3403?
uniquement en ASCII
3685
ASCII uniquement
65535
ASCII uniquement
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

Explication:

Nous définissons une fonction f, calculer un type f (0) n'est que le type d'unité, tandis que f (S (n)) calcule le type d'égalité appliqué à l'argument de fonction "hyperéxé" par lui-même et à f appliqué à n . La dernière ligne est une fonction qui attend une valeur d'un type comme (27 = (4 = (2 = (1 = ()))))) (pour n = 4).

Exemple simple

f 3 = (27 = (4 = (2 = (1 = ()))))
Mega Man
la source
1
Je ne connais pas vraiment Idris, mais je pense que cela peut échouer sur un plan technique: vous êtes censé maximiser la longueur de la signature de type d'une expression, pas la longueur de sa valeur. La signature de type de votre expression finale n'est-elle pas juste :Type?
Ørjan Johansen
Qu'entendez-vous par un nombre non calculable ? Je ne connais pas hyper; pourriez-vous expliquer?
dfeuer
@ ØrjanJohansen Oh oui, juste corrigé cela et appliqué quelques changements supplémentaires
Mega Man
1
(0) L'explication semble un peu en retard. (1) Il ne s'agit plus que de 98 octets. (2) Puisque le premier argument de hyperest amplifié beaucoup plus que les autres, je pense que vous voulez que tous / la plupart de ces 99s soient des 9s. (3) En supposant que les $travaux d'Idris comme Haskell, l'ensemble extérieur de parenthèses après f$est redondant. (4) Pourriez-vous abréger hyperou cela nécessiterait-il une signature de type elle-même?
Ørjan Johansen
1
@dfeuer en.wikipedia.org/wiki/Hyperoperation ( La définition Idris est une traduction directe.)
Ørjan Johansen
0

Haskell, 782

Expression:

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

Signature de type:

:: (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
ASCII uniquement
la source
Devient 1814 personnages avec ghc 8.0.2, comme c'est le cas sumalors(Num a, Foldable t) => t a -> a
Mathieu CAROFF
0

Ceylan, 38843546786070481 (~ 4 · 10 16 )

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

Il s'agit de 49 un-tuples imbriqués, avec un tuple vide à l'intérieur. Le nom court de ce type est en fait le même que la valeur dans ce cas, mais le nom entièrement développé est beaucoup plus long.

Le compilateur de Ceylan fonctionne pour toujours en essayant de compiler cela (le compilateur fonctionnait toujours après 180 minutes) - je vais devoir essayer de calculer la longueur théorique du type.

Le problème ici est qu'un type de tuple à un élément [X]est en fait représenté dans le système de types de Ceylan comme Tuple<X, X, []>(le premier paramètre est un supertype pour tous les types d'éléments, le deuxième est le type du premier élément, et le troisième le type de tous sauf les premiers éléments , qui est ici un tuple vide (l' emptyobjet, l'instance unique satisfaisant l'interface Empty)).

[]Est donc empty, [[]]est Tuple<[], [], []>= Tuple<empty, empty, empty>, [[[]]]est Tuple<[[]], [[]], []>= Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []>. Et le nom complet inclut les noms des packages, nous n'avons donc 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>que trois niveaux. Et nous voulons aller à 50.

Comme il ceylon.language::emptycontient 22 caractères, et chacun ceylon.language::Tuple<?,?,ceylon.language::empty>ajoute 47 au double du résultat de l'étape précédente, nous obtenons f(1) = 22, et f(n) = 2 · f(n-1) + 47. Cela simplifie f(n) = 69 · 2^(n - 1) - 47et la saisie de 50 nous donne 38843546786070481. Bien sûr, c'est beaucoup plus grand que ce qui tiendrait dans la mémoire de mon ordinateur (8 · 10 9 octets).

Bien sûr, le compilateur peut être intelligent et ne pas essayer d'avoir le nom de type entier en mémoire jusqu'à ce que son nom soit demandé.

Voici le programme complet essayant d'imprimer le type:

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

C # (Visual C # Interactive Compiler) , 99 octets, score 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))))))))))))))))))))))))

Essayez-le en ligne!

Les sorties

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]]]]]]]]]]]]]]]]]]]]]]]]
Incarnation de l'ignorance
la source