Rename Unknown -> Deferred

Author: mortenhaahr

README.md

@@ -17,10 +17,10 @@ The following result should be visible on the "z" topic:
 ```
 
 ### Note:
-If you want to provide e.g., an Unknown value then it must be done with:
+If you want to provide e.g., a Deferred value then it must be done with:
 ```json
 {
-    "Unknown": null
+    "Deferred": null
 }
 ```
 

examples/dynamic_lola/defer_default.lola

@@ -2,4 +2,4 @@
 in x
 in e
 out z
-z = defer(default(e, "x")) // Similar to defer("x") if e is Unknown on first sample
+z = defer(default(e, "x")) // Similar to defer("x") if e is Deferred on first sample

examples/dynamic_lola/defer_recvs_update.lola

@@ -3,5 +3,5 @@ in x
 in s
 out z
 // Receives a new property with an update inside it to ensure that
-// despite garbage collection we never receive unknown
+// despite garbage collection we never receive deferred
 z = defer(s)

examples/dynamic_lola/eval_default.lola

@@ -2,4 +2,4 @@
 in x
 in e
 out z
-z = eval(default(e, "x")) // On steps where e=Unknown, evaluate to eval("x")
+z = eval(default(e, "x")) // On steps where e=Deferred, evaluate to eval("x")

examples/dynamic_lola/guided_dup.lola

@@ -12,6 +12,6 @@ S = x
 // Adaptation condition is "x == 3"
 c = x == 3
 // R is Rcond
-R = when(T) && (c || default(R[-1], false)) // Eventually, after T was not Unknown
+R = when(T) && (c || default(R[-1], false)) // Eventually, after T was not Deferred
 // When we haven't received a new spec T, and R is not true, yield from old spec
 v = if R then defer(T) else S

examples/dynamic_lola/overlap_dup.lola

@@ -15,7 +15,7 @@ c = x == 3
 // T with a default value (because if currently doesn't lazy eval)
 Td = default(defer(T), 0)
 // R is Rcond
-R = when(T) && (c || default(R[-1], false)) // Eventually, after T was not Unknown
+R = when(T) && (c || default(R[-1], false)) // Eventually, after T was not Deferred
 // When T is not provided, use S. When T is provided but R is not true, use S + T. When T and R use T.
 v = if !when(T) then S else if !R then S + Td  else Td
 // v = if when(T) then if R then Td else S + Td else S

src/core/values.rs

@@ -24,7 +24,7 @@ pub enum Value {
     Bool(bool),
     List(EcoVec<Value>),
     Map(BTreeMap<EcoString, Value>),
-    Unknown,
+    Deferred,
     Unit,
 }
 
@@ -242,7 +242,7 @@ impl Display for Value {
                 }
                 write!(f, "}}")
             }
-            Value::Unknown => write!(f, "unknown"),
+            Value::Deferred => write!(f, "deferred"),
             Value::Unit => write!(f, "()"),
         }
     }
@@ -283,7 +283,7 @@ impl Serialize for Value {
         match self {
             Value::Unit => serializer.serialize_none(),
 
-            Value::Unknown => serializer.serialize_str("⊥"),
+            Value::Deferred => serializer.serialize_str("⊥"),
 
             Value::Bool(b) => serializer.serialize_bool(*b),
 
@@ -312,7 +312,7 @@ impl Serialize for Value {
 }
 
 impl<'de> Deserialize<'de> for Value {
-    // Certain edge cases were not covered by derived Serialize, such as handling Unknown
+    // Certain edge cases were not covered by derived Serialize, such as handling Deferred
     // symmetrically, hence manual impl
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -353,15 +353,15 @@ impl<'de> Deserialize<'de> for Value {
 
             fn visit_str<E>(self, v: &str) -> Result<Value, E> {
                 if v == "⊥" {
-                    Ok(Value::Unknown)
+                    Ok(Value::Deferred)
                 } else {
                     Ok(Value::Str(v.into()))
                 }
             }
 
             fn visit_string<E>(self, v: String) -> Result<Value, E> {
                 if v == "⊥" {
-                    Ok(Value::Unknown)
+                    Ok(Value::Deferred)
                 } else {
                     Ok(Value::Str(v.into()))
                 }
@@ -619,8 +619,8 @@ mod tests {
     }
 
     #[test]
-    fn test_json_serialize_unknown() {
-        let v = Value::Unknown;
+    fn test_json_serialize_deferred() {
+        let v = Value::Deferred;
         let json = to_string(&v).unwrap();
         assert_eq!(json, "\"⊥\"");
     }
@@ -720,9 +720,9 @@ mod tests {
     }
 
     #[test]
-    fn test_json_bot_maps_to_unknown() {
+    fn test_json_bot_maps_to_deferred() {
         let v = "\"⊥\"";
         let json: Value = from_str(&v).unwrap();
-        assert_eq!(json, Value::Unknown);
+        assert_eq!(json, Value::Deferred);
     }
 }

src/io/file/input_provider.rs

@@ -18,7 +18,7 @@ fn input_file_data_iter(
         Box::new((0..=*max_key).map(move |time| {
             data.get(&time)
                 .and_then(|data_for_time| data_for_time.get(&key).cloned())
-                .unwrap_or(Value::Unknown)
+                .unwrap_or(Value::Deferred)
         }))
     } else {
         Box::new(std::iter::empty())

src/io/testing/manual_output_handler.rs

@@ -311,7 +311,7 @@ mod tests {
 
             // Define ordering of variants
             let variant_order = |value: &Value| match value {
-                Unknown => 0,
+                Deferred => 0,
                 Unit => 1,
                 Bool(_) => 2,
                 Int(_) => 3,
@@ -340,7 +340,7 @@ mod tests {
                 }
                 (Str(a), Str(b)) => a.cmp(b),
                 (List(a), List(b)) => a.cmp(b), // Vec<Value> implements Ord if Value does
-                _ => Ordering::Equal, // Unit and Unknown are considered equal within their kind
+                _ => Ordering::Equal, // Unit and Deferred are considered equal within their kind
             }
         }
     }

src/lang/dist_lang/ast.rs

@@ -37,11 +37,11 @@ pub enum DistSExpr {
     Defer(Box<Self>),
     // Update between properties
     Update(Box<Self>, Box<Self>),
-    // Default value for properties (replaces Unknown with an alternative
+    // Default value for properties (replaces Deferred with an alternative
     // stream)
     Default(Box<Self>, Box<Self>),
-    IsDefined(Box<Self>), // True when .0 is not Unknown
-    When(Box<Self>),      // Becomes true after the first time .0 is not Unknown
+    IsDefined(Box<Self>), // True when .0 is not Deferred
+    When(Box<Self>),      // Becomes true after the first time .0 is not Deferred
 
     // Unary expressions (refactor if more are added...)
     Not(Box<Self>),