(.module:
  [lux #*
   [data
    ["." text
     ["%" format (#+ format)]]]]
  [//
   ["_" term]
   [//
    ["$" document]]])

(def: #export entire-agreement
  ($.paragraph (list (format _.license " constitutes the entire agreement between the parties with respect to the subject matter hereof"))))

(def: #export relationship-of-parties
  (let [legal-associations (: (List Text)
                              (list "an agency"
                                    "a partnership"
                                    "a joint venture"
                                    "any other form of legal association"))
        forms-of-representation (: (List Text)
                                   (list "expressly"
                                         "by implication"
                                         "by appearance"
                                         "otherwise"))
        disclaimer (format _.license " will not be construed as creating " ($.or legal-associations))
        scope (format "between or among " _.recipient
                      ", " _.licensor
                      " or any " _.contributor)
        constraint (format _.recipient
                           " will not represent to the contrary, whether " ($.or forms-of-representation))]
    ($.paragraph (list (format disclaimer " " scope ", and " constraint)))))

(def: #export independent-development
  (let [actions (: (List Text)
                   (list "acquire"
                         "license"
                         "develop"
                         "subcontract"
                         "market"
                         "distribute"
                         "produce"))
        scope (format "Nothing in " _.license)
        effect (format "impair the right of " _.licensor)
        target "technology or products"
        compete "perform the same or similar functions as, or otherwise compete with,"
        competition (format "any " _.extension)]
    ($.paragraph (list (format scope
                               " will " effect
                               " to " ($.or actions)
                               " " target
                               " that " compete
                               " "  competition
                               " that " _.recipient
                               " may " ($.or actions))))))

(def: #export not-waiver
  (let [culprits (format _.licensor " or any " _.contributor)
        duty (format "enforce any provision of " _.license)
        effect "a waiver of future enforcement of that or any other provision"]
    ($.paragraph (list (format "Failure by " culprits
                               " to " duty
                               " will not be deemed " effect)))))

(def: #export severability
  (let [on-reformation (format "If any provision of " _.license " is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable")
        on-contributor-protection (format "Any law or regulation which provides that the language of a contract shall be construed against the drafter shall not be used to construe " _.license
                                          " against a " _.contributor)]
    ($.paragraph (list on-reformation
                       on-contributor-protection))))

(def: #export export-restrictions
  (let [limiter "applicable laws and regulations"
        limited (: (List Text)
                   (list "downloading"
                         "acquiring"
                         "exporting"
                         "reexporting"))
        on-circumstances (let [limitation (format _.recipient
                                                  " may be restricted with respect to " ($.or limited))
                               target (format _.work " or any underlying information or technology")]
                           (format limitation " " target " by " limiter))
        on-acceptance-of-responsibility (let [trigger (format "By " ($.or limited) " " _.work)
                                              agreement (format _.recipient
                                                                " is agreeing to be responsible for compliance with all " limiter)]
                                          (format trigger ", " agreement))]
    ($.paragraph (list on-circumstances
                       on-acceptance-of-responsibility))))

(def: #export new-versions
  (let [on-publishing (let [when ", from time to time,"
                            what (format "revised versions of " _.license)]
                        (format _.licensor " may publish" when " " what))
        on-published-version-validity (let [condition (format _.work " has been published under a particular version of " _.license)
                                            effect (format _.recipient " may always continue to use it under the terms of that version")]
                                        (format "Once " condition ", " effect))
        on-license-upgrading (format _.recipient
                                     " may also choose to use " _.work
                                     " under the terms of any subsequent version of " _.license
                                     " published by " _.licensor)
        on-licensor-privilege (format "No one other than " _.licensor
                                      " has the right to modify the terms applicable to " _.work
                                      " created under " _.license)]
    ($.paragraph (list on-publishing
                       on-published-version-validity
                       on-license-upgrading
                       on-licensor-privilege))))