Buf.pm6

my class X::Assignment::RO      { ... }
my class X::Buf::AsStr          { ... }
my class X::Buf::Pack           { ... }
my class X::Buf::Pack::NonASCII { ... }
my class X::Cannot::Empty       { ... }
my class X::Cannot::Lazy        { ... }
my class X::Experimental        { ... }

# these constants temporary until they are available as nqp::const::FOO
constant BINARY_ENDIAN_NATIVE =  0;
constant BINARY_ENDIAN_LITTLE =  1;
constant BINARY_ENDIAN_BIG    =  2;

constant BINARY_SIZE_8_BIT    =  0;
constant BINARY_SIZE_16_BIT   =  4;
constant BINARY_SIZE_32_BIT   =  8;
constant BINARY_SIZE_64_BIT   = 12;

# externalize the endian indicators
enum Endian (
  native-endian => BINARY_ENDIAN_NATIVE,
  little-endian => BINARY_ENDIAN_LITTLE,
  big-endian    => BINARY_ENDIAN_BIG,
);

my role Blob[::T = uint8] does Positional[T] does Stringy is repr('VMArray') is array_type(T) {
    X::NYI.new(
      feature => "{$?CLASS.^name.comb(/^ \w+ /)}s with native {T.^name}"
    ).throw unless nqp::istype(T,Int);

    # other then *8 not supported yet
    my int $bpe = try {
#?if jvm
        # https://irclog.perlgeek.de/perl6-dev/2017-01-20#i_13961377
        CATCH { default { Nil } }
#?endif
        (T.^nativesize / 8).Int
    } // 1;

    multi method WHICH(Blob:D:) {
        nqp::box_s(
          nqp::concat(
            nqp::if(
              nqp::eqaddr(self.WHAT,Blob),
              'Blob|',
            nqp::concat(nqp::unbox_s(self.^name), '|')
            ),
            nqp::sha1(self.decode("latin-1"))
          ),
          ValueObjAt
        )
    }

    multi method new(Blob:) { nqp::create(self) }
    multi method new(Blob: Blob:D $blob) {
        nqp::splice(nqp::create(self),$blob,0,0)
    }
    multi method new(Blob: int @values) {
        nqp::splice(nqp::create(self),@values,0,0)
    }
    multi method new(Blob: @values) {
        nqp::create(self).STORE(@values, :INITIALIZE)
    }
    multi method new(Blob: *@values) {
        nqp::create(self).STORE(@values, :INITIALIZE)
    }

    proto method STORE(Blob:D: |) {*}
    multi method STORE(Blob:D: Iterable:D \iterable, :$INITIALIZE) {
        $INITIALIZE
          ?? iterable.is-lazy
            ?? X::Cannot::Lazy.new(:action<store>,:what(self.^name)).throw
            !! self!push-list("initializ",self,iterable)
          !! X::Assignment::RO.new(:value(self)).throw
    }

    proto method allocate(|) {*}
    multi method allocate(Blob:U: Int:D $elements) {
        nqp::setelems(nqp::create(self),$elements)
    }
    multi method allocate(Blob:U: Int:D $elements, int $value) {
        my int $elems = $elements;
        my $blob     := nqp::setelems(nqp::create(self),$elems);
        my int $i     = -1;
        nqp::bindpos_i($blob,$i,$value) while nqp::islt_i(++$i,$elems);
        $blob;
    }
    multi method allocate(Blob:U: Int:D $elements, Int:D \value) {
        my int $value = value;
        self.allocate($elements,$value)
    }
    multi method allocate(Blob:U: Int:D $elements, Mu:D $got) {
        self!fail-typecheck('allocate',$got)
    }
    multi method allocate(Blob:U: Int:D $elements, int @values) {
        self!spread(nqp::setelems(nqp::create(self),$elements),@values)
    }
    multi method allocate(Blob:U: Int:D $elements, Blob:D $blob) {
        self!spread(nqp::setelems(nqp::create(self),$elements),$blob)
    }
    multi method allocate(Blob:U: Int:D $elements, @values) {
        self!spread(nqp::setelems(nqp::create(self),$elements),Blob.new(@values))
    }

    multi method EXISTS-POS(Blob:D: int \pos) {
        nqp::hllbool(
          nqp::islt_i(pos,nqp::elems(self)) && nqp::isge_i(pos,0)
        );
    }
    multi method EXISTS-POS(Blob:D: Int:D \pos) {
        nqp::hllbool(
          nqp::islt_i(pos,nqp::elems(self)) && nqp::isge_i(pos,0)
        );
    }

    multi method AT-POS(Blob:D: int \pos) {
        nqp::if(
          (nqp::isge_i(pos,nqp::elems(self)) || nqp::islt_i(pos,0)),
          self!fail-range(pos),
          nqp::atpos_i(self,pos)
        )
    }
    multi method AT-POS(Blob:D: Int:D \pos) {
        nqp::if(
          (nqp::isge_i(pos,nqp::elems(self)) || nqp::islt_i(pos,0)),
          self!fail-range(pos),
          nqp::atpos_i(self,pos)
        )
    }

    # for simplicity's sake, these are not multis
    method read-int8( int $offset, Endian $? --> int) is raw {
        nqp::readint(self,$offset,
          nqp::bitor_i(BINARY_SIZE_8_BIT,BINARY_ENDIAN_NATIVE))
    }
    method read-int16(
      int $offset, Endian $endian = native-endian --> int
    ) is raw {
        nqp::readint(self,$offset,
          nqp::bitor_i(BINARY_SIZE_16_BIT,$endian))
    }
    method read-int32(
      int $offset, Endian $endian = native-endian --> int
    ) is raw {
        nqp::readint(self,$offset,
          nqp::bitor_i(BINARY_SIZE_32_BIT,$endian))
    }
    method read-int64(
      int $offset, Endian $endian = native-endian --> int
    ) is raw {
        nqp::readint(self,$offset,
          nqp::bitor_i(BINARY_SIZE_64_BIT,$endian))
    }

    method read-uint8(int $offset, Endian $? --> uint) is raw {
        nqp::readuint(self,$offset,
          nqp::bitor_i(BINARY_SIZE_8_BIT,BINARY_ENDIAN_NATIVE))
    }
    method read-uint16(
      int $offset, Endian $endian = native-endian --> uint
    ) is raw {
        nqp::readuint(self,$offset,
          nqp::bitor_i(BINARY_SIZE_16_BIT,$endian))
    }
    method read-uint32(
      int $offset, Endian $endian = native-endian --> uint
    ) is raw {
        nqp::readuint(self,$offset,
          nqp::bitor_i(BINARY_SIZE_32_BIT,$endian))
    }
    method read-uint64(
      int $offset, Endian $endian = native-endian --> uint
    ) is raw {
        nqp::readuint(self,$offset,
          nqp::bitor_i(BINARY_SIZE_64_BIT,$endian))
    }

    method read-num32(
      int $offset, Endian $endian = native-endian --> num
    ) is raw {
        nqp::readnum(self,$offset,
          nqp::bitor_i(BINARY_SIZE_32_BIT,$endian))
    }
    method read-num64(
      int $offset, Endian $endian = native-endian --> num
    ) is raw {
        nqp::readnum(self,$offset,
          nqp::bitor_i(BINARY_SIZE_64_BIT,$endian))
    }

    multi method Bool(Blob:D:) { nqp::hllbool(nqp::elems(self)) }
    method Capture(Blob:D:) { self.List.Capture }

    multi method elems(Blob:D:)   { nqp::p6box_i(nqp::elems(self)) }
    multi method elems(Blob:U: --> 1)   { }
    method Numeric(Blob:D:) { nqp::p6box_i(nqp::elems(self)) }
    method Int(Blob:D:)     { nqp::p6box_i(nqp::elems(self)) }

    method bytes(Blob:D:) { nqp::mul_i(nqp::elems(self),$bpe) }

    method chars(Blob:D:)       { X::Buf::AsStr.new(method => 'chars').throw }
    multi method Str(Blob:D:)   { X::Buf::AsStr.new(method => 'Str'  ).throw }
    multi method Stringy(Blob:D:) { X::Buf::AsStr.new(method => 'Stringy' ).throw }

    proto method decode(|) {*}
    multi method decode(Blob:D: $encoding = self.encoding // "utf-8") {
        nqp::p6box_s(
          nqp::decode(self, Rakudo::Internals.NORMALIZE_ENCODING($encoding))
        )
    }
#?if !jvm
    multi method decode(Blob:D: $encoding, Str :$replacement!, Bool:D :$strict = False) {
        nqp::p6box_s(
          nqp::decoderepconf(self,
            Rakudo::Internals.NORMALIZE_ENCODING($encoding),
            $replacement.defined ?? $replacement !! nqp::null_s(),
            $strict ?? 0 !! 1))
    }
    multi method decode(Blob:D: $encoding, Bool:D :$strict = False) {
        nqp::p6box_s(
          nqp::decodeconf(self,
            Rakudo::Internals.NORMALIZE_ENCODING($encoding),
            $strict ?? 0 !! 1))
    }
#?endif
#?if jvm
    multi method decode(Blob:D: $encoding, Bool:D :$strict = False) {
        nqp::p6box_s(
          nqp::decode(self, Rakudo::Internals.NORMALIZE_ENCODING($encoding)))
    }
    multi method decode(Blob:D: $encoding, Str:D :$replacement!, Bool:D :$strict = False) {
        X::NYI.new(:feature<decode-with-replacement>).throw
    }
#?endif

    my class BlobAsList does Rakudo::Iterator::Blobby {
        method pull-one() is raw {
            nqp::if(
              nqp::islt_i(($!i = nqp::add_i($!i,1)),nqp::elems($!blob)),
              nqp::atpos_i($!blob,$!i),
              IterationEnd
            )
        }
    }
    multi method list(Blob:D:) { Seq.new(BlobAsList.new(self)).cache }

    multi method gist(Blob:D:) {
        self.^name ~ ':0x<' ~ self.map( -> \el {
            state $i = 0;
            ++$i == 101 ?? '...'
                !! $i == 102 ?? last()
                    !! nqp::if(nqp::iseq_i( # el.fmt: '%02x'
                        nqp::chars(my str $v = el.base: 16),1),
                        nqp::concat('0',$v),$v)
        }) ~ '>'
    }
    multi method perl(Blob:D:) {
        self.^name ~ '.new(' ~ self.join(',') ~ ')';
    }

    # Made this a sub instead of a private method so that the optimizer
    # doesn't need to put in IntLexRef's for the native int parameters.
    # Since we're not using any attributes, just self, that was an easy
    # choice to make.
    sub subbuf-end(\SELF, int $start, int $end, int $elems) {
        nqp::if(
          nqp::islt_i($start,0) || nqp::isgt_i($start,$elems),
          Failure.new( X::OutOfRange.new(
            what  => '"From argument to subbuf',
            got   => $start,
            range => "0.." ~ $elems
          )),
          nqp::if(
            nqp::isle_i(
              (my int $last = nqp::if(nqp::isge_i($end,$elems),$elems-1,$end)),
              $start - 1
            ),                                # 0 elements to return
            nqp::create(SELF),                # just create a new one
            nqp::slice(SELF,$start,$last)     # do the actual slice
          )
        )
    }
    sub subbuf-length(\SELF, int $from, int $length, int $elems) {
        nqp::if(
          nqp::islt_i($length,0),
          Failure.new( X::OutOfRange.new(
            what  => 'Len element to subbuf',
            got   => $length,
            range => "0.." ~ $elems
          )),
          subbuf-end(SELF, $from, $from + $length - 1, $elems)
        )
    }

    proto method subbuf(|) {*}
    multi method subbuf(Blob:D: Range:D $fromto) {
        nqp::if(
          nqp::getattr_i($fromto,Range,'$!is-int'),
          nqp::stmts(
            (my int $start = nqp::add_i(
              nqp::unbox_i(nqp::getattr($fromto,Range,'$!min')),
              nqp::getattr_i($fromto,Range,'$!excludes-min')
            )),
            (my int $end = nqp::sub_i(
              nqp::unbox_i(nqp::getattr($fromto,Range,'$!max')),
              nqp::getattr_i($fromto,Range,'$!excludes-max')
            )),
            subbuf-end(self, $start, $end, nqp::elems(self))
          ),
          Failure.new( X::AdHoc.new(
            payload => "Must specify a Range with integer bounds to subbuf"
          ))
        )
    }
    multi method subbuf(Blob:D: Int:D $From) {
        my int $elems = nqp::elems(self);
        my int $from  = $From;
        subbuf-end(self, $from, $elems, $elems)
    }
    multi method subbuf(Blob:D: &From) {
        my int $elems = nqp::elems(self);
        my int $from  = From(nqp::box_i($elems,Int));
        subbuf-end(self, $from, $elems, $elems)
    }
    multi method subbuf(Blob:D: Int:D $From, Int:D $Length) {
        my int $from   = $From;
        my int $length = $Length;
        subbuf-length(self, $from, $length, nqp::elems(self))
    }
    multi method subbuf(Blob:D: Int:D $From, &End) {
        my int $elems  = nqp::elems(self);
        my int $from   = $From;
        my int $end    = End(nqp::box_i($elems,Int));
        subbuf-end(self, $from, $end, $elems)
    }
    multi method subbuf(Blob:D: &From, Int:D $Length) {
        my int $elems  = nqp::elems(self);
        my int $from   = From(nqp::box_i($elems,Int));
        my int $length = $Length;
        subbuf-length(self, $from, $length, $elems)
    }
    multi method subbuf(Blob:D: &From, &End) {
        my int $elems  = nqp::elems(self);
        my int $from   = From(nqp::box_i($elems,Int));
        my int $end    = End(nqp::box_i($elems,Int));
        subbuf-end(self, $from, $end, $elems)
    }
    multi method subbuf(Blob:D: \from, Whatever) {
        self.subbuf(from)
    }
    multi method subbuf(Blob:D: \from, Numeric \length) {
        length == Inf ?? self.subbuf(from) !! self.subbuf(from,length.Int)
    }
    multi method subbuf(Blob:D: \from, Any:U) {
        Rakudo::Deprecations.DEPRECATED(
          "{self.^name}.subbuf({from}) or {self.^name}.subbuf({from},*)",
          :what("{self.^name}.subbuf({from},Any)")
        );
        self.subbuf(from)
    }

    method reverse(Blob:D:) {
        my int $elems = nqp::elems(self);
        my int $last  = nqp::sub_i($elems,1);
        my $reversed := nqp::setelems(nqp::create(self),$elems);
        my int $i     = -1;
        nqp::while(
          nqp::islt_i(($i = nqp::add_i($i,1)),$elems),
          nqp::bindpos_i($reversed,nqp::sub_i($last,$i),
            nqp::atpos_i(self,$i))
        );
        $reversed
    }

    method COMPARE(Blob:D: Blob:D \other) {
        nqp::unless(
          nqp::cmp_i(
            (my int $elems = nqp::elems(self)),
            nqp::elems(my $other := nqp::decont(other))
          ),
          nqp::stmts(                            # same number of elements
            (my int $i = -1),
            nqp::while(
              nqp::islt_i(($i = nqp::add_i($i,1)),$elems)
                && nqp::not_i(
                     nqp::cmp_i(nqp::atpos_i(self,$i),nqp::atpos_i($other,$i))
                   ),
              nqp::null
            ),
            nqp::if(
              nqp::isne_i($i,$elems),
              nqp::cmp_i(nqp::atpos_i(self,$i),nqp::atpos_i($other,$i))
            )
          )
        )
    }

    method SAME(Blob:D: Blob:D \other) {
        nqp::if(
          nqp::iseq_i(
            (my int $elems = nqp::elems(self)),
            nqp::elems(my $other := nqp::decont(other))
          ),
          nqp::stmts(                            # same number of elements
            (my int $i = -1),
            nqp::while(
              nqp::islt_i(($i = nqp::add_i($i,1)),$elems)
                && nqp::iseq_i(nqp::atpos_i(self,$i),nqp::atpos_i($other,$i)),
              nqp::null
            ),
            nqp::iseq_i($i,$elems)
          )
        )
    }

    method join(Blob:D: $delim = '') {
        my int $elems = nqp::elems(self);
        my $list     := nqp::setelems(nqp::list_s,$elems);
        my int $i     = -1;

        nqp::bindpos_s($list,$i,
          nqp::tostr_I(nqp::p6box_i(nqp::atpos_i(self,$i))))
          while nqp::islt_i(++$i,$elems);

        nqp::join($delim.Str,$list)
    }

    proto method unpack(|) {*}
    multi method unpack(Blob:D: Str:D $template) {
        nqp::isnull(nqp::getlexcaller('EXPERIMENTAL-PACK'))
          ?? X::Experimental.new(
               feature => "the 'unpack' method",
               use     => "pack"
             ).throw
          !! self.unpack($template.comb(/<[a..zA..Z]>[\d+|'*']?/))
    }
    multi method unpack(Blob:D: @template) {
        nqp::isnull(nqp::getlexcaller('EXPERIMENTAL-PACK'))
          ?? X::Experimental.new(
               feature => "the 'unpack' method",
               use     => "pack"
             ).throw
          !! nqp::getlexcaller('EXPERIMENTAL-PACK')(self, @template)
    }

    # XXX: the pack.t spectest file seems to require this method
    # not sure if it should be changed to list there...
    method contents(Blob:D:) { self.list }

    method encoding() { Any }

    method !push-list(\action,\to,\from) {
        if nqp::istype(from,List) {
            my Mu $from := nqp::getattr(from,List,'$!reified');
            if nqp::defined($from) {
                my int $elems = nqp::elems($from);
                my int $j     = nqp::elems(to);
                nqp::setelems(to, $j + $elems);  # presize for efficiency
                my int $i = -1;
                my $got;
                nqp::while(
                  nqp::islt_i(++$i,$elems),
                  nqp::stmts(
                    ($got := nqp::atpos($from,$i)),
                    nqp::istype(nqp::hllize($got),Int)
                      ?? nqp::bindpos_i(to,$j++,$got)
                      !! self!fail-typecheck-element(action,$i,$got).throw))
            }
        }
        else {
            my $iter := from.iterator;
            my int $i = 0;
            nqp::until(
              nqp::eqaddr((my $got := $iter.pull-one),IterationEnd),
              nqp::if(
                nqp::istype(nqp::hllize($got),Int),
                nqp::stmts(
                  nqp::push_i(to,$got),
                  ($i = nqp::add_i($i,1))
                ),
                self!fail-typecheck-element(action,$i,$got).throw
              )
            )
        }
        to
    }
    method !unshift-list(\action,\to,\from) {
        if nqp::istype(from,List) {
            my Mu $from := nqp::getattr(from,List,'$!reified');
            if nqp::defined($from) {
                my int $i = nqp::elems($from);
                nqp::istype((my $got := nqp::atpos($from,$i)),Int)
                  ?? nqp::unshift_i(to,$got)
                  !! self!fail-typecheck-element(action,$i,$got).throw
                  while nqp::isge_i(--$i,0);
            }
            to
        }
        else {
            nqp::splice(to,self!push-list(action,nqp::create(self),from),0,0)
        }
    }
    method !spread(\to,\from) {
        if nqp::elems(from) -> int $values { # something to init with
            my int $elems = nqp::elems(to) - $values;
            my int $i     = -$values;
            nqp::splice(to,from,$i,$values)
              while nqp::isle_i($i = $i + $values,$elems);

            if nqp::isgt_i($i,$elems) {  # something left to init
                --$i;                    # went one too far
                $elems = $elems + $values;
                my int $j = -1;
                nqp::bindpos_i(to,$i,nqp::atpos_i(from,$j = ($j + 1) % $values))
                  while nqp::islt_i(++$i,$elems);
            }
        }
        to
    }
    method !fail-range($got) {
        Failure.new(X::OutOfRange.new(
          :what($*INDEX // 'Index'),
          :$got,
          :range("0..{nqp::elems(self)-1}")
        ))
    }
    method !fail-typecheck-element(\action,\i,\got) {
        self!fail-typecheck(action ~ "ing element #" ~ i,got);
    }
    method !fail-typecheck($action,$got) {
        Failure.new(X::TypeCheck.new(
          operation => $action ~ " to " ~ self.^name,
          got       => $got,
          expected  => T,
        ))
    }
    multi method ACCEPTS(Blob:D: Blob:D \Other) {
        nqp::hllbool(
          nqp::unless(
            nqp::eqaddr(self,my \other := nqp::decont(Other)),
            nqp::if(
              nqp::iseq_i(
                (my int $elems = nqp::elems(self)),
                nqp::elems(other)
              ),
              nqp::stmts(
                (my int $i = -1),
                nqp::while(
                  nqp::islt_i(($i = nqp::add_i($i,1)),$elems)
                    && nqp::iseq_i(nqp::atpos_i(self,$i),nqp::atpos_i(other,$i)
                       ),
                  nqp::null
                ),
                nqp::iseq_i($i,$elems)
              )
            )
          )
        )
    }
}

constant blob8 = Blob[uint8];
constant blob16 = Blob[uint16];
constant blob32 = Blob[uint32];
constant blob64 = Blob[uint64];

my class utf8 does Blob[uint8] is repr('VMArray') {
    method encoding(--> "utf-8") { }
    multi method Str(utf8:D:) { self.decode }
    multi method Stringy(utf8:D:) { self.decode }
}

my class utf16 does Blob[uint16] is repr('VMArray') {
    method encoding(--> "utf-16") { }
    multi method Str(utf16:D:) { self.decode }
    multi method Stringy(utf16:D:) { self.decode }
}

my class utf32 does Blob[uint32] is repr('VMArray') {
    method encoding(--> "utf-32") { }
    multi method Str(utf32:D:) { self.decode }
    multi method Stringy(utf32:D:) { self.decode }
}

my role Buf[::T = uint8] does Blob[T] is repr('VMArray') is array_type(T) {

    multi method WHICH(Buf:D:) { self.Mu::WHICH }

    multi method AT-POS(Buf:D: int \pos) is raw {
        nqp::islt_i(pos,0)
          ?? Failure.new(X::OutOfRange.new(
               :what($*INDEX // 'Index'),:got(pos),:range<0..^Inf>))
          !! nqp::atposref_i(self, pos)
    }
    multi method AT-POS(Buf:D: Int:D \pos) is raw {
        my int $pos = nqp::unbox_i(pos);
        nqp::islt_i($pos,0)
          ?? Failure.new(X::OutOfRange.new(
               :what($*INDEX // 'Index'),:got(pos),:range<0..^Inf>))
          !! nqp::atposref_i(self,$pos)
    }

    multi method ASSIGN-POS(Buf:D: int \pos, Mu \assignee) {
        nqp::islt_i(pos,0)
          ?? Failure.new(X::OutOfRange.new(
               :what($*INDEX // 'Index'),:got(pos),:range<0..^Inf>))
          !! nqp::bindpos_i(self,pos,assignee)
    }
    multi method ASSIGN-POS(Buf:D: Int:D \pos, Mu \assignee) {
        my int $pos = nqp::unbox_i(pos);
        nqp::islt_i($pos,0)
          ?? Failure.new(X::OutOfRange.new(
               :what($*INDEX // 'Index'),:got(pos),:range<0..^Inf>))
          !! nqp::bindpos_i(self,$pos,assignee)
    }

    multi method STORE(Buf:D: Blob:D $blob) {
        nqp::splice(nqp::setelems(self,0),$blob,0,0)
    }
    # The "is default" is needed to prevent runtime dispatch errors
    multi method STORE(Buf:D: int @values) is default {
        nqp::splice(nqp::setelems(self,0),@values,0,0)
    }
    multi method STORE(Buf:D: Iterable:D \iterable) {
        iterable.is-lazy
          ?? X::Cannot::Lazy.new(:action<store>,:what(self.^name)).throw
          !! self!push-list("initializ",nqp::setelems(self,0),iterable);
    }

    # for simplicity's sake, these are not multis
    method write-int8(
      int $offset, int $value, Endian $endian = native-endian --> Nil
    ) is raw {
        nqp::writeint(self,$offset,$value,
          nqp::bitor_i(BINARY_SIZE_8_BIT,$endian))
    }
    method write-int16(
      int $offset, int $value, Endian $endian = native-endian --> Nil
    ) is raw {
        nqp::writeint(self,$offset,$value,
          nqp::bitor_i(BINARY_SIZE_16_BIT,$endian))
    }
    method write-int32(
      int $offset, int $value, Endian $endian = native-endian --> Nil
    ) is raw {
        nqp::writeint(self,$offset,$value,
          nqp::bitor_i(BINARY_SIZE_32_BIT,$endian))
    }
    method write-int64(
      int $offset, int $value, Endian $endian = native-endian --> Nil
    ) is raw {
        nqp::writeint(self,$offset,$value,
          nqp::bitor_i(BINARY_SIZE_64_BIT,$endian))
    }
    method write-uint8(
      int $offset, uint8 $value, Endian $endian = native-endian --> Nil
    ) is raw {
        nqp::writeuint(self,$offset,$value,
          nqp::bitor_i(BINARY_SIZE_8_BIT,$endian))
    }
    method write-uint16(
      int $offset, uint16 $value, Endian $endian = native-endian --> Nil
    ) is raw {
        nqp::writeuint(self,$offset,$value,
          nqp::bitor_i(BINARY_SIZE_16_BIT,$endian))
    }
    method write-uint32(
      int $offset, uint32 $value, Endian $endian = native-endian --> Nil
    ) is raw {
        nqp::writeuint(self,$offset,$value,
          nqp::bitor_i(BINARY_SIZE_32_BIT,$endian))
    }
    method write-uint64(
      int $offset, uint64 $value, Endian $endian = native-endian --> Nil
    ) is raw {
        nqp::writeuint(self,$offset,$value,
          nqp::bitor_i(BINARY_SIZE_64_BIT,$endian))
    }
    method write-num32(
      int $offset, num32 $value, Endian $endian = native-endian --> Nil
    ) is raw {
        nqp::writenum(self,$offset,$value,
          nqp::bitor_i(BINARY_SIZE_32_BIT,$endian))
    }
    method write-num64(
      int $offset, num64 $value, Endian $endian = native-endian --> Nil
    ) is raw {
        nqp::writenum(self,$offset,$value,
          nqp::bitor_i(BINARY_SIZE_64_BIT,$endian))
    }

    multi method list(Buf:D:) {
        Seq.new(class :: does Rakudo::Iterator::Blobby {
            method pull-one() is raw {
                nqp::if(
                  nqp::islt_i(($!i = nqp::add_i($!i,1)),nqp::elems($!blob)),
                  nqp::atposref_i($!blob,$!i),
                  IterationEnd
                )
            }
        }.new(self)).cache
    }

    proto method pop(|) { * }
    multi method pop(Buf:D:) {
        nqp::elems(self)
          ?? nqp::pop_i(self)
          !! Failure.new(X::Cannot::Empty.new(:action<pop>,:what(self.^name)))
    }
    proto method shift(|) { * }
    multi method shift(Buf:D:) {
        nqp::elems(self)
          ?? nqp::shift_i(self)
          !! Failure.new(X::Cannot::Empty.new(:action<shift>,:what(self.^name)))
    }

    method reallocate(Buf:D: Int:D $elements) { nqp::setelems(self,$elements) }

    my $empty := nqp::list_i;
    proto method splice(|) { * }
    multi method splice(Buf:D \SELF:) { my $buf = SELF; SELF = Buf.new; $buf }
    multi method splice(Buf:D: Int:D $offset, $size = Whatever) {
        my int $remove = self!remove($offset,$size);
        my $result := $remove
          ?? self.subbuf($offset,$remove)  # until something smarter
          !! nqp::create(self);
        nqp::splice(self,$empty,$offset,$remove);
        $result
    }
    multi method splice(Buf:D: Int:D $offset, $size, int $got) {
        self!splice-native($offset,$size,$got)
    }
    multi method splice(Buf:D: Int:D $offset, $size, Int:D $got) {
        self!splice-native($offset,$size,$got)
    }
    multi method splice(Buf:D: Int:D $offset, $size, Mu:D $got) {
        self!fail-typecheck('splice',$got)
    }
    multi method splice(Buf:D: Int:D $offset, $size, Buf:D $buf) {
        self!splice-native($offset,$size,$buf)
    }
    multi method splice(Buf:D: Int:D $offset, $size, int @values) {
        self!splice-native($offset,$size,@values)
    }
    multi method splice(Buf:D: Int:D $offset, $size, @values) {
        self!splice-native($offset,$size,
          self!push-list("splic",nqp::create(self),@values))
    }

    method !remove(\offset,\size) {
        nqp::istype(size,Whatever)
          ?? nqp::elems(self) - offset
          !! nqp::istype(size,Int)
            ?? size
            !! size.Int
    }

    method !splice-native(Buf:D: Int:D $offset, $size, \x) {
        my int $remove = self!remove($offset,$size);
        my $result := $remove
          ?? self.subbuf($offset,$remove)  # until something smarter
          !! nqp::create(self);
        nqp::splice(
          self,nqp::islist(x) ?? x !! nqp::list_i(x),$offset,$remove);
        $result
    }

    proto method push(|) { * }
    multi method push(Buf:D: int $got) { nqp::push_i(self,$got); self }
    multi method push(Buf:D: Int:D $got) { nqp::push_i(self,$got); self }
    multi method push(Buf:D: Mu:D $got) { self!fail-typecheck('push',$got) }
    multi method push(Buf:D: Blob:D $buf) {
        nqp::splice(self,$buf,nqp::elems(self),0)
    }
    multi method push(Buf:D: **@values) { self!pend(@values,'push') }
    proto method append(|) { * }

    multi method append(Buf:D: int $got) { nqp::push_i(self,$got); self }
    multi method append(Buf:D: Int:D $got) { nqp::push_i(self,$got); self }
    multi method append(Buf:D: Mu:D $got) { self!fail-typecheck('append',$got) }
    multi method append(Buf:D: Blob:D $buf) {
        nqp::splice(self,$buf,nqp::elems(self),0)
    }
    multi method append(Buf:D: int @values) {
        nqp::splice(self,@values,nqp::elems(self),0)
    }
    multi method append(Buf:D:  @values) { self!pend(@values,'append') }
    multi method append(Buf:D: *@values) { self!pend(@values,'append') }
    proto method unshift(|) { * }

    multi method unshift(Buf:D: int $got) { nqp::unshift_i(self,$got); self }
    multi method unshift(Buf:D: Int:D $got) { nqp::unshift_i(self,$got); self }
    multi method unshift(Buf:D: Mu:D $got) { self!fail-typecheck('unshift',$got) }
    multi method unshift(Buf:D: Blob:D $buf) { nqp::splice(self,$buf,0,0) }
    multi method unshift(Buf:D: **@values) { self!pend(@values,'unshift') }

    proto method prepend(|) { * }
    multi method prepend(Buf:D: int $got) { nqp::unshift_i(self,$got); self }
    multi method prepend(Buf:D: Int:D $got) { nqp::unshift_i(self,$got); self }
    multi method prepend(Buf:D: Mu:D $got) { self!fail-typecheck('prepend',$got) }
    multi method prepend(Buf:D: Blob:D $buf)  { nqp::splice(self,$buf,0,0)    }
    multi method prepend(Buf:D: int @values) { nqp::splice(self,@values,0,0) }
    multi method prepend(Buf:D:  @values) { self!pend(@values,'prepend') }
    multi method prepend(Buf:D: *@values) { self!pend(@values,'prepend') }

    method !pend(Buf:D: @values, $action) {
        @values.is-lazy
          ?? Failure.new(X::Cannot::Lazy.new(:$action,:what(self.^name)))
          !! $action eq 'push' || $action eq 'append'
            ?? self!push-list($action,self,@values)
            !! self!unshift-list($action,self,@values)
    }

    method subbuf-rw($from = 0, $elems = self.elems - $from) is rw {
        my Blob $subbuf = self.subbuf($from, $elems);
        Proxy.new(
            FETCH   => sub ($) { $subbuf },
            STORE   => sub ($, Blob:D $new) {
                nqp::splice(self,nqp::decont($new),$from,$elems)
            }
        );
    }

}

constant buf8  = Buf[uint8];
constant buf16 = Buf[uint16];
constant buf32 = Buf[uint32];
constant buf64 = Buf[uint64];

multi sub infix:<~>(Blob:D \a) { a }
multi sub infix:<~>(Blob:D $a, Blob:D $b) {
    my $res := nqp::create(nqp::eqaddr($a.WHAT,$b.WHAT) ?? $a !! Buf.^pun);
    my $adc := nqp::decont($a);
    my $bdc := nqp::decont($b);
    my int $alen = nqp::elems($adc);
    my int $blen = nqp::elems($bdc);

    nqp::setelems($res, $alen + $blen);
    nqp::splice($res, $adc, 0, $alen);
    nqp::splice($res, $bdc, $alen, $blen);
}

multi sub prefix:<~^>(Blob:D \a) {
    my $a        := nqp::decont(a);
    my int $elems = nqp::elems($a);

    my $r := nqp::create($a);
    nqp::setelems($a,$elems);

    my int    $i    = -1;
    nqp::bindpos_i($r,$i,nqp::bitneg_i(nqp::atpos_i($a,$i)))
      while nqp::islt_i(++$i,$elems);

    $r
}

multi sub infix:<~&>(Blob:D \a, Blob:D \b) {
    my $a := nqp::decont(a);
    my $b := nqp::decont(b);
    my int $elemsa = nqp::elems($a);
    my int $elemsb = nqp::elems($b);
    my int $do  = $elemsa > $elemsb ?? $elemsb !! $elemsa;
    my int $max = $elemsa > $elemsb ?? $elemsa !! $elemsb;

    my $r := nqp::create($a);
    nqp::setelems($r,$max);

    my int $i = -1;
    nqp::bindpos_i($r,$i,
      nqp::bitand_i(nqp::atpos_i($a,$i),nqp::atpos_i($b,$i)))
      while nqp::islt_i(++$i,$do);

    --$i;    # went one too far
    nqp::bindpos_i($r,$i,0) while nqp::islt_i(++$i,$max);

    $r
}

multi sub infix:<~|>(Blob:D \a, Blob:D \b) {
    my $a := nqp::decont(a);
    my $b := nqp::decont(b);
    my int $elemsa = nqp::elems($a);
    my int $elemsb = nqp::elems($b);
    my int $do  = $elemsa > $elemsb ?? $elemsb !! $elemsa;
    my int $max = $elemsa > $elemsb ?? $elemsa !! $elemsb;
    my $from   := $elemsa > $elemsb ?? $a      !! $b;

    my $r := nqp::create($a);
    nqp::setelems($r,$max);

    my int $i = -1;
    nqp::bindpos_i($r,$i,
      nqp::bitor_i(nqp::atpos_i($a,$i),nqp::atpos_i($b,$i)))
      while nqp::islt_i(++$i,$do);

    $i = $i - 1;    # went one too far
    nqp::bindpos_i($r,$i,nqp::atpos_i($from,$i))
      while nqp::islt_i(++$i,$max);

    $r
}

multi sub infix:<~^>(Blob:D \a, Blob:D \b) {
    my $a := nqp::decont(a);
    my $b := nqp::decont(b);
    my int $elemsa = nqp::elems($a);
    my int $elemsb = nqp::elems($b);
    my int $do  = $elemsa > $elemsb ?? $elemsb !! $elemsa;
    my int $max = $elemsa > $elemsb ?? $elemsa !! $elemsb;
    my $from   := $elemsa > $elemsb ?? $a      !! $b;

    my $r := nqp::create($a);
    nqp::setelems($r,$max);

    my int $i = -1;
    nqp::bindpos_i($r,$i,
      nqp::bitxor_i(nqp::atpos_i($a,$i),nqp::atpos_i($b,$i)))
      while nqp::islt_i(++$i,$do);

    --$i;    # went one too far
    nqp::bindpos_i($r,$i,nqp::atpos_i($from,$i))
      while nqp::islt_i(++$i,$max);

    $r
}

multi sub infix:<eqv>(Blob:D \a, Blob:D \b) {
    nqp::hllbool(
      nqp::eqaddr(a,b) || (nqp::eqaddr(a.WHAT,b.WHAT) && a.SAME(b))
    )
}

multi sub infix:<cmp>(Blob:D \a, Blob:D \b) { ORDER(a.COMPARE(b))     }
multi sub infix:<eq> (Blob:D \a, Blob:D \b) {
    nqp::hllbool(nqp::eqaddr(a,b) || a.SAME(b))
}
multi sub infix:<ne> (Blob:D \a, Blob:D \b) {
    nqp::hllbool(nqp::not_i(nqp::eqaddr(a,b) || a.SAME(b)))
}
multi sub infix:<lt> (Blob:D \a, Blob:D \b) {
    nqp::hllbool(nqp::iseq_i(a.COMPARE(b),-1))
}
multi sub infix:<gt> (Blob:D \a, Blob:D \b) {
    nqp::hllbool(nqp::iseq_i(a.COMPARE(b),1))
}
multi sub infix:<le> (Blob:D \a, Blob:D \b) {
    nqp::hllbool(nqp::isne_i(a.COMPARE(b),1))
}
multi sub infix:<ge> (Blob:D \a, Blob:D \b) {
    nqp::hllbool(nqp::isne_i(a.COMPARE(b),-1))
}

proto sub subbuf-rw($, $?, $?, *%) {*}
multi sub subbuf-rw(Buf:D \b) is rw {
    b.subbuf-rw(0, b.elems);
}
multi sub subbuf-rw(Buf:D \b, Int() $from) is rw {
    b.subbuf-rw($from, b.elems - $from)
}
multi sub subbuf-rw(Buf:D \b, $from, $elems) is rw {
    b.subbuf-rw($from, $elems)
}

# vim: ft=perl6 expandtab sw=4