[codex] refine neuron lesson syntax with operator traits

[hghalebi]

Summary

This PR refines the authored neuron lessons so the teaching code uses semantic newtypes with operator traits instead of repeating .0 at every arithmetic step.

What Changed

• updated lessons/03-neuron/01-rust-essentials-for-a-tiny-neuron.md
• updated lessons/03-neuron/02-neuron-as-a-chain-of-functions.md

The lessons now explain and demonstrate:

• why Deref<Target = f64> is the wrong tool here
• how to keep semantic wrappers like Input, Weight, Prediction, and Target
• how to overload only the operations that are mathematically valid for the lesson
• how that changes examples from .0-heavy code into forms like x1 * w1 + x2 * w2 + b

Validation

• python3 scripts/check_course_content.py
• python3 scripts/check_lesson_rust_snippets.py

Both checks passed locally.

Summary by CodeRabbit

• Documentation
  • Updated Rust code examples to demonstrate operator overloading patterns for cleaner, more idiomatic implementations.
  • Added new guidance section on using Rust's type system effectively to reduce boilerplate in arithmetic expressions.
  • Enhanced explanations of trait implementations for neural network calculations.

[coderabbitai]

Caution

Review failed

The pull request is closed.

ℹ️ Recent review info

⚙️ Run configuration

Configuration used: Organization UI

Review profile: ASSERTIVE

Plan: Pro

Run ID: 2e57f0a3-1780-435f-ab16-6e00595b3c7d

📥 Commits

Reviewing files that changed from the base of the PR and between c42bccf and ea2861b.

📒 Files selected for processing (2)

• lessons/03-neuron/01-rust-essentials-for-a-tiny-neuron.md
• lessons/03-neuron/02-neuron-as-a-chain-of-functions.md

---

📝 Walkthrough

Walkthrough

The changes refactor Rust examples in neuron lessons to replace manual field access (.0) with operator trait implementations. Two lessons are updated to demonstrate cleaner arithmetic expressions using Mul, Add, and Sub traits for wrapper types, along with From implementations for f64 conversions. Learning objectives and practice questions are updated to reflect this operator-overloading approach.

Changes

Cohort / File(s)	Summary
First Lesson Examples lessons/03-neuron/01-rust-essentials-for-a-tiny-neuron.md	Shifted pre_activation computation from manual .0 extraction to operator-based arithmetic. Updated dataset-printing example to use pattern-matching for tuple newtypes instead of field access. Revised learning goals and practice questions to emphasize operator overloading as an alternative to .0 peeling.
Second Lesson with Operator Traits lessons/03-neuron/02-neuron-as-a-chain-of-functions.md	Added new "Cleaner Rust with operator traits" section. Implemented Mul, Add, and Sub trait definitions for wrapper types. Introduced From<Prediction> for f64 and From<Input> for f64 conversions. Updated pre_activation and loss implementations to use operators. Enhanced training step snippet with Gradient and Adjustment wrapper types using wrapper-driven arithmetic for parameter updates.

Estimated code review effort

🎯 3 (Moderate) | ⏱️ ~22 minutes

Poem

🐰 Operators hop, where .0 once did dwell,
Traits now weave their mathematical spell,
From inputs to weights, the symbols align,
Cleaner expressions make the neurons shine! ✨

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch rd/neuron-operator-traits

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[gemini-code-assist]

Code Review

This pull request refactors the Rust neuron lessons to use operator overloading and trait implementations (Add, Mul, Sub, From) for newtypes, reducing the noise of direct field access. The updates span explanatory text, code examples, and practice questions. Feedback suggests adopting the more idiomatic .into() method for type conversions in place of explicit f64::from() calls where the target type can be inferred.

[gemini-code-assist]

While f64::from(y_hat) is correct, it's often more idiomatic in Rust to use .into() when the target type can be inferred from the context. This can make the code slightly more concise and is a good pattern to teach.

Suggested change

	f64::from(y_hat),
	f64::from(y_hat).into(),

[gemini-code-assist]

While f64::from(prediction) is correct, it's often more idiomatic to use .into() when the target type can be inferred from the context. Since sigmoid_derivative_from_output takes an f64, the compiler can infer the type. Using .into() is a common Rust pattern that would be valuable to include in the lesson.

Suggested change

	let d_prediction_d_pre_activation =
	sigmoid_derivative_from_output(prediction.0);
	sigmoid_derivative_from_output(f64::from(prediction));
	let d_prediction_d_pre_activation =
	sigmoid_derivative_from_output(prediction.into());

[gemini-code-assist]

Similar to the previous comment, you can use .into() here for a more idiomatic conversion. The compiler can infer that an f64 is needed from how these variables are used in later calculations.

Suggested change

	let d_pre_activation_d_w1 = f64::from(x1);
	let d_pre_activation_d_w2 = f64::from(x2);
	let d_pre_activation_d_w1 = x1.into();
	let d_pre_activation_d_w2 = x2.into();

[gemini-code-assist]

You can use .into() here as well for more idiomatic conversions, which is a good pattern to demonstrate in the lesson.

Suggested change

	f64::from(before),
	loss_before,
	f64::from(after)
	before.into(),
	loss_before,
	after.into()