Question

我基本上想要做以下事情：

typealias CVODE_BDF CVODE_BDF{:Newton,:Dense}

即，允许用户传递给我的函数CVODE_BDF，如果他们没有设置任何类型参数，则将其解释为CVODE_BDF{:Newton,:Dense}。我知道typealias实际上并不起作用，但有没有办法模拟这个？就像在函数中一样，阅读T.parameters[1]并以某种方式看到它是空的？

Answer 1

如果函数接受该类型的对象而不是类型本身，则可以执行此操作。 E.g。

 if (columnName.field == 'amount') {
    angular.extend(columnName, { template: '<input type="text" class="k-textbox" ng-model="$ctrl.dataSourceName[dataItem.index].amount"/>' })
    if (paymentClicked) {
      angular.extend(columnName, { template: '<input type="text" class="k-textbox" ng-init="$ctrl.dataSourceName[dataItem.index].amount = dataItem.amountDue.due" ng-model="$ctrl.dataSourceName[dataItem.index].amountApplied" ng-change="$ctrl.change($event)" />' })
    }
  }

给出

type MyObject{T}
end


const DefaultMyObject = MyObject{Int64}()

f{T}(x::MyObject{T}=DefaultMyObject) = T

f(), f(MyObj{Float64}())

Answer 2

一种可能性是通过Constructors设置类型参数（{:Newton,:Dense}）。

以下是Julia（rational.jl）中定义的有理数字类型的示例：

immutable Rational{T<:Integer} <: Real
    num::T
    den::T

    function Rational(num::T, den::T)
        if num == 0 && den == 0
            error("invalid rational: 0//0")
        end
        g = gcd(den, num)
        num = div(num, g)
        den = div(den, g)
        new(num, den)
    end
end

在您的示例中，您可以在CVODE_BDF类型定义中定义构造函数，并检查类型，如果未设置，则回退到{:Newton,:Dense}。

Answer 3

这样的事情对你有用吗？

f{T, S}(::Type{A{T,S}}) = T, S

功能实现：

f(::Type{A}) = f(A{1, 1})
f{T}(::Type{A{T}}) = f(A{T, 1})
f{S}(::Type{A{:default, S}}) = f(A{1, S})

设置默认值的包装器：

f(A)                 # (1,1)
f(A{3,4})            # (3,4)
f(A{0})              # (0,1)
f(A{:default, 2})    # (1,2)

结果：

type A{T} end
type B{T} end

default{T}(::Type{A{T}}) = A{T}
default(::Type{A}) = A{1}
default{T}(::Type{B{T}}) = B{T}
default(::Type{B}) = B{1}

f{T,S}(::Type{A{T}}, ::Type{B{S}}) = T*S
f{T<:A, S<:B}(a::Type{T}, b::Type{S}) = f(default(a), default(b))

因为最后一次调用有点难看，如果需要最大的灵活性，对象可能是更好的选择。此外，构造函数可以对参数强制执行约束，因此不需要在函数中检查它们。

编辑：

如果你的函数有多个参数，那么为每个参数组合添加方法就太费了。相反，可以为每种类型定义一个默认方法（为简洁起见，只需一个参数）：

julia> @code_llvm f(A,B)

define i64 @julia_f_62099(%jl_value_t*, %jl_value_t*) #0 {
top:
  ret i64 1
}

在当前的夜晚，这没有运行时开销：

  public function create(Request $request)

  {

$this->validate($request,[
   'function' => 'max:255',
   'description' => 'max:255',
   'rate' => 'max:255',
   'location' => 'max:255'
]);

$card = new Card;
$card->user_id = Auth::id();;
$card->function = $request->function;
$card->description = $request->description;
$card->rate = $request->rate;
$card->location = $request->location;
// I also tried this:     $card->tag()->saveMany($tagsArray); (Did not work)
$card->save();

$tagsArray = explode(',', $request->tagsarray);

foreach($tagsArray as $tagInput) {

  $tag = new Tag;
  $tag->card_id = 'Cant know this yet :(';
  $tag->tag = $tagInput;
  $tag->save();
}

return redirect('/page');

  }

Answer 4

是的。 如果您执行Type{CVODE_BDF}，则可以检查生成的对象的参数。如果CVODE_BDF为“空”，则会返回带有通用参数的CVODE_BDF类型，否则它们将是使用的特定类型。

示例（使用Array，因为我没有CVODE_BDF方便）：

julia> Type{Array}.parameters
svec(Array{T,N})

julia> Type{Array{Float64, Int64}}.parameters
svec(Array{Float64,Int64})

示例功能：

function f{T}(t::T)
  if Type(t).parameters == Type(Array).parameters
    t = Array{Int64, 1};
  end
  return t;
end

julia> f(Array{Int64, 1})
Array{Int64,1}

julia> f(Array{Float64, 1})
Array{Float64,1}

julia> f(Array)
Array{Int64,1}

制作无参数类型具有“默认值”

4 个答案: