More PrologTerm documentation

diff --git a/src/machine/config.rs b/src/machine/config.rs
index 79752f31790a76d193a77852b802edbdee810deb..b968e62496cd2d4cc191b29cdc4f8783878268d9 100644 (file)
--- a/src/machine/config.rs
+++ b/src/machine/config.rs
@@ -55,7 +55,7 @@ impl MachineConfig {
         Default::default()
     }
 
-    /// Uses the given `crate::StreamConfig` in this configuration. 
+    /// Uses the given `crate::StreamConfig` in this configuration.
     pub fn with_streams(mut self, streams: StreamConfig) -> Self {
         self.streams = streams;
         self

diff --git a/src/machine/lib_machine.rs b/src/machine/lib_machine.rs
index abfe87bf1195d77594dc5ad2d4d21644e24c5b2e..4137a9855ff322e06b56c87b2f89e40f5300815e 100644 (file)
--- a/src/machine/lib_machine.rs
+++ b/src/machine/lib_machine.rs
@@ -1,17 +1,17 @@
 use std::collections::BTreeMap;
 
-use crate::{atom_table, StreamConfig};
 use crate::machine::machine_indices::VarKey;
 use crate::machine::mock_wam::CompositeOpDir;
 use crate::machine::{BREAK_FROM_DISPATCH_LOOP_LOC, LIB_QUERY_SUCCESS};
 use crate::parser::ast::{Var, VarPtr};
 use crate::parser::parser::{Parser, Tokens};
 use crate::read::{write_term_to_heap, TermWriteResult};
+use crate::{atom_table, StreamConfig};
 use indexmap::IndexMap;
 
 use super::{
-    streams::Stream, Atom, AtomCell, HeapCellValue, HeapCellValueTag, Machine, MachineConfig,
-    LeafAnswer, PrologTerm,
+    streams::Stream, Atom, AtomCell, HeapCellValue, HeapCellValueTag, LeafAnswer, Machine,
+    MachineConfig, PrologTerm,
 };
 
 pub struct QueryState<'a> {
@@ -138,7 +138,10 @@ impl Iterator for QueryState<'_> {
         // choice point, so we should break.
         self.machine.machine_st.backtrack();
 
-        Some(Ok(LeafAnswer::LeafAnswer { bindings: bindings, residual_goals: vec![] }))
+        Some(Ok(LeafAnswer::LeafAnswer {
+            bindings: bindings,
+            residual_goals: vec![],
+        }))
     }
 }
 

diff --git a/src/machine/parsed_results.rs b/src/machine/parsed_results.rs
index 93d15ee1f179a134e24f204f2cafa40713a39d1c..3688bc97ea236beff691f27635c441b7739c4c62 100644 (file)
--- a/src/machine/parsed_results.rs
+++ b/src/machine/parsed_results.rs
@@ -27,13 +27,23 @@ pub enum LeafAnswer {
 #[non_exhaustive]
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PrologTerm {
+    /// An arbitrary precision integer.
     Integer(Integer),
+    /// An arbitrary precision rational.
     Rational(Rational),
+    /// A float.
     Float(OrderedFloat<f64>),
+    /// A Prolog atom.
     Atom(String),
+    /// A Prolog string.
+    ///
+    /// In particular, this represents Prolog lists of characters.
     String(String),
+    /// A Prolog list.
     List(Vec<PrologTerm>),
+    /// A Prolog compound term.
     Compound(String, Vec<PrologTerm>),
+    /// A Prolog variable.
     Var(String),
 }
 
@@ -91,12 +101,11 @@ impl PrologTerm {
     /// Creates a conjunction, giving `None` if empty.
     pub fn try_conjunction(value: impl IntoIterator<Item = PrologTerm>) -> Option<Self> {
         let mut iter = value.into_iter();
-        iter.next()
-            .map(|first| {
-                PrologTerm::try_conjunction(iter)
-                    .map(|rest| PrologTerm::compound(",", [first.clone(), rest]))
-                    .unwrap_or(first)
-            })
+        iter.next().map(|first| {
+            PrologTerm::try_conjunction(iter)
+                .map(|rest| PrologTerm::compound(",", [first.clone(), rest]))
+                .unwrap_or(first)
+        })
     }
 
     /// Creates a disjunction, giving the atom `false` if empty.
@@ -107,12 +116,11 @@ impl PrologTerm {
     /// Creates a disjunction, giving `None` if empty.
     pub fn try_disjunction(value: impl IntoIterator<Item = PrologTerm>) -> Option<Self> {
         let mut iter = value.into_iter();
-        iter.next()
-            .map(|first| {
-                PrologTerm::try_disjunction(iter)
-                    .map(|rest| PrologTerm::compound(";", [first.clone(), rest]))
-                    .unwrap_or(first)
-            })
+        iter.next().map(|first| {
+            PrologTerm::try_disjunction(iter)
+                .map(|rest| PrologTerm::compound(";", [first.clone(), rest]))
+                .unwrap_or(first)
+        })
     }
 }
 
@@ -122,12 +130,17 @@ impl From<LeafAnswer> for PrologTerm {
             LeafAnswer::True => PrologTerm::atom("true"),
             LeafAnswer::False => PrologTerm::atom("false"),
             LeafAnswer::Exception(inner) => match inner.clone() {
-                PrologTerm::Compound(functor, args) if functor == "error" && args.len() == 2 => inner,
+                PrologTerm::Compound(functor, args) if functor == "error" && args.len() == 2 => {
+                    inner
+                }
                 _ => PrologTerm::compound("throw", [inner]),
             },
-            LeafAnswer::LeafAnswer { bindings: _, residual_goals: _ } => {
+            LeafAnswer::LeafAnswer {
+                bindings: _,
+                residual_goals: _,
+            } => {
                 todo!()
-            },
+            }
         }
     }
 }