Tries we have

the main inspiration for recent implementations are ART and HAMT

all implementations presently use HAMT-style array maps

all require V: Inline

Development process

I decided to document how I do the dev process, since it’s by now become core part of the project itself.

Atomic commits (and other Git things)

I fanatically split things into smaller commits when it’s easy to do so.

• when it’s not easy, make it easy
• when stuck/in doubt, reset everything, start over
• no branches
• no external issue tracking

Abstraction

Here I have a somewhat similar view: try to split as much as possible.

• don’t dyn for abstraction, only for necessary polymorphism (specifically the Fetches)
• having only 1 or 0 concretions is not reason enough to avoid an abstraction
• aim for encoding common interfaces as same trait even if they represent different things
  • this notably happened to the way we map Extras
• custom logic for concretions should mostly be implemented in abstractions and then composed
  • see how schema thing does so

planned for inclusion

Alisa Feistel maintains this list for herself, please do NOT treat this as an invitation for PRs.

• NonZero<i*> niches
• LEB128
• append but leaves old items in other
• IPLD storage
• encrypted IPLD storage
• Ipld
• {Hamt,Trie}{Map,Set}: FromIterator
• auto-inlining wrapper
• generic Trie algorithms
• type as value
• subtries
  • Amt
  • Trie
• #[derive(FromSized)]
• hybrid-array
• Immutable point
• fetch chain
  • consistency error cascade
• tokio_util::codec
• fixed-size reverse parse-ahead
• move Apply on things to things