In the past, I've used Python's struct module as an example when asked if there are any benefits of dynamic typing. It provides functions to convert between sequences of bytes and Python values, controlled by a compact "format string". Lua also supports very similar conversions via the string.pack & unpack functions.

For example, these few lines of Python are all it takes to interpret the header of a BMP image file and output the image's dimensions. Of course for this particular example it's easier to use an image library, but this code is much more flexible - it can be changed to support custom file types, and iteratively modified to investigate files of unknown type:

file_name = input('File name: ')
with open(file_name, 'rb') as f:
    signature, _, _, header_size, width, height = struct.unpack_from('<2sI4xIIii', f.read())
assert signature == b'BM' and header_size == 40
print(f'Dimensions: {width}x{abs(height)}')

Are there statically-typed languages that can offer similarly concise code for binary manipulation? I can see a couple of ways it could work:

• Require the format string to be a compile-time constant. The above call to unpack_from could then return Tuple<String, Int, Int, Int, Int, Int>

• Allow fully general format strings, but return List<Object> and require the programmer to cast the Objects to the correct type:

    assert (signature as String) == 'BM' and (header_size as Int) == 40
    print(f'Dimensions: {width as Int}x{abs(height as Int)}')

Is it possible for a statically-typed language to support a function like struct.unpack_from? The ones I'm familiar with require much more verbose code (e.g. defining a dataclass for the header layout). Or is there a reason that it's not possible?