Вызов

Найдите выражение длиной не более 100 байт с самой длинной сигнатурой типа.

правила

• Разрешен любой статически типизированный язык с выводом типа
• Тип должен быть однозначным, но в противном случае он может включать типы без определенных экземпляров. Например Num [a]и Eq [a]разрешено, даже без определенного экземпляра
• Нет импорта, кроме минимума, необходимого для компиляции программы с STDIN / STDOUT
• Бесконечные типы не допускаются
• Если ответ имеет более одного выражения, только один может внести свой вклад в оценку. Например, хотя типовая сигнатура композиции (.) :: (b -> c) -> (a -> b) -> a -> c, имеющая оценку 20, ответ с 25 копиями (.)\nбудет иметь оценку 20, а не 500
• Выражение должно быть не более 100 байтов
• Оценка - это количество символов в сигнатуре типа, исключая имя функции и любые пробелы. Например, f :: (a -> b) -> a -> bбудет иметь оценку 12
• Самый высокий балл побеждает!

Примеры

Хотя допускаются и другие языки, в 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)]

Хаскелл, ~ 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

Каждое приложение fпримерно удваивает сигнатуру типа путем преобразования сигнатуры типа Tв (T,T). Например, четырехкратная композиция f.f.f.f$0имеет тип

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

Каждая строка в четыре раза превышает количество заявлений f, поданных 4^9 = 2^18в конце. Итак, подпись типа имеет размер порядка 2^(2^18).

Ява, оценка 17301488

Требуется метод <T>java.util.Map<T,T>f(T t){return null;}, который был посчитан до 100-байтового предела.

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

Подпись типа времени компиляции этого должна соответствовать этому.

$\ggg A(A(A(A(220,0),0),0),0)$

Z::Z#Z#Z#Z#Z#Z#Z#Z#Z?Z
data a?b=Z|S(a?b)
type family m#n where Z#n=S n;S m#Z=m#S m;S m#S n=m#(S m#n)

Попробуйте онлайн!

Требуется -XDataKinds, -XPolyKinds, -XTypeOperators, -XUndecidableInstances, и -XTypeFamilies.

Огромное спасибо Орджану Йохансену, который понял, что создание инфиксного конструктора натуральных чисел и построение аргументов немного по-другому сэкономили два байта, оставив достаточно места для еще одной итерации #.

Очевидно, что средство проверки типов перестанет пытаться проверить эту программу. Чтобы получить общее представление о том, как будет выглядеть подпись (если она достаточно мала, чтобы поместиться в наблюдаемую вселенную), попробуйте гораздо меньшую

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

объяснение

Семейство #типов тесно связано с функцией Аккермана – Петера , обычно пишется как , но растет значительно быстрее. Определена функция Аккермана – Петера$A$#

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

$A(m,0)=A(m-1,1)$ когда$m > 0$

$A(m,n)=A(m-1, A(m, n-1))$ когда$m, n > 0$

#с другой стороны, мы можем позвонить и написать$B$

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

$B(m,0)=B(m-1,m)$m > 0 когда$m > 0$

$B(m,n)=B(m-1, B(m, n-1))$m , n > 0 когда$m,n > 0$

Только второй случай отличается. Доказательство завершения идентично стандартному для , и должно быть ясно, что для всех и .$A$$B(m,n) \ge A(m,n)$$m$$n$

Здесь мы вычисляем унарное представление

$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)$$5$$B$$A$

Количество цифр в четном слишком велико, чтобы выразить его практически в десятичном виде, так что это ... довольно смехотворно большое.$A(6,0)$

Определение натуральных чисел (?)немного нестандартно. Для экономии места мы используем (?)как натуральный тип числа (на уровне типа), так и тип прокси (на уровне термина).

Я считаю, что либо TypeFamiliesили (более многословно и запутанно) FunctionalDependenciesнеобходимо, чтобы получить вычисления на уровне типов, необходимые для достижения действительно больших типов. UndecidableInstancesнеобходимо обойти очень примитивную проверку завершения Haskell. Другие расширения нужны только для сжатия кода в небольшое доступное пространство.

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

Небольшое («маленькое») улучшение по сравнению с xnor's 5⋅2 ²⁶²¹⁴⁴ + 5 . Это 99 байтов.

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

Как это работает

У нас есть

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

и так далее, длина которых примерно удваивается для каждого (:). Данное выражение o.o.oотработано (:).(:).(:).….(:)с 2 · 4 ⁶ · 3 ⁴ = 663552 копий (:).

Haskell с FlexibleContextsи NoMonomorphismRestriction, (200 · 4 ³³¹⁷⁷⁶ + 75 · 331776 + 16) / 9 ≈ 2,53 · 10 ¹⁹⁹⁷⁵⁰

Небольшое улучшение по сравнению с Bubbler 12 · 2 ⁶⁶³⁵⁵² + 9 · 663552 - 4 ≈ 1,36 · 10 ¹⁹⁹⁷⁵⁰ , которое также опирается на эти расширения. Формулировка вызова предполагает, что можно полагаться на них («Например, Num [a]и Eq [a]разрешено, даже без определенного экземпляра»); Я не уверен. Это 100 байт.

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

Как это работает

У нас есть

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

и так далее, с длиной примерно в четыре раза для каждого (/).(:). Данное выражение -o.o.oработает -(/).(:).(/).(:).….(/).(:)с 4 ⁶ · 3 ⁴ = 331776 копий (/).(:).

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

Еще одно небольшое улучшение по сравнению с ответом Андерса Касерга .

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

Как это работает

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

Только что изменили состав функции (.)на дробное деление (/). Fractional xЧасть в функции подписи взрывается вместе с основной частью, давая немного более высокий постоянный множитель.

С, 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 имеет подпись:

int(*)(int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int)

C ++ 11, неконкурентный

Я едва могу получить это меньше 100 байт, но это настолько близко, что я решил, что мог бы опубликовать это в любом случае, в надежде, что кто-то заметит оптимизацию.

Это пролог стоимостью 93 байта:

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

И выражение, 9 байтов:

A<9>::T()

Проиллюстрировать:

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

Приблизительно удваивается каждый раз, когда число увеличивается.

C #, 363

Выражение:

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

Тип подписи:

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

Попробуйте онлайн!

Go 1.0 без reflect, 98

Типы Go 1.x определены статически. Вот моя первая попытка:

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

На игровой площадке Go :

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

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

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

Перейти 1.9 с использованием псевдонимов типа, 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{}

На игровой площадке 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)
}

Результат:

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 с помощью reflect65532

В пакете есть ограничениеreflect на длину имен типов:len(name) <= 1<<16-1

Мне удалось достичь имени типа 65532 байта с этим блоком:

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

Полный код на игровой площадке 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)
}

Идрис,> гипер (гипер (гипер (гипер (гипер (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

Объяснение:

Мы определяем функцию f, вычисляя тип f (0) - это просто тип модуля, в то время как f (S (n)) вычисляет тип равенства, примененный к аргументу функции, «раздутому» сам по себе, и к f, примененному к n , Последняя строка в основном представляет собой функцию, ожидающую значение типа (27 = (4 = (2 = (1 = ()))))) (для n = 4).

Простой пример

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

Хаскелл, 782

Выражение:

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

Тип подписи:

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

Цейлон, 38843546786070481 (~ 4 · 10 ¹⁶ )

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

Это 49 вложенных одн кортежей, с пустым кортежем внутри. Краткое имя этого типа фактически совпадает со значением в этом случае, но полностью развернутое имя намного длиннее.

Цейлонный компилятор работает вечно, пытаясь скомпилировать это (компилятор все еще работал через 180 минут) - мне придется попытаться вычислить теоретическую длину типа.

Проблема здесь состоит в том, что тип с одним элементом-кортежем [X]фактически представлен в системе типов Цейлона как Tuple<X, X, []>(первый параметр - супертип для всех типов элементов, второй - тип первого элемента, и третий - тип всех, кроме первых элементов , который является здесь пустым кортежем ( emptyобъект, единственный экземпляр, удовлетворяющий интерфейсу Empty)).

Так []есть empty, [[]]есть Tuple<[], [], []>= Tuple<empty, empty, empty>, [[[]]]есть Tuple<[[]], [[]], []>= Tuple<Tuple<[], [], []>, Tuple<[], [], []>, []>. И полное имя включает в себя имена пакетов, поэтому мы имеем на самом деле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> всего три уровня. И мы хотим перейти на 50.

Поскольку ceylon.language::emptyдлина составляет 22 символа, и каждый ceylon.language::Tuple<?,?,ceylon.language::empty>добавляет 47 к удвоенному результату предыдущего шага, мы получаем f(1) = 22, и f(n) = 2 · f(n-1) + 47. Это упрощает f(n) = 69 · 2^(n - 1) - 47, и ввод 50 дает нам 38843546786070481. Конечно, это намного больше, чем то, что уместилось бы в памяти моего компьютера (8 · 10 ⁹ байт).

Конечно, компилятор может быть умным и не пытаться хранить полное имя типа в памяти, пока не будет запрошено его имя.

Вот полная программа, пытающаяся напечатать тип:

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

C # (интерактивный компилятор Visual C #) , 99 байт, оценка 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))))))))))))))))))))))))

Попробуйте онлайн!

Выходы

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