diff --git a/cmd/install.go b/cmd/install.go
index d54a63e8..92fe1358 100644
--- a/cmd/install.go
+++ b/cmd/install.go
@@ -46,7 +46,7 @@ var installCmd = &cobra.Command{
 	},
 	Long: `Install packages in parallel`,
 	Run: func(cmd *cobra.Command, args []string) {
-		var toInstall []pkg.Package
+		var toInstall pkg.Packages
 		var systemDB pkg.PackageDatabase
 
 		for _, a := range args {
diff --git a/cmd/search.go b/cmd/search.go
index 6409c4d3..e54a5253 100644
--- a/cmd/search.go
+++ b/cmd/search.go
@@ -108,7 +108,7 @@ var searchCmd = &cobra.Command{
 			system := &installer.System{Database: systemDB, Target: LuetCfg.GetSystem().Rootfs}
 
 			var err error
-			iMatches := []pkg.Package{}
+			iMatches := pkg.Packages{}
 			if searchWithLabel {
 				iMatches, err = system.Database.FindPackageLabel(args[0])
 			} else if searchWithLabelMatch {
diff --git a/cmd/tree/validate.go b/cmd/tree/validate.go
index c2be1f7b..c7d7a2e9 100644
--- a/cmd/tree/validate.go
+++ b/cmd/tree/validate.go
@@ -184,7 +184,7 @@ func NewTreeValidateCommand() *cobra.Command {
 
 						if withSolver {
 							Spinner(32)
-							_, err := depSolver.Install([]pkg.Package{r})
+							_, err := depSolver.Install(pkg.Packages{r})
 							SpinnerStop()
 
 							if err != nil {
diff --git a/pkg/compiler/compiler.go b/pkg/compiler/compiler.go
index 7de98bc6..a8566198 100644
--- a/pkg/compiler/compiler.go
+++ b/pkg/compiler/compiler.go
@@ -433,7 +433,7 @@ func (cs *LuetCompiler) ComputeDepTree(p CompilationSpec) (solver.PackagesAssert
 
 	s := solver.NewResolver(pkg.NewInMemoryDatabase(false), cs.Database, pkg.NewInMemoryDatabase(false), cs.Options.SolverOptions.Resolver())
 
-	solution, err := s.Install([]pkg.Package{p.GetPackage()})
+	solution, err := s.Install(pkg.Packages{p.GetPackage()})
 	if err != nil {
 		return nil, errors.Wrap(err, "While computing a solution for "+p.GetPackage().HumanReadableString())
 	}
diff --git a/pkg/installer/installer.go b/pkg/installer/installer.go
index 3f057696..8f326aaa 100644
--- a/pkg/installer/installer.go
+++ b/pkg/installer/installer.go
@@ -74,7 +74,7 @@ func (l *LuetInstaller) Upgrade(s *System) error {
 		return errors.Wrap(err, "Failed solving solution for upgrade")
 	}
 
-	toInstall := []pkg.Package{}
+	toInstall := pkg.Packages{}
 	for _, assertion := range solution {
 		// Be sure to filter from solutions packages already installed in the system
 		if _, err := s.Database.FindPackage(assertion.Package); err != nil && assertion.Value {
@@ -107,7 +107,7 @@ func (l *LuetInstaller) SyncRepositories(inMemory bool) (Repositories, error) {
 	return syncedRepos, nil
 }
 
-func (l *LuetInstaller) Swap(toRemove []pkg.Package, toInstall []pkg.Package, s *System) error {
+func (l *LuetInstaller) Swap(toRemove pkg.Packages, toInstall pkg.Packages, s *System) error {
 	syncedRepos, err := l.SyncRepositories(true)
 	if err != nil {
 		return err
@@ -115,7 +115,7 @@ func (l *LuetInstaller) Swap(toRemove []pkg.Package, toInstall []pkg.Package, s
 	return l.swap(syncedRepos, toRemove, toInstall, s)
 }
 
-func (l *LuetInstaller) swap(syncedRepos Repositories, toRemove []pkg.Package, toInstall []pkg.Package, s *System) error {
+func (l *LuetInstaller) swap(syncedRepos Repositories, toRemove pkg.Packages, toInstall pkg.Packages, s *System) error {
 	// First match packages against repositories by priority
 	allRepos := pkg.NewInMemoryDatabase(false)
 	syncedRepos.SyncDatabase(allRepos)
@@ -153,7 +153,7 @@ func (l *LuetInstaller) swap(syncedRepos Repositories, toRemove []pkg.Package, t
 	return l.install(syncedRepos, toInstall, s)
 }
 
-func (l *LuetInstaller) Install(cp []pkg.Package, s *System, downloadOnly bool) error {
+func (l *LuetInstaller) Install(cp pkg.Packages, s *System, downloadOnly bool) error {
 	syncedRepos, err := l.SyncRepositories(true)
 	if err != nil {
 		return err
@@ -161,7 +161,7 @@ func (l *LuetInstaller) Install(cp []pkg.Package, s *System, downloadOnly bool)
 	return l.install(syncedRepos, cp, s)
 }
 
-func (l *LuetInstaller) download(syncedRepos Repositories, cp []pkg.Package) error {
+func (l *LuetInstaller) download(syncedRepos Repositories, cp pkg.Packages) error {
 	toDownload := map[string]ArtifactMatch{}
 
 	// FIXME: This can be optimized. We don't need to re-match this to the repository
@@ -169,7 +169,7 @@ func (l *LuetInstaller) download(syncedRepos Repositories, cp []pkg.Package) err
 
 	// Gathers things to download
 	for _, currentPack := range cp {
-		matches := syncedRepos.PackageMatches([]pkg.Package{currentPack})
+		matches := syncedRepos.PackageMatches(pkg.Packages{currentPack})
 		if len(matches) == 0 {
 			return errors.New("Failed matching solutions against repository for " + currentPack.HumanReadableString() + " where are definitions coming from?!")
 		}
@@ -206,8 +206,8 @@ func (l *LuetInstaller) download(syncedRepos Repositories, cp []pkg.Package) err
 	return nil
 }
 
-func (l *LuetInstaller) install(syncedRepos Repositories, cp []pkg.Package, s *System) error {
-	var p []pkg.Package
+func (l *LuetInstaller) install(syncedRepos Repositories, cp pkg.Packages, s *System) error {
+	var p pkg.Packages
 
 	// Check if the package is installed first
 	for _, pi := range cp {
@@ -237,7 +237,7 @@ func (l *LuetInstaller) install(syncedRepos Repositories, cp []pkg.Package, s *S
 	syncedRepos.SyncDatabase(allRepos)
 	p = syncedRepos.ResolveSelectors(p)
 	toInstall := map[string]ArtifactMatch{}
-	var packagesToInstall []pkg.Package
+	var packagesToInstall pkg.Packages
 	var err error
 	var solution solver.PackagesAssertions
 
@@ -261,7 +261,7 @@ func (l *LuetInstaller) install(syncedRepos Repositories, cp []pkg.Package, s *S
 
 	// Gathers things to install
 	for _, currentPack := range packagesToInstall {
-		matches := syncedRepos.PackageMatches([]pkg.Package{currentPack})
+		matches := syncedRepos.PackageMatches(pkg.Packages{currentPack})
 		if len(matches) == 0 {
 			return errors.New("Failed matching solutions against repository for " + currentPack.HumanReadableString() + " where are definitions coming from?!")
 		}
diff --git a/pkg/installer/interface.go b/pkg/installer/interface.go
index ac5119a1..64a64aa5 100644
--- a/pkg/installer/interface.go
+++ b/pkg/installer/interface.go
@@ -23,12 +23,12 @@ import (
 )
 
 type Installer interface {
-	Install([]pkg.Package, *System, bool) error
+	Install(pkg.Packages, *System, bool) error
 	Uninstall(pkg.Package, *System) error
 	Upgrade(s *System) error
 	Repositories([]Repository)
 	SyncRepositories(bool) (Repositories, error)
-	Swap([]pkg.Package, []pkg.Package, *System) error
+	Swap(pkg.Packages, pkg.Packages, *System) error
 }
 
 type Client interface {
diff --git a/pkg/installer/repository.go b/pkg/installer/repository.go
index 2fb1d5e5..ed85da4a 100644
--- a/pkg/installer/repository.go
+++ b/pkg/installer/repository.go
@@ -701,9 +701,9 @@ func (r Repositories) Less(i, j int) bool {
 	return r[i].GetPriority() < r[j].GetPriority()
 }
 
-func (r Repositories) World() []pkg.Package {
+func (r Repositories) World() pkg.Packages {
 	cache := map[string]pkg.Package{}
-	world := []pkg.Package{}
+	world := pkg.Packages{}
 
 	// Get Uniques. Walk in reverse so the definitions of most prio-repo overwrites lower ones
 	// In this way, when we will walk again later the deps sorting them by most higher prio we have better chance of success.
@@ -741,7 +741,7 @@ type PackageMatch struct {
 	Package pkg.Package
 }
 
-func (re Repositories) PackageMatches(p []pkg.Package) []PackageMatch {
+func (re Repositories) PackageMatches(p pkg.Packages) []PackageMatch {
 	// TODO: Better heuristic. here we pick the first repo that contains the atom, sorted by priority but
 	// we should do a permutations and get the best match, and in case there are more solutions the user should be able to pick
 	sort.Sort(re)
@@ -762,10 +762,10 @@ PACKAGE:
 
 }
 
-func (re Repositories) ResolveSelectors(p []pkg.Package) []pkg.Package {
+func (re Repositories) ResolveSelectors(p pkg.Packages) pkg.Packages {
 	// If a selector is given, get the best from each repo
 	sort.Sort(re) // respect prio
-	var matches []pkg.Package
+	var matches pkg.Packages
 PACKAGE:
 	for _, pack := range p {
 	REPOSITORY:
@@ -798,7 +798,7 @@ func (re Repositories) SearchPackages(p string, o LuetSearchOpts) []PackageMatch
 	var err error
 
 	for _, r := range re {
-		var repoMatches []pkg.Package
+		var repoMatches pkg.Packages
 
 		switch o.Mode {
 		case SRegexPkg:
diff --git a/pkg/installer/system.go b/pkg/installer/system.go
index fc35ef67..e66d6eb4 100644
--- a/pkg/installer/system.go
+++ b/pkg/installer/system.go
@@ -9,6 +9,6 @@ type System struct {
 	Target   string
 }
 
-func (s *System) World() ([]pkg.Package, error) {
+func (s *System) World() (pkg.Packages, error) {
 	return s.Database.World(), nil
 }
diff --git a/pkg/package/database.go b/pkg/package/database.go
index fe1f59c4..82983250 100644
--- a/pkg/package/database.go
+++ b/pkg/package/database.go
@@ -33,7 +33,7 @@ type PackageSet interface {
 	GetPackage(ID string) (Package, error)
 	Clean() error
 	FindPackage(Package) (Package, error)
-	FindPackages(p Package) ([]Package, error)
+	FindPackages(p Package) (Packages, error)
 	UpdatePackage(p Package) error
 	GetAllPackages(packages chan Package) error
 	RemovePackage(Package) error
@@ -41,13 +41,13 @@ type PackageSet interface {
 	GetPackageFiles(Package) ([]string, error)
 	SetPackageFiles(*PackageFile) error
 	RemovePackageFiles(Package) error
-	FindPackageVersions(p Package) ([]Package, error)
-	World() []Package
+	FindPackageVersions(p Package) (Packages, error)
+	World() Packages
 
 	FindPackageCandidate(p Package) (Package, error)
-	FindPackageLabel(labelKey string) ([]Package, error)
-	FindPackageLabelMatch(pattern string) ([]Package, error)
-	FindPackageMatch(pattern string) ([]Package, error)
+	FindPackageLabel(labelKey string) (Packages, error)
+	FindPackageLabelMatch(pattern string) (Packages, error)
+	FindPackageMatch(pattern string) (Packages, error)
 }
 
 type PackageFile struct {
diff --git a/pkg/package/database_boltdb.go b/pkg/package/database_boltdb.go
index 50fbb528..7418f010 100644
--- a/pkg/package/database_boltdb.go
+++ b/pkg/package/database_boltdb.go
@@ -314,7 +314,7 @@ func (db *BoltDatabase) RemovePackage(p Package) error {
 	return nil
 }
 
-func (db *BoltDatabase) World() []Package {
+func (db *BoltDatabase) World() Packages {
 
 	var all []Package
 	// FIXME: This should all be locked in the db - for now forbid the solver to be run in threads.
@@ -324,7 +324,7 @@ func (db *BoltDatabase) World() []Package {
 			all = append(all, pack)
 		}
 	}
-	return all
+	return Packages(all)
 }
 
 func (db *BoltDatabase) FindPackageCandidate(p Package) (Package, error) {
@@ -338,7 +338,7 @@ func (db *BoltDatabase) FindPackageCandidate(p Package) (Package, error) {
 		if err != nil || len(packages) == 0 {
 			required = p
 		} else {
-			required = Best(packages)
+			required = packages.Best()
 
 		}
 		return required, nil
@@ -351,7 +351,7 @@ func (db *BoltDatabase) FindPackageCandidate(p Package) (Package, error) {
 
 // FindPackages return the list of the packages beloging to cat/name  (any versions in requested range)
 // FIXME: Optimize, see inmemorydb
-func (db *BoltDatabase) FindPackages(p Package) ([]Package, error) {
+func (db *BoltDatabase) FindPackages(p Package) (Packages, error) {
 	// Provides: Treat as the replaced package here
 	if provided, err := db.getProvide(p); err == nil {
 		p = provided
@@ -370,11 +370,11 @@ func (db *BoltDatabase) FindPackages(p Package) ([]Package, error) {
 			versionsInWorld = append(versionsInWorld, w)
 		}
 	}
-	return versionsInWorld, nil
+	return Packages(versionsInWorld), nil
 }
 
 // FindPackageVersions return the list of the packages beloging to cat/name
-func (db *BoltDatabase) FindPackageVersions(p Package) ([]Package, error) {
+func (db *BoltDatabase) FindPackageVersions(p Package) (Packages, error) {
 	var versionsInWorld []Package
 	for _, w := range db.World() {
 		if w.GetName() != p.GetName() || w.GetCategory() != p.GetCategory() {
@@ -383,10 +383,10 @@ func (db *BoltDatabase) FindPackageVersions(p Package) ([]Package, error) {
 
 		versionsInWorld = append(versionsInWorld, w)
 	}
-	return versionsInWorld, nil
+	return Packages(versionsInWorld), nil
 }
 
-func (db *BoltDatabase) FindPackageLabel(labelKey string) ([]Package, error) {
+func (db *BoltDatabase) FindPackageLabel(labelKey string) (Packages, error) {
 	var ans []Package
 
 	for _, k := range db.GetPackages() {
@@ -398,10 +398,10 @@ func (db *BoltDatabase) FindPackageLabel(labelKey string) ([]Package, error) {
 			ans = append(ans, pack)
 		}
 	}
-	return ans, nil
+	return Packages(ans), nil
 }
 
-func (db *BoltDatabase) FindPackageLabelMatch(pattern string) ([]Package, error) {
+func (db *BoltDatabase) FindPackageLabelMatch(pattern string) (Packages, error) {
 	var ans []Package
 
 	re := regexp.MustCompile(pattern)
@@ -419,10 +419,10 @@ func (db *BoltDatabase) FindPackageLabelMatch(pattern string) ([]Package, error)
 		}
 	}
 
-	return ans, nil
+	return Packages(ans), nil
 }
 
-func (db *BoltDatabase) FindPackageMatch(pattern string) ([]Package, error) {
+func (db *BoltDatabase) FindPackageMatch(pattern string) (Packages, error) {
 	var ans []Package
 
 	re := regexp.MustCompile(pattern)
@@ -441,5 +441,5 @@ func (db *BoltDatabase) FindPackageMatch(pattern string) ([]Package, error) {
 		}
 	}
 
-	return ans, nil
+	return Packages(ans), nil
 }
diff --git a/pkg/package/database_mem.go b/pkg/package/database_mem.go
index 6a8056be..f3c44fa8 100644
--- a/pkg/package/database_mem.go
+++ b/pkg/package/database_mem.go
@@ -223,7 +223,7 @@ func (db *InMemoryDatabase) FindPackage(p Package) (Package, error) {
 }
 
 // FindPackages return the list of the packages beloging to cat/name
-func (db *InMemoryDatabase) FindPackageVersions(p Package) ([]Package, error) {
+func (db *InMemoryDatabase) FindPackageVersions(p Package) (Packages, error) {
 	versions, ok := db.CacheNoVersion[p.GetPackageName()]
 	if !ok {
 		return nil, errors.New("No versions found for package")
@@ -236,11 +236,11 @@ func (db *InMemoryDatabase) FindPackageVersions(p Package) ([]Package, error) {
 		}
 		versionsInWorld = append(versionsInWorld, w)
 	}
-	return versionsInWorld, nil
+	return Packages(versionsInWorld), nil
 }
 
 // FindPackages return the list of the packages beloging to cat/name (any versions in requested range)
-func (db *InMemoryDatabase) FindPackages(p Package) ([]Package, error) {
+func (db *InMemoryDatabase) FindPackages(p Package) (Packages, error) {
 
 	// Provides: Treat as the replaced package here
 	if provided, err := db.getProvide(p); err == nil {
@@ -265,7 +265,7 @@ func (db *InMemoryDatabase) FindPackages(p Package) ([]Package, error) {
 			versionsInWorld = append(versionsInWorld, w)
 		}
 	}
-	return versionsInWorld, nil
+	return Packages(versionsInWorld), nil
 }
 
 func (db *InMemoryDatabase) UpdatePackage(p Package) error {
@@ -327,7 +327,7 @@ func (db *InMemoryDatabase) RemovePackage(p Package) error {
 	delete(db.Database, p.GetFingerPrint())
 	return nil
 }
-func (db *InMemoryDatabase) World() []Package {
+func (db *InMemoryDatabase) World() Packages {
 	var all []Package
 	// FIXME: This should all be locked in the db - for now forbid the solver to be run in threads.
 	for _, k := range db.GetPackages() {
@@ -336,7 +336,7 @@ func (db *InMemoryDatabase) World() []Package {
 			all = append(all, pack)
 		}
 	}
-	return all
+	return Packages(all)
 }
 
 func (db *InMemoryDatabase) FindPackageCandidate(p Package) (Package, error) {
@@ -349,7 +349,7 @@ func (db *InMemoryDatabase) FindPackageCandidate(p Package) (Package, error) {
 		if err != nil || len(packages) == 0 {
 			required = p
 		} else {
-			required = Best(packages)
+			required = packages.Best()
 
 		}
 		return required, nil
@@ -360,7 +360,7 @@ func (db *InMemoryDatabase) FindPackageCandidate(p Package) (Package, error) {
 
 }
 
-func (db *InMemoryDatabase) FindPackageLabel(labelKey string) ([]Package, error) {
+func (db *InMemoryDatabase) FindPackageLabel(labelKey string) (Packages, error) {
 	var ans []Package
 
 	for _, k := range db.GetPackages() {
@@ -373,10 +373,10 @@ func (db *InMemoryDatabase) FindPackageLabel(labelKey string) ([]Package, error)
 		}
 	}
 
-	return ans, nil
+	return Packages(ans), nil
 }
 
-func (db *InMemoryDatabase) FindPackageLabelMatch(pattern string) ([]Package, error) {
+func (db *InMemoryDatabase) FindPackageLabelMatch(pattern string) (Packages, error) {
 	var ans []Package
 
 	re := regexp.MustCompile(pattern)
@@ -394,10 +394,10 @@ func (db *InMemoryDatabase) FindPackageLabelMatch(pattern string) ([]Package, er
 		}
 	}
 
-	return ans, nil
+	return Packages(ans), nil
 }
 
-func (db *InMemoryDatabase) FindPackageMatch(pattern string) ([]Package, error) {
+func (db *InMemoryDatabase) FindPackageMatch(pattern string) (Packages, error) {
 	var ans []Package
 
 	re := regexp.MustCompile(pattern)
@@ -416,5 +416,5 @@ func (db *InMemoryDatabase) FindPackageMatch(pattern string) ([]Package, error)
 		}
 	}
 
-	return ans, nil
+	return Packages(ans), nil
 }
diff --git a/pkg/package/package.go b/pkg/package/package.go
index 33bfa5ce..3ab06cdd 100644
--- a/pkg/package/package.go
+++ b/pkg/package/package.go
@@ -47,15 +47,15 @@ type Package interface {
 	GetPackageName() string
 	Requires([]*DefaultPackage) Package
 	Conflicts([]*DefaultPackage) Package
-	Revdeps(PackageDatabase) []Package
-	LabelDeps(PackageDatabase, string) []Package
+	Revdeps(PackageDatabase) Packages
+	LabelDeps(PackageDatabase, string) Packages
 
 	GetProvides() []*DefaultPackage
 	SetProvides([]*DefaultPackage) Package
 
 	GetRequires() []*DefaultPackage
 	GetConflicts() []*DefaultPackage
-	Expand(PackageDatabase) ([]Package, error)
+	Expand(PackageDatabase) (Packages, error)
 	SetCategory(string)
 
 	GetName() string
@@ -104,10 +104,12 @@ type Tree interface {
 	GetPackageSet() PackageDatabase
 	Prelude() string // A tree might have a prelude to be able to consume a tree
 	SetPackageSet(s PackageDatabase)
-	World() ([]Package, error)
+	World() (Packages, error)
 	FindPackage(Package) (Package, error)
 }
 
+type Packages []Package
+
 // >> Unmarshallers
 // DefaultPackageFromYaml decodes a package from yaml bytes
 func DefaultPackageFromYaml(yml []byte) (DefaultPackage, error) {
@@ -378,8 +380,8 @@ func (p *DefaultPackage) Matches(m Package) bool {
 	return false
 }
 
-func (p *DefaultPackage) Expand(definitiondb PackageDatabase) ([]Package, error) {
-	var versionsInWorld []Package
+func (p *DefaultPackage) Expand(definitiondb PackageDatabase) (Packages, error) {
+	var versionsInWorld Packages
 
 	all, err := definitiondb.FindPackages(p)
 	if err != nil {
@@ -398,8 +400,8 @@ func (p *DefaultPackage) Expand(definitiondb PackageDatabase) ([]Package, error)
 	return versionsInWorld, nil
 }
 
-func (p *DefaultPackage) Revdeps(definitiondb PackageDatabase) []Package {
-	var versionsInWorld []Package
+func (p *DefaultPackage) Revdeps(definitiondb PackageDatabase) Packages {
+	var versionsInWorld Packages
 	for _, w := range definitiondb.World() {
 		if w.Matches(p) {
 			continue
@@ -415,8 +417,8 @@ func (p *DefaultPackage) Revdeps(definitiondb PackageDatabase) []Package {
 	return versionsInWorld
 }
 
-func (p *DefaultPackage) LabelDeps(definitiondb PackageDatabase, labelKey string) []Package {
-	var pkgsWithLabelInWorld []Package
+func (p *DefaultPackage) LabelDeps(definitiondb PackageDatabase, labelKey string) Packages {
+	var pkgsWithLabelInWorld Packages
 	// TODO: check if integrate some index to improve
 	// research instead of iterate all list.
 	for _, w := range definitiondb.World() {
@@ -458,7 +460,7 @@ func (pack *DefaultPackage) RequiresContains(definitiondb PackageDatabase, s Pac
 	return false, nil
 }
 
-func Best(set []Package) Package {
+func (set Packages) Best() Package {
 	var versionsMap map[string]Package = make(map[string]Package)
 	if len(set) == 0 {
 		panic("Best needs a list with elements")
diff --git a/pkg/package/package_test.go b/pkg/package/package_test.go
index b007a34c..fb3f1eda 100644
--- a/pkg/package/package_test.go
+++ b/pkg/package/package_test.go
@@ -58,7 +58,7 @@ var _ = Describe("Package", func() {
 			Expect(lst).To(ContainElement(a1))
 			Expect(lst).ToNot(ContainElement(a01))
 			Expect(len(lst)).To(Equal(2))
-			p := Best(lst)
+			p := lst.Best()
 			Expect(p).To(Equal(a11))
 		})
 	})
diff --git a/pkg/solver/resolver.go b/pkg/solver/resolver.go
index 21f9e783..941da67b 100644
--- a/pkg/solver/resolver.go
+++ b/pkg/solver/resolver.go
@@ -77,11 +77,11 @@ type QLearningResolver struct {
 	Solver  PackageSolver
 	Formula bf.Formula
 
-	Targets []pkg.Package
-	Current []pkg.Package
+	Targets pkg.Packages
+	Current pkg.Packages
 
 	observedDelta       int
-	observedDeltaChoice []pkg.Package
+	observedDeltaChoice pkg.Packages
 
 	Agent *qlearning.SimpleAgent
 }
@@ -177,7 +177,7 @@ func (resolver *QLearningResolver) Try(c Choice) error {
 	packtoAdd := pkg.FromString(pack)
 	resolver.Attempted[pack+strconv.Itoa(int(c.Action))] = true // increase the count
 	s, _ := resolver.Solver.(*Solver)
-	var filtered []pkg.Package
+	var filtered pkg.Packages
 
 	switch c.Action {
 	case ActionAdded:
diff --git a/pkg/solver/solver.go b/pkg/solver/solver.go
index f6012fae..c2e0f52c 100644
--- a/pkg/solver/solver.go
+++ b/pkg/solver/solver.go
@@ -27,12 +27,12 @@ import (
 // PackageSolver is an interface to a generic package solving algorithm
 type PackageSolver interface {
 	SetDefinitionDatabase(pkg.PackageDatabase)
-	Install(p []pkg.Package) (PackagesAssertions, error)
-	Uninstall(candidate pkg.Package, checkconflicts bool) ([]pkg.Package, error)
+	Install(p pkg.Packages) (PackagesAssertions, error)
+	Uninstall(candidate pkg.Package, checkconflicts bool) (pkg.Packages, error)
 	ConflictsWithInstalled(p pkg.Package) (bool, error)
-	ConflictsWith(p pkg.Package, ls []pkg.Package) (bool, error)
-	World() []pkg.Package
-	Upgrade(checkconflicts bool) ([]pkg.Package, PackagesAssertions, error)
+	ConflictsWith(p pkg.Package, ls pkg.Packages) (bool, error)
+	World() pkg.Packages
+	Upgrade(checkconflicts bool) (pkg.Packages, PackagesAssertions, error)
 
 	SetResolver(PackageResolver)
 
@@ -43,7 +43,7 @@ type PackageSolver interface {
 type Solver struct {
 	DefinitionDatabase pkg.PackageDatabase
 	SolverDatabase     pkg.PackageDatabase
-	Wanted             []pkg.Package
+	Wanted             pkg.Packages
 	InstalledDatabase  pkg.PackageDatabase
 
 	Resolver PackageResolver
@@ -72,11 +72,11 @@ func (s *Solver) SetResolver(r PackageResolver) {
 	s.Resolver = r
 }
 
-func (s *Solver) World() []pkg.Package {
+func (s *Solver) World() pkg.Packages {
 	return s.DefinitionDatabase.World()
 }
 
-func (s *Solver) Installed() []pkg.Package {
+func (s *Solver) Installed() pkg.Packages {
 
 	return s.InstalledDatabase.World()
 }
@@ -130,8 +130,8 @@ func (s *Solver) BuildWorld(includeInstalled bool) (bf.Formula, error) {
 	return bf.And(formulas...), nil
 }
 
-func (s *Solver) getList(db pkg.PackageDatabase, lsp []pkg.Package) ([]pkg.Package, error) {
-	var ls []pkg.Package
+func (s *Solver) getList(db pkg.PackageDatabase, lsp pkg.Packages) (pkg.Packages, error) {
+	var ls pkg.Packages
 
 	for _, pp := range lsp {
 		cp, err := db.FindPackage(pp)
@@ -141,7 +141,7 @@ func (s *Solver) getList(db pkg.PackageDatabase, lsp []pkg.Package) ([]pkg.Packa
 			if err != nil || len(packages) == 0 {
 				cp = pp
 			} else {
-				cp = pkg.Best(packages)
+				cp = packages.Best()
 			}
 		}
 		ls = append(ls, cp)
@@ -149,7 +149,7 @@ func (s *Solver) getList(db pkg.PackageDatabase, lsp []pkg.Package) ([]pkg.Packa
 	return ls, nil
 }
 
-func (s *Solver) ConflictsWith(pack pkg.Package, lsp []pkg.Package) (bool, error) {
+func (s *Solver) ConflictsWith(pack pkg.Package, lsp pkg.Packages) (bool, error) {
 	p, err := s.DefinitionDatabase.FindPackage(pack)
 	if err != nil {
 		p = pack //Relax search, otherwise we cannot compute solutions for packages not in definitions
@@ -210,14 +210,14 @@ func (s *Solver) ConflictsWithInstalled(p pkg.Package) (bool, error) {
 	return s.ConflictsWith(p, s.Installed())
 }
 
-func (s *Solver) Upgrade(checkconflicts bool) ([]pkg.Package, PackagesAssertions, error) {
+func (s *Solver) Upgrade(checkconflicts bool) (pkg.Packages, PackagesAssertions, error) {
 
 	// First get candidates that needs to be upgraded..
 
-	toUninstall := []pkg.Package{}
-	toInstall := []pkg.Package{}
+	toUninstall := pkg.Packages{}
+	toInstall := pkg.Packages{}
 
-	availableCache := map[string][]pkg.Package{}
+	availableCache := map[string]pkg.Packages{}
 	for _, p := range s.DefinitionDatabase.World() {
 		// Each one, should be expanded
 		availableCache[p.GetName()+p.GetCategory()] = append(availableCache[p.GetName()+p.GetCategory()], p)
@@ -229,7 +229,7 @@ func (s *Solver) Upgrade(checkconflicts bool) ([]pkg.Package, PackagesAssertions
 		installedcopy.CreatePackage(p)
 		packages, ok := availableCache[p.GetName()+p.GetCategory()]
 		if ok && len(packages) != 0 {
-			best := pkg.Best(packages)
+			best := packages.Best()
 			if best.GetVersion() != p.GetVersion() {
 				toUninstall = append(toUninstall, p)
 				toInstall = append(toInstall, best)
@@ -261,8 +261,8 @@ func (s *Solver) Upgrade(checkconflicts bool) ([]pkg.Package, PackagesAssertions
 
 // Uninstall takes a candidate package and return a list of packages that would be removed
 // in order to purge the candidate. Returns error if unsat.
-func (s *Solver) Uninstall(c pkg.Package, checkconflicts bool) ([]pkg.Package, error) {
-	var res []pkg.Package
+func (s *Solver) Uninstall(c pkg.Package, checkconflicts bool) (pkg.Packages, error) {
+	var res pkg.Packages
 	candidate, err := s.InstalledDatabase.FindPackage(c)
 	if err != nil {
 
@@ -272,13 +272,13 @@ func (s *Solver) Uninstall(c pkg.Package, checkconflicts bool) ([]pkg.Package, e
 		if err != nil || len(packages) == 0 {
 			candidate = c
 		} else {
-			candidate = pkg.Best(packages)
+			candidate = packages.Best()
 		}
 		//Relax search, otherwise we cannot compute solutions for packages not in definitions
 		//	return nil, errors.Wrap(err, "Package not found between installed")
 	}
 	// Build a fake "Installed" - Candidate and its requires tree
-	var InstalledMinusCandidate []pkg.Package
+	var InstalledMinusCandidate pkg.Packages
 
 	// TODO: Can be optimized
 	for _, i := range s.Installed() {
@@ -296,7 +296,7 @@ func (s *Solver) Uninstall(c pkg.Package, checkconflicts bool) ([]pkg.Package, e
 	s2 := NewSolver(pkg.NewInMemoryDatabase(false), s.DefinitionDatabase, pkg.NewInMemoryDatabase(false))
 	s2.SetResolver(s.Resolver)
 	// Get the requirements to install the candidate
-	asserts, err := s2.Install([]pkg.Package{candidate})
+	asserts, err := s2.Install(pkg.Packages{candidate})
 	if err != nil {
 		return nil, err
 	}
@@ -403,7 +403,7 @@ func (s *Solver) Solve() (PackagesAssertions, error) {
 
 // Install given a list of packages, returns package assertions to indicate the packages that must be installed in the system in order
 // to statisfy all the constraints
-func (s *Solver) Install(c []pkg.Package) (PackagesAssertions, error) {
+func (s *Solver) Install(c pkg.Packages) (PackagesAssertions, error) {
 
 	coll, err := s.getList(s.DefinitionDatabase, c)
 	if err != nil {
diff --git a/pkg/solver/solver_test.go b/pkg/solver/solver_test.go
index 56482743..cd41ec82 100644
--- a/pkg/solver/solver_test.go
+++ b/pkg/solver/solver_test.go
@@ -882,7 +882,7 @@ var _ = Describe("Solver", func() {
 			Expect(lst).To(ContainElement(a03))
 			Expect(lst).ToNot(ContainElement(old))
 			Expect(len(lst)).To(Equal(5))
-			p := pkg.Best(lst)
+			p := lst.Best()
 			Expect(p).To(Equal(a03))
 		})
 	})
diff --git a/pkg/tree/builder/gentoo/gentoo.go b/pkg/tree/builder/gentoo/gentoo.go
index 0831bcc7..e520f019 100644
--- a/pkg/tree/builder/gentoo/gentoo.go
+++ b/pkg/tree/builder/gentoo/gentoo.go
@@ -50,7 +50,7 @@ type GentooBuilder struct {
 }
 
 type EbuildParser interface {
-	ScanEbuild(string) ([]pkg.Package, error)
+	ScanEbuild(string) (pkg.Packages, error)
 }
 
 func (gb *GentooBuilder) scanEbuild(path string, db pkg.PackageDatabase) error {
diff --git a/pkg/tree/builder/gentoo/simpleparser.go b/pkg/tree/builder/gentoo/simpleparser.go
index 98ee6efa..41625a46 100644
--- a/pkg/tree/builder/gentoo/simpleparser.go
+++ b/pkg/tree/builder/gentoo/simpleparser.go
@@ -323,7 +323,7 @@ func SourceFile(ctx context.Context, path string, pkg *_gentoo.GentooPackage) (m
 }
 
 // ScanEbuild returns a list of packages (always one with SimpleEbuildParser) decoded from an ebuild.
-func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) {
+func (ep *SimpleEbuildParser) ScanEbuild(path string) (pkg.Packages, error) {
 	Debug("Starting parsing of ebuild", path)
 
 	pkgstr := filepath.Base(path)
@@ -332,7 +332,7 @@ func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) {
 
 	gp, err := _gentoo.ParsePackageStr(pkgstr)
 	if err != nil {
-		return []pkg.Package{}, errors.New("Error on parsing package string")
+		return pkg.Packages{}, errors.New("Error on parsing package string")
 	}
 
 	pack := &pkg.DefaultPackage{
@@ -350,7 +350,7 @@ func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) {
 	vars, err := SourceFile(timeout, path, gp)
 	if err != nil {
 		Error("Error on source file ", pack.Name, ": ", err)
-		return []pkg.Package{}, err
+		return pkg.Packages{}, err
 	}
 
 	// TODO: Handle this a bit better
@@ -405,8 +405,8 @@ func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) {
 		gRDEPEND, err := ParseRDEPEND(rdepend.String())
 		if err != nil {
 			Warning("Error on parsing RDEPEND for package ", pack.Category+"/"+pack.Name, err)
-			return []pkg.Package{pack}, nil
-			//	return []pkg.Package{}, err
+			return pkg.Packages{pack}, nil
+			//	return pkg.Packages{}, err
 		}
 
 		pack.PackageConflicts = []*pkg.DefaultPackage{}
@@ -436,5 +436,5 @@ func (ep *SimpleEbuildParser) ScanEbuild(path string) ([]pkg.Package, error) {
 	Debug("Finished processing ebuild", path, "deps ", len(pack.PackageRequires))
 
 	//TODO: Deps and conflicts
-	return []pkg.Package{pack}, nil
+	return pkg.Packages{pack}, nil
 }