(.module:
  [lux (#- Info Source Module Name)
   [abstract
    [monoid (#+ Monoid)]
    ["." equivalence (#+ Equivalence)]]
   [control
    ["." exception (#+ exception:)]]
   [data
    ["." maybe ("#@." monoid)]
    ["." text]
    [collection
     ["." dictionary (#+ Dictionary)]
     ["." list ("#@." monoid)]
     ["." set (#+ Set)]]]
   [world
    [net (#+ URL)]
    [file (#+ Path)]]
   [tool
    [compiler
     [meta
      [archive
       [descriptor (#+ Module)]]]]]]
  [//
   ["." artifact (#+ Artifact)]
   ["." dependency]])

(def: #export file
  "project.lux")

(type: #export Distribution
  #Repo
  #Manual)

(structure: distribution-equivalence
  (Equivalence Distribution)

  (def: (= reference subject)
    (case [reference subject]
      (^template [<tag>]
        [<tag> <tag>]
        true)
      ([#Repo]
       [#Manual])

      _
      false)))

(type: #export License
  [Text
   URL
   Distribution])

(def: license-equivalence
  (Equivalence License)
  ($_ equivalence.product
      text.equivalence
      text.equivalence
      ..distribution-equivalence))

(type: #export SCM
  URL)

(type: #export Organization
  [Text
   URL])

(def: organization-equivalence
  (Equivalence Organization)
  ($_ equivalence.product
      text.equivalence
      text.equivalence))

(type: #export Email
  Text)

(type: #export Developer
  [Text
   Email
   (Maybe Organization)])

(def: developer-equivalence
  (Equivalence Developer)
  ($_ equivalence.product
      text.equivalence
      text.equivalence
      (maybe.equivalence ..organization-equivalence)))

(type: #export Contributor
  Developer)

(type: #export Info
  {#url (Maybe URL)
   #scm (Maybe SCM)
   #description (Maybe Text)
   #licenses (List License)
   #organization (Maybe Organization)
   #developers (List Developer)
   #contributors (List Contributor)})

(def: info-equivalence
  (Equivalence Info)
  ($_ equivalence.product
      (maybe.equivalence text.equivalence)
      (maybe.equivalence text.equivalence)
      (maybe.equivalence text.equivalence)
      (list.equivalence ..license-equivalence)
      (maybe.equivalence ..organization-equivalence)
      (list.equivalence ..developer-equivalence)
      (list.equivalence ..developer-equivalence)))

(def: #export default-info
  Info
  {#url #.None
   #scm #.None
   #description #.None
   #licenses (list)
   #organization #.None
   #developers (list)
   #contributors (list)})

(type: #export Source
  Path)

(def: #export default-source
  Source
  "source")

(type: #export Target
  Path)

(def: #export default-target
  Target
  "target")

(type: #export Name
  Text)

(def: #export default
  Name
  "")

(type: #export Profile
  {#parents (List Name)
   #identity (Maybe Artifact)
   #info (Maybe Info)
   #repositories (Set dependency.Repository)
   #dependencies (Set dependency.Dependency)
   #sources (Set Source)
   #target (Maybe Target)
   #program (Maybe Module)
   #test (Maybe Module)
   #deploy-repositories (Dictionary Text dependency.Repository)})

(def: #export empty
  Profile
  {#parents (list)
   #identity #.None
   #info #.None
   #repositories (set.new text.hash)
   #dependencies (set.new dependency.hash)
   #sources (set.new text.hash)
   #target #.None
   #program #.None
   #test #.None
   #deploy-repositories (dictionary.new text.hash)})

(def: #export equivalence
  (Equivalence Profile)
  ($_ equivalence.product
      ## #parents
      (list.equivalence text.equivalence)
      ## #identity
      (maybe.equivalence artifact.equivalence)
      ## #info
      (maybe.equivalence ..info-equivalence)
      ## #repositories
      set.equivalence
      ## #dependencies
      set.equivalence
      ## #sources
      set.equivalence
      ## #target
      (maybe.equivalence text.equivalence)
      ## #program
      (maybe.equivalence text.equivalence)
      ## #test
      (maybe.equivalence text.equivalence)
      ## #deploy-repositories
      (dictionary.equivalence text.equivalence)))

(structure: #export monoid
  (Monoid Profile)

  (def: identity
    {#parents (list)
     #identity #.None
     #info #.None
     #repositories (set.new text.hash)
     #dependencies (set.new dependency.hash)
     #sources (set.new text.hash)
     #target #.None
     #program #.None
     #test #.None
     #deploy-repositories (dictionary.new text.hash)})

  (def: (compose override baseline)
    {#parents (list@compose (get@ #parents baseline) (get@ #parents override))
     #identity (maybe@compose (get@ #identity override) (get@ #identity baseline))
     #info (maybe@compose (get@ #info override) (get@ #info baseline))
     #repositories (set.union (get@ #repositories baseline) (get@ #repositories override))
     #dependencies (set.union (get@ #dependencies baseline) (get@ #dependencies override))
     #sources (set.union (get@ #sources baseline) (get@ #sources override))
     #target (maybe@compose (get@ #target override) (get@ #target baseline))
     #program (maybe@compose (get@ #program override) (get@ #program baseline))
     #test (maybe@compose (get@ #test override) (get@ #test baseline))
     #deploy-repositories (dictionary.merge (get@ #deploy-repositories override) (get@ #deploy-repositories baseline))}))

(exception: #export no-identity)