Literals & Numeric Formats in M7 Script

Overview

M7 Script supports various numeric formats and literal representations, allowing for flexibility in numerical computations and data representation.

1. Integer Formats

M7 supports multiple formats for integer representation:

  • Decimal (Base 10) - Standard numeric representation.
  • Hexadecimal (Base 16) - Prefixed with 0x.
  • Binary (Base 2) - Prefixed with 0b.
  • Octal (Base 8) - Prefixed with 0o.

Example:

int decimalNumber = 42;      // Decimal
int hexNumber = 0x2A;        // Hexadecimal (42 in decimal)
int binaryNumber = 0b101010; // Binary (42 in decimal)
int octalNumber = 0o52;      // Octal (42 in decimal)

2. Floating-Point Formats

M7 supports standard floating-point notation as well as scientific notation for large or small numbers.

  • Standard Floating-Point Representation
    float pi = 3.14159;
float smallNumber = 0.00042;
  • Scientific Notation
    • Uses e or E to represent powers of 10.
    float largeNumber = 1.23e4;  // 12300
float tinyNumber = 5.6E-3;   // 0.0056

3. Boolean Literals

  • Booleans represent true or false values.
    bool isEnabled = true;
bool isComplete = false;

4. String Literals

M7 supports different string literal formats:

  • Single-quoted ('): No variable interpolation.
  • Double-quoted ("): Supports escape sequences.
  • Backtick-quoted (`): Allows string interpolation.
string single = 'Hello';
string double = "Hello\nWorld";
string interpolated = `Hello, ${name}!`;

5. Special Literals

  • Null (null) - Represents an explicitly empty or uninitialized value.
  • Undefined (undefined) - Represents an unassigned variable.
var emptyValue = null;
var uninitialized;

6. Hash & Array Literals

M7 supports inline declarations for arrays and hashes using literals.

Array Literals

  • Declared using [ ] brackets.
  • Ordered collection of values.
  • Example:
    array numbers = [1, 2, 3, 4];
array mixed = [1, "text", true, null];

Hash Literals

  • Declared using { } curly brackets.
  • Key-value mapping (associative array/dictionary).
  • Keys may be naked literals or strings.
  • Keys may be implicitly defined if they match a valid identifier.
  • Left-hand assignments for keys are not supported—dynamic key assignment must use . notation.
  • Example:
    hash user = { name: "Alice", age: 30 };
var value = user.age;      // Access via dot notation
var valueAlt = user{"age"}; // Access via explicit string conversion
var implicitKey = user{name}; // Accessing implicitly defined key

Key Behavior & Assignment Rules

  • Quoted keys ("name") and unquoted keys (name) behave the same.
  • Template literals (${name}) as keys are allowed but discouraged.
  • Invalid Key Assignments:
    { "abc".c : value } // INVALID
{ `${name}` : value } // VALID but discouraged
{ name : value } // VALID, key is "name"
{ "name" : value } // Same as without quotes

Array vs. Hash Key Resolution

  • Using bracket notation ([]) expects a numeric index.
  • Using curly brace notation ({}) forces interpretation as a string key.
user[name] = "Alice"; // Treated as an array index, expects name to be a number
user["name"] = "Alice"; // ERROR: Arrays do not support string keys
user{"name"} = "Alice"; // CORRECT: Hash key assignment
user{name} = "Alice"; // CORRECT: Interpreted as key "name"

Valid Dynamic Assignment Using . Notation:

user."dynamicKey" = "This works";

This document outlines the various literals and numeric formats available in M7 Script, including array and hash literals.