---
title: "Fields"
url: https://docs.zeroc.com/ice/3.8/slice/fields
language: matlab
docs_index: https://docs.zeroc.com/llms.txt
---

> For an index of every page, see [llms.txt](https://docs.zeroc.com/llms.txt).

# Fields

Programming language: MATLAB. Other languages: [C++](https://docs.zeroc.com/ice/3.8/slice/fields/cpp.md), [C#](https://docs.zeroc.com/ice/3.8/slice/fields/csharp.md), [Java](https://docs.zeroc.com/ice/3.8/slice/fields/java.md), [JavaScript](https://docs.zeroc.com/ice/3.8/slice/fields/js.md), [PHP](https://docs.zeroc.com/ice/3.8/slice/fields/php.md), [Python](https://docs.zeroc.com/ice/3.8/slice/fields/python.md), [Ruby](https://docs.zeroc.com/ice/3.8/slice/fields/ruby.md), [Swift](https://docs.zeroc.com/ice/3.8/slice/fields/swift.md).

## Syntax

A field is defined as `Type name`, where `Type` is the field's type and `name` is the field's name. For example:

```slice
string name;
ByteSeq image;
Fruit fruit;
```

The type of a field can be a [basic type](https://docs.zeroc.com/ice/3.8/slice/basic-types/matlab.md), a [user-defined type](https://docs.zeroc.com/ice/3.8/slice/user-defined-types.md), `Object*` (an untyped proxy), or `Value` (an untyped class instance).

## Nullable and Non-Nullable Fields

Fields with proxy and class types are nullable: they can hold null. Fields of other types always hold a value, unless they are [optional fields](#optional-fields) that are not set.

```slice
struct Example
{
    int count; // must be set
    Greeter* greeter; // proxy type, so it can be null
    Node node; // class type, so it can be null
}
```

## Optional Fields

A field of a Slice [class](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/classes/matlab.md) or [exception](https://docs.zeroc.com/ice/3.8/slice/exceptions/matlab.md) may be declared as optional to indicate that a program can leave its value unset. Fields not declared as optional are known as *required* fields.

Each optional field must be assigned a unique, non-negative integer *tag*:

```slice
module M
{
    class C
    {
        string name;
        bool active;
        optional(2) string alternateName;
        optional(5) int overrideCode;
    }
}
```

The scope of a tag is the class or exception that defines the field, and this class or exception only: a derived class or exception can reuse a tag of its base type. For example:

```slice
exception BaseException
{
    optional(1) int systemCode;
}

exception DerivedException extends BaseException
{
    optional(1) string diagnostic; // OK: a different scope
}
```

Optional and required fields can be interleaved, and their tags can be in any order. The tag identifies the field in the [encoding](https://docs.zeroc.com/ice/3.8/encoding/data-encoding-for-optional-values.md); the language mappings do not expose it.

An optional field cannot have a class type, or a constructed type that holds a class type.

## Default Values

You can specify a default value for a field that has one of the following types:

- An [integral](https://docs.zeroc.com/ice/3.8/slice/basic-types/matlab.md) type (`byte`, `short`, `int`, `long`)
- A [floating point](https://docs.zeroc.com/ice/3.8/slice/basic-types/matlab.md) type (`float` or `double`)
- [string](https://docs.zeroc.com/ice/3.8/slice/basic-types/matlab.md)
- [bool](https://docs.zeroc.com/ice/3.8/slice/basic-types/matlab.md)
- [enum](https://docs.zeroc.com/ice/3.8/slice/user-defined-types/enumerations/matlab.md)

For example:

```slice
struct Location
{
    string name;
    Point pt;
    bool display = true;
    string source = "GPS";
}
```

The legal syntax for literal values is the same as for Slice [constants](https://docs.zeroc.com/ice/3.8/slice/constants-and-literals/matlab.md), and you may also use a constant as a default value. The language mapping guarantees that fields are initialized to their declared default values using a language-specific mechanism.

You can declare a default value for optional fields just as you can for required fields:

```slice
class C
{
    string name;
    bool active = true;
    optional(2) string alternateName;
    optional(5) int overrideCode = -1;
}
```

An optional field with a default value is considered to be set by default.

## Language Mapping

A Slice field maps to a MATLAB property, with by default the same name. We often remap the field name with `matlab:identifier` to convert the name to Pascal case.

The MATLAB class for the property is the mapped type, as presented earlier, except the following properties don’t specify a MATLAB class:

- properties mapped from optional fields
- properties mapped from fields of class type or that reference class types.

The size and validation function(s) of each property depends on the field type:

| **Slice Field Type** | **MATLAB Size** | **MATLAB Validation Function** | **Remarks** |
| --- | --- | --- | --- |
| `bool`, numeric type, `enum`, `dictionary` | Scalar: `(1, 1)` |  |  |
| `string` | `(1, :)` |  | An empty array (of char) represents an empty string. |
| `sequence` | `(1, :)` |  | An empty array or an empty cell array represents an empty sequence. |
| `class`, proxy | No size constraint | `{mustBeScalarOrEmpty}` | An empty array represents a null class instance or null proxy. |
| `struct` | No size constraint | `{mustBeScalarOrEmpty}` | An empty array is a temporary value. Replace this empty array with a scalar. |

For example:

```slice
class Address { ... }

struct Person
{
    ["matlab:identifier:Name"]
    string name;

    ["matlab:identifier:Address"]
    Address address;
}
```

maps to:

```matlab
classdef Address < Ice.Value
    % ...
end

classdef (Sealed) Person
    properties
        Name    (1, :) char
        % empty corresponds to null
        Address {mustBeScalarOrEmpty} = Example.Address.empty
    end
    % ...
end
```

### Optional Fields {#language-mapping-optional-fields}

An optional field maps to a MATLAB property just like a regular field, and accepts the marker value `Ice.Unset` to mark the field as unset. `Ice.Unset` applies to any field type except proxies: use an empty proxy array, such as `GreeterPrx.empty`, to mark a proxy field as unset.

A well-behaved program must test a MATLAB property (mapped from an optional field) before using its value:

```matlab
obj = ...;
if obj.OptionalField ~= Ice.Unset
    disp(obj.OptionalField);
else
    disp('OptionalField is unset');
end
```

### Default Values {#language-mapping-default-values}

Slice default values are mapped to default MATLAB property values.

For example:

```slice
struct Location
{
    ["matlab:identifier:Name"]
    string name;

    ["matlab:identifier:Point"]
    Point point;

    ["matlab:identifier:Display"]
    bool display = true;

    ["matlab:identifier:Source"]
    string source = "GPS";
}
```

maps to:

```matlab
classdef (Sealed) Location
    properties
        Name    (1, :) char
        Point          Example.Point {mustBeScalarOrEmpty} = Example.Point.empty
        Display (1, 1) logical = true
        Source  (1, :) char = sprintf('GPS')
    end
    methods
        function obj = Location(Name, Point, Display, Source)
            if nargin > 0
                assert(nargin == 4, 'Invalid number of arguments');
                obj.Name = Name;
                obj.Point = Point;
                obj.Display = Display;
                obj.Source = Source;
            end
       end
   % ...
   end
end
```

When you don’t define a default value in Slice, and you initialize a property without providing a value for this property, the generated code uses the following default:

| **Optional Field?** | **Slice Field Type** | **MATLAB Default Value** |
| --- | --- | --- |
| No | `bool`, numeric type | 0 (implicit default) |
|  | `string` | Empty 1-by-0 array of char (implicit default) |
|  | `enum` | First enumerator (implicit default) |
|  | `Object*`, proxy | `MappedPrx.empty`(implicit default) |
|  | `Value`, `class`, `struct` | `MappedType.empty`(implicit default when the MATLAB class is specified) |
|  | `sequence` | `MappedElementType.empty`(implicit default), or `{}` (implicit default when the MATLAB class is specified). |
|  | `dictionary` | `configureDictionary('keyType', 'valueType')` |
| Yes | `Object*`, proxy | `MappedPrx.empty` |
|  | Other types | `Ice.Unset` |
