MAPs - Datenstruktur/ Typ direkt abspeichern?

Ja - der Begriff hierzu heißt "Serialisieren/Deserialisieren".
Man nimmt eine Datenstruktur in einer Programmiersprache und speichert diese als Datei so ab, dass die Hierarchie und die Datentypen erhalten bleiben.
Anschließend kann man diese Datei wieder irgendwann einlesen und erhält genau diese Datenstruktur wieder in seinem Programm.

Bei den Formaten bist du ziemlich frei. Du kannst dir was völlig eigenes überlegen oder vorhandene Formate hierfür verwenden.
Ini z.B. ist halt beschränkt, da dort Verschachtelungen nicht gut umsetzbar sind aber wenn deine Datenhierarchie flach ist, kann ini ein guter Kandidat hierfür sein.
Für beliebig verschachtelte Datenstrukturen käme z.B. XML in Frage aber da ist mir keine UDF bekannt, welche direkt aus AutoIt-Strukturen lesen und in diese schreiben kann.
Da müsstest du also was eigenes drumherum basteln.

Bleiben noch die klassischen Kandidaten für diese Aufgabe: >>JSON<< - als (menschenlesbares) Textformat oder >>CBOR<< als (speicherkompaktes) Binärformat.
Das schöne an solchen standardisierten Formaten ist es, dass man problemlos zwischen Programmen die Daten austauschen kann.
Also eine JSON oder CBOR-Datei, welche aus AutoIt heraus erzeugt wurde, kann dann wieder in Python eingelesen werden und dort weitergearbeitet werden.

Zitat von uuchip

Der beschriebene Weg ist wahrscheinlich der von Profis!
[...]
Ich denke jetzt evtl. zu naiv, und weil ich keine Schnittstelle zu anderen Sprachen benötige, dass man die Map im Speicher lokalisieren könnte, und diese Daten dann in einem binären Format abspeichert, und später wieder einlesen kann?

So richtig weiß ich ehrlich gesagt nicht was du denkst.
Du wolltest eine Funktionialität mit welcher du verschachtelte AutoIt-Strukturen in Dateien abspeichern kannst und später wieder einlesen.
Sowohl CBOR als auch JSON machen das mit dem nur denkbar geringsten Aufwand.

Beispiel JSON:

; AutoIt-Variable in Datei speichern
FileWrite("myData.json", _JSON_GenerateCompact($mMap))

; AutoIt-Struktur aus JSON-formatierter Datei einlesen:
$mMap = _JSON_Parse(FileRead("myData.json"))

Beispiel CBOR:

; AutoIt-Variable in Datei speichern
FileWrite("myData.bin", _cbor_encode($mMap))

; AutoIt-Struktur aus CBOR-formatierter Datei einlesen:
$mMap = _cbor_decode(FileRead("myData.bin"))

Ich weiß nicht was dich daran stört.
Das Label "Profi" verstehe ich auch nicht in dem Zusammenhang.
Mal abgesehen davon, dass ich genauso wenig Profi bin wie du (vermutlich), sollte die Auswahl der Werkzeuge sich bei einem Amateur nicht wirklich von einem Profi unterscheiden.
In beiden Fällen wird das Werkzeug genommen mit der man eine gestellte Aufgabe möglichst effektiv und effizient lösen kann.
Die Anforderungen bei einem Profi sind es, welche eine Unterscheidung bringen können.
Aber bei gleicher Aufgabenstellung sollten auch ähnliche Lösungen herauskommen.

Du möchtest den vorgeschlagenen Ansatz nun nicht verwenden weil sie deiner Meinung nach "Profis" vorbehalten ist? - hab ich das so richtig verstanden?
Was möchtest du dann?
Eine umständlichere, fehleranfälligere Lösung damit sie mehr nach Amateur aussieht?
JSON und CBOR darfst du als "Amateur" genauso verwenden ohne dass jemand dann mit dir schimpft.

Wenn ich dir stattdessen zeigen wöllte was für ein toller Hecht ich doch bin, dann hätte ich dir einfach die Begriffe Avro, Thrift oder protobuf vor die Füße geworfen und mich dann als echt großer Profi gefühlt...
Das hätte dich kein Stück weiter gebracht - im Gegensatz zu meinem Vorschlag mit JSON und CBOR.
Das war tasächlich ernst gemeint von mir, dass ich dies für die sinnvollste Lösung für deine Problemstellung halte.
Aber behalte im Hinterkopf: Es ist nur eine Amateurmeinung - Profis würden dir vielleicht zu etwas ganz anderem raten...

Das direkte auslesen des Speichers hätte dir auch nicht wirklich geholfen.

Datenstrukturen sind nicht zwingend alle auf einem Haufen im Speicher. Es wird viel mit Referenzen gearbeitet, also wo bei einem Objekt nur die Adresse der anderen Objekte gespeichert sind und nicht die Objekte selbst. Die befinden sich dann irgendwo anders im Speicher. Es müsste also sowieso die ganze Struktur durchgegangen werden um die Daten zu finden und zu speichern. Außerdem geht dabei ggf. der Datentyp verloren, da der nicht im Speicher angegeben wird, sondern sich von den Zusammenhängen des Programmes ergibt.

Das serialisieren von AspirinJunkie ist also tatsächlich die einfachste und beste Methode.

Zitat von uuchip

In dem beigefügten Code-Schnipsel müsste eigentlich $B = $A sein, aber die Quelle $A ist ein 2D Array, und B besteht scheinbar aus 2x 1D Array, bzw. _ArrayDisplay kann $B nicht richtig auflösen/ darstellen.

Exakt. JSON, als auch CBOR hat keine Möglichkeit mehrdimensionale Arrays von verschachtelten Arrays zu unterscheiden.
Dies hängt damit zusammen, dass viele Programmiersprachen mehrdimensionale Arrays in dieser Form gar nicht kennen (Javascript oder Python wären Beispiele hierfür).
Ein 2D-Array wird dort also implizit in ein Array-In-Array serialisiert.
Beim Einlesen wiederrum, gibt es keine Möglichkeit zu detektieren ob es sich mal um ein mehrdimensionales Array oder ein Array-In-Array handeln soll.
Daher obliegt es dem User die Arrays bei Bedarf in die Form zu bringen, welche er benötigt.

Genau daher gibt es in der JSON-UDF Funktionen, welche genau dies bewerkstelligen, so dass dein Skript folgendermaßen anzupassen wäre:

#include <JSON.au3>
#include <Array.au3>

; Aufbau der Datenstruktur in AutoIt
Global $A[2][2] = [[1, 2], [3, 4]]
Global $M[]
$M["A"] = $A
$M["S"] = "Hallo Welt"
Global $M1 = $M
$M["M"] = $M1

; erstmal löschen - sonst wird es nur angefügt
FileDelete("mtest.json")

; AutoIt-Variable in JSON-Datei serialisieren
FileWrite("mtest.json", _JSON_GenerateCompact($M))

; JSON-Datei wieder in AutoIt deserialisieren:
Global $InPut = FileRead("mtest.json")
Global $M2 = _JSON_Parse($InPut)

; Array-In-Array in ein 2D-Array konvertieren:
$B = __JSON_AinAToA2d($M2["A"])

; Ausgeben
_ArrayDisplay($A, "$A")
_ArrayDisplay($B, "$B")