That seemed to do the trick. I kinda like how this forces you to be explicit in what you will extend from the main module.
On Thursday, May 7, 2015 at 8:28:47 PM UTC+2, Kristoffer Carlsson wrote: > > Question: > > Is the solution to define "main functions" in the library module and then > import those functions into the book modules? > > Sort of like how you import Base.push! if you want to extend the push! > function. > > > On Thursday, May 7, 2015 at 7:43:26 PM UTC+2, Kristoffer Carlsson wrote: >> >> I realized this doesn't work well for me. >> >> The problem with using @lazymod and splitting my "books" into different >> modules is that I have methods with the same name in the "book" modules. >> This will cause conflicts and I won't get the methods when I import the >> second book module. >> >> Maybe I could use https://github.com/davidagold/MetaMerge.jl but at this >> point it seems like an awful amount of work just to be able to do something >> as simple as not loading the whole package... >> >> Assuming that I have a huge number of different types that all have the >> same parent abstract type. There is a method for each type operating on the >> type. >> >> Is it right that there is no way to put this in a package and have a user >> only load part of the types and methods? >> >> >> >> On Tuesday, May 5, 2015 at 6:52:24 PM UTC+2, Jameson wrote: >>> >>> Also see https://github.com/JuliaLang/julia/pull/6884 >>> >>> On Tue, May 5, 2015 at 12:52 PM Kristoffer Carlsson <[email protected]> >>> wrote: >>> >>>> Thank you for the link. My current structure is now then: >>>> >>>> # MyPackage.jl >>>> module MyPackage >>>> >>>> export foo, AbstractBook >>>> >>>> include("required.jl") >>>> include("library.jl") >>>> end >>>> >>>> # required.jl >>>> abstract AbstractBook >>>> foo(a::AbstractBook) = print(a) >>>> >>>> # library.jl >>>> module Library >>>> >>>> using Requires >>>> >>>> @lazymod BookModule1 "book1.jl" >>>> @lazymod BookModule" "book2.jl" >>>> >>>> end >>>> >>>> >>>> # book1.jl >>>> module BookModule1 >>>> using MyPackage >>>> export Book1 >>>> type Book1 <: AbstractBook >>>> end >>>> >>>> # book2.jl >>>> module BookModule2 >>>> using MyPackage >>>> export Book2 >>>> type Book2 <: AbstractBook >>>> end >>>> >>>> I can then load the Book1Mod using >>>> >>>> julia> MyPackage.Library.bookmodule1() >>>> MyPackage.Library.BookModule1 >>>> >>>> >>>> which is a little bit uglier than what I would like but it works! >>>> >>>> Thanks! >>>> >>>> // Kristoffer >>>> >>>> On Tuesday, May 5, 2015 at 6:12:35 PM UTC+2, Isaiah wrote: >>>> >>>>> Have a look at https://github.com/one-more-minute/Requires.jl >>>>> >>>> >>>>> On Tue, May 5, 2015 at 12:04 PM, Kristoffer Carlsson < >>>>> [email protected]> wrote: >>>>> >>>>>> I have a package where some functionality should always be loaded >>>>>> when writing the normal "using MyPackage" and some functionality needs >>>>>> to >>>>>> be explicitly loaded. The use case for me is that I have a library of >>>>>> different things (let's call them books) and it is likely that only a >>>>>> few >>>>>> books from this library are used and I want to reduce the loading time >>>>>> of >>>>>> the package. >>>>>> >>>>>> To make it concrete let's assume I currently have the following >>>>>> file/module structure: >>>>>> # MyPackage.jl >>>>>> module MyPackage >>>>>> export foo >>>>>> include("required.jl") >>>>>> include("library.jl") >>>>>> end >>>>>> >>>>>> # required.jl >>>>>> abstract AbstractBook >>>>>> foo(a::AbstractBook) = print(a) >>>>>> >>>>>> # library.jl >>>>>> >>>>>> include("book1.jl") >>>>>> include("book2.jl") >>>>>> >>>>>> # book1.jl >>>>>> type Book1 <: AbstractBook >>>>>> >>>>>> # book2.jl (oh boy...) >>>>>> using Gadfly >>>>>> using Winston >>>>>> using Images >>>>>> using PyCall >>>>>> type Book2 <: AbstractBook >>>>>> >>>>>> Now, I want my usage of the package to look something like this: >>>>>> using MyPackage # Loads everything required >>>>>> using MyPackage.Library.Book1 # Only loads book1.jl, book2.jl is not >>>>>> touched, fast loading >>>>>> >>>>>> Foo(Book1()) >>>>>> >>>>>> I guess I have to put my books into their own separate modules, akin: >>>>>> >>>>>> # MyPackage.jl >>>>>> module MyPackage >>>>>> export foo >>>>>> include("required.jl") >>>>>> end >>>>>> >>>>>> # required.jl >>>>>> abstract AbstractBook >>>>>> foo(a::AbstractBook) = print(a) >>>>>> >>>>>> # book1.jl >>>>>> module BookModule1 >>>>>> using MyPackage >>>>>> export Book1 >>>>>> type Book1 <: AbstractBook >>>>>> end >>>>>> >>>>>> # book2.jl >>>>>> module BookModule2 >>>>>> using MyPackage >>>>>> export Book2 >>>>>> type Book2 <: AbstractBook >>>>>> end >>>>>> >>>>>> But now there is no convenient way to load the book modules? >>>>>> >>>>>> Can anyone help me how to properly structure this? A link to a >>>>>> package that does this will likely work just fine. >>>>>> >>>>>> Best regards, >>>>>> Kristoffer Carlsson >>>>>> >>>>> >>>>>
