Merge branch 'master' into dashu-fixes

diff --cc Cargo.toml
Simple merge

diff --cc src/arithmetic.rs
index a13510b7cd934a7f41824d4f3a3f193211a8d22f,fd8a8edcd7ed8cf91abb1afd4c78227952ba0f6a..95b4fe2c9846cdb86a5c91239b03cba9d2a7e860
--- 1/src/arithmetic.rs
--- 2/src/arithmetic.rs
+++ b/src/arithmetic.rs
@@@ -572,11 -563,15 +567,15 @@@ impl PartialEq for Number 
                  }
                  #[cfg(not(feature = "num"))]
                  {
 -                    &**n1 == &**n2
 +                    (&**n1).num_eq(&**n2)
                  }
              }
-             (&Number::Rational(ref n1), &Number::Float(n2)) => OrderedFloat(n1.to_f64().value()).eq(&n2),
-             (&Number::Float(n1), &Number::Rational(ref n2)) => n1.eq(&OrderedFloat(n2.to_f64().value())),
+             (&Number::Rational(ref n1), &Number::Float(n2)) => {
+                 OrderedFloat(n1.to_f64().value()).eq(&n2)
+             }
+             (&Number::Float(n1), &Number::Rational(ref n2)) => {
+                 n1.eq(&OrderedFloat(n2.to_f64().value()))
+             }
              (&Number::Float(f1), &Number::Float(f2)) => f1.eq(&f2),
              (&Number::Rational(ref r1), &Number::Rational(ref r2)) => r1.eq(&r2),
          }
@@@ -663,11 -660,15 +664,15 @@@ impl Ord for Number 
                  }
                  #[cfg(not(feature = "num"))]
                  {
 -                    (&*n1).partial_cmp(&*n2).unwrap_or(Ordering::Less)
 +                    (&*n1).num_partial_cmp(&*n2).unwrap_or(Ordering::Less)
                  }
              }
-             (&Number::Rational(n1), &Number::Float(n2)) => OrderedFloat(n1.to_f64().value()).cmp(&n2),
-             (&Number::Float(n1), &Number::Rational(n2)) => n1.cmp(&OrderedFloat(n2.to_f64().value())),
+             (&Number::Rational(n1), &Number::Float(n2)) => {
+                 OrderedFloat(n1.to_f64().value()).cmp(&n2)
+             }
+             (&Number::Float(n1), &Number::Rational(n2)) => {
+                 n1.cmp(&OrderedFloat(n2.to_f64().value()))
+             }
              (&Number::Float(f1), &Number::Float(f2)) => f1.cmp(&f2),
              (&Number::Rational(r1), &Number::Rational(r2)) => (*r1).cmp(&*r2),
          }

diff --cc src/heap_print.rs
Simple merge

diff --cc src/indexing.rs
Simple merge

diff --cc src/machine/arithmetic_ops.rs
index da2f28d6d5b2cecfcb16cb435bf7bc9b3c7f9632,62b151e6ab80c696d7455096f3ae3ecbcc06e9bc..21d46a8513b02b2b019f0e3a52a625c1911f143b
--- 1/src/machine/arithmetic_ops.rs
--- 2/src/machine/arithmetic_ops.rs
+++ b/src/machine/arithmetic_ops.rs
@@@ -681,21 -673,17 +681,22 @@@ pub(crate) fn shr(n1: Number, n2: Numbe
          }
          (Number::Integer(n1), Number::Fixnum(n2)) => match usize::try_from(n2.get_num()) {
              Ok(n2) => Ok(Number::arena_from(Integer::from(&*n1 >> n2), arena)),
-             _ => {
-                       Ok(Number::arena_from(Integer::from(&*n1 >> usize::max_value()),arena))
-               },
+             _ => Ok(Number::arena_from(
+                 Integer::from(&*n1 >> usize::max_value()),
+                 arena,
+             )),
          },
 -        (Number::Integer(n1), Number::Integer(n2)) => match n2.to_usize() {
 -            Some(n2) => Ok(Number::arena_from(Integer::from(&*n1 >> n2), arena)),
 -            _ => Ok(Number::arena_from(
 -                Integer::from(&*n1 >> usize::max_value()),
 -                arena,
 -            )),
 +        (Number::Integer(n1), Number::Integer(n2)) => {
 +            let result: Result<usize, _> = (&*n2).try_into();
 +
 +            match result {
 +                Ok(n2) => {
 +                    Ok(Number::arena_from(Integer::from(&*n1 >> n2), arena))
 +                }
 +                Err(_) => {
 +                    Ok(Number::arena_from(Integer::from(&*n1 >> usize::max_value()), arena))
 +                }
 +            }
          },
          (Number::Integer(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),
          (Number::Fixnum(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),
@@@ -741,18 -724,20 +742,19 @@@ pub(crate) fn shl(n1: Number, n2: Numbe
          }
          (Number::Integer(n1), Number::Fixnum(n2)) => match usize::try_from(n2.get_num()) {
              Ok(n2) => Ok(Number::arena_from(Integer::from(&*n1 << n2), arena)),
-             _ => {
-                       Ok(Number::arena_from(Integer::from(&*n1 << usize::max_value()),arena))
-                   }
+             _ => Ok(Number::arena_from(
+                 Integer::from(&*n1 << usize::max_value()),
+                 arena,
+             )),
          },
 -        (Number::Integer(n1), Number::Integer(n2)) => match n2.to_u32() {
 -            Some(n2) => Ok(Number::arena_from(
 -                Integer::from(n1.to_u64().unwrap() << n2),
 -                arena,
 -            )),
 -            _ => Ok(Number::arena_from(
 -                Integer::from(&*n1 << usize::max_value()),
 -                arena,
 -            )),
 +        (Number::Integer(n1), Number::Integer(n2)) => match (&*n2).try_into() as Result<u32, _> {
 +            Ok(n2) => {
 +                let n1: u64 = (&*n1).try_into().unwrap();
 +                Ok(Number::arena_from(Integer::from(n1 << n2), arena))
 +            },
 +            _ => {
 +                      Ok(Number::arena_from(Integer::from(&*n1 << usize::max_value()),arena))
 +              }
          },
          (Number::Integer(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),
          (Number::Fixnum(_), n2) => Err(numerical_type_error(ValidType::Integer, n2, stub_gen)),

diff --cc src/machine/heap.rs
Simple merge

diff --cc src/machine/loader.rs
Simple merge

diff --cc src/machine/machine_state.rs
Simple merge

diff --cc src/machine/machine_state_impl.rs
index 90adee3832c9c53b41f710c52b7b160662f92266,8fd74279f98b784f417040801d0816026863b0c5..465b96f5f531b3316400243ff3344aa0c22fd2e6
--- 1/src/machine/machine_state_impl.rs
--- 2/src/machine/machine_state_impl.rs
+++ b/src/machine/machine_state_impl.rs
@@@ -14,9 -13,9 +13,10 @@@ use crate::machine::stack::*
  use crate::machine::unify::*;
  use crate::parser::ast::*;
  use crate::parser::dashu::{Integer, Rational};
+ use crate::types::*;
  
  use indexmap::IndexSet;
 +use num_order::NumOrd;
  
  use std::cmp::Ordering;
  use std::convert::TryFrom;

diff --cc src/machine/preprocessor.rs
index f7fa110feed75dff9280ef6b138e2438342ef90e,b51ee2fba1530e7770cc706b6f2458935c99fcec..958bc3c451f0cb91f810ca1a9ff856e417e0d6e5
--- 1/src/machine/preprocessor.rs
--- 2/src/machine/preprocessor.rs
+++ b/src/machine/preprocessor.rs
@@@ -65,13 -58,11 +58,14 @@@ fn setup_predicate_indicator(term: &mu
              let name = terms.pop().unwrap();
  
              let arity = match arity {
 -                Term::Literal(_, Literal::Integer(n)) => n.to_usize(),
 +                Term::Literal(_, Literal::Integer(n)) => {
 +                    let value: usize = (&*n).try_into().unwrap();
 +                    Some(value)
 +                },
                  Term::Literal(_, Literal::Fixnum(n)) => usize::try_from(n.get_num()).ok(),
                  _ => None,
-             }.ok_or(CompilationError::InvalidModuleExport)?;
+             }
+             .ok_or(CompilationError::InvalidModuleExport)?;
  
              let name = match name {
                  Term::Literal(_, Literal::Atom(name)) => Some(name),

diff --cc src/machine/system_calls.rs
index 609bcdcd081b8fe8052fe58b4e81ac45636be626,3e6a7090b78294274187bf9d83da5987bf5d831d..00cc39c63f9d2f1b4d604a2944907a173eebc9fb
--- 1/src/machine/system_calls.rs
--- 2/src/machine/system_calls.rs
+++ b/src/machine/system_calls.rs
@@@ -1104,20 -1109,17 +1115,18 @@@ impl MachineState 
              let addr = self.store(self.deref(addr));
  
              match Number::try_from(addr) {
-                 Ok(Number::Fixnum(n)) => {
-                     match u32::try_from(n.get_num()) {
-                         Ok(n) => {
-                             if let Some(c) = std::char::from_u32(n) {
-                                 string.push(c);
-                                 continue;
-                             }
+                 Ok(Number::Fixnum(n)) => match u32::try_from(n.get_num()) {
+                     Ok(n) => {
+                         if let Some(c) = std::char::from_u32(n) {
+                             string.push(c);
+                             continue;
                          }
-                         _ => {}
                      }
-                 }
+                     _ => {}
+                 },
                  Ok(Number::Integer(n)) => {
 -                    if let Some(c) = n.to_u32().and_then(std::char::from_u32) {
 +                    let n: u32 = (&*n).try_into().unwrap();
 +                    if let Some(c) = std::char::from_u32(n) {
                          string.push(c);
                          continue;
                      }
@@@ -4520,71 -4628,71 +4655,71 @@@ impl Machine 
      #[cfg(feature = "http")]
      #[inline(always)]
      pub(crate) fn http_answer(&mut self) -> CallResult {
 -        let culprit = self.deref_register(1);
 -        let status_code = self.deref_register(2);
 -        let status_code: u16 = match Number::try_from(status_code) {
 -            Ok(Number::Fixnum(n)) => n.get_num() as u16,
 -            Ok(Number::Integer(n)) => match n.to_u16() {
 -                Some(u) => u,
 -                _ => {
 -                    self.machine_st.fail = true;
 -                    return Ok(());
 -                }
 -            },
 -            _ => unreachable!(),
 -        };
 -        let stub_gen = || functor_stub(atom!("http_listen"), 2);
 -        let headers = match self
 -            .machine_st
 -            .try_from_list(self.machine_st.registers[3], stub_gen)
 -        {
 +      let culprit = self.deref_register(1);
 +      let status_code = self.deref_register(2);
 +      let status_code: u16 = match Number::try_from(status_code) {
 +          Ok(Number::Fixnum(n)) => n.get_num() as u16,
 +          Ok(Number::Integer(n)) => {
 +            let n: Result<u16, _> = (&*n).try_into();
 +            
 +            if let Ok(value) = n {
 +                value
 +            } else {
 +                self.machine_st.fail = true;
 +                return Ok(());
 +            }
 +        }
 +          _ => unreachable!()
 +      };
 +      let stub_gen = || functor_stub(atom!("http_listen"), 2);
 +      let headers = match self.machine_st.try_from_list(self.machine_st.registers[3], stub_gen) {
              Ok(addrs) => {
                  let mut header_map = HeaderMap::new();
-                 for heap_cell in addrs{
-                    read_heap_cell!(heap_cell,
-                        (HeapCellValueTag::Str, s) => {
-                            let name = cell_as_atom_cell!(self.machine_st.heap[s]).get_name();
-                            let value = self.machine_st.value_to_str_like(self.machine_st.heap[s + 1]).unwrap();
-                            header_map.insert(HeaderName::from_str(name.as_str()).unwrap(), HeaderValue::from_str(value.as_str()).unwrap());
-                        }
-                        _ => {
-                            unreachable!()
-                        }
-                    )
+                 for heap_cell in addrs {
+                     read_heap_cell!(heap_cell,
+                         (HeapCellValueTag::Str, s) => {
+                             let name = cell_as_atom_cell!(self.machine_st.heap[s]).get_name();
+                             let value = self.machine_st.value_to_str_like(self.machine_st.heap[s + 1]).unwrap();
+                             header_map.insert(HeaderName::from_str(&*name.as_str()).unwrap(), HeaderValue::from_str(&*value.as_str()).unwrap());
+                         }
+                         _ => {
+                             unreachable!()
+                         }
+                     )
                  }
                  header_map
-             },
-             Err(e) => return Err(e)
+             }
+             Err(e) => return Err(e),
          };
-       let stream_addr = self.deref_register(4);
- 
-       read_heap_cell!(culprit,
-           (HeapCellValueTag::Cons, cons_ptr) => {
-               match_untyped_arena_ptr!(cons_ptr,
-                   (ArenaHeaderTag::HttpResponse, http_response) => {
-                       let mut stream = Stream::from_http_sender(
-                           http_response,
-                           status_code,
-                           headers,
-                           &mut self.machine_st.arena
-                       );
-                       *stream.options_mut() = StreamOptions::default();
-                       stream.options_mut().set_stream_type(StreamType::Binary);
-                       self.indices.streams.insert(stream);
-                       let stream = stream_as_cell!(stream);
-                       self.machine_st.bind(stream_addr.as_var().unwrap(), stream);
-                   }
-                   _ => {
-                       unreachable!();
-                   }
-               );
-           }
-           _ => {
-               unreachable!();
-           }
-       );
- 
-       Ok(())
+         let stream_addr = self.deref_register(4);
+ 
+         read_heap_cell!(culprit,
+             (HeapCellValueTag::Cons, cons_ptr) => {
+             match_untyped_arena_ptr!(cons_ptr,
+                 (ArenaHeaderTag::HttpResponse, http_response) => {
+                 let mut stream = Stream::from_http_sender(
+                     http_response,
+                     status_code,
+                     headers,
+                     &mut self.machine_st.arena
+                 );
+                 *stream.options_mut() = StreamOptions::default();
+                 stream.options_mut().set_stream_type(StreamType::Binary);
+                 self.indices.streams.insert(stream);
+                 let stream = stream_as_cell!(stream);
+                 self.machine_st.bind(stream_addr.as_var().unwrap(), stream);
+                 }
+                 _ => {
+                 unreachable!();
+                 }
+             );
+             }
+             _ => {
+             unreachable!();
+             }
+         );
+ 
+         Ok(())
      }
  
      #[cfg(feature = "ffi")]
@@@ -5369,15 -5512,9 +5549,12 @@@
  
          let n = match Number::try_from(a2) {
              Ok(Number::Fixnum(bp)) => bp.get_num() as usize,
 -            Ok(Number::Integer(n)) => n.to_usize().unwrap(),
 +            Ok(Number::Integer(n)) => {
 +                let value: usize = (&*n).try_into().unwrap();
 +                value
 +            },
              _ => {
-                 let stub = functor_stub(
-                     atom!("call_with_inference_limit"),
-                     3,
-                 );
+                 let stub = functor_stub(atom!("call_with_inference_limit"), 3);
  
                  let err = self.machine_st.type_error(ValidType::Integer, a2);
                  return Err(self.machine_st.error_form(err, stub));
@@@ -5415,12 -5551,10 +5592,12 @@@
          let a3 = self.deref_register(3);
  
          let arity = match Number::try_from(a3) {
-             Ok(Number::Fixnum(n))  => n.get_num() as usize,
+             Ok(Number::Fixnum(n)) => n.get_num() as usize,
              Ok(Number::Integer(n)) => {
 -                if let Some(n) = n.to_usize() {
 -                    n
 +                let result = (&*n).try_into();
 +
 +                if let Ok(value) = result {
 +                    value
                  } else {
                      return false;
                  }
@@@ -6058,22 -6220,18 +6264,21 @@@
      pub(crate) fn set_seed(&mut self) {
          let seed = self.deref_register(1);
  
- 
          match Number::try_from(seed) {
              Ok(Number::Fixnum(n)) => {
 -                let _: StdRng = SeedableRng::seed_from_u64(Integer::from(n).to_u64().unwrap());
 -            }
 +                let n: u64 = Integer::from(n).try_into().unwrap();
 +                let _: StdRng = SeedableRng::seed_from_u64(n);
 +            },
              Ok(Number::Integer(n)) => {
 -                let _: StdRng = SeedableRng::seed_from_u64(n.to_u64().unwrap());
 -            }
 +                let n: u64 = (&*n).try_into().unwrap();
 +                let _: StdRng = SeedableRng::seed_from_u64(n);
 +            },
              Ok(Number::Rational(n)) => {
                  if n.denominator() == &UBig::from(1 as u32) {
 -                    let _: StdRng = SeedableRng::seed_from_u64(n.numerator().to_u64().unwrap());
 +                    let n: u64 = n.numerator().try_into().unwrap();
 +                    let _: StdRng = SeedableRng::seed_from_u64(n);
                  }
-             },
+             }
              _ => {
                  self.machine_st.fail = true;
              }

diff --cc src/machine/unify.rs
Simple merge