A few minor lints and docs (#1436)

* A few minor lints and docs

* Added required packages to compile on Debian-style linux
* Inlined some format args, and removed some `&` in args (they cause about 6% slowdown that compiler cannot inline)
* a few spelling mistakes

* fix fmt

node-graph/compilation-client/src/main.rs

@@ -32,7 +32,7 @@ fn main() {
 		.json(&compile_request)
 		.send()
 		.unwrap();
-	println!("response: {:?}", response);
+	println!("response: {response:?}");
 }
 
 fn add_network() -> NodeNetwork {

node-graph/compilation-server/src/main.rs

@@ -41,7 +41,7 @@ async fn post_compile_spirv(State(state): State<Arc<AppState>>, Json(compile_req
 
 	let path = std::env::var("CARGO_MANIFEST_DIR").unwrap() + "/../gpu-compiler/Cargo.toml";
 	let result = compile_request.compile(state.compile_dir.path().to_str().expect("non utf8 tempdir path"), &path).map_err(|e| {
-		eprintln!("compilation failed: {}", e);
+		eprintln!("compilation failed: {e}");
 		StatusCode::INTERNAL_SERVER_ERROR
 	})?;
 	state.cache.write().unwrap().insert(compile_request, Ok(result.clone()));

node-graph/gcore/src/graphic_element/renderer.rs

@@ -3,7 +3,7 @@ use crate::uuid::{generate_uuid, ManipulatorGroupId};
 use crate::{vector::VectorData, Artboard, Color, GraphicElementData, GraphicGroup};
 use base64::Engine;
 use bezier_rs::Subpath;
-use image::ImageEncoder;
+
 pub use quad::Quad;
 
 use glam::{DAffine2, DVec2};
@@ -156,7 +156,7 @@ pub fn format_transform_matrix(transform: DAffine2) -> String {
 	let mut result = "matrix(".to_string();
 	let cols = transform.to_cols_array();
 	for (index, item) in cols.iter().enumerate() {
-		write!(result, "{}", item).unwrap();
+		write!(result, "{item}").unwrap();
 		if index != cols.len() - 1 {
 			result.push_str(", ");
 		}

node-graph/gcore/src/logic.rs

@@ -5,7 +5,7 @@ pub struct LogToConsoleNode;
 #[node_macro::node_fn(LogToConsoleNode)]
 fn log_to_console<T: core::fmt::Debug>(value: T) -> T {
 	#[cfg(not(target_arch = "spirv"))]
-	debug!("{:#?}", value);
+	debug!("{value:#?}");
 	value
 }
 

node-graph/gcore/src/types.rs

@@ -190,13 +190,13 @@ impl Type {
 impl core::fmt::Debug for Type {
 	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
 		match self {
-			Self::Generic(arg0) => write!(f, "Generic({})", arg0),
+			Self::Generic(arg0) => write!(f, "Generic({arg0})"),
 			#[cfg(feature = "type_id_logging")]
 			Self::Concrete(arg0) => write!(f, "Concrete({}, {:?})", arg0.name, arg0.id),
 			#[cfg(not(feature = "type_id_logging"))]
 			Self::Concrete(arg0) => write!(f, "Concrete({})", arg0.name),
-			Self::Fn(arg0, arg1) => write!(f, "({:?} -> {:?})", arg0, arg1),
-			Self::Future(arg0) => write!(f, "Future({:?})", arg0),
+			Self::Fn(arg0, arg1) => write!(f, "({arg0:?} -> {arg1:?})"),
+			Self::Future(arg0) => write!(f, "Future({arg0:?})"),
 		}
 	}
 }
@@ -204,10 +204,10 @@ impl core::fmt::Debug for Type {
 impl std::fmt::Display for Type {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		match self {
-			Type::Generic(name) => write!(f, "{}", name),
+			Type::Generic(name) => write!(f, "{name}"),
 			Type::Concrete(ty) => write!(f, "{}", ty.name),
-			Type::Fn(input, output) => write!(f, "({} -> {})", input, output),
-			Type::Future(ty) => write!(f, "Future<{}>", ty),
+			Type::Fn(input, output) => write!(f, "({input} -> {output})"),
+			Type::Future(ty) => write!(f, "Future<{ty}>"),
 		}
 	}
 }

node-graph/gcore/src/vector/style.rs

@@ -14,7 +14,7 @@ const OPACITY_PRECISION: usize = 3;
 
 fn format_opacity(name: &str, opacity: f32) -> String {
 	if (opacity - 1.).abs() > 10_f32.powi(-(OPACITY_PRECISION as i32)) {
-		format!(r#" {}-opacity="{:.precision$}""#, name, opacity, precision = OPACITY_PRECISION)
+		format!(r#" {name}-opacity="{opacity:.OPACITY_PRECISION$}""#)
 	} else {
 		String::new()
 	}
@@ -187,7 +187,7 @@ impl Fill {
 			Self::Solid(color) => format!(r##" fill="#{}"{}"##, color.rgb_hex(), format_opacity("fill", color.a())),
 			Self::Gradient(gradient) => {
 				let gradient_id = gradient.render_defs(svg_defs, multiplied_transform, bounds, transformed_bounds);
-				format!(r##" fill="url('#{}')""##, gradient_id)
+				format!(r##" fill="url('#{gradient_id}')""##)
 			}
 		}
 	}
@@ -533,7 +533,7 @@ impl PathStyle {
 			(_, None) => String::new(),
 		};
 
-		format!("{}{}", fill_attribute, stroke_attribute)
+		format!("{fill_attribute}{stroke_attribute}")
 	}
 }
 

node-graph/gcore/src/vector/subpath.rs

@@ -392,7 +392,7 @@ impl Subpath {
 				(true, true, true) => 'C',
 				(false, false, true) => 'L',
 				(_, false, false) => 'Z',
-				_ => panic!("Invalid shape {:#?}", self),
+				_ => panic!("Invalid shape {self:#?}"),
 			};
 
 			// Complete the last curve
@@ -567,7 +567,7 @@ impl From<&Subpath> for BezPath {
 					}
 				}
 				[None, None, None] => (PathEl::ClosePath, true),
-				_ => panic!("Invalid path element {:#?}", subpath),
+				_ => panic!("Invalid path element {subpath:#?}"),
 			}
 		};
 

node-graph/gpu-compiler/src/lib.rs

@@ -47,7 +47,7 @@ pub fn create_files(metadata: &Metadata, networks: &[ProtoNetwork], compile_dir:
 	}
 	let lib = src.join("lib.rs");
 	let shader = serialize_gpu(networks, io)?;
-	eprintln!("{}", shader);
+	eprintln!("{shader}");
 	std::fs::write(lib, shader)?;
 	Ok(())
 }

node-graph/gpu-executor/src/lib.rs

@@ -531,7 +531,7 @@ where
 #[node_macro::node_fn(RenderTextureNode)]
 async fn render_texture_node<'a: 'input, E: 'a + GpuExecutor>(image: ShaderInputFrame<E>, surface: Arc<SurfaceHandle<E::Surface>>, executor: &'a E) -> SurfaceFrame {
 	let surface_id = surface.surface_id;
-	log::trace!("rendering to surface {:?}", surface_id);
+	log::trace!("rendering to surface {surface_id:?}");
 
 	executor.create_render_pass(image.shader_input, surface).unwrap();
 

node-graph/graph-craft/src/document.rs

@@ -58,9 +58,9 @@ impl DocumentNode {
 	}
 
 	fn resolve_proto_node(mut self) -> ProtoNode {
-		assert!(!self.inputs.is_empty() || self.manual_composition.is_some(), "Resolving document node {:#?} with no inputs", self);
+		assert!(!self.inputs.is_empty() || self.manual_composition.is_some(), "Resolving document node {self:#?} with no inputs");
 		let DocumentNodeImplementation::Unresolved(fqn) = self.implementation else {
-			unreachable!("tried to resolve not flattened node on resolved node {:?}", self);
+			unreachable!("tried to resolve not flattened node on resolved node {self:?}");
 		};
 		let (input, mut args) = if let Some(ty) = self.manual_composition {
 			(ProtoNodeInput::ShortCircut(ty), ConstructionArgs::Nodes(vec![]))
@@ -68,7 +68,7 @@ impl DocumentNode {
 			let first = self.inputs.remove(0);
 			match first {
 				NodeInput::Value { tagged_value, .. } => {
-					assert_eq!(self.inputs.len(), 0, "{}, {:?}", &self.name, &self.inputs);
+					assert_eq!(self.inputs.len(), 0, "{}, {:?}", self.name, self.inputs);
 					(ProtoNodeInput::None, ConstructionArgs::Value(tagged_value))
 				}
 				NodeInput::Node { node_id, output_index, lambda } => {
@@ -82,9 +82,9 @@ impl DocumentNode {
 		assert!(!self.inputs.iter().any(|input| matches!(input, NodeInput::Network(_))), "recieved non resolved parameter");
 		assert!(
 			!self.inputs.iter().any(|input| matches!(input, NodeInput::Value { .. })),
-			"recieved value as parameter. inupts: {:#?}, construction_args: {:#?}",
-			&self.inputs,
-			&args
+			"received value as parameter. inputs: {:#?}, construction_args: {:#?}",
+			self.inputs,
+			args
 		);
 
 		// If we have one parameter of the type inline, set it as the construction args
@@ -689,7 +689,7 @@ impl NodeNetwork {
 	pub fn flatten_with_fns(&mut self, node: NodeId, map_ids: impl Fn(NodeId, NodeId) -> NodeId + Copy, gen_id: impl Fn() -> NodeId + Copy) {
 		self.resolve_extract_nodes();
 		let Some((id, mut node)) = self.nodes.remove_entry(&node) else {
-			warn!("The node which was supposed to be flattened does not exist in the network, id {} network {:#?}", node, self);
+			warn!("The node which was supposed to be flattened does not exist in the network, id {node} network {self:#?}");
 			return;
 		};
 
@@ -804,7 +804,7 @@ impl NodeNetwork {
 	}
 
 	fn remove_id_node(&mut self, id: NodeId) -> Result<(), String> {
-		let node = self.nodes.get(&id).ok_or_else(|| format!("Node with id {} does not exist", id))?.clone();
+		let node = self.nodes.get(&id).ok_or_else(|| format!("Node with id {id} does not exist"))?.clone();
 		if let DocumentNodeImplementation::Unresolved(ident) = &node.implementation {
 			if ident.name == "graphene_core::ops::IdNode" {
 				assert_eq!(node.inputs.len(), 1, "Id node has more than one input");
@@ -855,7 +855,7 @@ impl NodeNetwork {
 			.collect::<Vec<_>>();
 		for id in id_nodes {
 			if let Err(e) = self.remove_id_node(id) {
-				log::warn!("{}", e)
+				log::warn!("{e}")
 			}
 		}
 	}
@@ -1070,8 +1070,8 @@ mod test {
 		network.generate_node_paths(&[]);
 		network.flatten_with_fns(1, |self_id, inner_id| self_id * 10 + inner_id, gen_node_id);
 		let flat_network = flat_network();
-		println!("{:#?}", flat_network);
-		println!("{:#?}", network);
+		println!("{flat_network:#?}");
+		println!("{network:#?}");
 
 		assert_eq!(flat_network, network);
 	}
@@ -1131,7 +1131,7 @@ mod test {
 		let resolved_network = network.into_proto_networks().collect::<Vec<_>>();
 
 		println!("{:#?}", resolved_network[0]);
-		println!("{:#?}", construction_network);
+		println!("{construction_network:#?}");
 		assert_eq!(resolved_network[0], construction_network);
 	}
 
@@ -1248,7 +1248,7 @@ mod test {
 	#[test]
 	fn simple_duplicate() {
 		let result = output_duplicate(vec![NodeOutput::new(1, 0)], NodeInput::node(1, 0));
-		println!("{:#?}", result);
+		println!("{result:#?}");
 		assert_eq!(result.outputs.len(), 1, "The number of outputs should remain as 1");
 		assert_eq!(result.outputs[0], NodeOutput::new(11, 0), "The outer network output should be from a duplicated inner network");
 		let mut ids = result.nodes.keys().copied().collect::<Vec<_>>();

node-graph/graph-craft/src/document/value.rs

@@ -202,7 +202,7 @@ impl<'a> TaggedValue {
 	pub fn to_primitive_string(&self) -> String {
 		match self {
 			TaggedValue::None => "()".to_string(),
-			TaggedValue::String(x) => format!("\"{}\"", x),
+			TaggedValue::String(x) => format!("\"{x}\""),
 			TaggedValue::U32(x) => x.to_string() + "_u32",
 			TaggedValue::F32(x) => x.to_string() + "_f32",
 			TaggedValue::F64(x) => x.to_string() + "_f64",

node-graph/graph-craft/src/proto.rs

@@ -104,8 +104,8 @@ impl core::fmt::Display for ProtoNetwork {
 			f.write_str("Primary input: ")?;
 			match &node.input {
 				ProtoNodeInput::None => f.write_str("None")?,
-				ProtoNodeInput::Network(ty) => f.write_fmt(format_args!("Network (type = {:?})", ty))?,
-				ProtoNodeInput::ShortCircut(ty) => f.write_fmt(format_args!("Lambda (type = {:?})", ty))?,
+				ProtoNodeInput::Network(ty) => f.write_fmt(format_args!("Network (type = {ty:?})"))?,
+				ProtoNodeInput::ShortCircut(ty) => f.write_fmt(format_args!("Lambda (type = {ty:?})"))?,
 				ProtoNodeInput::Node(_, _) => f.write_str("Node")?,
 			}
 			f.write_str("\n")?;
@@ -220,7 +220,7 @@ impl ProtoNodeInput {
 	pub fn unwrap_node(self) -> NodeId {
 		match self {
 			ProtoNodeInput::Node(id, _) => id,
-			_ => panic!("tried to unwrap id from non node input \n node: {:#?}", self),
+			_ => panic!("tried to unwrap id from non node input \n node: {self:#?}"),
 		}
 	}
 }
@@ -273,7 +273,7 @@ impl ProtoNode {
 	pub fn unwrap_construction_nodes(&self) -> Vec<(NodeId, bool)> {
 		match &self.construction_args {
 			ConstructionArgs::Nodes(nodes) => nodes.clone(),
-			_ => panic!("tried to unwrap nodes from non node construction args \n node: {:#?}", self),
+			_ => panic!("tried to unwrap nodes from non node construction args \n node: {self:#?}"),
 		}
 	}
 }
@@ -282,10 +282,7 @@ impl ProtoNetwork {
 	fn check_ref(&self, ref_id: &NodeId, id: &NodeId) {
 		assert!(
 			self.nodes.iter().any(|(check_id, _)| check_id == ref_id),
-			"Node id:{} has a reference which uses node id:{} which doesn't exist in network {:#?}",
-			id,
-			ref_id,
-			self
+			"Node id:{id} has a reference which uses node id:{ref_id} which doesn't exist in network {self:#?}"
 		);
 	}
 
@@ -403,7 +400,7 @@ impl ProtoNetwork {
 				return Ok(());
 			};
 			if temp_marks.contains(&node_id) {
-				return Err(format!("Cycle detected {:#?}, {:#?}", &inwards_edges, &network));
+				return Err(format!("Cycle detected {inwards_edges:#?}, {network:#?}"));
 			}
 
 			if let Some(dependencies) = inwards_edges.get(&node_id) {
@@ -586,7 +583,7 @@ impl TypingContext {
 			.ok_or(format!("No implementations found for {:?}. Other implementations found {:?}", node.identifier, self.lookup))?;
 
 		if matches!(input, Type::Generic(_)) {
-			return Err(format!("Generic types are not supported as inputs yet {:?} occurred in {:?}", &input, node.identifier));
+			return Err(format!("Generic types are not supported as inputs yet {:?} occurred in {:?}", input, node.identifier));
 		}
 		if parameters.iter().any(|p| {
 			matches!(p,
@@ -695,7 +692,7 @@ mod test {
 	fn topological_sort() {
 		let construction_network = test_network();
 		let sorted = construction_network.topological_sort().expect("Error when calling 'topological_sort' on 'construction_network.");
-		println!("{:#?}", sorted);
+		println!("{sorted:#?}");
 		assert_eq!(sorted, vec![14, 10, 11, 1]);
 	}
 
@@ -715,7 +712,7 @@ mod test {
 		println!("nodes: {:#?}", construction_network.nodes);
 		assert_eq!(sorted, vec![0, 1, 2, 3]);
 		let ids: Vec<_> = construction_network.nodes.iter().map(|(id, _)| *id).collect();
-		println!("{:#?}", ids);
+		println!("{ids:#?}");
 		println!("nodes: {:#?}", construction_network.nodes);
 		assert_eq!(construction_network.nodes[0].1.identifier.name.as_ref(), "value");
 		assert_eq!(ids, vec![0, 1, 2, 3]);
@@ -729,7 +726,7 @@ mod test {
 		let sorted = construction_network.topological_sort().expect("Error when calling 'topological_sort' on 'construction_network.");
 		assert_eq!(sorted, vec![0, 1, 2, 3]);
 		let ids: Vec<_> = construction_network.nodes.iter().map(|(id, _)| *id).collect();
-		println!("{:#?}", ids);
+		println!("{ids:#?}");
 		assert_eq!(construction_network.nodes[0].1.identifier.name.as_ref(), "value");
 		assert_eq!(ids, vec![0, 1, 2, 3]);
 	}
@@ -738,7 +735,7 @@ mod test {
 	fn input_resolution() {
 		let mut construction_network = test_network();
 		construction_network.resolve_inputs().expect("Error when calling 'resolve_inputs' on 'construction_network.");
-		println!("{:#?}", construction_network);
+		println!("{construction_network:#?}");
 		assert_eq!(construction_network.nodes[0].1.identifier.name.as_ref(), "value");
 		assert_eq!(construction_network.nodes.len(), 6);
 		assert_eq!(construction_network.nodes[5].1.construction_args, ConstructionArgs::Nodes(vec![(3, false), (4, true)]));

node-graph/graphene-cli/src/main.rs

@@ -21,7 +21,7 @@ struct UpdateLogger {}
 
 impl NodeGraphUpdateSender for UpdateLogger {
 	fn send(&self, message: graphene_core::application_io::NodeGraphUpdateMessage) {
-		println!("{:?}", message);
+		println!("{message:?}");
 	}
 }
 
@@ -60,7 +60,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 	loop {
 		//println!("executing");
 		let _result = (&executor).execute(editor_api.clone()).await?;
-		//println!("result: {:?}", result);
+		//println!("result: {result:?}");
 		std::thread::sleep(std::time::Duration::from_millis(16));
 	}
 }
@@ -211,7 +211,7 @@ mod test {
 			render_config: graphene_core::application_io::RenderConfig::default(),
 		};
 		let result = (&executor).execute(editor_api.clone()).await.unwrap();
-		println!("result: {:?}", result);
+		println!("result: {result:?}");
 	}
 
 	#[tokio::test]
@@ -228,6 +228,6 @@ mod test {
 			render_config: graphene_core::application_io::RenderConfig::default(),
 		};
 		let result = (&executor).execute(editor_api.clone()).await.unwrap();
-		println!("result: {:?}", result);
+		println!("result: {result:?}");
 	}
 }

node-graph/gstd/src/gpu_nodes.rs

@@ -75,7 +75,7 @@ async fn map_gpu<'a: 'input>(image: ImageFrame<Color>, node: DocumentNode, edito
 	let quantization = crate::quantization::generate_quantization_from_image_frame(&image);
 	#[cfg(not(feature = "quantization"))]
 	let quantization = QuantizationChannels::default();
-	log::debug!("quantization: {:?}", quantization);
+	log::debug!("quantization: {quantization:?}");
 
 	#[cfg(feature = "image-compare")]
 	let img: image::DynamicImage = image::Rgba32FImage::from_raw(image.image.width, image.image.height, bytemuck::cast_vec(image.image.data.clone()))
@@ -163,7 +163,7 @@ async fn create_compute_pass_descriptor<T: Clone + Pixel + StaticTypeSized>(
 	let compiler = graph_craft::graphene_compiler::Compiler {};
 	let inner_network = NodeNetwork::value_network(node);
 
-	log::debug!("inner_network: {:?}", inner_network);
+	log::debug!("inner_network: {inner_network:?}");
 	let network = NodeNetwork {
 		inputs: vec![2, 1], //vec![0, 1],
 		#[cfg(feature = "quantization")]
@@ -285,7 +285,7 @@ async fn create_compute_pass_descriptor<T: Clone + Pixel + StaticTypeSized>(
 	let canvas = editor_api.application_io.create_surface();
 
 	let surface = unsafe { executor.create_surface(canvas) }.unwrap();
-	//log::debug!("id: {:?}", surface);
+	//log::debug!("id: {surface:?}");
 	let surface_id = surface.surface_id;
 
 	let texture = executor.create_texture_buffer(image.image.clone(), TextureBufferOptions::Texture).unwrap();

node-graph/gstd/src/quantization.rs

@@ -79,7 +79,7 @@ fn generate_quantization<const N: usize>(data: Vec<f64>, samples: usize, channel
 			None => Some(error.clone()),
 		};
 
-		println!("Merged: {:?}", merged_error);
+		println!("Merged: {merged_error:?}");
 
 		let bits = merged_error.as_ref().unwrap().bits.iter().map(|x| x[i]).collect::<Vec<_>>();
 		let model_fit = autoquant::models::OptimizedLin::new(channel_data, 1 << bits[bin_size]);

node-graph/gstd/src/wasm_application_io.rs

@@ -192,7 +192,7 @@ impl ApplicationIo for WasmApplicationIo {
 
 	fn load_resource(&self, url: impl AsRef<str>) -> Result<ResourceFuture, ApplicationError> {
 		let url = url::Url::parse(url.as_ref()).map_err(|_| ApplicationError::InvalidUrl)?;
-		log::trace!("Loading resource: {:?}", url);
+		log::trace!("Loading resource: {url:?}");
 		match url.scheme() {
 			#[cfg(feature = "tokio")]
 			"file" => {
@@ -219,7 +219,7 @@ impl ApplicationIo for WasmApplicationIo {
 			"graphite" => {
 				let path = url.path();
 				let path = path.to_owned();
-				log::trace!("Loading local resource: {}", path);
+				log::trace!("Loading local resource: {path}");
 				let data = self.resources.get(&path).ok_or(ApplicationError::NotFound)?.clone();
 				Ok(Box::pin(async move { Ok(data.clone()) }) as Pin<Box<dyn Future<Output = Result<Arc<[u8]>, _>>>>)
 			}

node-graph/interpreted-executor/src/dynamic_executor.rs

@@ -158,7 +158,7 @@ impl BorrowTree {
 			ConstructionArgs::Nodes(ids) => {
 				let ids: Vec<_> = ids.iter().map(|(id, _)| *id).collect();
 				let construction_nodes = self.node_deps(&ids);
-				let constructor = typing_context.constructor(id).ok_or(format!("No constructor found for node {:?}", identifier))?;
+				let constructor = typing_context.constructor(id).ok_or(format!("No constructor found for node {identifier:?}"))?;
 				let node = constructor(construction_nodes).await;
 				let node = NodeContainer::new(node);
 				self.store_node(node, id);

node-graph/interpreted-executor/src/lib.rs

@@ -74,7 +74,7 @@ mod tests {
 		let compiler = Compiler {};
 		let protograph = compiler.compile_single(network).expect("Graph should be generated");
 
-		let exec = block_on(DynamicExecutor::new(protograph)).unwrap_or_else(|e| panic!("Failed to create executor: {}", e));
+		let exec = block_on(DynamicExecutor::new(protograph)).unwrap_or_else(|e| panic!("Failed to create executor: {e}"));
 
 		let result = block_on((&exec).execute(32_u32)).unwrap();
 		assert_eq!(result, TaggedValue::U32(33));

node-graph/wgpu-executor/src/lib.rs

@@ -206,11 +206,11 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 	}
 
 	fn create_output_buffer(&self, len: usize, ty: Type, cpu_readable: bool) -> Result<WgpuShaderInput> {
-		log::debug!("Creating output buffer with len: {}", len);
+		log::debug!("Creating output buffer with len: {len}");
 		let create_buffer = |usage| {
 			Ok::<_, anyhow::Error>(self.context.device.create_buffer(&BufferDescriptor {
 				label: None,
-				size: len as u64 * ty.size().ok_or_else(|| anyhow::anyhow!("Cannot create buffer of type {:?}", ty))? as u64,
+				size: len as u64 * ty.size().ok_or_else(|| anyhow::anyhow!("Cannot create buffer of type {ty:?}"))? as u64,
 				usage,
 				mapped_at_creation: false,
 			}))
@@ -290,7 +290,7 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 
 		let surface = &canvas.as_ref().surface;
 		let surface_caps = surface.get_capabilities(&self.context.adapter);
-		println!("{:?}", surface_caps);
+		println!("{surface_caps:?}");
 		if surface_caps.formats.is_empty() {
 			log::warn!("No surface formats available");
 			//return Ok(());
@@ -455,7 +455,7 @@ impl gpu_executor::GpuExecutor for WgpuExecutor {
 
 		let size = window.surface.inner_size();
 		let surface_caps = surface.get_capabilities(&self.context.adapter);
-		println!("{:?}", surface_caps);
+		println!("{surface_caps:?}");
 		let surface_format = wgpu::TextureFormat::Bgra8Unorm;
 		let config = wgpu::SurfaceConfiguration {
 			usage: wgpu::TextureUsages::RENDER_ATTACHMENT,