instituted sane-people naming for counter types

Author: BartMassey

rc/examples/01-count.rs renamed to rc/examples/01-simple.rs

@@ -1,13 +1,13 @@
-use rc::count::Count;
+use rc::simple::Counter;
 
 /// Increment the given count. Note that this function takes
 /// `count` by mutable reference.
-fn update_count(count: &mut Count) {
+fn update_count(count: &mut Counter) {
     count.incr();
 }
 
 fn main() {
-    let mut count = Count::default();
+    let mut count = Counter::default();
     println!("{}", count.value());
     update_count(&mut count);
     println!("{}", count.value());

rc/examples/02-badcount.rs

@@ -1,9 +1,9 @@
-use rc::count::Count;
+use rc::simple::Counter;
 
 /// A "message" struct. More later.
 struct Message<'a> {
     note: &'static str,
-    counter: &'a mut Count,
+    counter: &'a mut Counter,
 }
 
 /// Increment the given count. Note that this function takes
@@ -20,7 +20,7 @@ fn main() {
     todo!();
     // This code will fail to compile because of two mutable
     // references to `count`.
-    let mut count = Count::default();
+    let mut count = Counter::default();
     let mut left = Message { note: "left", counter: &mut count };
     let mut right = Message { note: "right", counter: &mut count };
     left.update_count();

rc/examples/04-messages.rs

@@ -1,6 +1,4 @@
-use rc::message::Message;
 use rc::misc::make_messages;
-use rc::counter::Counter;
 
 fn main() {
     let (m1, m2) = make_messages("m1", "m2");

rc/examples/03-counter.rs renamed to rc/examples/06-cell.rs

@@ -1,5 +1,4 @@
-// https://doc.rust-lang.org/std/cell/
-use rc::counter::Counter;
+use rc::cell::Counter;
 
 /// Increment the given counter. Note that this function
 /// takes `counter` by immutable reference.
@@ -12,5 +11,4 @@ fn main() {
     println!("{}", counter.value());
     update_counter(&counter);
     println!("{}", counter.value());
-    println!("{}", counter.incr_value());
 }

rc/examples/06-ctr.rs

@@ -1,24 +1,24 @@
 use std::cell::Cell;
 
-use crate::count::Count;
+use crate::simple;
 
 /// An interior-mutable counter over the restricted `Count`.
 #[derive(Default)]
-pub struct Ctr(Cell<Count>);
+pub struct Counter(Cell<simple::Counter>);
 
-impl Ctr {
+impl Counter {
     /// Increase the count of the contained counter by one.
     /// Note that this method takes `self` by immutable
     /// reference, then changes it anyway.
     pub fn incr(&self) {
-        let mut count = self.0.replace(Count::default());
+        let mut count = self.0.replace(simple::Counter::default());
         count.incr();
         let _ = self.0.replace(count);
     }
 
     /// Return the value of the contained counter.
     pub fn value(&self) -> u64 {
-        let count = self.0.replace(Count::default());
+        let count = self.0.replace(simple::Counter::default());
         let value = count.value();
         let _ = self.0.replace(count);
         value

rc/src/ctr.rs renamed to rc/src/cell.rs

@@ -1,7 +1,7 @@
 //! Counting-related ADTs.
 
-pub mod count;
-pub mod counter;
+pub mod simple;
+pub mod cell;
+pub mod refcell;
 pub mod message;
-pub mod ctr;
 pub mod misc;

rc/src/lib.rs

@@ -11,7 +11,7 @@
 //!     assert_eq!(htmp.text(), "hello");
 //!     assert_eq!(hello.accesses(), 2);
 
-use crate::counter::Counter;
+use crate::refcell::Counter;
 
 /// Message to print plus usage counter.
 #[derive(Debug, Clone)]

rc/src/message.rs

@@ -1,4 +1,4 @@
-use crate::counter::Counter;
+use crate::refcell::Counter;
 use crate::message::Message;
 
 /// Make a couple of messages with given message strings.

rc/src/misc.rs

@@ -2,7 +2,7 @@
 //!
 //! # Examples
 //!
-//!     # use rc::counter::Counter;
+//!     # use rc::refcell::Counter;
 //!     let c0 = Counter::default();
 //!     c0.incr();
 //!     assert_eq!(c0.value(), 1);
@@ -12,14 +12,14 @@
 //!     assert_eq!(c0.value(), 3);
 //!     assert_eq!(c1.value(), 3);
 
-use crate::count::Count;
+use crate::simple;
 
 use std::cell::{RefCell, RefMut};
 use std::rc::Rc;
 
-/// An interior-mutable shared counter over the restricted `Count`.
+/// An interior-mutable shared counter over the restricted `simple::Counter`.
 #[derive(Debug, Default, Clone)]
-pub struct Counter(Rc<RefCell<Count>>);
+pub struct Counter(Rc<RefCell<simple::Counter>>);
 
 impl Counter {
     // Note that this method takes `self` by immutable
@@ -42,7 +42,7 @@ impl Counter {
         self.value()
     }
 
-    pub fn count_mut(&self) -> RefMut<Count> {
+    pub fn count_mut(&self) -> RefMut<simple::Counter> {
         self.0.borrow_mut()
     }
 }

rc/src/counter.rs renamed to rc/src/refcell.rs

@@ -2,16 +2,16 @@
 //!      
 //! # Examples
 //!
-//!     # use rc::count::Count;
-//!     let mut count = Count::default();
+//!     # use rc::simple::Counter;
+//!     let mut count = Counter::default();
 //!     count.incr();
 //!     assert_eq!(count.value(), 1);
 
-/// A non-negative count.
+/// A non-negative counter.
 #[derive(Debug, Default)]
-pub struct Count(u64);
+pub struct Counter(u64);
 
-impl Count {
+impl Counter {
     /// Increase the count by one.
     pub fn incr(&mut self) {
         self.0 += 1;

rc/src/count.rs renamed to rc/src/simple.rs

@@ -1,4 +1,4 @@
-use rc::counter::Counter;
+use rc::refcell::Counter;
 
 #[test]
 #[should_panic]