julia - Julia中自指代不可变类型的生成

Julia lang文档解释了如何使用内部构造函数和new（）函数构造自引用对象：

  type SelfReferential
      obj::SelfReferential
      SelfReferential() = (x = new(); x.obj = x)
    end

但是，该方法不适用于不可变类型，因为它实质上使用了未完全初始化的实例x的突变。

如何在Julia中生成自引用不可变对象？

最佳答案

因为您以前似乎曾经使用过Haskell，所以我将从功能编程的角度来定制此答案。自引用不可变类型的常见用法是创建一个惰性列表。

作为严格（即非惰性）语言，不可变对象无法直接引用自身。

但是，这并不排除使用可变对象（例如Ref或Vector）间接引用自身。

对于惰性结构的特殊情况，我可能建议将可变性限制在特殊对象（例如Lazy{T}）中。例如，

import Base: getindex
type Lazy
    thunk
    value
    Lazy(thunk) = new(thunk)
end

evaluate!(lazy::Lazy) = (lazy.value = lazy.thunk(); lazy.value)
getindex(lazy::Lazy) = isdefined(lazy, :value) ? lazy.value : evaluate!(lazy)

然后，例如，可以制作一个简单的惰性列表，如下所示：

import Base: first, tail, start, next, done, iteratorsize, HasLength, SizeUnknown
abstract List
immutable Cons <: List
    head
    tail::Lazy
end
immutable Nil <: List end

macro cons(x, y)
    quote
        Cons($(esc(x)), Lazy(() -> $(esc(y))))
    end
end

first(xs::Cons) = xs.head
tail(xs::Cons) = xs.tail[]
start(xs::Cons) = xs
next(::Cons, xs) = first(xs), tail(xs)
done(::List, ::Cons) = false
done(::List, ::Nil) = true
iteratorsize(::Nil) = HasLength()
iteratorsize(::Cons) = SizeUnknown()

确实可以像Haskell这样的语言工作：

julia> xs = @cons(1, ys)
Cons(1,Lazy(false,#3,#undef))

julia> ys = @cons(2, xs)
Cons(2,Lazy(false,#5,#undef))

julia> [take(xs, 5)...]
5-element Array{Int64,1}:
 1
 2
 1
 2
 1

该功能看似很复杂，但幸运的是它已经在Lazy.jl中实现。



重要的是要注意，由于类型不稳定和可变类型，上述代码会产生大量开销。如果您使用immutable的目标不是表达性而是性能，那么显然这种方法是不合适的。但是通常不可能有一个引用自身的堆栈分配结构，因此，在需要最大性能的情况下，最好完全避免自我引用。