如何从 Julia 结构的构造函数中调用函数？

Question

我是一名具有 C++ 和 Python 背景的程序员，最近偶然发现了 Julia，我真的很喜欢它所提供的功能。为了同时更熟悉区块链实现和 Julia，我有点雄心勃勃，正在尝试通过转换 Hackernoon 发布的 Python 实现在 Julia 中创建区块链的基本实现（作者解释了每种方法应该比我做得更好的地方）。

但是，我在创建实际的 Blockchain 结构时遇到了问题。为了创建创世块，Hackernoon 建议我在构造函数中调用成员函数new_block。到目前为止，我还没有弄清楚如何在 Julia 中最好地复制它。到目前为止，这是我所拥有的：

import JSON
import SHA

mutable struct Blockchain
    chain::Array{Dict{String, Any}}
    current_transactions::Array{String}
    block::Dict{String, Any}
    new_block::Function

    function Blockchain(chain::Array{Dict{String, Any}}, current::Array{String})    
        new(chain, current, new_block(previous_hash=1, proof=100)) 
        # ^issue calling function within the constructor here
    end
end

当我尝试运行我的代码时，我收到以下错误：

invalid redefinition of constant Blockchain.

这是new_block 函数：

function new_block(proof::String, previous_hash::String=nothing)
    block = Dict(
    "index" => length(chain) + 1,
    "timestamp" => time(),
    "transactions" => current_transactions,
    "proof" => proof,
    "previous_hash" => previous_hash | hash(chain[end]),
    )
    current_transactions = []
    append!(chain, block)
    return block
end

以下是我目前拥有的其他功能：

function new_transaction(this::Blockchain, sender::String, recipient::String, amount::Int)
    
     transaction = Dict(
        "sender"=> sender,
        "recipient"=> recipient,
        "amount"=> amount,
     )

    append!(this.current_transactions, transaction)

    return length(this.chain) + 1
end

function hash(block::Blockchain)
    block_string = JSON.dumps(block, sort_keys=true).encode()
    return sha256(block_string).hexdigest()
end

我可能对类型/结构在 Julia 中的工作方式有一些误解；我的大部分信息是从第三方网站以及官方文档中获得的。以下是我一直依赖的一些来源：

• https://scls.gitbooks.io/ljthw/content/_chapters/06-ex3.html
• https://thenewphalls.wordpress.com/2014/02/19/understanding-object-oriented-programming-in-julia-part-1/
• https://juliabyexample.helpmanual.io/

以更聪明/更有效的方式尝试完成我的工作将不胜感激。

编辑：

以下是我根据给定建议所做的一些更改：

struct Blockchain
    chain::Array{Dict{String, Any}}
    current_transactions::Array{String}

    function Blockchain(chain::Array{Dict{String, Any}}, current::Array{String})    
        new(chain, current)
    end
end

function new_block!(this::Blockchain, proof::Int, previous_hash::Int=nothing)
    block = Dict(
    "index" => length(this.chain) + 1,
    "timestamp" => time(),
    "transactions" => this.current_transactions,
    "proof" => proof,
    )
    if previous_hash == nothing
        block["previous_hash"] = hash(this.chain[end])
    else
        block["previous_hash"] = previous_hash
    end

    this.current_transactions = []
    append!(this.chain, block)
    return this
end

我意识到block 属性没有用，因为它只是为了添加到chain 而存在，所以我将其删除。

此外，这里还有一个没有内部构造函数的替代 Blockchain 定义：

struct Blockchain
    chain::Array{Dict{String, Any}}
    current_transactions::Array{String}
    
    Blockchain(x::Array{Dict{String, Any}}, y::Array{String}) = new(x, y)
end

Answer 1

免责声明。这可能不一定是您问题的答案。但我想将其发布为答案，因为评论不允许让我轻松表达以下内容。

mutable struct Blockchain
    chain::Array{Dict{String, Any}}
    current_transactions::Array{String}
    block::Dict{String, Any}
    new_block::Function

    function Blockchain(chain::Array{Dict{String, Any}}, current::Array{String})    
        new(chain, current, new_block(previous_hash=1, proof=100)) 
        # ^issue calling function within the constructor here
    end
end

在这里，我假设您正在尝试添加一些成员函数功能到您的struct，因为您已经声明您来自C++ 背景。然而，这不是朱利安。在 Julia 中，正如 @crstnbr 已经建议的那样，我们需要定义作用于对象的全局函数。惯例是您在函数末尾添加!，以表明该函数将至少更改其参数之一。

然后，通过检查new_block 的定义：

function new_block(proof::String, previous_hash::String=nothing)
    block = Dict(
    "index" => length(chain) + 1, # which chain?
    "timestamp" => time(),
    "transactions" => current_transactions, # which current_transactions?
    "proof" => proof,
    "previous_hash" => previous_hash | hash(chain[end]), # which chain?
    )
    current_transactions = []
    append!(chain, block) # which chain?
    return block
end

我注意到几个严重的错误。首先，您尝试使用一些未定义的变量，例如chain 和current_transactions。我假设，再次从C++ 开始，您认为new_block 将是Blockchain 的成员函数，因此可以看到它的chain 成员变量。这不是Julia 的工作原理。第二个问题是你如何尝试调用new_block：

new_block(previous_hash=1, proof=100)

这个调用是完全错误的。上述调用符号依赖于keyword arguments；但是，您的函数定义 only 具有位置参数。为了能够支持关键字参数，您需要将函数定义更改为如下所示：

function new_block(; proof::String, previous_hash::String=nothing)
  #                ^ note the semi-colon here
  # ...
end

最后，您将proof 和previous_hash 定义为String 类型，但使用1、100 和nothing 调用它们，它们的类型为Int、Int和Void。

我无法理解您对区块链应用程序的设计选择，但我强烈建议您应该通过更简单的示例逐步学习该语言。例如，如果您只是尝试以下示例，您将了解类型注释在 Julia 中的工作原理：

Main> f(s::String = nothing) = s
f (generic function with 2 methods)

Main> f()
ERROR: MethodError: no method matching f(::Void)
Closest candidates are:
  f(::String) at none:1
  f() at none:1
Stacktrace:
 [1] f() at ./none:1
 [2] eval(::Module, ::Any) at ./boot.jl:235

Main> g(s::String) = s
g (generic function with 1 method)

Main> g(100)
ERROR: MethodError: no method matching g(::Int64)
Closest candidates are:
  g(::String) at none:1
Stacktrace:
 [1] eval(::Module, ::Any) at ./boot.jl:235

Main> h1(var1 = 1, var2 = 100) = var1 + var2
h1 (generic function with 3 methods)

Main> h1(var2 = 5, var1 = 6)
ERROR: function h1 does not accept keyword arguments
Stacktrace:
 [1] kwfunc(::Any) at ./boot.jl:237
 [2] eval(::Module, ::Any) at ./boot.jl:235

最后一条评论是，据我从您的示例中可以看出，您不需要mutable struct。 struct 应该只是帮助您进行设计 --- 您仍然可以添加/修改其 chain、current_transactions 和 block 变量。再次检查以下更简单的示例：

Main> struct MyType
         a::Vector{Float64}
       end

Main> m = MyType([1,2,3]);

Main> append!(m.a, 4);

Main> m
MyType([1.0, 2.0, 3.0, 4.0])

您可以将上面示例中的MyType 的a 变量视为C++ 术语中的double * const a。您不允许将a 更改为指向不同的内存位置，但您可以修改a 指向的内存位置。

简而言之，您应该绝对尝试逐步从官方文档中学习该语言，并在此处发布涉及真正最小示例的问题。从这个意义上说，您的示例令人费解。