pub fn with_backend(backend: Backend) -> Self {
        assert!(State::BITS >= 2 * Word::BITS);
        assert_eq!(State::BITS % Word::BITS, 0);

        Self {
            bulk: backend,
            state: RangeCoderState::default(),
            situation: EncoderSituation::Normal,
        }
    }
/// Assumes that the `backend` is in a state where the encoder can start writing as if
/// it was an empty backend. If there's already some compressed data on `backend`, then
/// this method will just concatanate the new sequence of `Word`s to the existing
/// sequence of `Word`s without gluing them together. This is likely not what you want
/// since you won't be able to decode the data in one go (however, it is Ok to
/// concatenate arbitrary data to the output of a `RangeEncoder`; it won't invalidate
/// the existing data).
///
/// If you need an entropy coder that can be interrupted and serialized/deserialized
/// (i.e., an encoder that can encode some symbols, return the compressed bit string as
/// a sequence of `Words`, load the `Words` back in at a later point and then encode
/// some more symbols), then consider using an [`AnsCoder`].
///
/// TODO: rename to `with_write_backend` and then add the same method to `AnsCoder`
///
/// [`AnsCoder`]: super::stack::AnsCoder
Assumes that the `backend` is in a state where the encoder can start writing as if
it was an empty backend.

If you need an entropy coder that can be interrupted and serialized/deserialized
, then consider using an [`AnsCoder`].

rename to `with_write_backend` and then add the same method to `AnsCoder`


Assumes that the ` backend ` is in a state where the encoder can start writing as if it was an empty backend . If you need an entropy coder that can be interrupted and serialized / deserialized then consider using an [ ` AnsCoder ` ] . rename to ` with_write_backend ` and then add the same method to ` AnsCoder `
pub fn with_backend(backend: Backend) -> Self {
        assert!(State::BITS >= 2 * Word::BITS);
        assert_eq!(State::BITS % Word::BITS, 0);
        Self {
            bulk: backend,
            state: RangeCoderState::default(),
            situation: EncoderSituation::Normal,
        }
    }
pub fn with_backend ( backend : Backend ) -> Self { assert ! ( State BITS 2 Word BITS ) ; assert_eq ! ( State BITS Word BITS 0 ) ; Self { bulk : backend , state : RangeCoderState :: default ( ) , situation : EncoderSituation :: Normal , } }
Assumes that the `backend` is in a state where the encoder can start writing as if
it was an empty backend.
Assumes that the ` backend ` is in a state where the encoder can start writing as if it was an empty backend .
backend
Backend
backend
Backend