Axel Rauschmayer rauschma

Creating synchronous iterators

The methods of class Iterator let us process data incrementally. Let’s explore where we can use them.

Iterator.from(iterable) always returns instances of Iterator (converting non-instances to instances as needed).
iterable[Symbol.iterator]() returns an iterator:
- With all built-in data structures, the result is an instance of Iterator.
- With other, older iterable objects, the result may not be an instance of Iterator.

For sale in Munich (to be picked up in person): EUR 700

If you see a JavaScript feature in this book that you don’t understand, you can look it up in my book “Exploring JavaScript” which is free to read online. Some of the “Further reading” sections at the ends of chapters refer to this book.

The official “TypeScript Handbook” is a good reference for the language. It currently has a few holes that are filled by the release notes and GitHub pull requests (which handbook and release notes link to).
“TypeScript Deep Dive” by Basarat Ali Syed was not updated much after 2020 – e.g., it does not cover template string types. But this book is still a valuable resource.

Did I forget anything?

	// Triggered by: https://fediverse.zachleat.com/@zachleat/115300801628689509
	// Interesting inconsistency...
	// The reason is probably backward compatibility:
	// Truthiness checks are often used to answer the question “Is this value an object?”

	class MyBool {
	#bool;
	constructor(bool) {
	this.#bool = bool;
	}

	<?xml version="1.0" encoding="UTF-8"?>
	<opml version="1.0">
	<head>
	<title>RSS subscriptions for [email protected]</title>
	<dateCreated>Sat, 02 Aug 2025 13:20:09 +0000</dateCreated>
	<ownerEmail>[email protected]</ownerEmail>
	</head>
	<body>
	<outline text="Sustainability" title="Sustainability">
	<outline text="Modern Farmer" title="Modern Farmer" type="rss" xmlUrl="http://modernfarmer.com/feed/" htmlUrl="https://modernfarmer.com/"/>

	#!/usr/bin/env node

	import { watch } from 'node:fs/promises';
	import * as fs from 'node:fs';
	import * as path from 'node:path';

	async function main() {
	const args = process.argv.slice(2);
	if (args.length === 0) {
	const bin = path.basename(process.argv[1]);

	// More information on enum objects as an alternative to enums:
	// https://2ality.com/2025/01/typescript-enum-patterns.html#alternative-to-enum%3A-object-literal-1

	/**
	* Returns an enum object. Adds the following improvements:
	* - Sets the prototype to `null`.
	* - Freezes the object.
	* - The result has the same type as if `as const` had been applied.
	*/
	function createEnum<

	// Experiment: I’m not sure if I would use this myself.

	const call = Symbol('call');
	class Callable {
	constructor() {
	// Can’t use .bind() here. Not sure why. Maybe the result doesn’t
	// interact well with Object.setPrototypeOf().
	const _this = (...args) => new.target.prototype[call].call(_this, ...args);
	Object.setPrototypeOf(_this, new.target.prototype);
	return _this;

	//========== Testing types ==========

	const expectType = <Type>(_: Type): void => void 0;
	type TypeEqual<Target, Value> = (<T>() => T extends Target
	? 1
	: 2) extends <T>() => T extends Value ? 1 : 2
	? true
	: false;

	//========== applyPartial ==========