Yes, exactly -- this is what e.g. the StatsBase and GraphicsBase packages are doing, on a multi-module scale. But it works well within a single module too, in combination with the lazy loading.
On Thu, May 7, 2015 at 2:49 PM, Kristoffer Carlsson <[email protected]> wrote: > 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 >>>>>>> >>>>>> >>>>>>
