Jaki jest właściwy sposób napisania metody finalizacji modułu w Julii?

Question

Próbuję znaleźć właściwą drogę do korzystania finalizatory w Julia

Zapoznaj się z dokumentacją Julia:

finalizatora (x, funkcja)

przypisać funkcję f (x) wywoływane, gdy nie ma żadnych dostępnych w programie odniesień do x. Zachowanie tej funkcji jest nieprzewidywalne, jeśli x jest typu bitowego.

Najpierw genetated pakiet standardowy TestModule z TestModule.jl

#in TestModule.jl 
module TestModule 
end 
finalizer(TestModule,(t)->println("fin")) 

a także runtest.jl

#in runtest.jl 
using Base.Test 
using TestModule 

potem starałem się przetestować pakiet, ale dostałem błąd podczas test został przyjęty:

julia> Pkg.test("TestModule") 
INFO: Testing TestModule 
jl_uv_writecb() ERROR: bad file descriptor EBADF 
jl_uv_writecb() ERROR: bad file descriptor EBADF 
jl_uv_writecb() ERROR: bad file descriptor EBADF 
jl_uv_writecb() ERROR: bad file descriptor EBADF 
jl_uv_writecb() ERROR: bad file descriptor EBADF 
jl_uv_writecb() ERROR: bad file descriptor EBADF 
jl_uv_writecb() ERROR: bad file descriptor EBADF 
jl_uv_writecb() ERROR: bad file descriptor EBADF 
jl_uv_writecb() ERROR: bad file descriptor EBADF 
jl_uv_writecb() ERROR: bad file descriptor EBADF 
INFO: TestModule tests passed 

po tym umówiłem kolejny przypadek testowy

julia> workspace() # new workspace 

julia> typeof(TestModule) # make sure *there are no program-accessible references to `TestModule`* 

ERROR: UndefVarError: TestModule not defined 

julia> using TestModule 

julia> finalize(TestModule) 
fin # finalize method is working 

julia> typeof(TestModule) 
Module # make sure *there is program-accessible reference to `TestModule`* 

julia> workspace() # force clear references 

julia> typeof(TestModule) # check that *there are no program-accessible references* 
ERROR: UndefVarError: TestModule not defined 

Według powyższych przypadków testowych mam kilka pytań

1. Dlaczego dodanie takiej metody finalize dla TestModule generuje błąd podczas procesu testowego?
2. Dlaczego finalize metoda nie został powołany, a ja wyraźne odniesienia

3. Co jest właściwym sposobem na dodanie finalize metodę moduł

   (OS = Ubuntu, Julia Version = 0.4.0)

EDIT

jak @Maciek wspomniałem, nazywając gc() po workspace() Ponadto, nie pomoże.

dzięki

Answer 1

IMHO, workspace nie bierze jeńców, a ponadto finalizer działa dobrze tylko na typach zdefiniowanych przez użytkownika i kompozytowych.

Przeprowadziłem kilka testów. Spojrzeć na moje wyniki:

julia> type Foo 
     x 
     Foo(x) = begin obj = new(x); finalizer(obj,(o) -> println("The end.")); return obj end 
     end 

julia> Foo(1) 

julia> workspace() 

julia> gc() 
Module the end.error in running finalizer: ErrorException("task switch not allowed from inside gc finalizer") 
The end.error in running finalizer: ErrorException("task switch not allowed from inside gc finalizer") 

kolejny test z obiektu wewnątrz zdefiniowanego zakresu modułu:

julia> module FinMod 

     type T 
      x::Int 
     end 

     finalizer(T(1), (t) -> println("Module the end.")) 
     end 
FinMod 

julia> FinMod 
FinMod 

julia> workspace() 

julia> gc() 
Module the end.error in running finalizer: ErrorException("task switch not allowed from inside gc finalizer") 

Co o funkcje (pierwszej klasy obiektów)?

julia> function foo() println("I'm foo") end 
foo (generic function with 1 method) 

julia> finalizer(foo, (f) -> println("foo function is dead now.")) 

julia> foo 
foo (generic function with 1 method) 

julia> workspace() 

julia> foo 
ERROR: UndefVarError: foo not defined 

julia> gc() 

julia> #nothing happened 

Tak więc, aby podsumować: Moim zdaniem workspace nie wymaga finalize.Funkcja finalizer działa poprawnie tylko w przypadku typów zdefiniowanych przez użytkownika i złożonych. To nie działa dla Module lub Function.

Aktualizacja: Przypomniałem sobie, że workspace przepisuje poprzedni moduł na LastMain. Więc nawet jeśli nasz moduł nie jest dostępny z poziomu Main, to wciąż żyje w zasięgu LastMain (to samo działa dla funkcji, której użyłem powyżej).