Polytypic programming based on induction, instead of parsing.

documentation/bookmark/health.md

@@ -1,5 +1,8 @@
 # Reference
 
+0. [Young blood transfusion](https://en.wikipedia.org/wiki/Young_blood_transfusion)
+   * [EXCLUSIVE: Ambrosia, the Young Blood Transfusion Startup, Is Quietly Back in Business](https://onezero.medium.com/exclusive-ambrosia-the-young-blood-transfusion-startup-is-quietly-back-in-business-ee2b7494b417)
+   * [El tratamiento controversial](https://www.youtube.com/watch?v=oksvKi1n3ts)
 0. [From Worst-Case CANCER to Best-Case Scenario (NO CANCER)](https://www.youtube.com/watch?v=6JD_JzprK5U)
 0. [How To Naturally Reverse Premature Graying of Hair](https://www.youtube.com/watch?v=LMLdClbwqhE)
 0. [Contraceptive Properties of Stevia rebaudiana](https://www.science.org/doi/10.1126/science.162.3857.1007.a)

lux-mode/lux-mode.el

@@ -377,7 +377,6 @@ Called by `imenu--generic-function'."
 												 "Class"
 												 "type"))
 							(type//checking (altRE "is" "as" "let" "as_expected" "type_of" "sharing" "by_example" "hole"))
-							(type//poly (altRE "polytypic"))
 							(type//dynamic (altRE "dynamic" "static"))
 							(type//capability (altRE "capability"))
 							;; Data
@@ -409,7 +408,6 @@ Called by `imenu--generic-function'."
 											  control//polymorphism))
 							  (type (altRE type//syntax
 										   type//checking
-										   type//poly
 										   type//dynamic
 										   type//capability))
 							  (data (altRE data//record
@@ -583,7 +581,6 @@ This function also returns nil meaning don't specify the indentation."
   ("macro" 'defun)
   ("syntax" 'defun)
   ("template" 'defun)
-  ("polytypic" 'defun)
   ("program" 'defun)
 
   ("the" 'defun)

stdlib/source/documentation/lux/data/collection/bits.lux

@@ -42,7 +42,7 @@
 
         ($.definition /.intersects?
           ""
-          ($.example (' (intersects? reference sample))))
+          ($.example (' (intersects? reference it))))
 
         ($.definition /.not
           ""

stdlib/source/documentation/lux/math/number/frac.lux

@@ -96,23 +96,23 @@
 
                     ($.definition /.=
                       "Frac(tion) equivalence."
-                      ($.example (' (= reference sample))))
+                      ($.example (' (= expected actual))))
 
                     ($.definition /.<
                       "Frac(tion) less-than."
-                      ($.example (' (< reference sample))))
+                      ($.example (' (< reference it))))
 
                     ($.definition /.<=
                       "Frac(tion) less-than or equal."
-                      ($.example (' (<= reference sample))))
+                      ($.example (' (<= reference it))))
 
                     ($.definition /.>
                       "Frac(tion) greater-than."
-                      ($.example (' (> reference sample))))
+                      ($.example (' (> reference it))))
 
                     ($.definition /.>=
                       "Frac(tion) greater-than or equal."
-                      ($.example (' (>= reference sample))))
+                      ($.example (' (>= reference it))))
 
                     (,, (with_template [<name> <doc>]
                           [($.definition <name>

stdlib/source/documentation/lux/math/number/int.lux

@@ -39,23 +39,23 @@
 
             ($.definition /.=
               "Int(eger) equivalence."
-              ($.example (' (= reference sample))))
+              ($.example (' (= expected actual))))
 
             ($.definition /.<
               "Int(eger) less-than."
-              ($.example (' (< reference sample))))
+              ($.example (' (< reference it))))
 
             ($.definition /.<=
               "Int(eger) less-than or equal."
-              ($.example (' (<= reference sample))))
+              ($.example (' (<= reference it))))
 
             ($.definition /.>
               "Int(eger) greater-than."
-              ($.example (' (> reference sample))))
+              ($.example (' (> reference it))))
 
             ($.definition /.>=
               "Int(eger) greater-than or equal."
-              ($.example (' (>= reference sample))))
+              ($.example (' (>= reference it))))
 
             (,, (with_template [<name> <doc>]
                   [($.definition <name>

stdlib/source/documentation/lux/math/number/rev.lux

@@ -46,23 +46,23 @@
 
             ($.definition /.=
               "Rev(olution) equivalence."
-              ($.example (' (= reference sample))))
+              ($.example (' (= expected actual))))
 
             ($.definition /.<
               "Rev(olution) less-than."
-              ($.example (' (< reference sample))))
+              ($.example (' (< reference it))))
 
             ($.definition /.<=
               "Rev(olution) less-than or equal."
-              ($.example (' (<= reference sample))))
+              ($.example (' (<= reference it))))
 
             ($.definition /.>
               "Rev(olution) greater-than."
-              ($.example (' (> reference sample))))
+              ($.example (' (> reference it))))
 
             ($.definition /.>=
               "Rev(olution) greater-than or equal."
-              ($.example (' (>= reference sample))))
+              ($.example (' (>= reference it))))
 
             (,, (with_template [<name> <doc>]
                   [($.definition <name>

stdlib/source/library/lux.lux

@@ -1226,9 +1226,9 @@
         {#End}}
        [xs ys]))
 
-(def' .private (text#= reference sample)
+(def' .private (text#= expected actual)
       {#Function Text {#Function Text Bit}}
-      (.text_=# reference sample))
+      (.text_=# expected actual))
 
 (def' .private (replacement for environment)
       {#Function Text {#Function Replacement_Environment ($ Maybe Code)}}
@@ -2640,16 +2640,16 @@
           I64)
       (.i64_and# low_mask value))
 
-(def' .private (n#< reference sample)
+(def' .private (n#< reference it)
       (-> Nat Nat
           Bit)
       (let' [referenceH (high_bits reference)
-             sampleH (high_bits sample)]
-            (if (.int_<# referenceH sampleH)
+             itH (high_bits it)]
+            (if (.int_<# referenceH itH)
               #1
-              (if (.i64_=# referenceH sampleH)
+              (if (.i64_=# referenceH itH)
                 (.int_<# (low_bits reference)
-                         (low_bits sample))
+                         (low_bits it))
                 #0))))
 
 (def' .private (list#conjoint xs)
@@ -4568,12 +4568,12 @@
   [(.text_clip# 0 at x)
    (.text_clip# at (|> x .text_size# (.i64_-# at)) x)])
 
-(the (text#split_by token sample)
+(the (text#split_by token it)
   (-> Text Text
       (Maybe [Text Text]))
   (do ..maybe#monad
-    [index (..index token sample)
-     .let [[pre post'] (text#split_at' index sample)
+    [index (..index token it)
+     .let [[pre post'] (text#split_at' index it)
            [_ post] (text#split_at' (.text_size# token) post')]]
     (in [pre post])))
 
@@ -5752,11 +5752,11 @@
         {#None}
         (failure ..wrong_syntax)))))
 
-(the .public (same? reference sample)
+(the .public (same? expected actual)
   (All (_ of)
     (-> of of
         Bit))
-  (.is?# reference sample))
+  (.is?# expected actual))
 
 (the .public as_expected
   (macro (_ tokens)

stdlib/source/library/lux/abstract/equivalence.lux

@@ -19,8 +19,8 @@
   (implementation
    (the (each value it)
      (implementation
-      (the (= reference sample)
-        (of it = (value reference) (value sample)))))))
+      (the (= expected actual)
+        (of it = (value expected) (value actual)))))))
 
 (the .public (sum left right)
   (All (_ left right)

stdlib/source/library/lux/abstract/functor/contravariant.lux

@@ -5,9 +5,9 @@
  [library
   [lux (.except)]])
 
-(every .public (Functor f)
+(every .public (Functor !)
   (Interface
-   (is (All (_ a b)
-         (-> (-> b a)
-             (-> (f a) (f b))))
+   (is (All (_ a z)
+         (-> (-> z a)
+             (-> (! a) (! z))))
        each)))

stdlib/source/library/lux/abstract/interval.lux

@@ -97,49 +97,49 @@
    (the bottom (of interval succ (of interval top)))
    (the top (of interval pred (of interval bottom)))))
 
-(the .public (precedes? reference sample)
+(the .public (precedes? reference it)
   (All (_ a) (-> (Interval a) (Interval a) Bit))
   (let [(open "[0]") reference
         limit (of reference bottom)]
-    (and (< limit (of sample bottom))
-         (< limit (of sample top)))))
+    (and (< limit (of it bottom))
+         (< limit (of it top)))))
 
-(the .public (succeeds? reference sample)
+(the .public (succeeds? reference it)
   (All (_ a) (-> (Interval a) (Interval a) Bit))
-  (precedes? sample reference))
+  (precedes? it reference))
 
 (with_template [<name> <comp>]
-  [(the .public (<name> reference sample)
+  [(the .public (<name> reference it)
      (All (_ a) (-> a (Interval a) Bit))
-     (let [(open ",#[0]") sample]
+     (let [(open ",#[0]") it]
        (and (<comp> reference ,#bottom)
             (<comp> reference ,#top))))]
 
   [before? ,#<]
   [after?  (order.> ,#order)]
   )
 
-(the .public (meets? reference sample)
+(the .public (meets? reference it)
   (All (_ a) (-> (Interval a) (Interval a) Bit))
   (let [(open ",#[0]") reference
         limit (of reference bottom)]
-    (and (,#= limit (of sample top))
-         (order.<= ,#order limit (of sample bottom)))))
+    (and (,#= limit (of it top))
+         (order.<= ,#order limit (of it bottom)))))
 
-(the .public (touches? reference sample)
+(the .public (touches? reference it)
   (All (_ a) (-> (Interval a) (Interval a) Bit))
-  (or (meets? reference sample)
-      (meets? sample reference)))
+  (or (meets? reference it)
+      (meets? it reference)))
 
 (with_template [<name> <eq_side> <ineq> <ineq_side>]
-  [(the .public (<name> reference sample)
+  [(the .public (<name> reference it)
      (All (_ a) (-> (Interval a) (Interval a) Bit))
      (let [(open ",#[0]") reference]
        (and (,#= (of reference <eq_side>)
-                 (of sample <eq_side>))
+                 (of it <eq_side>))
             (<ineq> ,#order
                     (of reference <ineq_side>)
-                    (of sample <ineq_side>)))))]
+                    (of it <ineq_side>)))))]
 
   [starts?   ,#bottom order.<= ,#top]
   [finishes? ,#top    order.>= ,#bottom]
@@ -148,51 +148,51 @@
 (the .public equivalence
   (All (_ a) (Equivalence (Interval a)))
   (implementation
-   (the (= reference sample)
-     (let [(open ",#[0]") reference]
-       (and (,#= ,#bottom (of sample bottom))
-            (,#= ,#top (of sample top)))))))
+   (the (= expected actual)
+     (let [(open ",#[0]") expected]
+       (and (,#= ,#bottom (of actual bottom))
+            (,#= ,#top (of actual top)))))))
 
-(the .public (nested? reference sample)
+(the .public (nested? reference it)
   (All (_ a) (-> (Interval a) (Interval a) Bit))
-  (cond (or (singleton? sample)
-            (and (inner? reference) (inner? sample))
-            (and (outer? reference) (outer? sample)))
+  (cond (or (singleton? it)
+            (and (inner? reference) (inner? it))
+            (and (outer? reference) (outer? it)))
         (let [(open ",#[0]") reference]
-          (and (order.>= ,#order (of reference bottom) (of sample bottom))
-               (order.<= ,#order (of reference top) (of sample top))))
+          (and (order.>= ,#order (of reference bottom) (of it bottom))
+               (order.<= ,#order (of reference top) (of it top))))
 
         (or (singleton? reference)
-            (and (inner? reference) (outer? sample)))
+            (and (inner? reference) (outer? it)))
         false
 
-        ... (and (outer? reference) (inner? sample))
+        ... (and (outer? reference) (inner? it))
         (let [(open ",#[0]") reference]
-          (or (and (order.>= ,#order (of reference bottom) (of sample bottom))
-                   (order.> ,#order (of reference bottom) (of sample top)))
-              (and (,#< (of reference top) (of sample bottom))
-                   (order.<= ,#order (of reference top) (of sample top)))))
+          (or (and (order.>= ,#order (of reference bottom) (of it bottom))
+                   (order.> ,#order (of reference bottom) (of it top)))
+              (and (,#< (of reference top) (of it bottom))
+                   (order.<= ,#order (of reference top) (of it top)))))
         ))
 
-(the .public (overlaps? reference sample)
+(the .public (overlaps? reference it)
   (All (_ a) (-> (Interval a) (Interval a) Bit))
   (let [(open ",#[0]") reference]
-    (and (not (of ..equivalence = reference sample))
-         (cond (singleton? sample)
+    (and (not (of ..equivalence = reference it))
+         (cond (singleton? it)
                false
 
                (singleton? reference)
-               (nested? sample reference)
+               (nested? it reference)
 
-               (or (and (inner? sample) (outer? reference))
-                   (and (outer? sample) (inner? reference)))
-               (or (order.>= ,#order (of reference bottom) (of sample top))
-                   (order.<= ,#order (of reference top) (of sample bottom)))
+               (or (and (inner? it) (outer? reference))
+                   (and (outer? it) (inner? reference)))
+               (or (order.>= ,#order (of reference bottom) (of it top))
+                   (order.<= ,#order (of reference top) (of it bottom)))
 
                ... both inner
-               (inner? sample)
-               (inner? (intersection reference sample))
+               (inner? it)
+               (inner? (intersection reference it))
 
                ... both outer
-               (not (nested? reference sample))
+               (not (nested? reference it))
                ))))