进行长型签名

23

挑战

查找最长具有100个字节且类型签名最长的表达式。

规则

  • 允许任何具有类型推断的静态类型语言
  • 该类型必须是无歧义的，但否则可能包括没有定义实例的类型。例如Num [a]和Eq [a]是允许的，即使没有定义的实例
  • 除了使用STDIN / STDOUT编译程序所需的最低要求外，没有其他导入
  • 不允许无限类型
  • 如果一个答案有多个表达，则只有一个可以参与评分。例如，尽管composition的类型签名为(.) :: (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)]
code-challenge  busy-beaver  functional-programming 
— 迈克尔·克莱因
source
相关的。我确实认为有一个几乎完全是骗子，但我没有找到它。
— 彼得·泰勒
2
我怀疑具有依赖类型的语言可以使任何数量的can计算长度的类型签名。
— xnor
@xnor由于类型系统本身可能正在完善（stackoverflow.com/a/4047732/5154287），所以我认为这将成为一个越来越繁忙的海狸问题。我应该编辑标签吗？
— Michael Klein '02

Answers:

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

每个应用程序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)。

— 异或
source
2
这是经典方法，但是我认为可以更好地调整参数。具体而言，我认为f x=(x,x,x)以n.最后一行的代价为总体结构提供最佳分数。
— 彼得·泰勒，
我不认识Haskell，所以我可能不在这里，但我要指出4 ^（4 ^ 4）小于3 ^（4 ^ 5）
— Sparr
可以肯定的是第四个n.会更大。2^18vs，3 * (2^16)除非我在计算原始指数时出错：2^(4^9)vs.3^((4^8)*3)
— Draco18s
不，@ PeterTaylor是正确的：2 ^（4 ^ 9）= 16 ^（4 ^ 8）<27 ^（4 ^ 8）= 3 ^（4 ^ 8⋅3）。
— Anders Kaseorg
(,)（或(,,)）可用于节省一些字节并通过使用more来提高得分n。
— ბიმო
11

Java，得分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)))))))))))))))))))

此的编译时类型签名应与此匹配。

— 超级绝地224
source
嗯。由于允许使用lambda，这可能会获得更高的分数
— 仅ASCII的
10

Haskell中与扩展，⋙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。

非常感谢ØrjanJohansen，他意识到使自然数构造函数为infix并以不同的方式构建参数节省了两个字节，从而为的另一个迭代留出了足够的空间#。

显然，类型检查器将放弃尝试检查此程序的尝试。要大致了解签名的外观（如果签名足够小以适合可观察的宇宙），请尝试缩小签名

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

说明

该#类型的家庭密切相关的阿克曼彼得功能，通常写A，而是#相当快的增长。定义了Ackermann–Péter函数

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时））m,n>0

#，另一方面，我们可以调用B并编写

B(0,n)=n+1

B(m,0)=B(m−1,m)当 m > 0时 m ）m>0

B(m,n)=B(m−1,B(m,n−1))当 m ，n > 0时 B （m ，n ）= B （m − 1 ，B （m ，n − 1 ））m,n>0

仅第二种情况不同。终止证明是相同的标准之一A，并且应该清楚的是，B(m,n)≥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，但是考虑到计算的进行方式，它的增长速度似乎可能要快得多。

偶数位数 A(6,0)太大，十进制实际表现，所以这是...相当大的离谱。

自然数的定义(?)有点不规范。为了节省空间，我们(?)同时使用自然数类型（在类型级别）和代理类型（在术语级别）。

我相信，要么获得TypeFamilies（要么更冗长和模糊不清）要么，要么获得（达到冗长和混淆），要么FunctionalDependencies达到真正的大类型就需要进行类型级别的计算。UndecidableInstances需要解决Haskell非常原始的终止检查。其他扩展仅需要将代码压缩到较小的可用空间中。

— dfeuer
source
— 与Orjan约翰森
@ØrjanJohansen，将Zs 堆在前面比以开头S(S Z)#S Z还是一样好？
— dfeuer
无论哪种方式，最后的额外内容#Z都是最受欢迎的。
— dfeuer
1
它是完全相同的值，但保存一个字节，将数据类型更改为保存另一个字节，?为多余的空间留出了余地#Z。
— 与Orjan约翰森
1
在您进行第一次编辑时，我发现A(m,1)它从来没有大于A(A(m,0),0)，并打算对此进行评论，但是随后您就进行了优化，使选项相等。（也m+1永远不会比A(m,0)。）
— ØrjanJohansen
9

Haskell，9·2 663552-3（≈1.02 ·10 199750）

比xnor的5⋅2小（“小”）改进 262144 + 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 6 ·3 4 = 663552的副本(:)。

Haskell与FlexibleContexts和NoMonomorphismRestriction，（200·4 331776 + 75·331776 + 16）/ 9≈2.53·10 9≈2.53 199750

对Bubbler的12·2 663552 + 9·663552 − 4≈1.36 ·10 199750进行了小幅改进，后者也依赖于这些扩展。挑战之类的措辞表明，它可能是正确的依靠他们（“例如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 6 ·3 4 = 331776个副本(/).(:)。

— 安德斯·卡塞格（Anders Kaseorg）
source
7

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

与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

怎么运行的

(/) -- 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函数签名中的部分与主要部分一起爆炸，从而提供了更高的常数乘数。

— 起泡器
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 具有签名：

int(*)(int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int,int)
— 军团哺乳动物978
source
1
979 33554438 58640620148060这看起来像是一些荒谬的OEIS条目。可能是我在PPCG条目中所见过的最大幅度的变化。
— Sparr
@Sparr，您还没看到
— 猫
5

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

每次增加时，大约增加一倍。

— 奥尔普
source
我似乎记得有一些使用关键字class而不是的非常老的（标准前？）C ++版本typename。我想知道是否有某个编译器仍然支持向后兼容的措辞？
4

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

在线尝试！

— 仅ASCII
source
1

Go 1.0不带reflect，98

Go 1.x类型是静态定义的。这是我的第一次尝试：

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

在“去”操场上：

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

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

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

使用类型别名2389转到1.9

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

在“去”操场上：

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

使用1 reflect，转到65532

有封装的限制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)
}

注意：x:=永不计算在内。

— 都尔门
source
无效，reflect需要计算导入次数
— （仅ASCII）
— –仅限ASCII
— 仅限ASCII
— 仅限ASCII
1

Idris，> hyper（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

说明：

我们正在定义一个函数f，计算类型f（0）只是单位类型，而f（S（n））则计算自身应用于函数参数“ hypered”的相等类型以及应用于n的f 。最后一行基本上是一个函数，期望值的类型为（27 =（4 =（2 =（1 =（））））））））（对于n = 4）。

简单的例子

f 3 = (27 = (4 = (2 = (1 = ()))))
— 洛克人
source
1
我并不是很了解Idris，但是我认为这可能在技术上会失败：您应该最大化表达式的类型签名的长度，而不是其值的长度。您的最终表达式的类型签名不就是:Type吗？
— 与Orjan约翰森
你说的一个不可计算的意思号？我不熟悉hyper; 你能解释一下吗？
— dfeuer
@ØrjanJohansen哦，是的，只是解决了这个问题，然后应用了一些更改
— Mega Man
1
（0）解释似乎有点滞后。（1）现在只有98个字节。（2）由于第一个参数hyper被大大超过其余放大，我想你想全部/大部分那些99使他能9秒。（3）假设Idris的$作品像Haskell 的作品一样，后面的括号f$是多余的。（4）您可以缩写hyper吗，或者本身需要类型签名？
— 与Orjan约翰森
1
— 与Orjan约翰森
0

哈斯克尔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
— 仅ASCII
source
用ghc 8.0.2变成1814个字符，因为当时的类型sum是(Num a, Foldable t) => t a -> a
— Mathieu CAROFF
0

锡兰，38843546786070481（〜4·10 16）

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

这是49个嵌套的单元组，最里面是一个空的元组。这种类型的简称实际上与这种情况下的值相同，但是完全扩展的名称要长得多。

尝试编译时，Ceylon编译器将永远工作（编译器在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 9字节）。

当然，编译器可能很聪明，在请求其名称之前，不要尝试将整个类型名称存储在内存中。

这是尝试打印类型的完整程序：

import ceylon.language.meta {
    type
}
"Run the module `codegolf.signature71797`."
shared void run() {
    value x = [[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]];
    print(type(x));
}
— 帕洛·埃伯曼
source
0

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]]]]]]]]]]]]]]]]]]]]]]]]
— 无知的体现
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.