Extracted Licentia out of the standard library.

1 files changed, 43 insertions, 43 deletions

diff --git a/stdlib/source/program/licentia/license/distribution.lux b/licentia/source/program/licentia/license/distribution.lux
index f911623a0..8ec4e9bae 100644
--- a/stdlib/source/program/licentia/license/distribution.lux
+++ b/licentia/source/program/licentia/license/distribution.lux
@@ -23,90 +23,90 @@
           (notices "limitation of liability")
           (notices "other"))))
 
-(def: #export source-code-form
-  (let [on-license-propagation (let [coverage (format "All distribution of " _.work " in " _.source-code-form)
-                                     with-contributions (format "including any " ($.plural _.contribution)
+(def: #export source_code_form
+  (let [on_license_propagation (let [coverage (format "All distribution of " _.work " in " _.source_code_form)
+                                     with_contributions (format "including any " ($.plural _.contribution)
                                                                 " that " _.recipient
                                                                 " creates")
-                                     same-license (format "must be under the terms of " _.license)]
-                                 (format coverage ", " with-contributions ", " same-license))
-        on-license-access (let [responsibility-to-inform (format _.recipient
-                                                                 " must inform recipients that the " _.source-code-form
+                                     same_license (format "must be under the terms of " _.license)]
+                                 (format coverage ", " with_contributions ", " same_license))
+        on_license_access (let [responsibility_to_inform (format _.recipient
+                                                                 " must inform recipients that the " _.source_code_form
                                                                  " of " _.work
                                                                  " is governed by the terms of " _.license)
-                                license-copy (format "and how they can obtain a copy of " _.license)]
-                            (format responsibility-to-inform ", " license-copy))
-        on-license-immutability (format _.recipient
-                                        " may not attempt to alter or restrict the recipients’ rights in the " _.source-code-form
+                                license_copy (format "and how they can obtain a copy of " _.license)]
+                            (format responsibility_to_inform ", " license_copy))
+        on_license_immutability (format _.recipient
+                                        " may not attempt to alter or restrict the recipients’ rights in the " _.source_code_form
                                         ", as specified in " _.license)
-        on-notice-retention (let [obligation (format _.recipient " must retain")
-                                  location (format "in the " _.source-code-form
+        on_notice_retention (let [obligation (format _.recipient " must retain")
+                                  location (format "in the " _.source_code_form
                                                    " of any " _.extension
                                                    " that " _.recipient
                                                    " distributes")
-                                  what (format "all " ($.and notices) " from the " _.source-code-form " of " _.work)
+                                  what (format "all " ($.and notices) " from the " _.source_code_form " of " _.work)
                                   exclusion ($.or (list (format "those notices that do not pertain to any part of the " _.extension)
                                                         "those notices that contain known factual inaccuracies"))]
                               (format obligation ", " location ", " what ", excluding " exclusion))
-        on-additional-notices (let [right (format _.recipient
+        on_additional_notices (let [right (format _.recipient
                                                   " may add additional "($.and notices)
                                                   " within an " _.extension
                                                   " that " _.recipient
                                                   " distributes")
                                     constraint (format "such additional " ($.and notices) " cannot be construed as modifying " _.license)]
                                 (format right ", provided that " constraint))]
-    ($.paragraph (list on-license-propagation
-                       on-license-access
-                       on-license-immutability
-                       on-notice-retention
-                       on-additional-notices))))
+    ($.paragraph (list on_license_propagation
+                       on_license_access
+                       on_license_immutability
+                       on_notice_retention
+                       on_additional_notices))))
 
-(def: #export object-form
-  (let [on-responsibility (let [condition (format "If " _.recipient
+(def: #export object_form
+  (let [on_responsibility (let [condition (format "If " _.recipient
                                                   " distributes " _.work
-                                                  " in " _.object-form)
-                                responsibility (let [availability-responsibility (format _.work " must also be made available in " _.source-code-form)
-                                                     source-code-responsibility (format _.recipient
-                                                                                        " must inform recipients of the " _.object-form
-                                                                                        " how they can obtain a copy of such " _.source-code-form)
+                                                  " in " _.object_form)
+                                responsibility (let [availability_responsibility (format _.work " must also be made available in " _.source_code_form)
+                                                     source_code_responsibility (format _.recipient
+                                                                                        " must inform recipients of the " _.object_form
+                                                                                        " how they can obtain a copy of such " _.source_code_form)
                                                      constraints "by reasonable means in a timely manner, at a charge no more than the cost of distribution to the recipient"]
-                                                 (format availability-responsibility ", and " source-code-responsibility " " constraints))]
+                                                 (format availability_responsibility ", and " source_code_responsibility " " constraints))]
                             (format condition " then " responsibility))
-        on-licensing (format _.recipient
-                             " may distribute such " _.object-form
+        on_licensing (format _.recipient
+                             " may distribute such " _.object_form
                              " under the terms of "_.license)]
-    ($.paragraph (list on-responsibility
-                       on-licensing))))
+    ($.paragraph (list on_responsibility
+                       on_licensing))))
 
-(def: #export allow-re-licensing
-  (let [can-license (format _.recipient
+(def: #export allow_re_licensing
+  (let [can_license (format _.recipient
                             " may create and distribute an " _.extension
                             " under terms " _.recipient
                             " chooses")
         requirement (format _.recipient
                             " also comply with the requirements of " _.license
                             " for the " _.work)]
-    (format can-license ", " "provided that " requirement)))
+    (format can_license ", " "provided that " requirement)))
 
-(def: #export allow-multi-licensing
-  (let [condition (format "the " _.extension " is a combination of " _.work " with a work governed by one or more " ($.plural _.secondary-license))
+(def: #export allow_multi_licensing
+  (let [condition (format "the " _.extension " is a combination of " _.work " with a work governed by one or more " ($.plural _.secondary_license))
         permission (let [relicensing (format _.license
                                              " permits " _.recipient
                                              " to additionally distribute " _.work
-                                             " under the terms of such " ($.plural _.secondary-license))
+                                             " under the terms of such " ($.plural _.secondary_license))
                          distribution (format "so that the recipient of the " _.extension
                                               " may, at their option, further distribute " _.work
                                               " under the terms of either " _.license
-                                              " or such " ($.plural _.secondary-license))]
+                                              " or such " ($.plural _.secondary_license))]
                      (format relicensing ", " distribution))]
     (format "If " condition ", " permission)))
 
 (def: #export (extension distribution)
   (-> Distribution Text)
   ($.paragraph ($_ list\compose
-                   (if (get@ #//.can-re-license? distribution)
-                     (list allow-re-licensing)
+                   (if (get@ #//.can_re_license? distribution)
+                     (list allow_re_licensing)
                      (list))
-                   (if (get@ #//.can-multi-license? distribution)
-                     (list allow-multi-licensing)
+                   (if (get@ #//.can_multi_license? distribution)
+                     (list allow_multi_licensing)
                      (list)))))