# Variable size/Set

Demonstrate how to specify the minimum size of a variable or a data type.

Variable size/Set
You are encouraged to solve this task according to the task description, using any language you may know.

## 11l

In 11l, for base types, the size of a variable is determined by the type. There is some flexibility, as it is possible to choose the type according to the required size. For instance, for signed integers, we can choose among Int8, Int16, Int32 and Int64. The size of the variable of type “Int” is 32 or 64 bits according to the platform. The same exists for unsigned integers (Byte, UInt16, UInt32, UInt64) and for floating point numbers (Float32, Float64/Float).

## 360 Assembly

The 360 architecture data specifications are:

* Binary interger (H,F)
I2       DS     H          half word        2 bytes
I4       DS     F          full word        4 bytes
* Real (floating point) (E,D,L)
X4       DS     E          short            4 bytes
X8       DS     D          double           8 bytes
X16      DS     L          extended        16 bytes
* Packed decimal (P)
P3       DS     PL3                         2 bytes
P7       DS     PL7                         4 bytes
P15      DS     PL15                        8 bytes
* Zoned decimal (Z)
Z8       DS     ZL8                         8 bytes
Z16      DS     ZL16                       16 bytes
* Character (C)
C1       DS     C                           1 byte
C16      DS     CL16                       16 bytes
C256     DS     CL256                     256 bytes
* Bit value (B)
B1       DC     B'10101010'                 1 byte
X1       DC     X'AA'                       1 byte
A4       DC     A(176)                      4 bytes   but only 3 bytes used
*                                                     (24 bits => 16 MB of storage)

## 6502 Assembly

Syntax will vary depending on the assembler and whether your program will run in RAM or ROM. For programs that execute from RAM such as those that are loaded from a disk, you can use the same syntax that you would use to define constants. When defining bytes as variables or constants, you do not prefix them with a # sign. Only in actual CPU instructions do you need to use a # to prevent the assembler from treating the numeric value as a memory location.

Since these are variables, the value given to them (in this case, 0) is the initial value, and can be changed later at runtime. If you don't care what the initial value is, some assemblers allow you to use a "?" where the 0s are.

MyByte:
byte 0       ;most assemblers will also accept DB or DFB
MyWord:
word 0       ;most assemblers will also accept DW or DFW
MyDouble:
dd 0

For programs that are executed solely from ROM, such as video game console cartridges, you won't be able to use the above method. The assembler can often use an enum or rsset directive to sequentially assign labels to a series of consecutive memory locations in the system's RAM.

.rsset \$00        ;starting at \$0400, the following labels represent sequential memory locations of length ".rs n"
VBlankFlag     .rs 1   ;\$00
soft_PPUCTRL   .rs 1   ;\$01
soft_PPUSTATUS .rs 1   ;\$02
soft_SCROLL_X  .rs 1   ;\$03
soft_SCROLL_Y  .rs 1   ;\$04
temp_16        .rs 2   ;\$05,\$06
tempStack      .rs 1   ;\$07

Assemblers that don't have an enum or rsset directive can use the equ directive instead. This method lets you immediately see what each memory location actually is, but it makes it harder to insert a new one without having to redo all the numbering. Certain 6502 instructions rely on two memory addresses being consecutive.

VBlankFlag     equ \$00
soft_PPUCTRL   equ \$01
soft_PPUSTATUS equ \$02
soft_SCROLL_X  equ \$03
soft_SCROLL_Y  equ \$04
temp_16        equ \$05	;you have to keep track of spacing yourself in this method
tempStack      equ \$07

While setting a variable's size is easy, getting it isn't possible without knowing it in advance. The CPU does not (and cannot) know the intended size of a variable. There's no enforcement of types whatsoever on the 6502; anything is fair game.

## 68000 Assembly

Translation of: 6502 Assembly

Syntax will vary depending on the assembler and whether your program will run in RAM or ROM. For programs that execute from RAM such as those that are loaded from a disk, you can use the same syntax that you would use to define constants. When defining bytes as variables or constants, you do not prefix them with a # sign. Only in actual CPU instructions do you need to use a # to prevent the assembler from treating the numeric value as a memory location.

Since these are variables, the value given to them (in this case, 0) is the initial value, and can be changed later at runtime. If you don't care what the initial value is, some assemblers allow you to use a "?" where the 0s are.

MyByte:
DC.B 0
EVEN         ;you need this to prevent alignment problems if you define an odd number of bytes.
MyWord:
DC.W 0       ;this takes up 2 bytes even though only one 0 was written
MyLong:
DC.L 0       ;this takes up 4 bytes even though only one 0 was written

For programs that are executed solely from ROM, such as video game console cartridges, you won't be able to use the above method. The assembler can often use an enum or rsset directive to sequentially assign labels to a series of consecutive memory locations in the system's RAM. Assemblers that don't have an enum or rsset directive can use the equ directive instead. This method lets you immediately see what each memory location actually is, but it makes it harder to insert a new one without having to redo all the numbering. These variables are located in the heap and thus there is no need to use EVEN directives to align this data.

Cursor_X equ \$100000      ;byte - only comments can tell you the intended variable size.
Cursor_Y equ \$100001      ;byte
tempWord equ \$100002      ;word - also occupies \$100003
tempLong equ \$100004      ;long - also occupies \$100005,6,7

While setting a variable's size is easy, getting it isn't possible without knowing it in advance. The CPU does not (and cannot) know the intended size of a variable. There's no enforcement of types whatsoever on the 6502; anything is fair game.

## 8086 Assembly

Syntax will vary depending on the assembler you're using, but the following should apply to most assemblers.

.data             ;data segment

TestValue_00 byte 0       ;an 8-bit variable
TestValue_01 word 0       ;a 16-bit variable
TestValue_02 dword 0      ;a 32-bit variable

.code

start:

mov dh, byte ptr [ds:TestValue_00]     ;load the value stored at the address "TestValue_00"
mov ax, word ptr [ds:TestValue_01]     ;load the value stored at the address "TestValue_01"

For programs that are executed from ROM, such as those on video game cartridges, the above syntax can only be used to define constants. Defining variables will need to be done using equ directives, and you'll need to read the system's documentation to know where the heap is located. For example, the Bandai Wonderswan has its heap located starting at memory address 100h.

There is some enforcement of variable sizes, but it's not as strict as most other languages. The two commands above would not have worked had the wrong register sizes been used. However, using the wrong labels is perfectly legal in the eyes of most assemblers.

mov al, byte ptr [ds:TestValue_02]
;even though this was listed as a dword in the data segment, the assembler lets us do this!

In fact, data sizes don't matter to the CPU all that much, as the following definitions are all equivalent:

foo byte 0,0,0,0
bar word 0,0
baz dword 0

The data types are more for the programmer's convenience, so that it's clear how the data should be interpreted.

Data can be organized in a table for better readability; however it has no effect on how the data is structured apart from visually. (The data will be organized in a linear fashion regardless, so it makes no difference to the CPU). The following two structures are the same:

Array1 byte 00,01,02,03

Array2 byte 00,01
byte 02,03

If you have a variable of a pre-determined size that isn't 1, 2, or 4 bytes you can use the following to define it:

BigNumber byte 256 dup (0)  ;reserve 256 bytes, each equals zero

While it's easy to set a variable's size, getting it is impossible without knowing it in advance. Variables are nothing more than just a section of RAM; the CPU does not (and cannot) know how many bytes your variable is supposed to be.

type Response is (Yes, No); -- Definition of an enumeration type with two values
for Response'Size use 1; -- Setting the size of Response to 1 bit, rather than the default single byte size

## ARM Assembly

Syntax will vary depending on your assembler. VASM uses .byte for 8-bit data, .word for 16-bit data, and .long for 32-bit data, but this is not the norm for most assemblers, as a "processor's word size" is usually the same as its "bitness." I'll use the VASM standard anyway, just because. When defining data smaller than 32-bits, there needs to be sufficient padding to align anything after it to a 4-byte boundary. (Assemblers often take care of this for you, but you can use a directive like .align 4 or .balign 4to make it happen.

.byte 0xFF
.align 4
.word 0xFFFF
.align 4
.long 0xFFFFFFFF

Keep in mind that although you may have intended the data to be of a particular size, the CPU does not (and cannot) enforce that you use the proper length version of LDR/STR to access it. It's perfectly legal for the programmer to do the following:

main:
LDRB r0,[r1]     ;loads 0x000000EF into r0 (assuming the CPU is operating as little-endian, otherwise it will load 0x000000DE)
BX LR
TestData:

The reverse is also true; you can point a register to the label of a .byte data directive and load it as a long, which will give you the byte along with the padding that it would receive to keep everything aligned. Generally speaking, you don't want to do this, as it can lead to problems where a register doesn't contain what the code assumes it does. However, being able to ignore typing at will can be advantageous, such as when trying to copy large blocks of consecutive memory, where you can achieve more throughput by copying 32 bits per instruction instead of only 8 or 16.

## AutoHotkey

The documentation explains how the built-in function VarSetCapacity() may be used to do so.

## BASIC

Numerical values and arrays generally are a fixed size. Strings are dynamically resized according to the data that they hold.

Variable sizes are in chunks relating to the type of data that they contain. There may also be additional bytes of storage in the variable table that do not show in the dimensions. Typically, strings are allocated in single characters (bytes), so C\$(12) in the following example is stored as 12 bytes + additional bytes used for the header in the variable table. In some implementations of basic (such as those that support the storage of variable length strings in arrays), additional terminator characters (such as a trailing Ascii NUL) may also be included. In traditional basic, integers are typically 2 bytes each, so A%(10) contains 10 lots of 2 bytes (20 bytes in total) + additional bytes used for header data in the variable table. Floating point values are typically 8 bytes each, so B(10) holds 10 lots of 8 bytes (80 bytes in total) + additional bytes for header in the variable table:

10 DIM A%(10): REM the array size is 10 integers
20 DIM B(10): REM the array will hold 10 floating point values
30 DIM C\$(12): REM a character array of 12 bytes

### Applesoft BASIC

The first time a (non-array) variable is used a minimum of 7 bytes of memory are used. Seven bytes is the minimum size for 3 of the data types: floating point (or real), integer, and string. Two bytes are used to store the two character variable name and the data type. The five remaining bytes are used to store the data. Floating point values are 40-bit Microsoft Binary Format (MBF) which are 5 bytes in size: 1 byte signed exponent, and a 4 byte mantissa / 32-bit signed signficand. Integers are 16 bit signed integers: 2 bytes in size with the zeroes in the remaining 3 bytes. Strings are 3 bytes in size: 1 byte for the length of the string, a 2 byte (16 bit pointer) to the string, and zeroes in the remaining 2 bytes.

Defined functions use 14 bytes. 6 bytes are used to store a pointer to the definition: the 2 character function name and the function data type, a 2 byte pointer to the function within the program, and a 2 byte pointer to the local variable storage. An additional 3 bytes are used to store a copy of the first character of the function, and a two character local variable name. 5 bytes are used to store the local floating point variable.

Arrays use a minimum of 7 bytes plus the space to store an array of the data type. Two bytes are used to store the two character variable name and the data type. A 16-bit offset to the next variable: 2 bytes. One byte stores the number of dimensions, and two bytes minimum for each size of a dimension. The space required in an array for each data type is 5 bytes for each floating point, 2 bytes for each integer, and 3 bytes for each string. No space is wasted in the array. There are no arrays of defined functions.

Using one character variable names, and reusing variables is one way to save on space. The FRE(0) function can be used to houseclean (garbage collect) unused string space. If arrays are not declared with DIM they default to 11 elements in size. PEEK and POKE can be used to operate on byte and bit sized data.

0  CLEAR : PRINT "DATA TYPES":F = 0:F =  FRE (0)
1  PRINT "FLOATING POINT:";:G = 0: GOSUB 9
2  PRINT "INTEGER:";:I0% = 0: GOSUB 9
3  PRINT "STRING:";:Z9\$ = "": GOSUB 9
4  PRINT "DEFINED-FUNCTION:";: DEF  FN DO(IT) = 1 +  LEN ( MID\$ (Z9\$,1)) + IT: GOSUB 9: PRINT
5  PRINT "ARRAYS OF SIZE 1"
6  PRINT "FLOATING POINT:";: DIM F(0): GOSUB 9: PRINT "INTEGER:";: DIM I%(0): GOSUB 9: PRINT "STRING:";: DIM S\$(0): GOSUB 9: PRINT
7  PRINT "ARRAYS OF SIZE 2"
8  PRINT "FLOATING POINT:";: DIM G(1): GOSUB 9: PRINT "INTEGER:";: DIM J%(1): GOSUB 9: PRINT "STRING:";: DIM T\$(1): GOSUB 9: END
9  PRINT F -  FRE (0)" ";:F =  FRE (0): RETURN
DATA TYPES
FLOATING POINT:7 INTEGER:7 STRING:7 DEFINED-FUNCTION:14
ARRAYS OF SIZE 1
FLOATING POINT:12 INTEGER:9 STRING:10
ARRAYS OF SIZE 2
FLOATING POINT:17 INTEGER:11 STRING:13

### BBC BASIC

The only way to 'set' the size of a scalar numeric variable is to declare it with the appropriate type suffix:

var& = 1 : REM Variable occupies 8 bits
var% = 1 : REM Variable occupies 32 bits
var  = 1 : REM Variable occupies 40 bits
var# = 1 : REM Variable occupies 64 bits

If the task is talking about setting the size of a variable at run time that is only possible with strings, arrays and structures.

### IS-BASIC

100 DIM A(10)
110 NUMERIC ARRAY(1 TO 100)
120 NUMERIC MATRIX(1 TO 10,1 TO 10)
130 NUMERIC NR,X,Y
140 STRING NAME\$(1 TO 100)*24
150 STRING LINE\$*254
160 STRING CHAR\$*1

## C

Works with: C99
#include <stdint.h>

int_least32_t foo;

Here foo is a signed integer with at least 32 bits. stdint.h also defines minimum-width types for at least 8, 16, 32, and 64 bits, as well as unsigned integer types.

union u {
int i;
long l;
double d;
/* ... */
};

Here the use of union results in a datatype which is at least as large as the largest type. Unions are sometimes exploited to just meet a minimum size:

union must_be_at_least_512_bytes {
int interesting_datum;
};

Here, the application will never access padding nor store anything; the padding is there to make the type large enough to meet some requirement. For instance, so that some third party API function which fills in the object, doesn't write past the end of the memory, when the program is only interested in interesting_datum.

## C++

Works with: C++11
or
Works with: Boost
#include <boost/cstdint.hpp>

boost::int_least32_t foo;

Alternatively,

C++'s primitive types are fixed in size. If a programmer wants a numeric type to be able to accommodate

a certain size of number, up to a maximum of eight bytes, then they declare a variable of the appropriate type.

#include <iostream>
#include <climits>
#include <cfloat>

int main() {
std::cout << "The ranges of C++'s primitive data types are:" << std::endl << std::endl;

std::cout << "a  char ranges from          : " << CHAR_MIN << " to " << CHAR_MAX << std::endl;
std::cout << "a  short char ranges from    : " << SCHAR_MIN << " to " << SCHAR_MAX << std::endl;
std::cout << "an unsigned char ranges from : " << 0 << " to " << UCHAR_MAX << std::endl << std::endl;

std::cout << "a  short int ranges from          : " << SHRT_MIN << " to " << SHRT_MAX << std::endl;
std::cout << "an unsigned short int ranges from : " << 0 << " to " << USHRT_MAX << std::endl << std::endl;

std::cout << "an int ranges from          : " << INT_MIN << " to " << INT_MAX << std::endl;
std::cout << "an unsigned int ranges from : " << 0 << " to " << UINT_MAX << std::endl << std::endl;

std::cout << "a  long int ranges from               : " << LONG_MIN << " to " << LONG_MAX << std::endl;
std::cout << "an unsigned long int ranges from      : " << 0 << " to " << ULONG_MAX << std::endl;
std::cout << "a  long long int ranges from          : " << LLONG_MIN << " to " << LLONG_MAX << std::endl;
std::cout << "an unsigned long long int ranges from : " << 0 << " to " << ULLONG_MAX <<std::endl << std::endl;

std::cout << "a  float ranges from : " << -FLT_MAX << " to " << +FLT_MAX << std::endl << std::endl;

std::cout << "a  double ranges from : " << -DBL_MAX << " to " << +DBL_MAX << std::endl;
}
Output:
The ranges of C++'s primitive data types are:

a  char ranges from          : -128 to 127
a  short char ranges from    : -128 to 127
an unsigned char ranges from : 0 to 255

a  short int ranges from          : -32768 to 32767
an unsigned short int ranges from : 0 to 65535

an int ranges from          : -2147483648 to 2147483647
an unsigned int ranges from : 0 to 4294967295

a  long int ranges from               : -2147483648 to 2147483647
an unsigned long int ranges from      : 0 to 4294967295
a  long long int ranges from          : -9223372036854775808 to 9223372036854775807
an unsigned long long int ranges from : 0 to 18446744073709551615

a  float ranges from : -3.40282e+38 to 3.40282e+38

a  double ranges from : -1.79769e+308 to 1.79769e+308

## D

In D, any variables of static array of zero length has a size of zero. But such data is useless, as no base type element can be accessed.

typedef long[0] zeroLength ;
writefln(zeroLength.sizeof) ; // print 0

NOTE: a dynamic array variable's size is always 8 bytes, 4(32-bit) for length and 4 for a reference pointer of the actual storage somewhere in runtime memory.
The proper candidates of minimum size variable are empty structure, 1-byte size data type variable (include byte, ubyte, char and bool), and void, they all occupy 1 byte.

byte b ;
ubyte ub ;
char c ;
bool t ;

bool is logically 1-bit size, but it actually occupy 1 byte.
void can't be declared alone, but void.sizeof gives 1.
An empty structure is logically zero size, but still occupy 1 byte.

struct Empty { }
writefln(Empty.sizeof) ; // print 1

## Delphi

Works with: Delphi version 6.0

{In Delphi you can have variables of a range of sizes}
var B: Byte;		{8-bit, unsigned}
var C: char;		{ASCII character}
var SI: shortint;	{8-bit, signed}
var SM: Smallint;	{16-bit signed}
var LI: Longint;	{32-bit signed}
var W: word;		{16-bit unsigned}
var LW: Longword;	{32-bit unsigned}
var II: Int64;		{64-bit signed}
var SR: Real48;		{6-byte real}
var SN: single;		{4-byte real}
var DB: double;		{8-byte real}
var EX: Extended;	{10-byte real}
var CM: Comp;		{8-byte fixed point}
var CR: Currency;	{8-byte fixed point}

{You can also custom define the size range of variable}

type TNumRange = -128..127;
var NM: TNumRange;

type TUpperCase = 'A'..'Z';
var UP: TUpperCase;
Output:

## Erlang

Variables and data type sizes are outside of the programmers control, with one exception: binary data. Here you can say exactly how many bits you want. Default is 8 bits so below the 0 is 8 bits and the 1 is 3 bits.

15> <<1:11>>.
<<0,1:3>>

## ERRE

Numerical values and arrays generally are a fixed size. Strings are dynamically resized according to the data that they hold.

Variable sizes are in chunks relating to the type of data that they contain. There may also be additional bytes of storage in the variable table that do not show in the dimensions. Typically, in ERRE strings are allocated in single characters (bytes), so C\$[12] in the following example is stored as 12 bytes + additional bytes used for the header in the variable table. Integers are typically 2 bytes each, so A%[10] contains 10 numbers of 2 bytes (20 bytes in total) + additional bytes used for header data in the variable table. Floating point values are typically 4 bytes each, so B[10] holds 10 numbers of 4 bytes (40 bytes in total) + additional bytes for header in the variable table:

DIM A%[10] ! the array size is 10 integers

DIM B[10]  ! the array will hold 10 floating point values

DIM C\$[12] ! a character array of 12 bytes

There is also "double" floating point values (8 bytes). Variables of this type use the suffix #.

## Forth

create cvar 0 c, \ char size variable

variable var \ cell size variable

2variable 2var \ 2 cells size variable

fvariable fvar \ float size variable

## Fortran

Since Fortran 90 each intrinsic data type (INTEGER, REAL, COMPLEX, LOGICAL and CHARACTER) has a KIND parameter associated with it that can be used to set the required level of precision. The actual values which these KIND parameters can take are not specified in the standard and are implementation-dependent. In order to select an appropriate KIND value that is portable over different platforms we can use the intrinsic functions SELECTED_REAL_KIND and SELECTED_INT_KIND.

The syntax of these functions are as follows:-

selected_real_kind(P, R), where P is the required number of significant decimal digits and R is the required decimal exponent range. At least one argument must be present. The return value is the kind type parameter for real values with the given precision and/or range. A value of -1 is returned if P is out of range, a value of -2 is returned if R is out of range and a value of -3 is returned if both P and R are out of range.

selected_int_kind(R), where R is the required decimal exponent range. The return value is the kind type parameter for integer values n such that -10^R < n < 10^R. A value of -1 is returned if R is out of range.

program setsize
implicit none

integer, parameter :: p1 = 6
integer, parameter :: p2 = 12
integer, parameter :: r1 = 30
integer, parameter :: r2 = 1000
integer, parameter :: r3 = 2
integer, parameter :: r4 = 4
integer, parameter :: r5 = 8
integer, parameter :: r6 = 16
integer, parameter :: rprec1 = selected_real_kind(p1, r1)
integer, parameter :: rprec2 = selected_real_kind(p2, r1)
integer, parameter :: rprec3 = selected_real_kind(p2, r2)
integer, parameter :: iprec1 = selected_int_kind(r3)
integer, parameter :: iprec2 = selected_int_kind(r4)
integer, parameter :: iprec3 = selected_int_kind(r5)
integer, parameter :: iprec4 = selected_int_kind(r6)

real(rprec1)    :: n1
real(rprec2)    :: n2
real(rprec3)    :: n3
integer(iprec1) :: n4
integer(iprec2) :: n5
integer(iprec3) :: n6
integer(iprec4) :: n7
character(30) :: form

form = "(a7, i11, i10, i6, i9, i8)"
write(*, "(a)") "KIND NAME   KIND NUMBER   PRECISION        RANGE "
write(*, "(a)") "                          min   set     min     set"
write(*, "(a)") "______________________________________________________"
write(*, form) "rprec1", kind(n1), p1, precision(n1), r1, range(n1)
write(*, form) "rprec2", kind(n2), p2, precision(n2), r1, range(n2)
write(*, form) "rprec3", kind(n3), p2, precision(n3), r2, range(n3)
write(*,*)
form = "(a7, i11, i25, i8)"
write(*, form) "iprec1", kind(n4), r3, range(n4)
write(*, form) "iprec2", kind(n5), r4, range(n5)
write(*, form) "iprec3", kind(n6), r5, range(n6)
write(*, form) "iprec4", kind(n7), r6, range(n7)

end program

Output

KIND NAME   KIND NUMBER   PRECISION        RANGE
min   set     min     set
______________________________________________________
rprec1          1         6     6       30      37
rprec2          2        12    15       30     307
rprec3          3        12    18     1000    4931

iprec1          1                        2       2
iprec2          2                        4       4
iprec3          3                        8       9
iprec4          4                       16      18

## Free Pascal

Only enumeration type definitions can have a minimum size:
type
{\$packEnum 4}
enum = (x, y, z);

Only a {\$packEnum} of 1, 2, or 4 Bytes can be specified.

## FreeBASIC

FreeBASIC variables have a fixed size (depending on their type) with four exceptions:

1. The size of the Integer and UInteger types depends on the underlying platform - 4 bytes for 32-bit and 8 bytes for 64-bit platforms.

2. The size of individual characters of the WString type depends on the operating system - 2 bytes for Windows and 4 bytes for Linux.

3. The length of variable length strings is determined at run time and can be changed.

4. The bounds of dynamic arrays are determined at run time and can be changed (using ReDim). However, the number of dimensions (which can be up to 8) must be specified at compile time and cannot be changed.

Variables of types 3. and 4. don't hold their data directly but instead contain a fixed length descriptor - 24 bytes for a string and between 64 and 232 bytes for an array depending on the number of dimensions. The descriptor contains, amongst other things, a pointer to where the actual data is stored.

## Go

For task interpretation this follows the spirit of the Ada example included by the task author. In it, an enumeration type is defined from enumeration values, then a storage size--smaller than the default--is specified for the type. A similar situation exists within Go. Defining types from values is called duck-typing, and the situation where a type smaller than the default can be specified exists when a variable is duck-typed from a numeric literal.

package main

import (
"fmt"
"unsafe"
)

func main() {
i := 5   // default type is int
r := '5' // default type is rune (which is int32)
f := 5.  // default type is float64
c := 5i  // default type is complex128
fmt.Println("i:", unsafe.Sizeof(i), "bytes")
fmt.Println("r:", unsafe.Sizeof(r), "bytes")
fmt.Println("f:", unsafe.Sizeof(f), "bytes")
fmt.Println("c:", unsafe.Sizeof(c), "bytes")
iMin := int8(5)
rMin := byte('5')
fMin := float32(5.)
cMin := complex64(5i)
fmt.Println("iMin:", unsafe.Sizeof(iMin), "bytes")
fmt.Println("rMin:", unsafe.Sizeof(rMin), "bytes")
fmt.Println("fMin:", unsafe.Sizeof(fMin), "bytes")
fmt.Println("cMin:", unsafe.Sizeof(cMin), "bytes")
}

Output:

i: 4 bytes
r: 4 bytes
f: 8 bytes
c: 16 bytes
iMin: 1 bytes
rMin: 1 bytes
fMin: 4 bytes
cMin: 8 bytes

import Data.Int
import Foreign.Storable

task name value = putStrLn \$ name ++ ": " ++ show (sizeOf value) ++ " byte(s)"

main = do
let i8  = 0::Int8
let i16 = 0::Int16
let i32 = 0::Int32
let i64 = 0::Int64
let int = 0::Int
Output:
Int8: 1 byte(s)
Int16: 2 byte(s)
Int32: 4 byte(s)
Int64: 8 byte(s)
Int: 8 byte(s)

## Icon and Unicon

Icon and Unicon values are self-descriptive types subject to automatic garbage collection. As a result the opportunities for setting the sizes of the variables are limited.

• strings are always variable in length with some fixed overhead
• csets are a fixed size
• tables and sets are variable in size and start empty
• integers and reals are fixed sizes
• records are a fized size
• co-expressions vary in size based on the environment when they are created
• file, window, and procedure references are all fixed in size
• lists can be specified with a minimum size (see below):
L := list(10) # 10 element list

## J

v=: ''

Here, v is specified to have a minimum size. In this case, the minimum size of the content is zero, though the size of the representation is somewhat larger.

## Java

Java's primitive types are fixed in size. If a programmer wants a numeric type to be able to accommodate

a certain size of number, up to a maximum of eight bytes, then they declare a variable of the appropriate type.

If more than eight bytes of precision is required they can use either BigInteger or BigDecimal.

public final class VariableSizeSet {

public static void main(String[] args) {
System.out.println("The ranges of Java's primitive data types are:");
System.out.println();
System.out.println("A  Byte   variable has a range of " + Byte.MIN_VALUE + " to " + Byte.MAX_VALUE);
System.out.println("A  Short  variable has a range of " + Short.MIN_VALUE + " to " + Short.MAX_VALUE);
System.out.println("An Int    variable has a range of " + Integer.MIN_VALUE + " to " + Integer.MAX_VALUE);
System.out.println("A  Long   variable has a range of " + Long.MIN_VALUE +" to " + Long.MAX_VALUE);
System.out.println("A  Float  variable has a range of " + Float.MIN_VALUE + " to " + Float.MAX_VALUE);
System.out.println("A  Double variable has a range of " + Double.MIN_VALUE + " to " + Double.MAX_VALUE);
}

}
Output:
The ranges of Java's primitive data types are:

A  Byte   variable has a range of -128 to 127
A  Short  variable has a range of -32768 to 32767
An Int    variable has a range of -2147483648 to 2147483647
A  Long   variable has a range of -9223372036854775808 to 9223372036854775807
A  Float  variable has a range of 1.4E-45 to 3.4028235E38
A  Double variable has a range of 4.9E-324 to 1.7976931348623157E308

## Julia

types = [Bool, Char, Int8, UInt8, Int16, UInt16, Int32, UInt32, Int64, UInt64]

for t in types
println("For type ", lpad(t,6), " size is \$(sizeof(t)) 8-bit bytes, or ",
end

primitive type MyInt24 24 end

println("\nFor the 24-bit user defined type MyInt24, size is ", sizeof(MyInt24), " bytes.")
Output:

For type Bool size is 1 8-bit bytes, or 8 bits. For type Char size is 4 8-bit bytes, or 32 bits. For type Int8 size is 1 8-bit bytes, or 8 bits. For type UInt8 size is 1 8-bit bytes, or 8 bits. For type Int16 size is 2 8-bit bytes, or 16 bits. For type UInt16 size is 2 8-bit bytes, or 16 bits. For type Int32 size is 4 8-bit bytes, or 32 bits. For type UInt32 size is 4 8-bit bytes, or 32 bits. For type Int64 size is 8 8-bit bytes, or 64 bits. For type UInt64 size is 8 8-bit bytes, or 64 bits.

For the 24-bit user defined type MyInt24, size is 3 bytes.

## Kotlin

In Kotlin (or any other language targetting the JVM) the size of variables is outside the programmer's control. The primitive types are either fixed in size or (in the case of Boolean) implementation dependent and the size of objects will depend not only on the aggregate size of their fields but also on any overhead or alignment padding needed.

If one wants a numeric type to be able to accomodate a certain size of number, then one can of course declare a variable of the appropriate type (up to 8 bytes) or use the BigInteger or BigDecimal types where more than 8 byte precision is required.

The following program shows the range of numbers which the primitive numeric types can accomodate to enable one to choose the appropriate type:

// version 1.0.6

fun main(args: Array<String>) {
/* ranges for variables of the primitive numeric types */
println("A  Byte   variable has a range of :  \${Byte.MIN_VALUE} to \${Byte.MAX_VALUE}")
println("A  Short  variable has a range of :  \${Short.MIN_VALUE} to \${Short.MAX_VALUE}")
println("An Int    variable has a range of :  \${Int.MIN_VALUE} to \${Int.MAX_VALUE}")
println("A  Long   variable has a range of :  \${Long.MIN_VALUE} to \${Long.MAX_VALUE}")
println("A  Float  variable has a range of :  \${Float.MIN_VALUE} to \${Float.MAX_VALUE}")
println("A  Double variable has a range of :  \${Double.MIN_VALUE} to \${Double.MAX_VALUE}")
}
Output:
A  Byte   variable has a range of :  -128 to 127
A  Short  variable has a range of :  -32768 to 32767
An Int    variable has a range of :  -2147483648 to 2147483647
A  Long   variable has a range of :  -9223372036854775808 to 9223372036854775807
A  Float  variable has a range of :  1.4E-45 to 3.4028235E38
A  Double variable has a range of :  4.9E-324 to 1.7976931348623157E308

## Mathematica/Wolfram Language

Mathematica stores variables in symbols : e.g. variable 'A' containing integer 0 requires 24 bytes under Windows.

## Modula-3

TYPE UByte = BITS 8 FOR [0..255];

Note that this only works for records, arrays, and objects. Also note that the size in bits must be large enough to hold the entire range (in this case, 8 bits is the correct amount for the range 0 to 255) or the compiler will error.

## Nim

1) In Nim, for base types, the size of a variable is determined by the type. There is some flexibility, as it is possible to choose the type according to the required size. For instance, for signed integers, we can choose among int8, int16, int32 and int64. The size of the variable of type “int” is 32 or 64 bits according to the platform. The same exists for unsigned integers (uint8/byte, uint16, uint32, uint64) and for floating point numbers (float32, float64/float).

2) For structured types, the size is generally fixed, except for sequences and strings. Sequences and strings are managed via a descriptor whose size is fixed (eight bytes for now). The actual data are allocated on the heap. The true size of a sequence or a string is named its capacity. The capacity is managed at runtime but the user may indicate the initial size using the procedures initSeqOfCap or initStringOfCap. For instance, var s = initStringOfCap(20) allocates an empty string (whose length is 0) but with the capacity to accept 20 bytes without any reallocation. If the length exceeds the capacity, the reallocation algorithm increases the capacity to a new size.

3) Nim offers also the possibility to set the size of fields into an object. This is done with the pragma bitsize. For instance, we can specify:

type
MyBitfield = object
flag {.bitsize:1.}: cuint

When Nim uses C as intermediate language, the pragma “bitsize” is translated in C bit fields. The previous example will produce something like that:

struct mybitfield {
unsigned int flag:1;
};

## ooRexx

ooRexx variables are all references to object instances, so the variables themselves have no settable or gettable size.

## PARI/GP

default(precision, 1000)

Alternately, in the gp interpreter,

\p 1000

## Pascal

Pascal discourages the programmer to think about specific internal memory structures. Therefore, there is no way to specify the size of any data type.

The GPC (GNU Pascal compiler), however, allows for integer types the specification of a minimum precision:

type
correctInteger = integer attribute (size = 42);

## Perl

I suppose you could use vec() or similar to twiddle a single bit. The thing is, as soon as you store this in a variable, the SV (the underlying C implementation of the most simple data type) already takes a couple dozen of bytes.

In Perl, memory is readily and happily traded for expressiveness and ease of use.

## Phix

Phix native numeric types are fixed size:
on 32 bit integers are 4 bytes and floats 8 bytes,
on 64 bit integers are 8 bytes and floats 10 bytes.

Note that native integers are always signed and one bit shy of a full machine word, ie
-1,073,741,824 to +1,073,741,823 (-#40000000 to #3FFFFFFF) on 32 bit, and
-4,611,686,018,427,387,904 to +4,611,686,018,427,387,903 (-#4000000000000000 to #3FFFFFFFFFFFFFFF) on 64 bit.

Sequences are 4 or 8 bytes per element, and can grow or shrink at will.
Strings are always one byte per character, ie ansi or utf-8, utf-16 and utf-32 are held as sequences.

When using mprf.e (aka gmp), variables can have any precision required, up to available memory.
mpz (integer) variables automatically grow as needed but can optionally be initialised with a minimum bitcount to avoid later reallocations.
mpfr (floating point) variables require the precision to be explicitly specified in binary bits, for example if you want PI to 120 decimal places:

Library: Phix/mpfr
with javascript_semantics
requires("1.0.0")
include mpfr.e
mpfr pi = mpfr_init(0,-121) -- 120 dp, +1 for the "3."
mpfr_const_pi(pi)
printf(1,"PI with 120 decimals: %s\n\n",mpfr_get_fixed(pi,120))

## PicoLisp

In PicoLisp, all variables have the same size (a single cell). But it is possible to create a data structure of a given minimal size with the 'need' function.

## PL/I

declare i fixed binary (7),      /* occupies  1 byte  */
j fixed binary (15),     /* occupies  2 bytes */
k fixed binary (31),     /* occupies  4 bytes */
l fixed binary (63);     /* occupies  8 bytes */

declare d fixed decimal (1),     /* occupies  1 byte  */
e fixed decimal (3),     /* occupies  2 bytes */
/* an so on ...      */
f fixed decimal (15);    /* occupies  8 bytes */

declare b(16) bit (1) unaligned; /* occupies  2 bytes */
declare c(16) bit (1) aligned;   /* occupies 16 bytes */

declare x float decimal (6),     /* occupies  4 bytes */
y float decimal (16),    /* occupies  8 bytes */
z float decimal (33);    /* occupies 16 bytes */

## PureBasic

EnableExplicit

Structure AllTypes
b.b
a.a
w.w
u.u
c.c    ; character type : 1 byte on x86, 2 bytes on x64
l.l
i.i    ; integer type : 4 bytes on x86, 8 bytes on x64
q.q
f.f
d.d
s.s    ; pointer to string on heap : pointer size same as integer
z.s{2} ; fixed length string of 2 characters, stored inline
EndStructure

If OpenConsole()
Define at.AllTypes
PrintN("Size of types in bytes (x64)")
PrintN("")
PrintN("byte      = " + SizeOf(at\b))
PrintN("ascii     = " + SizeOf(at\a))
PrintN("word      = " + SizeOf(at\w))
PrintN("unicode   = " + SizeOf(at\u))
PrintN("character = " + SizeOf(at\c))
PrintN("long      = " + SizeOf(at\l))
PrintN("integer   = " + SizeOf(at\i))
PrintN("quod      = " + SizeOf(at\q))
PrintN("float     = " + SizeOf(at\f))
PrintN("double    = " + SizeOf(at\d))
PrintN("string    = " + SizeOf(at\s))
PrintN("string{2} = " + SizeOf(at\z))
PrintN("---------------")
PrintN("AllTypes  = " + SizeOf(at))
PrintN("")
PrintN("Press any key to close the console")
Repeat: Delay(10) : Until Inkey() <> ""
CloseConsole()
EndIf
Output:
Size of types in bytes (x64)

byte      = 1
ascii     = 1
word      = 2
unicode   = 2
character = 2
long      = 4
integer   = 8
quod      = 8
float     = 4
double    = 8
string    = 8
string{2} = 4
---------------
AllTypes  = 52

## Python

For compatibility with the calling conventions of external C functions, the ctypes module has functions that map data types and sizes between Python and C:

ctypes type C type Python type
c_char char 1-character string
c_wchar wchar_t 1-character unicode string
c_byte char int/long
c_ubyte unsigned char int/long
c_short short int/long
c_ushort unsigned short int/long
c_int int int/long
c_uint unsigned int int/long
c_long long int/long
c_ulong unsigned long int/long
c_longlong __int64 or long long int/long
c_ulonglong unsigned __int64 or unsigned long long int/long
c_float float float
c_double double float
c_longdouble long double float
c_char_p char * (NUL terminated) string or None
c_wchar_p wchar_t * (NUL terminated) unicode or None
c_void_p void * int/long or None

## Racket

Like many other highlevel languages, Racket doesn't have direct control on object sizes. More than that, objects are almost always references, so holding a vector or a list still starts from some object with pointers to the rest. It is possible, however, to create random ffi structs with some given length, by using something like (_array _byte N) and it's possible to add that to some other ffi type by wrapping it with such an array in a struct. But to create and manage chunks of memory, it's much better to just use malloc (which is also available via the ffi).

## Raku

(formerly Perl 6) In Raku, normal user-facing types (Int, Rat, Str, Array, Hash) are all auto-sizing, so there is no need to specify a minimum size for them. (Floating point, known as "Num", defaults to a machine double.) For storage declarations, native storage types (starting with a lowercase letter) may also be specified, in which case the required bit size is part of the type name: int16, uint8 (aka "byte"), num32 (a "float"), complex64 (made of two num64's), etc. More generally, such types are created through an API supporting representational polymorphism, in this case, the NativeHOW representation, when provides methods to set the size of a type; the actual allocation calculation happens when such generic types are composed into a class instance representing the semantics of the effective type to the compiler and run-time system. But mostly this is not something users will concern themselves with directly.

By spec, arrays may be declared with dimensions of fixed size, but as of this writing, such arrays not yet implemented. An array of fixed size that returns elements of a native type will be stored compactly, and uses exactly the memory you'd think it should, (modulo alignment constraints between elements and any slop at the end due to your memory allocator).

## REXX

In REXX, there are no minimums for variables holding character literals, so you just simply assign (set)
character strings (or numbers) to REXX variables.

Note that REXX stores all the values of variables as characters, and that includes numbers (all kinds),
booleans (logical), and labels (including subroutine/function names).

However, to insure that REXX can store numbers with a minimum size (amount of decimal digits),
the     NUMERIC DIGITS nnn     REXX instruction can be used.   This will ensure that the decimal
number can be stored without resorting to exponential notation   (although exponential notation
can be forced via the   format   BIF  (Built In Function).

The default for   numeric digits   is   9   (decimal) digits.

There's effectively no limit for the precision [or length] for REXX numbers (except for memory),
but eight million is probably the practical limit.

/*REXX program demonstrates on setting a variable (using a "minimum var size".*/
numeric digits 100                     /*default: 9 (decimal digs) for numbers*/

/*──         1         2         3         4         5         6         7──*/
/*──1234567890123456789012345678901234567890123456789012345678901234567890──*/

z = 12345678901111111112222222222333333333344444444445555555555.66
n =-12345678901111111112222222222333333333344444444445555555555.66

/* [↑]  these #'s are stored as coded. */
/*stick a fork in it,  we're all done. */

## Scala

/* Ranges for variables of the primitive numeric types */
println(s"A  Byte   variable has a range of :  \${Byte.MinValue} to \${Byte.MaxValue}")
println(s"A  Short  variable has a range of :  \${Short.MinValue} to \${Short.MaxValue}")
println(s"An Int    variable has a range of :  \${Int.MinValue} to \${Int.MaxValue}")
println(s"A  Long   variable has a range of :  \${Long.MinValue} to \${Long.MaxValue}")
println(s"A  Float  variable has a range of :  \${Float.MinValue} to \${Float.MaxValue}")
println(s"A  Double variable has a range of :  \${Double.MinValue} to \${Double.MaxValue}")

See it running in your browser by Scastie (JVM).

## Tcl

In Tcl, most values are (Unicode) strings. Their size is measured in characters, and the minimum size of a string is of course 0. However, one can arrange, via write traces, that the value of a variable is reformatted to bigger size. Examples, from an interactive tclsh session:

% proc format_trace {fmt _var el op} {upvar 1 \$_var v; set v [format \$fmt \$v]}

% trace var foo w {format_trace %10s}
% puts "/[set foo bar]/"
/       bar/

% trace var grill w {format_trace %-10s}
% puts "/[set grill bar]/"
/bar       /
..or limit its size to a certain length:
% proc range_trace {n _var el op} {upvar 1 \$_var v; set v [string range \$v 0 [incr n -1]]}

% trace var baz w {range_trace 2}
% set baz Frankfurt
Fr

## TXR

This task has many possible interpretations in many contexts.

For instance, there is a buffer type. When we create a buffer, we specify its length. Optionally, we can also specify how much storage is actually allocated. This will prevent re-allocations if the length is increased within that limit.

Here, the buffer holds eight zero bytes, but 4096 bytes is allocated to it:

(make-buf 8 0 4096)

Another situation, in the context of FFI, is that some structure needs to achieve some size, but we don't care about all of its members. We can add anonymous padding to ensure that it meets the minimum size. For instance, suppose we want to call uname, and we only care about retrieving the sysname:

1> (with-dyn-lib nil
(deffi uname "uname" int ((ptr-out (struct utsname
(sysname (zarray 65 char))
(nil (array 512 uint)))))))
** warning: (expr-1:2) defun: redefining uname, which is a built-in defun
#:lib-0172
2> (defvar u (new utsname))
u
3> (uname u)
0
4> u
#S(utsname sysname "Linux" nodename nil release nil version nil machine nil
domainname nil)

We have specified a FFI definition for utsname which lays down the sysname member to the correct system-specific array size, and then a generous amount of padding: 512 unsigned integers.

Anonymous padding can be specified anywhere in a FFI structure by using the slot name nil. The corresponding space will be reserved in the structure using the type of that slot, but the slot will not participate in any data conversions. FFI will not fill in that area of the structure when preparing data, and will not extract anything from that area in the reverse direction.

The padding prevents the uname function from accessing beyond the end of the memory that is passed to it.

We can, of course, determine the exact size of struct utsname we can specify the padding such that we know for certain that it meets or exceeds the requirement.

## Ursala

There is no way to set the minimum size of natural, integer, or rational numbers, but no need because they all have unlimited precision.

For (mpfr format) arbitrary precision floating point numbers, there are several mechanisms for setting the minimum precision, although not the exact amount of real memory used.

• If it's initialized from a literal constant, the compiler infers the intended precision from the number of digits in the constant (or 160 bits, whichever is greater).
• The library function mpfr..grow(x,n) returns a copy of x with its precision increased by n bits (padded with zeros).
• The library function mpfr..shrink(x,n) returns a copy of x with its precision reduced by n bits, or to MPFR_PREC_MIN, whichever is greater.
• Library functions such as mpfr..pi and mpfr..const_catalan take a natural number specifying the precision as an argument and return a constant with at least that precision.
• If two numbers of unequal precision are combined using any binary operation from the mpfr library, the result is computed and allocated using the greater precision of the two.

The last feature eliminates the need for explicitly setting the precision of numbers having exact representations, albeit contrary to the convention in physical sciences.

p = mpfr..pi 200               # 200 bits of precision

x = mpfr..grow(1.0E+0,1000)    # 160 default precision, grown to 1160

y = mpfr..shrink(1.0+0,40)     # 160 default shrunk to 120

z = mpfr..add(p,y)             # inherits 200 bits of precision

a = # 180 bits (not the default 160) because of more digits in the constant

1.00000000000000000000000000000000000000000000000000000E0

## V (Vlang)

fn main() {
b := true
i := 5   // default type is i32
r := '5'
f := 5.0  // default type is float64
println("b: \${sizeof(b)} bytes")
println("i: \${sizeof(i)} bytes")
println("r: \${sizeof(r)} bytes")
println("f: \${sizeof(f)} bytes")
i_min := i8(5)
r_min := `5`
f_min := f32(5.0)
println("i_min: \${sizeof(i_min)} bytes")
println("r_min: \${sizeof(r_min)} bytes")
println("f_min: \${sizeof(f_min)} bytes")
}
Output:
b: 1 bytes
i: 4 bytes
r: 16 bytes
f: 8 bytes
i_min: 1 bytes
r_min: 4 bytes
f_min: 4 bytes

## Wren

In Wren, variables are always exactly 8 bytes in size. They either store their value directly (Num, Bool or Null) or a reference (a 64 bit pointer) to where an object is stored in memory.

Technically, a variable always contains an 8 byte double precision floating point value but uses a technique known as 'NaN tagging' to store bools, nulls or pointers as well as numbers.

So there is no such thing as a minimum size for a variable or scalar type; the size of the former is always 8 bytes and of the latter however many 8 byte values are needed to store its fields.

Wren has four built-in collection types: String, Range, Map and List. The size of the first two is determined by their currently assigned value which is immutable but the size of the last two can change dynamically as elements are added or removed. Of course, a variable which has been assigned values of these types is always exactly 8 bytes in size and holds a reference to where the actual object is stored on the heap,

The programmer cannot specify a minimum size for a Map but can specify a minimum size for a List - in effect the amount of heap storage required to store its elements. This can still be increased dynamically by adding futher elements to the List. Here's an example.

// create a list with 10 elements all initialized to zero
var l = List.filled(10, 0)
// give them different values and print them
for (i in 0..9) l[i] = i
System.print(l)
// add another element to the list dynamically and print it again
System.print(l)
Output:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

## XPL0

include c:\cxpl\codes;  \intrinsic 'code' declarations
string 0;               \use zero-terminated strings
char S,
A(1),              \sets up an array containing one byte
B(0);              \sets up an array containing no bytes
int  I;
[S:= "";                \a zero-length (null) string
A:= Reserve(1);         \sets up a 1-byte array at runtime
B:= Reserve(0);         \sets up a 0-byte array at runtime
I:= I ! 1<<3;           \stores a single 1 bit into an integer
I:= I & ~(1<<29);       \stores a 0 bit into bit 29 of the integer
IntOut(0, I>>3 & 1);    \displays value of bit 3
]

Other than arrays and strings, variables are a fixed size. Integers are four bytes and reals are eight bytes.

## Z80 Assembly

Translation of: 6502 Assembly

Syntax will vary depending on the assembler and whether your program will run in RAM or ROM. For programs that execute from RAM such as those that are loaded from a disk, you can use the same syntax that you would use to define constants. When defining bytes as variables or constants, you do not prefix them with a # sign. Only in actual CPU instructions do you need to use a # to prevent the assembler from treating the numeric value as a memory location.

Since these are variables, the value given to them (in this case, 0) is the initial value, and can be changed later at runtime. If you don't care what the initial value is, some assemblers allow you to use a "?" where the 0s are.

MyByte:
byte 0       ;most assemblers will also accept DB or DFB
MyWord:
word 0       ;most assemblers will also accept DW or DFW
MyDouble:
dd 0

For programs that are executed solely from ROM, such as video game console cartridges, you won't be able to use the above method. The assembler can often use an enum or rsset directive to sequentially assign labels to a series of consecutive memory locations in the system's RAM.

.rsset \$C000        ;starting at \$C000, the following labels represent sequential memory locations of length ".rs n"
tempByte .rs 1
tempWord .rs 2
tempLong .rs 4

Assemblers that don't have an enum or rsset directive can use the equ directive instead. This method lets you immediately see what each memory location actually is, but it makes it harder to insert a new one without having to redo all the numbering. When loading from an immediate memory location to a 16-bit register pair (e.g. LD HL,(\$4000), the "low register" is loaded with the byte stored at the memory location specified by the operand, and the "high register" is loaded with the byte stored at the memory location after that.

tempByte equ \$C000
tempWord equ \$C001   ;high byte at \$C002
tempLong equ \$C003   ;you have to track spacing yourself with this method

While setting a variable's size is easy, getting it isn't possible without knowing it in advance. The CPU does not (and cannot) know the intended size of a variable. There's no enforcement of types whatsoever on the Z80, anything goes. If, for example, you executed LD HL,(\$4000) and \$4000 was intended to be the storage location of an 8-bit value, you'd get the intended value in L and whatever happened to be after it in memory into H. Whether that's a problem or not is up to the programmer, not the CPU.

## zkl

It is up to the object to decide on size. For example, Ints and Floats are 8 bytes, Strings are immutable and are sized when created. Mutable lists and dictionaries grow and shrink as needed. Some mutable types (such as Lists and Dictionaries) can take [programmer supplied] hints as to how big they might become.

## ZX Spectrum Basic

10 DIM a\$(10): REM This array will be 10 characters long
20 DIM b(10): REM this will hold a set of numbers. The fixed number of bytes per number is implementation specific
30 LET c=5: REM this is a single numerical value of fixed size