ok, clippy is back :)

Author: aduarterengifo

.direnv/flake-profile

@@ -1 +1 @@
-flake-profile-2-link
+flake-profile-3-link

.direnv/flake-profile-2-link

@@ -0,0 +1 @@
+/nix/store/3gj43axg67kbk0frm6zjbm5h5jjyn7qp-nix-shell-env

.direnv/flake-profile-3-link

@@ -1,7 +1,7 @@
 [package]
 name = "rusty-tokey"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]

Cargo.toml

@@ -1,28 +1,41 @@
 {
-  description = "A flake providing a Python development shell with uv";
-
   inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
+    fenix = {
+      url = "github:nix-community/fenix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+    nixpkgs.url = "nixpkgs/nixos-unstable";
     flake-utils.url = "github:numtide/flake-utils";
   };
-
-  outputs = { self, nixpkgs, flake-utils, ... }:
+ 
+  outputs = { self, fenix, flake-utils, nixpkgs }:
     flake-utils.lib.eachDefaultSystem (system:
       let
         pkgs = import nixpkgs { inherit system; config.allowUnfree = true; };
+        rust-toolchain = with fenix.packages.${system}; fromToolchainFile {
+          file = ./rust-toolchain.toml;
+          sha256 = "sha256-KUm16pHj+cRedf8vxs/Hd2YWxpOrWZ7UOrwhILdSJBU=";
+        };
       in {
-        pkgs.config.allowUnfree = true;
-        devShells.default = pkgs.mkShell {
-          buildInputs = [
-            pkgs.python312
-            pkgs.uv
-            pkgs.claude-code
+        devShell = pkgs.mkShell rec {
+          buildInputs = with pkgs; [
+            lld
+            rust-toolchain
+            pkg-config
+            rust-analyzer
+            graphviz
+            websocat
+            python312
+            uv
+            claude-code
           ];
           shellHook = ''
             echo "Python: $(python --version)"
             echo "uv: $(uv --version)"
           '';
+          LD_LIBRARY_PATH = pkgs.lib.makeLibraryPath buildInputs;
         };
       }
     );
 }
+

flake.lock

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "stable"
+components = [ "rust-analyzer", "rust-src" ]

flake.nix

@@ -47,98 +47,15 @@ impl LinkedArray<u32> {
         vec![0]
     }
 
-    fn replace_pair(&mut self, idx: usize, token_id: u32) -> () {
-        // Extract all the indices and values we need first
-        // let (curr_elem, next_elem, next_next_idx) = {
-        //     let curr = self.vec.get(idx)?;
-        //     if let Some(curr) = curr {
-        //         let next_idx = curr.next?;
-        //         let next = self.vec.get(next_idx)?;
-        //         if let Some(next) = next {
-        //             let next_next_idx = next.next;
-        //             return (curr.elem, next.elem, next_next_idx)
-        //         };
-        //     }
-        // };
-
-        // what do i actually need to write?
-
-        let (curr_elem, new_token_id,next_next_idx) = match self.vec.get(idx) {
-           Some(Some(curr)) => {
-            match curr.next.and_then(|x| self.vec.get(x)) {
-                Some(Some(next)) => {
-                    // byte representation 
-                    // string interning 
-                    let curr_elem_bytes = self.interner.get_bytes(curr.elem);
-                    let next_elem_bytes = self.interner.get_bytes(next.elem);
-                    let merged_bytes = [curr_elem_bytes, next_elem_bytes].concat();
-                    let new_token_id = self.interner.intern(merged_bytes);
-
-                    // update curr elem.
-                    //curr.elem = new_token_id;
-
-                    let next_next_idx = next.next;
-                    match next.next.and_then(|x| self.vec.get(x)) {
-                        Some(Some(next_next)) => {
-                            // set curr's next to next-next.
-                            // curr.next = next_next_idx;
-                            // next_next.prev = Some(idx);
-                            (Some(curr.elem), Some(new_token_id),next_next_idx)
-                        },
-                        _ => (Some(curr.elem), Some(new_token_id),None)
-                    }
-                },
-                _ => (None,None,None)
-            }
-           },
-           _ => (None,None,None)
-        };
-
-        // if curr exists.
-        if let Some(Some(curr_mut)) = self.vec.get_mut(idx) {
-
-            // curr.elem <- new_token_id
-            curr_mut.elem = new_token_id.unwrap();
-
-            // if next_next exists
-            // if let Some(Some(next_next_mut)) = self.vec.get_mut(next_next_idx.unwrap()) {
-            //     // curr.next <- next_next_idx
-            //     curr_mut.next = next_next_idx;  
-            // } else {
-            //     curr_mut.next = None;
-            // }
-
-
-            self.vec[next_next_idx.unwrap()].unwrap().prev = Some(idx);
- 
+    fn replace_pair(&mut self, idx: usize, token_id: u32) -> Result<(), MergeError> {
+        if idx >= self.vec.len() {
+            return Err(MergeError::InvalidIndex)
         }
 
-
-
-        // Get the byte representations for merging
-        // let curr_elem_bytes = self.interner.get_bytes(curr_elem);
-        // let next_elem_bytes = self.interner.get_bytes(next_elem);
-        // let merged_bytes = [curr_elem_bytes, next_elem_bytes].concat();
-        // let new_token_id = self.interner.intern(merged_bytes);
-
-        // // mutations
-
-        // // Update current node with merged token
-        // self.vec[idx].elem = new_token_id;
-        // self.vec[idx].next = next_next_idx;
-
-        // // Update next-next node's prev pointer (if it exists)
-        // if let Some(next_next_idx) = next_next_idx {
-        //     if next_next_idx < self.vec.len() {
-        //         self.vec[next_next_idx].prev = Some(idx);
-        //     }
-        // }
-
-        // Mark the next node as deleted or handle it as needed
-        // You might want to mark it as inactive rather than actually removing it
+        let left_ref = self.vec[idx].as_ref();
 
-        ();
-    }
+        Ok(())
+    }   
 
     fn prev(&self, idx: usize,) -> Option<&LinkedArrayNode<u32>> {   
         // let node = self.vec.get(idx)?;