Well, you could use arrays of optional bytes, but are use sure it's clever?

Maybe it's much better to define an abstract module of type

    module type Mem = sig
      type t
      val get_byte : t -> ~offset:int -> char option  
    end

And invent some clever (maybe lazy) implementation using just Bigarray?

BAP also has something like this in

https://github.com/BinaryAnalysisPlatform/bap/blob/master/li...

You could ask about BAP in general on

https://discuss.ocaml.org/

especially

https://discuss.ocaml.org/u/ivg/summary

(one of the guys behind BAP, very clever and talented in explaining stuff)

You can always do something like:

  type optional_bytes = (Bytes.t * Bytes.t)

  let get i (data, mask) =
    match mask.[i] with
    | '\x00' -> None
    | _ -> Some data.[i]

If you need immutability and you're not changing often, you can use strings.

If you're using lists because you're doing all manner of comprehensions, you'd still be better iterating over the Bytes and rebuilding using a Buffer.

>I really don't want to start using complicated module features and functors, for the reasons I explained above.

And why is that? Because you really don't want to write ML without modules (and you are using them anyway).

Edit: Ah, I see, you have an auto-generated ocaml code, which is used along with the Isabelle. That makes sense (although your code generator is rather strange and there is still no need to use lists for memory representations since Isabelle reasoning about memory chunks shouldn't be that hard). Anyway I wouldn't claim that OCaml is that bad for low level programming basing on such a subset of a language.