Monads - Revision history

Iwiseman: /* 🧠 What I Learned */

2025-09-24T03:45:45Z

🧠 What I Learned

← Older revision		Revision as of 03:45, 24 September 2025
Line 353:		Line 353:
	* They make chaining operations predictable and clean		* They make chaining operations predictable and clean
	* Even simple wrappers can teach deep ideas about functional design		* Even simple wrappers can teach deep ideas about functional design
			=Finally=
			The YouTube left us with this slide. I guess the most obvious ones are Option, Result, Writer, Future/Promise<br>
			[[File:Monad2.png]]<br>

Iwiseman: /* 🧭 Conclusion: My First Monad */

2025-09-24T03:31:17Z

🧭 Conclusion: My First Monad

← Older revision		Revision as of 03:31, 24 September 2025
Line 286:		Line 286:
	! Simple Explanation		! Simple Explanation
	! My Example		! My Example
	! Also ~~Know~~ As		! Also Known As
	\|-		\|-
	\|
	\| '''Wrapper Type'''		\| '''Wrapper Type'''
	\| A container that holds a value and extra info (like logs)		\| A container that holds a value and extra info (like logs)
	\| <code>NumberWithLogs</code>		\| <code>NumberWithLogs</code>
	\|-		\| —
	\|
	\|-		\|-
	\| '''Wrap Function'''		\| '''Wrap Function'''
	\| Takes a plain value and puts it into the container		\| Takes a plain value and puts it into the container
	\| <code>wrapWithLogs</code>		\| <code>wrapWithLogs</code>
	\|-		\| <code>return</code>, <code>pure</code>, <code>unit</code>
	\|return, pure, unit
	\|-		\|-
	\| '''Run Function'''		\| '''Run Function'''
	\| Applies a transformation to the value, keeping the container structure		\| Applies a transformation to the value, keeping the container structure
	\| <code>runWithLogs</code>		\| <code>runWithLogs</code>
	\|-		\| <code>bind</code>, <code>flatMap</code>, <code>>>=</code>
	\| bind, flatMap, >>=
	\|}		\|}

Iwiseman: /* 🧱 Monad Building Blocks (Simplified) */

2025-09-24T03:30:24Z

🧱 Monad Building Blocks (Simplified)

← Older revision		Revision as of 03:30, 24 September 2025
Line 287:		Line 287:
	! My Example		! My Example
	! Also Know As		! Also Know As
			\|-
	\|		\|
	\| '''Wrapper Type'''		\| '''Wrapper Type'''
	\| A container that holds a value and extra info (like logs)		\| A container that holds a value and extra info (like logs)
	\| <code>NumberWithLogs</code>		\| <code>NumberWithLogs</code>
	-		\|-
	\|		\|
	\|-		\|-
Line 297:		Line 298:
	\| Takes a plain value and puts it into the container		\| Takes a plain value and puts it into the container
	\| <code>wrapWithLogs</code>		\| <code>wrapWithLogs</code>
	-		\|-
	\|return, pure, unit		\|return, pure, unit
	\|-		\|-
Line 303:		Line 304:
	\| Applies a transformation to the value, keeping the container structure		\| Applies a transformation to the value, keeping the container structure
	\| <code>runWithLogs</code>		\| <code>runWithLogs</code>
	-		\|-
	\| bind, flatMap, >>=		\| bind, flatMap, >>=
	\|}		\|}

Iwiseman: /* 🧭 Conclusion: My First Monad */

2025-09-24T03:29:28Z

🧭 Conclusion: My First Monad

← Older revision		Revision as of 03:29, 24 September 2025
Line 287:		Line 287:
	! My Example		! My Example
	! Also Know As		! Also Know As
	\|-		\|
	\| '''Wrapper Type'''		\| '''Wrapper Type'''
	\| A container that holds a value and extra info (like logs)		\| A container that holds a value and extra info (like logs)

Iwiseman: /* 🧱 Monad Building Blocks (Simplified) */

2025-09-24T03:29:04Z

🧱 Monad Building Blocks (Simplified)

← Older revision		Revision as of 03:29, 24 September 2025
Line 286:		Line 286:
	! Simple Explanation		! Simple Explanation
	! My Example		! My Example
			! Also Know As
	\|-		\|-
	\| '''Wrapper Type'''		\| '''Wrapper Type'''
	\| A container that holds a value and extra info (like logs)		\| A container that holds a value and extra info (like logs)
	\| <code>NumberWithLogs</code>		\| <code>NumberWithLogs</code>
			-
			\|
	\|-		\|-
	\| '''Wrap Function'''		\| '''Wrap Function'''
	\| Takes a plain value and puts it into the container		\| Takes a plain value and puts it into the container
	\| <code>wrapWithLogs</code>		\| <code>wrapWithLogs</code>
			-
			\|return, pure, unit
	\|-		\|-
	\| '''Run Function'''		\| '''Run Function'''
	\| Applies a transformation to the value, keeping the container structure		\| Applies a transformation to the value, keeping the container structure
	\| <code>runWithLogs</code>		\| <code>runWithLogs</code>
			-
			\| bind, flatMap, >>=
	\|}		\|}

Iwiseman: /* Step 6 - The RunWithLogs function */

2025-09-24T03:25:52Z

Step 6 - The RunWithLogs function

← Older revision		Revision as of 03:25, 24 September 2025
Line 272:		Line 272:
	}		}
	</syntaxhighlight>		</syntaxhighlight>
			== 🧭 Conclusion: My First Monad ==

			In exploring monads, I built a simple wrapper called <code>NumberWithLogs</code> that tracks both a result and a log of operations. This helped me understand how monads let us:

			* Wrap values with extra context (like logs)
			* Chain operations while keeping that context
			* Keep the code readable and composable

			=== 🧱 Monad Building Blocks (Simplified) ===

			{\| class="wikitable"
			! Concept
			! Simple Explanation
			! My Example
			\|-
			\| '''Wrapper Type'''
			\| A container that holds a value and extra info (like logs)
			\| <code>NumberWithLogs</code>
			\|-
			\| '''Wrap Function'''
			\| Takes a plain value and puts it into the container
			\| <code>wrapWithLogs</code>
			\|-
			\| '''Run Function'''
			\| Applies a transformation to the value, keeping the container structure
			\| <code>runWithLogs</code>
			\|}

			=== 🧪 Transform Functions I Used ===

			Each function takes a number and returns a <code>NumberWithLogs</code> — a result plus a log message.

			<syntaxhighlight lang="ts">
			const squareTransform = (x: number): NumberWithLogs => {
			const result = x * x;
			return {
			result,
			logs: [`Squared ${x} to get ${result}`]
			};
			};

			const addOneTransform = (x: number): NumberWithLogs => {
			const result = x + 1;
			return {
			result,
			logs: [`Added one to ${x} to get ${result}`]
			};
			};
			</syntaxhighlight>

			=== 🧰 Monad Functions ===

			<syntaxhighlight lang="ts">
			function wrapWithLogs(x: number): NumberWithLogs {
			return {
			result: x,
			logs: []
			};
			}

			const runWithLogs = (
			input: NumberWithLogs,
			transform: (x: number) => NumberWithLogs
			): NumberWithLogs => {
			const numberWithLogs = transform(input.result);
			return {
			result: numberWithLogs.result,
			logs: input.logs.concat(numberWithLogs.logs)
			};
			};
			</syntaxhighlight>

			=== 🧠 What I Learned ===

			* Monads help manage extra context (like logs) without cluttering logic
			* They make chaining operations predictable and clean
			* Even simple wrappers can teach deep ideas about functional design

Iwiseman: /* Step 6 - The RunWithLogs function */

2025-09-24T03:08:24Z

Step 6 - The RunWithLogs function

← Older revision		Revision as of 03:08, 24 September 2025
Line 263:		Line 263:
	const runWithLogs = (		const runWithLogs = (
	input: NumberWithLogs,		input: NumberWithLogs,
	transform: (x: ~~NumberWithLogs~~) => NumberWithLogs): NumberWithLogs => {		transform: (x: number) => NumberWithLogs): NumberWithLogs => {

	const numberWithLogs = transform(input);		const numberWithLogs = transform(input.result);
	return {		return {
	result: numberWithLogs.result,		result: numberWithLogs.result,

Iwiseman: /* Step 5 - The NumberWithLogs Transform function */

2025-09-24T03:06:15Z

Step 5 - The NumberWithLogs Transform function

@@ Line 235: / Line 235: @@
              `Added one to ${x.result} to get ${x.result + 1}`
+         ]
+     }
+}

Iwiseman: /* Step 5 - The NumberWithLogs Transform function */

2025-09-24T02:50:55Z

Step 5 - The NumberWithLogs Transform function

← Older revision		Revision as of 02:50, 24 September 2025
Line 223:		Line 223:
	return {		return {
	result: x.result * x.result,		result: x.result * x.result,
	logs: ~~x.logs.concat(~~[		logs: [
	`Squared ${x.result} to get ${x.result * x.result}`		`Squared ${x.result} to get ${x.result * x.result}`
	])		]
	}		}
	}		}
Line 232:		Line 232:
	return {		return {
	result: x.result + 1,		result: x.result + 1,
	logs: ~~x.logs.concat(~~[		logs: [
	`Added one to ${x.result} to get ${x.result + 1}`		`Added one to ${x.result} to get ${x.result + 1}`
	])		]
	}		}
	}		}
	</syntaxhighlight>		</syntaxhighlight>

	==Step 6 - The RunWithLogs function==		==Step 6 - The RunWithLogs function==
	Now we can run either of these functions with this		Now we can run either of these functions with this

Iwiseman: /* Rework Version 2 */

2025-09-24T02:49:49Z

Rework Version 2

← Older revision		Revision as of 02:49, 24 September 2025
Line 186:		Line 186:
	const numberWithLogs: NumberWithLogs = {		const numberWithLogs: NumberWithLogs = {
	result: x.result + 1,		result: x.result + 1,
	logs: ~~x.logs.concat(~~[		logs: [
	`Added one to ${x.result} to get ${x.result + 1}`		`Added one to ${x.result} to get ${x.result + 1}`
	])		]
	}		}
	return {		return {
Line 199:		Line 199:
	const numberWithLogs: NumberWithLogs = {		const numberWithLogs: NumberWithLogs = {
	result: x.result * x.result,		result: x.result * x.result,
	logs: ~~x.logs.concat(~~[		logs: [
	`Squared ${x.result} to get ${x.result * x.result}`		`Squared ${x.result} to get ${x.result * x.result}`
	])		]
	}		}

Line 210:		Line 210:
	}		}
	</syntaxhighlight>		</syntaxhighlight>

	==Step 5 - The NumberWithLogs Transform function==		==Step 5 - The NumberWithLogs Transform function==
	So looking at both functions we can see the top half is a function which takes x as an argument and returns a NumberWithLogs. e.g.		So looking at both functions we can see the top half is a function which takes x as an argument and returns a NumberWithLogs. e.g.