Looking for advice, do you feel like using a WeakMap would be better here than using the symbol?
import{BufferWithPointer}from"./buffer"constbyteLength=Symbol("ByteLengthRead")/** Utility to specifiy that a reader function consumes a constant length of buffer */exportconstfixedLength=<Lextendsnumber,Fextends((r:BufferWithPointer)=>any)&{[byteLength]?:L}>(len:L,fn:F)=>{if(!Number.isInteger(len)||len<1)thrownewTypeError(`byte length must be a positive integer, got ${len} instead`)fn[byteLength]=lenreturnfnasF&{[byteLength]:L}}/** Wraps a reader function, to read until end of buffer and return array */exportconstreadUntilEnd=<R>(fn:((r:BufferWithPointer)=>R)&{[byteLength]?:number}):((r:BufferWithPointer)=>R[])=>{constlen=fn[byteLength]returnlen?r=>{constrepeats=r.remaining()/lenif(!Number.isInteger(repeats))thrownewRangeError(`Bad buffer: Remaining length not multiple of repeat unit length`)constarr:R[]=newArray(repeats)for(leti=0;i<repeats;i++){arr[i]=fn(r)}returnarr}:r=>{constarr:R[]=[]letlast=r.remaining()while(last){arr.push(fn(r))constremaining=r.remaining()if(remaining>=last)thrownewError(`Infinite loop: repeat unit isn't consuming buffer`)last=remaining}returnarr}}
Yep, I think WeakMap suits this more but it's just a semantical change in this case, not a critical one. Theoretically, this implementation could cause issues with some Proxy based libraries (which do intercept Symbol get/set).
Generally, I like to use symbols like well-known symbols. When I create an internal feature that I want to expose to experienced devs (by exporting the symbol) but don't want to be accidentally overwritten (like a normal prop).
I hope this helps a bit.
PS: I use both Symbols and WeakMaps in a lib which I perf profile often and I found no real difference in performance (in Chrome and Node at least.)
Cool. Maybe I'll switch then.
It was fun to type this, with the "wrapped" functions having a literal number attached to them, but it's not like either the Symbol or the WeakMap will ever be exported.
On the other hand, I won't be able to tell if a function is "wrapped" by type tooltip any more or see its bytelength :/
Looking for advice, do you feel like using a WeakMap would be better here than using the symbol?
Yep, I think WeakMap suits this more but it's just a semantical change in this case, not a critical one. Theoretically, this implementation could cause issues with some Proxy based libraries (which do intercept Symbol get/set).
Generally, I like to use symbols like well-known symbols. When I create an internal feature that I want to expose to experienced devs (by exporting the symbol) but don't want to be accidentally overwritten (like a normal prop).
I hope this helps a bit.
PS: I use both Symbols and WeakMaps in a lib which I perf profile often and I found no real difference in performance (in Chrome and Node at least.)
Cool. Maybe I'll switch then.
It was fun to type this, with the "wrapped" functions having a literal number attached to them, but it's not like either the
Symbol
or theWeakMap
will ever be exported.On the other hand, I won't be able to tell if a function is "wrapped" by type tooltip any more or see its bytelength :/
That's true. I only use TypeScript when I must so I tend to not think about typings.