got something working in ch10

Author: cfsamson

ch10/x-pin-experiments/.vscode/launch.json

@@ -0,0 +1,45 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug executable 'x-pin-experiments'",
+            "cargo": {
+                "args": [
+                    "build",
+                    "--bin=x-pin-experiments",
+                    "--package=x-pin-experiments"
+                ],
+                "filter": {
+                    "name": "x-pin-experiments",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        },
+        {
+            "type": "lldb",
+            "request": "launch",
+            "name": "Debug unit tests in executable 'x-pin-experiments'",
+            "cargo": {
+                "args": [
+                    "test",
+                    "--no-run",
+                    "--bin=x-pin-experiments",
+                    "--package=x-pin-experiments"
+                ],
+                "filter": {
+                    "name": "x-pin-experiments",
+                    "kind": "bin"
+                }
+            },
+            "args": [],
+            "cwd": "${workspaceFolder}"
+        }
+    ]
+}

ch10/x-pin-experiments/src/main.exe

@@ -1,68 +1,108 @@
-use rand::prelude::*;
+// fn main() {
+//     let list1: Vec<SelfRef> = (0..10).map(|_| {
+//         let mut picker = SelfRef::new();
+//         picker.pick(2);
+//         picker
+//     }).collect();
 
+//     list1.iter().for_each(|p| println!("{}", p.show()));
+
+//     let list2 = Vec::from_iter(list1.iter());
+//     list2.iter().for_each(|p| println!("{}", p.show()));
+// }
 fn main() {
-    selfref1();
+    let mut picker1 = Picker::new();
+    picker1.pick(2);
+    println!("{}", picker1.show());
+    let replaced = std::mem::replace(&mut picker1, Picker::new());
+    println!("{}", replaced.show());
 }
 
-fn selfref1() {
-    let mut first = SelfRef1::new(0);
-    println!("It's OK: {}", first.b());
-    let second = std::mem::replace(first.as_mut(), *SelfRef1::new(2));
-    println!("Ooops: {}", first.b());
-    println!("Ooops: {}", second.b());
+#[derive(Clone, Default)]
+struct Picker {
+    numbers: Option<[usize; 3]>,
+    picked: Option<*const usize>,
 }
 
-#[derive(Debug)]
-struct SelfRef1 {
-    a: [char;3],
-    b: *const char,
-}
+impl Picker {
+    fn new() -> Self {
+        Picker {
+            numbers: None,
+            picked: None,
+        }
+    }
 
-impl SelfRef1 {
-    fn new(n: usize) -> Box<Self> {
-        let mut selfref = Box::new(Self {
-            a: ['a', 'b', 'c'],
-            b: std::ptr::null(),
-        });
-        selfref.b = &selfref.a[n] as *const _;
-        selfref
+    fn pick(&mut self, n: usize) {
+        self.numbers = Some([1, 2, 3]);
+        self.picked = Some(&self.numbers.as_ref().unwrap()[n]);
     }
 
-    fn b(&self) -> &char {
-        unsafe { &*self.b }
+    fn show(&self) -> String {
+        match self.picked {
+            Some(p) => format!("Pick: {}", unsafe {*p}),
+            None => format!("Nothing picked yet"),
+        }
     }
 }
 
-// =======================================================
-use std::pin::Pin;
+// fn main() {
+//     let code_table = ['d','h','e','x','l','w','p','y','z'];
 
-fn selfref2() {
-    let mut first = SelfRef2::new(0);
-    println!("It's OK: {}", first.b());
-    let mut second = SelfRef2::new(2);
-    std::mem::swap(&mut first, &mut second);
-    println!("Ooops: {}", first.b());
-}
+//     let mut selfref = SelfRef {
+//         code_table,
+//         encoder: Encoder::new(),
+//     };
 
-#[derive(Debug)]
-struct SelfRef2 {
-    a: [char;3],
-    b: *const char,
-    _pin: std::marker::PhantomPinned,
-}
+//     selfref.encoder.set(&selfref.code_table);
 
-impl SelfRef2 {
-    fn new(n: usize) -> Pin<Box<Self>> {
-        let mut selfref = Box::pin(Self {
-            a: ['a', 'b', 'c'],
-            b: std::ptr::null(),
-            _pin: std::marker::PhantomPinned,
-        });
-        //selfref.b = &selfref.a[n] as *const _;
-        selfref
-    }
+//     selfref.encoder.encode(&[1,2,3,2,3,4,5,2]);
+//     println!("{}", selfref.encoder.txt);
+// }
 
-    fn b(&self) -> &char {
-        unsafe { &*self.b }
-    }
-}
+// struct SelfRef<'a> {
+//     code_table: [char; 9],
+//     encoder: Encoder<'a>,
+// }
+
+// struct Encoder<'a> {
+//     code_table: Option<&'a [char; 9]>,
+//     txt: String,
+// }
+
+// impl<'a> Encoder<'a> {
+//     fn new() -> Self {
+//         Encoder { code_table: None, txt: String::new() }
+//     }
+//     fn set(&mut self, code_table: &'a [char; 9]) {
+//         self.code_table = Some(code_table);
+//     }
+//     fn encode(&mut self, numbers: &[usize]) {
+//         let table = self.code_table.expect("Not set");
+//         for num in numbers {
+//             self.txt.push(table[*num]);
+//         }
+//     }
+// }
+
+// struct SecretFmt<'a> {
+//     random: &'a String,
+//     something_big: Vec<u8>,
+// }
+
+// impl<'a> SecretFmt<'a> {
+//     fn new(random: &'a String) -> Self {
+//         Self {
+//             random,
+//             something_big: vec![0u8; 1024 * 1000 * 1000],
+//         }
+//     }
+
+//     fn fmt(&self, txt: &str) -> String {
+//         format!("{}: {}", self.random, txt)
+//     }
+// }
+
+// struct MyFormatter<'a> {
+//     data: String,
+//     formatter: SecretFmt<'a>,
+// }

ch10/x-pin-experiments/src/main.pdb

@@ -0,0 +1,53 @@
+// async fn foo() {
+//     let numbers: Vec<usize> = (0..10).collect();
+//     let mut nums = numbers.iter();
+
+//     if let Some(n) = nums.next() {
+//         printfut("Future {n}").wait;
+//     }
+
+//     for num in nums {
+//         println!("Hello #{num}");
+//     }
+// }
+
+enum SelfRef<'a> {
+    Start,
+    Wait(State1<'a>),
+    Resolved,
+}
+
+impl<'a> SelfRef<'a> {
+    pub fn poll(&mut self) -> bool {
+        loop {
+            match self {
+                SelfRef::Start => {
+                    let numbers: Vec<usize> = (0..10).collect();
+                    let mut nums = numbers.iter();
+                    if let Some(n) = nums.next() {
+                        println!("Future {n}")
+                    }
+
+                    // store state
+                    *self = SelfRef::Wait(State1 { numbers, nums });
+                    break false;
+                }
+
+                SelfRef::Wait(State1 {numbers, nums }) => {
+                    for num in nums {
+                        println!("Hello #{num}")
+                    }
+                    *self = SelfRef::Resolved;
+                    break true;
+                }
+
+                SelfRef::Resolved => panic!("Polled a resoved future!"),
+            }
+        }
+    }
+}
+
+struct State1<'a> {
+    numbers: Vec<usize>,
+    nums: Iter<'a, usize>,
+}

ch10/x-pin-experiments/src/main.rs

@@ -0,0 +1,22 @@
+fn main() {
+
+}
+
+struct SelfRef<'a> {
+    numbers: [usize; 3],
+    picked: Option<&'a usize>,
+}
+
+impl<'a> SelfRef<'a> {
+    fn new() -> Self {
+        SelfRef {numbers: [1,2,3], picked: None}
+    }
+
+    fn pick(&mut self, n: usize) {
+        self.picked = Some(&self.numbers[n]);
+    }
+
+    fn show(&self) -> usize {
+        *self.picked.unwrap()
+    }
+}