A list of all the patterns I've discovered, as well as what they do.
These patterns seem to represent common operations I perform on lists. Though these are perfectly possible to do with normal List Manipulation, it often requires more effort. Perhaps Nature willed them into existence to better understand what I'm doing... or perhaps they are my own invention?
Ferris Distillation ([a], int → [a])
Rotates the array leftward: an argument of 1 moves the first item of the list to the end. Negative numbers allow rotating the list rightward.
Retention Distillation ([a], int → [a])
Selects the first few elements from the input list. If the number is negative, selects the last few elements instead.
Rejection Distillation ([a], int → [a])
Drops the first few elements from the input list; the dual to Retention Distillation.
Retention Distillation ([a], [int] → [a])
Selects from the list only elements corresponding to the given indices. Unlike Selection Distillation, this cannot reorder or duplicate iotas.
Rejection Distillation ([a], [int] → [a])
Drops from the list iotas at the given indices. All other iotas are kept in the same order as the input.
Though my Hexes can use Reveal to transmit information to my mind, the resulting message is ephemeral — unless I stand still and reflect on what I've heard recently, it will slip away like anything else someone says. Additionally, constantly hammering my mind with iotas distracts me from more important things.
Thus, I've devised a new pattern of my own. It's similar to Reveal, but the message is lodged well within my mind, and I forget it instantly if I replace it with something else. It can also take a list of messages, for convenience.
Greater Reveal ([iota] | iota →)
Takes a list of iotas (or a single non-iota, which is treated as a list with one element) and displays them permanently to the caster. Displayed iotas survive all methods that would clear a normal Reveal, and can only be cleared by another casting of Greater Reveal.
To be a Hexcaster is to glimpse a truth that might best be hidden.
I've discovered a way to create a new type of iota — an abhorrence against Nature of my own doing. This pattern weaves a 'sheath' of media out of some iota, letting me customize several attributes of the new iota. Though this can make my spells more expressive, this ability is not to be taken lightly — I cannot imagine the mischief others would do with these 'patchwork' iotas.
To assemble a patchwork iota, I must provide four source iotas:
The 'userdata' iota, passed to my overload Hexes.
The 'display' iota, visible to my eyes.
A color for the iota, as an RGB vector in the 0-1 range.
A pointer to an overload map.
Such an 'overload map' is merely a regular Map iota (mapping patterns to the Hexes they should be replaced with), but stored within a Property. I assume that Nature's reason for boxing like this is to save space: it's likely I'll have many patched iotas all using the same overloads. This also gives me the convenience of updating every instance with merely Schrödinger's Gambit, rather than finding and updating them all by hand.
These overload maps resemble a technique I've seen before — the concept of redefining patterns on a fundamental level resembles the moon cultists' (little time to explain) metatables, which allow associating a table with another table to redefine its operations. When my 'metamethods' are invoked, the userdata iota is pushed to the top of the stack. All other information about the patchwork disintegrates: I'll need to recreate it from scratch (maybe I should use a 'constructor' macro?) if I want to return a new iota of the same type.
Important note: unlike these 'metatables' I've heard about, patchwork replaces the behavior of the underlying iota. For example, operators such as <ne,waaw> won't work on two patchwork numbers unless I define it myself. However, I feel uneasy relying on this behavior — Nature will be perfectly happy to change this at any moment.
Maps are an efficient structure holding pairings of some iota to some other iota. While this is perfectly possible using merely list operations, dedicated map iotas use some arcane substance called a 'Hash'. While this doesn't reduce the operations required to access a map, it desperately reduces the load on Nature, nearing O(1) for most access.
Vacant Reflection: Map (→ map<⊥, ⊥>)
Creates a new empty map for my usage.
Additive Distillation (map<k, v>, map<k, v> → map<k, v>)
Merges two maps together. Maps cannot have duplicate items: any entry in the latter map will override that in the first map.
Subtractive Distillation (map<k, v>, map<t, *> → map<k, v>)
Removes every entry in the first map that is found in the second map. The values in the second map are ignored.
Selection Distillation (map<k, v>, k → v?)
Disintegrates the map, returning only the value associated with the given key. O(1), unlike scanning a list.
Derivation Decomposition (map<k, v> → map<k, v>, (k, v)?)
Shaves off one element of a map. Which element gets shaved off is undefined and subject to Nature's whims. If used on an empty map, returns two nulls.
Surgeon's Exaltation (map<k, v>, k, v → map<k, v>)
Replaces the element associated with k with v. If k is not present in the map, the entry is created.
Excisor's Distillation (map<k, v>, k → map<k, v>)
Throws out the map's association for the given key. If there is no matching association, the map is returned unchanged.
My studies have led me to understand the fabric undermining every facet of this world. Nature's memory manifests itself as a recursive structure of 'tags' of several types. I've documented these over the next few pages. Though many types of tag appear to be redundant with each other, I must keep in mind that they are not freely interchangeable — and since I am dealing directly with Nature's memories, such a mistake could be worse than fatal.
If everything in the world is merely reduced to a tag... what am I? Is my entire existence reducible to a pile of bytes? At least this gives me some comfort, knowing that the villagers I've sacrificed in my journey truly had no life of their own... what about mine? What am I? Were the words I am writing in this very book, just a manifestation of random ones and zeroes?
I best not ponder too much. Though I may pry into everything I wish in detail, doing so would suck the joy from this illusion.
Secretary's Purification: Byte (number → nbt)
Converts a number into a Byte tag: an integer between -128 and 127, inclusive.
Secretary's Purification: Short (number → nbt)
Converts a number into a Short tag, between -65536 and 65535.
Secretary's Purification: Integer (number → nbt)
Converts a number into an Int tag, between roughly negative 2 billion and positive 2 billion.
Secretary's Purification: Long (number → nbt)
Converts a number into a Long tag: bounded to 9 quintillion, which I will likely never reach.
Secretary's Purification: Double (number → nbt)
Converts a number into a Double tag. Oddly, doubles seem to perfectly correspond to my knowledge of numbers, plus the ability to represent infinities and non-numbers.
Secretary's Purification: Float (number → nbt)
Converts a number into a Float tag. These seem similar to Doubles, albeit with less precision.
No. No. No. I— I thought Horrible was bad— etched into every waking moment— no— no— it hurts— must draw— can't draw— what have I done— why must Nature be like this—
Suffering (??? → ???)
How could one even begin to draw this?
These patterns force me to cast a Hex as if I drew it by hand. There are two variants of this pattern: the Greater version keeps the stack from the outside, while the Lesser version uses my staff's stack. My ravenmind is preserved in both cases.
Lani's Greater Gambit (∀αβ. α, [α → β] → β)
Coerces my staff to cast a Hex. The hex uses the stack of the outer casting environment.
Something's odd about how these patterns are named. I can simulate the Greater variant with merely a wrapper around the Lesser variant, but accessing the staff's stack itself is impossible with purely Greater. Does this not make Lesser strictly more powerful than Greater?
Lani's Lesser Gambit ([? → ?] →)
Coerces my staff to cast a Hex. The hex uses the stack of the staff itself, but keeps the outer environment's ravenmind.
For some strange reason, I feel the need to document this pattern in a separate chapter, despite its resemblance to Whisper Reflection — something about "mods shouldn't modify other mods' entries" and all that.
Murmur Reflection (→ str)
Adds the phrase on the tip of my tongue to the stack, regardless of whether I intend to say it.