[artiq] cleanup module functionality tests

move tests from artiq to standalone
nac3artiq/demo: merge EmbeddingMap into min_artiq
2025-01-20 10:24:08 +08:00 · 2025-01-17 13:10:35 +08:00 · 2025-01-17 12:45:51 +08:00 · 2025-01-16 12:42:13 +08:00 · 2025-01-16 12:41:30 +08:00 · 2025-01-16 12:40:56 +08:00
102 changed files with 7046 additions and 5916 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@ -65,11 +65,12 @@ dependencies = [

 [[package]]
 name = "anstyle-wincon"
-version = "3.0.6"
+version = "3.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2109dbce0e72be3ec00bed26e6a7479ca384ad226efdd66db8fa2e3a38c83125"
+checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
 dependencies = [
 "anstyle",
+ "once_cell",
 "windows-sys 0.59.0",
 ]

@ -105,9 +106,9 @@ checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"

 [[package]]
 name = "bitflags"
-version = "2.6.0"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "8f68f53c83ab957f72c32642f3868eec03eb974d1fb82e453128456482613d36"

 [[package]]
 name = "block-buffer"
@ -126,9 +127,9 @@ checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"

 [[package]]
 name = "cc"
-version = "1.2.4"
+version = "1.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9157bbaa6b165880c27a4293a474c91cdcf265cc68cc829bf10be0964a391caf"
+checksum = "c8293772165d9345bdaaa39b45b2109591e63fe5e6fbc23c6ff930a048aa310b"
 dependencies = [
 "shlex",
 ]
@ -141,9 +142,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"

 [[package]]
 name = "clap"
-version = "4.5.23"
+version = "4.5.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3135e7ec2ef7b10c6ed8950f0f792ed96ee093fa088608f1c76e569722700c84"
+checksum = "a8eb5e908ef3a6efbe1ed62520fb7287959888c88485abe072543190ecc66783"
 dependencies = [
 "clap_builder",
 "clap_derive",
@ -151,9 +152,9 @@ dependencies = [

 [[package]]
 name = "clap_builder"
-version = "4.5.23"
+version = "4.5.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30582fc632330df2bd26877bde0c1f4470d57c582bbc070376afcd04d8cb4838"
+checksum = "96b01801b5fc6a0a232407abc821660c9c6d25a1cafc0d4f85f29fb8d9afc121"
 dependencies = [
 "anstream",
 "anstyle",
@ -163,14 +164,14 @@ dependencies = [

 [[package]]
 name = "clap_derive"
-version = "4.5.18"
+version = "4.5.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ac6a0c7b1a9e9a5186361f67dfa1b88213572f427fb9ab038efb2bd8c582dab"
+checksum = "54b755194d6389280185988721fffba69495eed5ee9feeee9a599b53db80318c"
 dependencies = [
 "heck 0.5.0",
 "proc-macro2",
 "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]

 [[package]]
@ -187,14 +188,14 @@ checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"

 [[package]]
 name = "console"
-version = "0.15.8"
+version = "0.15.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e1f83fc076bd6dd27517eacdf25fef6c4dfe5f1d7448bafaaf3a26f13b5e4eb"
+checksum = "ea3c6ecd8059b57859df5c69830340ed3c41d30e3da0c1cbed90a96ac853041b"
 dependencies = [
 "encode_unicode",
- "lazy_static",
 "libc",
- "windows-sys 0.52.0",
+ "once_cell",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@ -221,18 +222,18 @@ dependencies = [

 [[package]]
 name = "crossbeam-channel"
-version = "0.5.13"
+version = "0.5.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33480d6946193aa8033910124896ca395333cae7e2d1113d1fef6c3272217df2"
+checksum = "06ba6d68e24814cb8de6bb986db8222d3a027d15872cabc0d18817bc3c0e4471"
 dependencies = [
 "crossbeam-utils",
 ]

 [[package]]
 name = "crossbeam-deque"
-version = "0.8.5"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "613f8cc01fe9cf1a3eb3d7f488fd2fa8388403e97039e2f73692932e291a770d"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
 dependencies = [
 "crossbeam-epoch",
 "crossbeam-utils",
@ -249,18 +250,18 @@ dependencies = [

 [[package]]
 name = "crossbeam-queue"
-version = "0.3.11"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df0346b5d5e76ac2fe4e327c5fd1118d6be7c51dfb18f9b7922923f287471e35"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
 dependencies = [
 "crossbeam-utils",
 ]

 [[package]]
 name = "crossbeam-utils"
-version = "0.8.20"
+version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22ec99545bb0ed0ea7bb9b8e1e9122ea386ff8a48c0922e43f36d45ab09e0e80"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"

 [[package]]
 name = "crypto-common"
@ -305,9 +306,9 @@ dependencies = [

 [[package]]
 name = "encode_unicode"
-version = "0.3.6"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a357d28ed41a50f9c765dbfe56cbc04a64e53e5fc58ba79fbc34c10ef3df831f"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"

 [[package]]
 name = "equivalent"
@ -378,9 +379,9 @@ dependencies = [

 [[package]]
 name = "glob"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
+checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"

 [[package]]
 name = "hashbrown"
@ -417,11 +418,11 @@ checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"

 [[package]]
 name = "home"
-version = "0.5.9"
+version = "0.5.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
+checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
 dependencies = [
- "windows-sys 0.52.0",
+ "windows-sys 0.59.0",
 ]

 [[package]]
@ -472,7 +473,7 @@ checksum = "9dd28cfd4cfba665d47d31c08a6ba637eed16770abca2eccbbc3ca831fef1e44"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]

 [[package]]
@ -559,9 +560,9 @@ checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"

 [[package]]
 name = "libc"
-version = "0.2.168"
+version = "0.2.169"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aaeb2981e0606ca11d79718f8bb01164f1d6ed75080182d3abf017e6d244b6d"
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"

 [[package]]
 name = "libloading"
@ -581,9 +582,9 @@ checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"

 [[package]]
 name = "linux-raw-sys"
-version = "0.4.14"
+version = "0.4.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78b3ae25bc7c8c38cec158d1f2757ee79e9b3740fbc7ccf0e59e4b08d793fa89"
+checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"

 [[package]]
 name = "llvm-sys"
@ -610,9 +611,9 @@ dependencies = [

 [[package]]
 name = "log"
-version = "0.4.22"
+version = "0.4.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
+checksum = "04cbf5b083de1c7e0222a7a51dbfdba1cbe1c6ab0b15e29fff3f6c077fd9cd9f"

 [[package]]
 name = "memchr"
@ -678,7 +679,7 @@ dependencies = [
 "proc-macro-error",
 "proc-macro2",
 "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 "trybuild",
 ]

@ -761,45 +762,45 @@ dependencies = [

 [[package]]
 name = "phf"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
+checksum = "1fd6780a80ae0c52cc120a26a1a42c1ae51b247a253e4e06113d23d2c2edd078"
 dependencies = [
 "phf_macros",
- "phf_shared 0.11.2",
+ "phf_shared 0.11.3",
 ]

 [[package]]
 name = "phf_codegen"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8d39688d359e6b34654d328e262234662d16cc0f60ec8dcbe5e718709342a5a"
+checksum = "aef8048c789fa5e851558d709946d6d79a8ff88c0440c587967f8e94bfb1216a"
 dependencies = [
 "phf_generator",
- "phf_shared 0.11.2",
+ "phf_shared 0.11.3",
 ]

 [[package]]
 name = "phf_generator"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
+checksum = "3c80231409c20246a13fddb31776fb942c38553c51e871f8cbd687a4cfb5843d"
 dependencies = [
- "phf_shared 0.11.2",
+ "phf_shared 0.11.3",
 "rand",
 ]

 [[package]]
 name = "phf_macros"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b"
+checksum = "f84ac04429c13a7ff43785d75ad27569f2951ce0ffd30a3321230db2fc727216"
 dependencies = [
 "phf_generator",
- "phf_shared 0.11.2",
+ "phf_shared 0.11.3",
 "proc-macro2",
 "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]

 [[package]]
@ -808,16 +809,16 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
 dependencies = [
- "siphasher",
+ "siphasher 0.3.11",
 ]

 [[package]]
 name = "phf_shared"
-version = "0.11.2"
+version = "0.11.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
+checksum = "67eabc2ef2a60eb7faa00097bd1ffdb5bd28e62bf39990626a582201b7a754e5"
 dependencies = [
- "siphasher",
+ "siphasher 1.0.1",
 ]

 [[package]]
@ -873,9 +874,9 @@ dependencies = [

 [[package]]
 name = "proc-macro2"
-version = "1.0.92"
+version = "1.0.93"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37d3544b3f2748c54e147655edb5025752e2303145b5aefb3c3ea2c78b973bb0"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
 dependencies = [
 "unicode-ident",
 ]
@ -927,7 +928,7 @@ dependencies = [
 "proc-macro2",
 "pyo3-macros-backend",
 "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]

 [[package]]
@ -940,14 +941,14 @@ dependencies = [
 "proc-macro2",
 "pyo3-build-config",
 "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]

 [[package]]
 name = "quote"
-version = "1.0.37"
+version = "1.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5b9d34b8991d19d98081b46eacdd8eb58c6f2b201139f7c5f643cc155a633af"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
 dependencies = [
 "proc-macro2",
 ]
@ -1049,9 +1050,9 @@ dependencies = [

 [[package]]
 name = "rustix"
-version = "0.38.42"
+version = "0.38.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93dc38ecbab2eb790ff964bb77fa94faf256fd3e73285fd7ba0903b76bedb85"
+checksum = "a78891ee6bf2340288408954ac787aa063d8e8817e9f53abb37c695c6d834ef6"
 dependencies = [
 "bitflags",
 "errno",
@ -1062,9 +1063,9 @@ dependencies = [

 [[package]]
 name = "rustversion"
-version = "1.0.18"
+version = "1.0.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e819f2bc632f285be6d7cd36e25940d45b2391dd6d9b939e79de557f7014248"
+checksum = "f7c45b9784283f1b2e7fb61b42047c2fd678ef0960d4f6f1eba131594cc369d4"

 [[package]]
 name = "ryu"
@ -1095,29 +1096,29 @@ checksum = "3cb6eb87a131f756572d7fb904f6e7b68633f09cca868c5df1c4b8d1a694bbba"

 [[package]]
 name = "serde"
-version = "1.0.216"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e"
+checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
 dependencies = [
 "serde_derive",
 ]

 [[package]]
 name = "serde_derive"
-version = "1.0.216"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e"
+checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]

 [[package]]
 name = "serde_json"
-version = "1.0.133"
+version = "1.0.135"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"
+checksum = "2b0d7ba2887406110130a978386c4e1befb98c674b4fba677954e4db976630d9"
 dependencies = [
 "itoa",
 "memchr",
@ -1174,6 +1175,12 @@ version = "0.3.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d"

+[[package]]
+name = "siphasher"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
+
 [[package]]
 name = "smallvec"
 version = "1.13.2"
@ -1226,7 +1233,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "rustversion",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]

 [[package]]
@ -1242,9 +1249,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.90"
+version = "2.0.96"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "919d3b74a5dd0ccd15aeb8f93e7006bd9e14c295087c9896a110f490752bcf31"
+checksum = "d5d0adab1ae378d7f53bdebc67a39f1f151407ef230f0ce2883572f5d8985c80"
 dependencies = [
 "proc-macro2",
 "quote",
@ -1265,12 +1272,13 @@ checksum = "42a4d50cdb458045afc8131fd91b64904da29548bcb63c7236e0844936c13078"

 [[package]]
 name = "tempfile"
-version = "3.14.0"
+version = "3.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28cce251fcbc87fac86a866eeb0d6c2d536fc16d06f184bb61aeae11aa4cee0c"
+checksum = "9a8a559c81686f576e8cd0290cd2a24a2a9ad80c98b3478856500fcbd7acd704"
 dependencies = [
 "cfg-if",
 "fastrand",
+ "getrandom",
 "once_cell",
 "rustix",
 "windows-sys 0.59.0",
@ -1278,9 +1286,9 @@ dependencies = [

 [[package]]
 name = "term"
-version = "1.0.0"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4df4175de05129f31b80458c6df371a15e7fc3fd367272e6bf938e5c351c7ea0"
+checksum = "a3bb6001afcea98122260987f8b7b5da969ecad46dbf0b5453702f776b491a41"
 dependencies = [
 "home",
 "windows-sys 0.52.0",
@ -1325,7 +1333,7 @@ checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]

 [[package]]
@ -1603,9 +1611,9 @@ checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"

 [[package]]
 name = "winnow"
-version = "0.6.20"
+version = "0.6.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b"
+checksum = "c8d71a593cc5c42ad7876e2c1fda56f314f3754c084128833e64f1345ff8a03a"
 dependencies = [
 "memchr",
 ]
@ -1637,5 +1645,5 @@ checksum = "fa4f8080344d4671fb4e831a13ad1e68092748387dfc4f55e356242fae12ce3e"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.90",
+ "syn 2.0.96",
 ]
--- a/flake.lock
+++ b/flake.lock
@ -2,11 +2,11 @@
  "nodes": {
    "nixpkgs": {
      "locked": {
-        "lastModified": 1733940404,
-        "narHash": "sha256-Pj39hSoUA86ZePPF/UXiYHHM7hMIkios8TYG29kQT4g=",
+        "lastModified": 1736798957,
+        "narHash": "sha256-qwpCtZhSsSNQtK4xYGzMiyEDhkNzOCz/Vfu4oL2ETsQ=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "5d67ea6b4b63378b9c13be21e2ec9d1afc921713",
+        "rev": "9abb87b552b7f55ac8916b6fc9e5cb486656a2f3",
        "type": "github"
      },
      "original": {
--- a/nac3artiq/demo/embedding_map.py
+++ b/nac3artiq/demo/embedding_map.py
@ -1,39 +0,0 @@
-class EmbeddingMap:
-    def __init__(self):
-        self.object_inverse_map = {}
-        self.object_map = {}
-        self.string_map = {}
-        self.string_reverse_map = {}
-        self.function_map = {}
-        self.attributes_writeback = []
-
-    def store_function(self, key, fun):
-        self.function_map[key] = fun
-        return key
-
-    def store_object(self, obj):
-        obj_id = id(obj)
-        if obj_id in self.object_inverse_map:
-            return self.object_inverse_map[obj_id]
-        key = len(self.object_map) + 1
-        self.object_map[key] = obj
-        self.object_inverse_map[obj_id] = key
-        return key
-
-    def store_str(self, s):
-        if s in self.string_reverse_map:
-            return self.string_reverse_map[s]
-        key = len(self.string_map)
-        self.string_map[key] = s
-        self.string_reverse_map[s] = key
-        return key
-
-    def retrieve_function(self, key):
-        return self.function_map[key]
-
-    def retrieve_object(self, key):
-        return self.object_map[key]
-
-    def retrieve_str(self, key):
-        return self.string_map[key]
-
--- a/nac3artiq/demo/min_artiq.py
+++ b/nac3artiq/demo/min_artiq.py
@ -6,7 +6,6 @@ from typing import Generic, TypeVar
 from math import floor, ceil

 import nac3artiq
-from embedding_map import EmbeddingMap


 __all__ = [
@ -193,6 +192,46 @@ def print_int64(x: int64):
    raise NotImplementedError("syscall not simulated")


+class EmbeddingMap:
+    def __init__(self):
+        self.object_inverse_map = {}
+        self.object_map = {}
+        self.string_map = {}
+        self.string_reverse_map = {}
+        self.function_map = {}
+        self.attributes_writeback = []
+
+    def store_function(self, key, fun):
+        self.function_map[key] = fun
+        return key
+
+    def store_object(self, obj):
+        obj_id = id(obj)
+        if obj_id in self.object_inverse_map:
+            return self.object_inverse_map[obj_id]
+        key = len(self.object_map) + 1
+        self.object_map[key] = obj
+        self.object_inverse_map[obj_id] = key
+        return key
+
+    def store_str(self, s):
+        if s in self.string_reverse_map:
+            return self.string_reverse_map[s]
+        key = len(self.string_map)
+        self.string_map[key] = s
+        self.string_reverse_map[s] = key
+        return key
+
+    def retrieve_function(self, key):
+        return self.function_map[key]
+
+    def retrieve_object(self, key):
+        return self.object_map[key]
+
+    def retrieve_str(self, key):
+        return self.string_map[key]
+
+
@nac3
 class Core:
    ref_period: KernelInvariant[float]
--- a/nac3artiq/demo/module.py
+++ b/nac3artiq/demo/module.py
@ -0,0 +1,26 @@
+from min_artiq import *
+from numpy import int32
+
+# Global Variable Definition
+X: Kernel[int32] = 1
+
+# TopLevelFunction Defintion
+@kernel
+def display_X():
+    print_int32(X)
+
+# TopLevel Class Definition
+@nac3
+class A:    
+    @kernel
+    def __init__(self):
+        self.set_x(1)
+    
+    @kernel
+    def set_x(self, new_val: int32):
+        global X
+        X = new_val
+    
+    @kernel
+    def get_X(self) -> int32:
+        return X
--- a/nac3artiq/demo/module_support.py
+++ b/nac3artiq/demo/module_support.py
@ -0,0 +1,26 @@
+from min_artiq import *
+import module as module_definition
+
+@nac3
+class TestModuleSupport:
+    core: KernelInvariant[Core]
+
+    def __init__(self):
+        self.core = Core()
+
+    @kernel
+    def run(self):
+        # Accessing classes
+        obj = module_definition.A()
+        obj.get_X()
+        obj.set_x(2)
+        
+        # Calling functions
+        module_definition.display_X()
+
+        # Updating global variables
+        module_definition.X = 9
+        module_definition.display_X()
+
+if __name__ == "__main__":
+    TestModuleSupport().run()
--- a/nac3artiq/demo/numpy_primitives_decay.py
+++ b/nac3artiq/demo/numpy_primitives_decay.py
@ -0,0 +1,29 @@
+from min_artiq import *
+import numpy
+from numpy import int32
+
+
+@nac3
+class NumpyBoolDecay:
+    core: KernelInvariant[Core]
+    np_true: KernelInvariant[bool]
+    np_false: KernelInvariant[bool]
+    np_int: KernelInvariant[int32]
+    np_float: KernelInvariant[float]
+    np_str: KernelInvariant[str]
+
+    def __init__(self):
+        self.core = Core()
+        self.np_true = numpy.True_
+        self.np_false = numpy.False_
+        self.np_int = numpy.int32(0)
+        self.np_float = numpy.float64(0.0)
+        self.np_str = numpy.str_("")
+
+    @kernel
+    def run(self):
+        pass
+
+
+if __name__ == "__main__":
+    NumpyBoolDecay().run()
--- a/nac3artiq/demo/string_attribute_issue337.py
+++ b/nac3artiq/demo/string_attribute_issue337.py
@ -1,24 +0,0 @@
-from min_artiq import *
-from numpy import int32
-
-
-@nac3
-class Demo:
-    core: KernelInvariant[Core]
-    attr1: KernelInvariant[str]
-    attr2: KernelInvariant[int32]
-
-
-    def __init__(self):
-        self.core = Core()
-        self.attr2 = 32
-        self.attr1 = "SAMPLE"
-
-    @kernel
-    def run(self):
-        print_int32(self.attr2)
-        self.attr1
-
-
-if __name__ == "__main__":
-    Demo().run()
--- a/nac3artiq/demo/support_class_attr_issue102.py
+++ b/nac3artiq/demo/support_class_attr_issue102.py
@ -1,40 +0,0 @@
-from min_artiq import *
-from numpy import int32
-
-
-@nac3
-class Demo:
-    attr1: KernelInvariant[int32] = 2
-    attr2: int32 = 4
-    attr3: Kernel[int32]
-
-    @kernel
-    def __init__(self):
-        self.attr3 = 8
-
-
-@nac3
-class NAC3Devices:
-    core: KernelInvariant[Core]
-    attr4: KernelInvariant[int32] = 16
-    
-    def __init__(self):
-        self.core = Core()
-
-    @kernel
-    def run(self):
-        Demo.attr1  # Supported
-        # Demo.attr2  # Field not accessible on Kernel
-        # Demo.attr3  # Only attributes can be accessed in this way
-        # Demo.attr1 = 2  # Attributes are immutable
-
-        self.attr4  # Attributes can be accessed within class
-
-        obj = Demo()
-        obj.attr1  # Attributes can be accessed by class objects
-
-        NAC3Devices.attr4  # Attributes accessible for classes without __init__
-
-
-if __name__ == "__main__":
-    NAC3Devices().run()
--- a/nac3artiq/src/codegen.rs
+++ b/nac3artiq/src/codegen.rs
@ -29,6 +29,7 @@ use nac3core::{
    inkwell::{
        context::Context,
        module::Linkage,
+        targets::TargetMachine,
        types::{BasicType, IntType},
        values::{BasicValueEnum, IntValue, PointerValue, StructValue},
        AddressSpace, IntPredicate, OptimizationLevel,
@ -87,13 +88,13 @@ pub struct ArtiqCodeGenerator<'a> {
 impl<'a> ArtiqCodeGenerator<'a> {
    pub fn new(
        name: String,
-        size_t: u32,
+        size_t: IntType<'_>,
        timeline: &'a (dyn TimeFns + Sync),
    ) -> ArtiqCodeGenerator<'a> {
-        assert!(size_t == 32 || size_t == 64);
+        assert!(matches!(size_t.get_bit_width(), 32 | 64));
        ArtiqCodeGenerator {
            name,
-            size_t,
+            size_t: size_t.get_bit_width(),
            name_counter: 0,
            start: None,
            end: None,
@ -102,6 +103,17 @@ impl<'a> ArtiqCodeGenerator<'a> {
        }
    }

+    #[must_use]
+    pub fn with_target_machine(
+        name: String,
+        ctx: &Context,
+        target_machine: &TargetMachine,
+        timeline: &'a (dyn TimeFns + Sync),
+    ) -> ArtiqCodeGenerator<'a> {
+        let llvm_usize = ctx.ptr_sized_int_type(&target_machine.get_target_data(), None);
+        Self::new(name, llvm_usize, timeline)
+    }
+
    /// If the generator is currently in a direct-`parallel` block context, emits IR that resets the
    /// position of the timeline to the initial timeline position before entering the `parallel`
    /// block.
@ -162,7 +174,7 @@ impl<'a> ArtiqCodeGenerator<'a> {
    }
 }

-impl<'b> CodeGenerator for ArtiqCodeGenerator<'b> {
+impl CodeGenerator for ArtiqCodeGenerator<'_> {
    fn get_name(&self) -> &str {
        &self.name
    }
@ -459,13 +471,13 @@ fn format_rpc_arg<'ctx>(
            // libproto_artiq: NDArray = [data[..], dim_sz[..]]

            let llvm_i1 = ctx.ctx.bool_type();
-            let llvm_usize = generator.get_size_type(ctx.ctx);
+            let llvm_usize = ctx.get_size_type();

            let (elem_ty, ndims) = unpack_ndarray_var_tys(&mut ctx.unifier, arg_ty);
            let ndims = extract_ndims(&ctx.unifier, ndims);
            let dtype = ctx.get_llvm_type(generator, elem_ty);
-            let ndarray = NDArrayType::new(generator, ctx.ctx, dtype, Some(ndims))
-                .map_value(arg.into_pointer_value(), None);
+            let ndarray =
+                NDArrayType::new(ctx, dtype, ndims).map_value(arg.into_pointer_value(), None);

            let ndims = llvm_usize.const_int(ndims, false);

@ -544,7 +556,7 @@ fn format_rpc_ret<'ctx>(
    let llvm_i32 = ctx.ctx.i32_type();
    let llvm_i8_8 = ctx.ctx.struct_type(&[llvm_i8.array_type(8).into()], false);
    let llvm_pi8 = llvm_i8.ptr_type(AddressSpace::default());
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_usize = ctx.get_size_type();
    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());

    let rpc_recv = ctx.module.get_function("rpc_recv").unwrap_or_else(|| {
@ -597,7 +609,7 @@ fn format_rpc_ret<'ctx>(
            let (dtype, ndims) = unpack_ndarray_var_tys(&mut ctx.unifier, ret_ty);
            let dtype_llvm = ctx.get_llvm_type(generator, dtype);
            let ndims = extract_ndims(&ctx.unifier, ndims);
-            let ndarray = NDArrayType::new(generator, ctx.ctx, dtype_llvm, Some(ndims))
+            let ndarray = NDArrayType::new(ctx, dtype_llvm, ndims)
                .construct_uninitialized(generator, ctx, None);

            // NOTE: Current content of `ndarray`:
@ -685,7 +697,7 @@ fn format_rpc_ret<'ctx>(

            // debug_assert(nelems * sizeof(T) >= ndarray_nbytes)
            if ctx.registry.llvm_options.opt_level == OptimizationLevel::None {
-                let num_elements = ndarray.size(generator, ctx);
+                let num_elements = ndarray.size(ctx);

                let expected_ndarray_nbytes =
                    ctx.builder.build_int_mul(num_elements, itemsize, "").unwrap();
@ -797,7 +809,7 @@ fn rpc_codegen_callback_fn<'ctx>(
 ) -> Result<Option<BasicValueEnum<'ctx>>, String> {
    let int8 = ctx.ctx.i8_type();
    let int32 = ctx.ctx.i32_type();
-    let size_type = generator.get_size_type(ctx.ctx);
+    let size_type = ctx.get_size_type();
    let ptr_type = int8.ptr_type(AddressSpace::default());
    let tag_ptr_type = ctx.ctx.struct_type(&[ptr_type.into(), size_type.into()], false);

@ -1040,6 +1052,34 @@ pub fn attributes_writeback<'ctx>(
                        ));
                    }
                }
+                TypeEnum::TModule { attributes, .. } => {
+                    let mut fields = Vec::new();
+                    let obj = inner_resolver.get_obj_value(py, val, ctx, generator, ty)?.unwrap();
+
+                    for (name, (field_ty, is_method)) in attributes {
+                        if *is_method {
+                            continue;
+                        }
+                        if gen_rpc_tag(ctx, *field_ty, &mut scratch_buffer).is_ok() {
+                            fields.push(name.to_string());
+                            let (index, _) = ctx.get_attr_index(ty, *name);
+                            values.push((
+                                *field_ty,
+                                ctx.build_gep_and_load(
+                                    obj.into_pointer_value(),
+                                    &[zero, int32.const_int(index as u64, false)],
+                                    None,
+                                ),
+                            ));
+                        }
+                    }
+                    if !fields.is_empty() {
+                        let pydict = PyDict::new(py);
+                        pydict.set_item("obj", val)?;
+                        pydict.set_item("fields", fields)?;
+                        host_attributes.append(pydict)?;
+                    }
+                }
                _ => {}
            }
        }
@ -1155,7 +1195,7 @@ fn polymorphic_print<'ctx>(

    let llvm_i32 = ctx.ctx.i32_type();
    let llvm_i64 = ctx.ctx.i64_type();
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_usize = ctx.get_size_type();

    let suffix = suffix.unwrap_or_default();

@ -1505,7 +1545,7 @@ pub fn call_rtio_log_impl<'ctx>(
 /// Generates a call to `core_log`.
 pub fn gen_core_log<'ctx>(
    ctx: &mut CodeGenContext<'ctx, '_>,
-    obj: &Option<(Type, ValueEnum<'ctx>)>,
+    obj: Option<&(Type, ValueEnum<'ctx>)>,
    fun: (&FunSignature, DefinitionId),
    args: &[(Option<StrRef>, ValueEnum<'ctx>)],
    generator: &mut dyn CodeGenerator,
@ -1522,7 +1562,7 @@ pub fn gen_core_log<'ctx>(
 /// Generates a call to `rtio_log`.
 pub fn gen_rtio_log<'ctx>(
    ctx: &mut CodeGenContext<'ctx, '_>,
-    obj: &Option<(Type, ValueEnum<'ctx>)>,
+    obj: Option<&(Type, ValueEnum<'ctx>)>,
    fun: (&FunSignature, DefinitionId),
    args: &[(Option<StrRef>, ValueEnum<'ctx>)],
    generator: &mut dyn CodeGenerator,
--- a/nac3artiq/src/lib.rs
+++ b/nac3artiq/src/lib.rs
@ -43,7 +43,7 @@ use nac3core::{
        OptimizationLevel,
    },
    nac3parser::{
-        ast::{Constant, ExprKind, Located, Stmt, StmtKind, StrRef},
+        ast::{self, Constant, ExprKind, Located, Stmt, StmtKind, StrRef},
        parser::parse_program,
    },
    symbol_resolver::SymbolResolver,
@ -78,14 +78,62 @@ enum Isa {
 }

 impl Isa {
-    /// Returns the number of bits in `size_t` for the [`Isa`].
-    fn get_size_type(self) -> u32 {
-        if self == Isa::Host {
-            64u32
-        } else {
-            32u32
+    /// Returns the [`TargetTriple`] used for compiling to this ISA.
+    pub fn get_llvm_target_triple(self) -> TargetTriple {
+        match self {
+            Isa::Host => TargetMachine::get_default_triple(),
+            Isa::RiscV32G | Isa::RiscV32IMA => TargetTriple::create("riscv32-unknown-linux"),
+            Isa::CortexA9 => TargetTriple::create("armv7-unknown-linux-gnueabihf"),
        }
    }
+
+    /// Returns the [`String`] representing the target CPU used for compiling to this ISA.
+    pub fn get_llvm_target_cpu(self) -> String {
+        match self {
+            Isa::Host => TargetMachine::get_host_cpu_name().to_string(),
+            Isa::RiscV32G | Isa::RiscV32IMA => "generic-rv32".to_string(),
+            Isa::CortexA9 => "cortex-a9".to_string(),
+        }
+    }
+
+    /// Returns the [`String`] representing the target features used for compiling to this ISA.
+    pub fn get_llvm_target_features(self) -> String {
+        match self {
+            Isa::Host => TargetMachine::get_host_cpu_features().to_string(),
+            Isa::RiscV32G => "+a,+m,+f,+d".to_string(),
+            Isa::RiscV32IMA => "+a,+m".to_string(),
+            Isa::CortexA9 => "+dsp,+fp16,+neon,+vfp3,+long-calls".to_string(),
+        }
+    }
+
+    /// Returns an instance of [`CodeGenTargetMachineOptions`] representing the target machine
+    /// options used for compiling to this ISA.
+    pub fn get_llvm_target_options(self) -> CodeGenTargetMachineOptions {
+        CodeGenTargetMachineOptions {
+            triple: self.get_llvm_target_triple().as_str().to_string_lossy().into_owned(),
+            cpu: self.get_llvm_target_cpu(),
+            features: self.get_llvm_target_features(),
+            reloc_mode: RelocMode::PIC,
+            ..CodeGenTargetMachineOptions::from_host()
+        }
+    }
+
+    /// Returns an instance of [`TargetMachine`] used in compiling and linking of a program of this
+    /// ISA.
+    pub fn create_llvm_target_machine(self, opt_level: OptimizationLevel) -> TargetMachine {
+        self.get_llvm_target_options()
+            .create_target_machine(opt_level)
+            .expect("couldn't create target machine")
+    }
+
+    /// Returns the number of bits in `size_t` for this ISA.
+    fn get_size_type(self, ctx: &Context) -> u32 {
+        ctx.ptr_sized_int_type(
+            &self.create_llvm_target_machine(OptimizationLevel::Default).get_target_data(),
+            None,
+        )
+        .get_bit_width()
+    }
 }

 #[derive(Clone)]
@ -111,6 +159,7 @@ pub struct PrimitivePythonId {
    generic_alias: (u64, u64),
    virtual_id: u64,
    option: u64,
+    module: u64,
 }

 type TopLevelComponent = (Stmt, String, PyObject);
@ -228,6 +277,10 @@ impl Nac3 {
                        }
                    })
                }
+                // Allow global variable declaration with `Kernel` type annotation
+                StmtKind::AnnAssign { ref annotation, .. } => {
+                    matches!(&annotation.node, ExprKind::Subscript { value, .. } if matches!(&value.node, ExprKind::Name {id, ..} if id == &"Kernel".into()))
+                }
                _ => false,
            };

@ -330,7 +383,7 @@ impl Nac3 {
                        vars: into_var_map([arg_ty]),
                    },
                    Arc::new(GenCall::new(Box::new(move |ctx, obj, fun, args, generator| {
-                        gen_core_log(ctx, &obj, fun, &args, generator)?;
+                        gen_core_log(ctx, obj.as_ref(), fun, &args, generator)?;

                        Ok(None)
                    }))),
@ -360,7 +413,7 @@ impl Nac3 {
                        vars: into_var_map([arg_ty]),
                    },
                    Arc::new(GenCall::new(Box::new(move |ctx, obj, fun, args, generator| {
-                        gen_rtio_log(ctx, &obj, fun, &args, generator)?;
+                        gen_rtio_log(ctx, obj.as_ref(), fun, &args, generator)?;

                        Ok(None)
                    }))),
@ -378,7 +431,7 @@ impl Nac3 {
        py: Python,
        link_fn: &dyn Fn(&Module) -> PyResult<T>,
    ) -> PyResult<T> {
-        let size_t = self.isa.get_size_type();
+        let size_t = self.isa.get_size_type(&Context::create());
        let (mut composer, mut builtins_def, mut builtins_ty) = TopLevelComposer::new(
            self.builtins.clone(),
            Self::get_lateinit_builtins(),
@ -421,12 +474,14 @@ impl Nac3 {
        ];
        add_exceptions(&mut composer, &mut builtins_def, &mut builtins_ty, &exception_names);

+        // Stores a mapping from module id to attributes
        let mut module_to_resolver_cache: HashMap<u64, _> = HashMap::new();

        let mut rpc_ids = vec![];
        for (stmt, path, module) in &self.top_levels {
            let py_module: &PyAny = module.extract(py)?;
            let module_id: u64 = id_fn.call1((py_module,))?.extract()?;
+            let module_name: String = py_module.getattr("__name__")?.extract()?;
            let helper = helper.clone();
            let class_obj;
            if let StmtKind::ClassDef { name, .. } = &stmt.node {
@ -441,7 +496,7 @@ impl Nac3 {
            } else {
                class_obj = None;
            }
-            let (name_to_pyid, resolver) =
+            let (name_to_pyid, resolver, _, _) =
                module_to_resolver_cache.get(&module_id).cloned().unwrap_or_else(|| {
                    let mut name_to_pyid: HashMap<StrRef, u64> = HashMap::new();
                    let members: &PyDict =
@ -470,9 +525,17 @@ impl Nac3 {
                    })))
                        as Arc<dyn SymbolResolver + Send + Sync>;
                    let name_to_pyid = Rc::new(name_to_pyid);
-                    module_to_resolver_cache
-                        .insert(module_id, (name_to_pyid.clone(), resolver.clone()));
-                    (name_to_pyid, resolver)
+                    let module_location = ast::Location::new(1, 1, stmt.location.file);
+                    module_to_resolver_cache.insert(
+                        module_id,
+                        (
+                            name_to_pyid.clone(),
+                            resolver.clone(),
+                            module_name.clone(),
+                            Some(module_location),
+                        ),
+                    );
+                    (name_to_pyid, resolver, module_name, Some(module_location))
                });

            let (name, def_id, ty) = composer
@ -546,6 +609,24 @@ impl Nac3 {
            }
        }

+        // Adding top level module definitions
+        for (module_id, (module_name_to_pyid, module_resolver, module_name, module_location)) in
+            module_to_resolver_cache
+        {
+            let def_id = composer
+                .register_top_level_module(
+                    &module_name,
+                    &module_name_to_pyid,
+                    module_resolver,
+                    module_location,
+                )
+                .map_err(|e| {
+                    CompileError::new_err(format!("compilation failed\n----------\n{e}"))
+                })?;
+
+            self.pyid_to_def.write().insert(module_id, def_id);
+        }
+
        let id_fun = PyModule::import(py, "builtins")?.getattr("id")?;
        let mut name_to_pyid: HashMap<StrRef, u64> = HashMap::new();
        let module = PyModule::new(py, "tmp")?;
@ -665,6 +746,9 @@ impl Nac3 {
                            "Unsupported @rpc annotation on global variable",
                        )))
                    }
+                    TopLevelDef::Module { .. } => {
+                        unreachable!("Type module cannot be decorated with @rpc")
+                    }
                }
            }
        }
@ -703,14 +787,18 @@ impl Nac3 {
            let buffer = buffer.as_slice().into();
            membuffer.lock().push(buffer);
        })));
-        let size_t = context
-            .ptr_sized_int_type(&self.get_llvm_target_machine().get_target_data(), None)
-            .get_bit_width();
        let num_threads = if is_multithreaded() { 4 } else { 1 };
        let thread_names: Vec<String> = (0..num_threads).map(|_| "main".to_string()).collect();
        let threads: Vec<_> = thread_names
            .iter()
-            .map(|s| Box::new(ArtiqCodeGenerator::new(s.to_string(), size_t, self.time_fns)))
+            .map(|s| {
+                Box::new(ArtiqCodeGenerator::with_target_machine(
+                    s.to_string(),
+                    &context,
+                    &self.get_llvm_target_machine(),
+                    self.time_fns,
+                ))
+            })
            .collect();

        let membuffer = membuffers.clone();
@ -719,8 +807,13 @@ impl Nac3 {
            let (registry, handles) =
                WorkerRegistry::create_workers(threads, top_level.clone(), &self.llvm_options, &f);

-            let mut generator = ArtiqCodeGenerator::new("main".to_string(), size_t, self.time_fns);
            let context = Context::create();
+            let mut generator = ArtiqCodeGenerator::with_target_machine(
+                "main".to_string(),
+                &context,
+                &self.get_llvm_target_machine(),
+                self.time_fns,
+            );
            let module = context.create_module("main");
            let target_machine = self.llvm_options.create_target_machine().unwrap();
            module.set_data_layout(&target_machine.get_target_data().get_data_layout());
@ -839,52 +932,10 @@ impl Nac3 {
        link_fn(&main)
    }

-    /// Returns the [`TargetTriple`] used for compiling to [isa].
-    fn get_llvm_target_triple(isa: Isa) -> TargetTriple {
-        match isa {
-            Isa::Host => TargetMachine::get_default_triple(),
-            Isa::RiscV32G | Isa::RiscV32IMA => TargetTriple::create("riscv32-unknown-linux"),
-            Isa::CortexA9 => TargetTriple::create("armv7-unknown-linux-gnueabihf"),
-        }
-    }
-
-    /// Returns the [`String`] representing the target CPU used for compiling to [isa].
-    fn get_llvm_target_cpu(isa: Isa) -> String {
-        match isa {
-            Isa::Host => TargetMachine::get_host_cpu_name().to_string(),
-            Isa::RiscV32G | Isa::RiscV32IMA => "generic-rv32".to_string(),
-            Isa::CortexA9 => "cortex-a9".to_string(),
-        }
-    }
-
-    /// Returns the [`String`] representing the target features used for compiling to [isa].
-    fn get_llvm_target_features(isa: Isa) -> String {
-        match isa {
-            Isa::Host => TargetMachine::get_host_cpu_features().to_string(),
-            Isa::RiscV32G => "+a,+m,+f,+d".to_string(),
-            Isa::RiscV32IMA => "+a,+m".to_string(),
-            Isa::CortexA9 => "+dsp,+fp16,+neon,+vfp3,+long-calls".to_string(),
-        }
-    }
-
-    /// Returns an instance of [`CodeGenTargetMachineOptions`] representing the target machine
-    /// options used for compiling to [isa].
-    fn get_llvm_target_options(isa: Isa) -> CodeGenTargetMachineOptions {
-        CodeGenTargetMachineOptions {
-            triple: Nac3::get_llvm_target_triple(isa).as_str().to_string_lossy().into_owned(),
-            cpu: Nac3::get_llvm_target_cpu(isa),
-            features: Nac3::get_llvm_target_features(isa),
-            reloc_mode: RelocMode::PIC,
-            ..CodeGenTargetMachineOptions::from_host()
-        }
-    }
-
    /// Returns an instance of [`TargetMachine`] used in compiling and linking of a program to the
-    /// target [isa].
+    /// target [ISA][isa].
    fn get_llvm_target_machine(&self) -> TargetMachine {
-        Nac3::get_llvm_target_options(self.isa)
-            .create_target_machine(self.llvm_options.opt_level)
-            .expect("couldn't create target machine")
+        self.isa.create_llvm_target_machine(self.llvm_options.opt_level)
    }
 }

@ -992,7 +1043,8 @@ impl Nac3 {
            Isa::RiscV32IMA => &timeline::NOW_PINNING_TIME_FNS,
            Isa::CortexA9 | Isa::Host => &timeline::EXTERN_TIME_FNS,
        };
-        let (primitive, _) = TopLevelComposer::make_primitives(isa.get_size_type());
+        let (primitive, _) =
+            TopLevelComposer::make_primitives(isa.get_size_type(&Context::create()));
        let builtins = vec![
            (
                "now_mu".into(),
@ -1080,6 +1132,7 @@ impl Nac3 {
            tuple: get_attr_id(builtins_mod, "tuple"),
            exception: get_attr_id(builtins_mod, "Exception"),
            option: get_id(artiq_builtins.get_item("Option").ok().flatten().unwrap()),
+            module: get_attr_id(types_mod, "ModuleType"),
        };

        let working_directory = tempfile::Builder::new().prefix("nac3-").tempdir().unwrap();
@ -1141,7 +1194,7 @@ impl Nac3 {
            deferred_eval_store: DeferredEvaluationStore::new(),
            llvm_options: CodeGenLLVMOptions {
                opt_level: OptimizationLevel::Default,
-                target: Nac3::get_llvm_target_options(isa),
+                target: isa.get_llvm_target_options(),
            },
        })
    }
--- a/nac3artiq/src/symbol_resolver.rs
+++ b/nac3artiq/src/symbol_resolver.rs
@ -23,7 +23,7 @@ use nac3core::{
    inkwell::{
        module::Linkage,
        types::{BasicType, BasicTypeEnum},
-        values::BasicValueEnum,
+        values::{BasicValue, BasicValueEnum},
        AddressSpace,
    },
    nac3parser::ast::{self, StrRef},
@ -674,6 +674,48 @@ impl InnerResolver {
            })
        });

+        // check if obj is module
+        if self.helper.id_fn.call1(py, (ty.clone(),))?.extract::<u64>(py)?
+            == self.primitive_ids.module
+            && self.pyid_to_def.read().contains_key(&py_obj_id)
+        {
+            let def_id = self.pyid_to_def.read()[&py_obj_id];
+            let def = defs[def_id.0].read();
+            let TopLevelDef::Module { name: module_name, module_id, attributes, methods, .. } =
+                &*def
+            else {
+                unreachable!("must be a module here");
+            };
+            // Construct the module return type
+            let mut module_attributes = HashMap::new();
+            for (name, _) in attributes {
+                let attribute_obj = obj.getattr(name.to_string().as_str())?;
+                let attribute_ty =
+                    self.get_obj_type(py, attribute_obj, unifier, defs, primitives)?;
+                if let Ok(attribute_ty) = attribute_ty {
+                    module_attributes.insert(*name, (attribute_ty, false));
+                } else {
+                    return Ok(Err(format!("Unable to resolve {module_name}.{name}")));
+                }
+            }
+
+            for name in methods.keys() {
+                let method_obj = obj.getattr(name.to_string().as_str())?;
+                let method_ty = self.get_obj_type(py, method_obj, unifier, defs, primitives)?;
+                if let Ok(method_ty) = method_ty {
+                    module_attributes.insert(*name, (method_ty, true));
+                } else {
+                    return Ok(Err(format!("Unable to resolve {module_name}.{name}")));
+                }
+            }
+
+            let module_ty =
+                TypeEnum::TModule { module_id: *module_id, attributes: module_attributes };
+
+            let ty = unifier.add_ty(module_ty);
+            return Ok(Ok(ty));
+        }
+
        if let Some(ty) = constructor_ty {
            self.pyid_to_type.write().insert(py_obj_id, ty);
            return Ok(Ok(ty));
@ -931,10 +973,13 @@ impl InnerResolver {
                        |_| Ok(Ok(extracted_ty)),
                    )
                } else if unifier.unioned(extracted_ty, primitives.bool) {
-                    obj.extract::<bool>().map_or_else(
-                        |_| Ok(Err(format!("{obj} is not in the range of bool"))),
-                        |_| Ok(Ok(extracted_ty)),
-                    )
+                    if obj.extract::<bool>().is_ok()
+                        || obj.call_method("__bool__", (), None)?.extract::<bool>().is_ok()
+                    {
+                        Ok(Ok(extracted_ty))
+                    } else {
+                        Ok(Err(format!("{obj} is not in the range of bool")))
+                    }
                } else if unifier.unioned(extracted_ty, primitives.float) {
                    obj.extract::<f64>().map_or_else(
                        |_| Ok(Err(format!("{obj} is not in the range of float64"))),
@ -974,10 +1019,14 @@ impl InnerResolver {
            let val: u64 = obj.extract().unwrap();
            self.id_to_primitive.write().insert(id, PrimitiveValue::U64(val));
            Ok(Some(ctx.ctx.i64_type().const_int(val, false).into()))
-        } else if ty_id == self.primitive_ids.bool || ty_id == self.primitive_ids.np_bool_ {
+        } else if ty_id == self.primitive_ids.bool {
            let val: bool = obj.extract().unwrap();
            self.id_to_primitive.write().insert(id, PrimitiveValue::Bool(val));
            Ok(Some(ctx.ctx.i8_type().const_int(u64::from(val), false).into()))
+        } else if ty_id == self.primitive_ids.np_bool_ {
+            let val: bool = obj.call_method("__bool__", (), None)?.extract().unwrap();
+            self.id_to_primitive.write().insert(id, PrimitiveValue::Bool(val));
+            Ok(Some(ctx.ctx.i8_type().const_int(u64::from(val), false).into()))
        } else if ty_id == self.primitive_ids.string || ty_id == self.primitive_ids.np_str_ {
            let val: String = obj.extract().unwrap();
            self.id_to_primitive.write().insert(id, PrimitiveValue::Str(val.clone()));
@ -1000,7 +1049,7 @@ impl InnerResolver {
                }
                _ => unreachable!("must be list"),
            };
-            let size_t = generator.get_size_type(ctx.ctx);
+            let size_t = ctx.get_size_type();
            let ty = if len == 0
                && matches!(&*ctx.unifier.get_ty_immutable(elem_ty), TypeEnum::TVar { .. })
            {
@ -1089,7 +1138,7 @@ impl InnerResolver {

            let llvm_i8 = ctx.ctx.i8_type();
            let llvm_pi8 = llvm_i8.ptr_type(AddressSpace::default());
-            let llvm_usize = generator.get_size_type(ctx.ctx);
+            let llvm_usize = ctx.get_size_type();
            let llvm_ndarray = NDArrayType::from_unifier_type(generator, ctx, ndarray_ty);
            let dtype = llvm_ndarray.element_type();

@ -1107,7 +1156,7 @@ impl InnerResolver {
                self.global_value_ids.write().insert(id, obj.into());
            }

-            let ndims = llvm_ndarray.ndims().unwrap();
+            let ndims = llvm_ndarray.ndims();

            // Obtain the shape of the ndarray
            let shape_tuple: &PyTuple = obj.getattr("shape")?.downcast()?;
@ -1124,7 +1173,10 @@ impl InnerResolver {
                            super::CompileError::new_err(format!("Error getting element {i}: {e}"))
                        })?
                        .unwrap();
-                    let value = value.into_int_value();
+                    let value = ctx
+                        .builder
+                        .build_int_z_extend(value.into_int_value(), llvm_usize, "")
+                        .unwrap();
                    Ok(value)
                })
                .collect::<Result<Vec<_>, PyErr>>()?;
@ -1203,8 +1255,16 @@ impl InnerResolver {
            data_global.set_initializer(&data);

            // Get the constant itemsize.
-            let itemsize = dtype.size_of().unwrap();
-            let itemsize = itemsize.get_zero_extended_constant().unwrap();
+            //
+            // NOTE: dtype.size_of() may return a non-constant, where `TargetData::get_store_size`
+            // will always return a constant size.
+            let itemsize = ctx
+                .registry
+                .llvm_options
+                .create_target_machine()
+                .map(|tm| tm.get_target_data().get_store_size(&dtype))
+                .unwrap();
+            assert_ne!(itemsize, 0);

            // Create the strides needed for ndarray.strides
            let strides = make_contiguous_strides(itemsize, ndims, &shape_u64s);
@ -1214,7 +1274,7 @@ impl InnerResolver {

            // create a global for ndarray.strides and initialize it
            let strides_global = ctx.module.add_global(
-                llvm_i8.array_type(ndims as u32),
+                llvm_usize.array_type(ndims as u32),
                Some(AddressSpace::default()),
                &format!("${id_str}.strides"),
            );
@ -1230,9 +1290,30 @@ impl InnerResolver {

            let ndarray_ndims = llvm_usize.const_int(ndims, false);

+            // calling as_pointer_value on shape and strides returns [i64 x ndims]*
+            // convert into i64* to conform with expected layout of ndarray
+
            let ndarray_shape = shape_global.as_pointer_value();
+            let ndarray_shape = unsafe {
+                ctx.builder
+                    .build_in_bounds_gep(
+                        ndarray_shape,
+                        &[llvm_usize.const_zero(), llvm_usize.const_zero()],
+                        "",
+                    )
+                    .unwrap()
+            };

            let ndarray_strides = strides_global.as_pointer_value();
+            let ndarray_strides = unsafe {
+                ctx.builder
+                    .build_in_bounds_gep(
+                        ndarray_strides,
+                        &[llvm_usize.const_zero(), llvm_usize.const_zero()],
+                        "",
+                    )
+                    .unwrap()
+            };

            let ndarray = llvm_ndarray
                .as_base_type()
@ -1334,6 +1415,77 @@ impl InnerResolver {
                    None => Ok(None),
                }
            }
+        } else if ty_id == self.primitive_ids.module {
+            let id_str = id.to_string();
+
+            if let Some(global) = ctx.module.get_global(&id_str) {
+                return Ok(Some(global.as_pointer_value().into()));
+            }
+
+            let top_level_defs = ctx.top_level.definitions.read();
+            let ty = self
+                .get_obj_type(py, obj, &mut ctx.unifier, &top_level_defs, &ctx.primitives)?
+                .unwrap();
+            let ty = ctx
+                .get_llvm_type(generator, ty)
+                .into_pointer_type()
+                .get_element_type()
+                .into_struct_type();
+
+            {
+                if self.global_value_ids.read().contains_key(&id) {
+                    let global = ctx.module.get_global(&id_str).unwrap_or_else(|| {
+                        ctx.module.add_global(ty, Some(AddressSpace::default()), &id_str)
+                    });
+                    return Ok(Some(global.as_pointer_value().into()));
+                }
+                self.global_value_ids.write().insert(id, obj.into());
+            }
+
+            let fields = {
+                let definition =
+                    top_level_defs.get(self.pyid_to_def.read().get(&id).unwrap().0).unwrap().read();
+                let TopLevelDef::Module { attributes, .. } = &*definition else { unreachable!() };
+                attributes
+                    .iter()
+                    .filter_map(|f| {
+                        let definition = top_level_defs.get(f.1 .0).unwrap().read();
+                        if let TopLevelDef::Variable { ty, .. } = &*definition {
+                            Some((f.0, *ty))
+                        } else {
+                            None
+                        }
+                    })
+                    .collect_vec()
+            };
+
+            let values: Result<Option<Vec<_>>, _> = fields
+                .iter()
+                .map(|(name, ty)| {
+                    self.get_obj_value(
+                        py,
+                        obj.getattr(name.to_string().as_str())?,
+                        ctx,
+                        generator,
+                        *ty,
+                    )
+                    .map_err(|e| {
+                        super::CompileError::new_err(format!("Error getting field {name}: {e}"))
+                    })
+                })
+                .collect();
+            let values = values?;
+
+            if let Some(values) = values {
+                let val = ty.const_named_struct(&values);
+                let global = ctx.module.get_global(&id_str).unwrap_or_else(|| {
+                    ctx.module.add_global(ty, Some(AddressSpace::default()), &id_str)
+                });
+                global.set_initializer(&val);
+                Ok(Some(global.as_pointer_value().into()))
+            } else {
+                Ok(None)
+            }
        } else {
            let id_str = id.to_string();

@ -1413,9 +1565,12 @@ impl InnerResolver {
        } else if ty_id == self.primitive_ids.uint64 {
            let val: u64 = obj.extract()?;
            Ok(SymbolValue::U64(val))
-        } else if ty_id == self.primitive_ids.bool || ty_id == self.primitive_ids.np_bool_ {
+        } else if ty_id == self.primitive_ids.bool {
            let val: bool = obj.extract()?;
            Ok(SymbolValue::Bool(val))
+        } else if ty_id == self.primitive_ids.np_bool_ {
+            let val: bool = obj.call_method("__bool__", (), None)?.extract()?;
+            Ok(SymbolValue::Bool(val))
        } else if ty_id == self.primitive_ids.string || ty_id == self.primitive_ids.np_str_ {
            let val: String = obj.extract()?;
            Ok(SymbolValue::Str(val))
@ -1513,9 +1668,50 @@ impl SymbolResolver for Resolver {
    fn get_symbol_value<'ctx>(
        &self,
        id: StrRef,
-        _: &mut CodeGenContext<'ctx, '_>,
-        _: &mut dyn CodeGenerator,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        generator: &mut dyn CodeGenerator,
    ) -> Option<ValueEnum<'ctx>> {
+        if let Some(def_id) = self.0.id_to_def.read().get(&id) {
+            let top_levels = ctx.top_level.definitions.read();
+            if matches!(&*top_levels[def_id.0].read(), TopLevelDef::Variable { .. }) {
+                let module_val = &self.0.module;
+                let ret = Python::with_gil(|py| -> PyResult<Result<BasicValueEnum, String>> {
+                    let module_val = module_val.as_ref(py);
+
+                    let ty = self.0.get_obj_type(
+                        py,
+                        module_val,
+                        &mut ctx.unifier,
+                        &top_levels,
+                        &ctx.primitives,
+                    )?;
+                    if let Err(ty) = ty {
+                        return Ok(Err(ty));
+                    }
+                    let ty = ty.unwrap();
+                    let obj = self.0.get_obj_value(py, module_val, ctx, generator, ty)?.unwrap();
+                    let (idx, _) = ctx.get_attr_index(ty, id);
+                    let ret = unsafe {
+                        ctx.builder.build_gep(
+                            obj.into_pointer_value(),
+                            &[
+                                ctx.ctx.i32_type().const_zero(),
+                                ctx.ctx.i32_type().const_int(idx as u64, false),
+                            ],
+                            id.to_string().as_str(),
+                        )
+                    }
+                    .unwrap();
+                    Ok(Ok(ret.as_basic_value_enum()))
+                })
+                .unwrap();
+                if ret.is_err() {
+                    return None;
+                }
+                return Some(ret.unwrap().into());
+            }
+        }
+
        let sym_value = {
            let id_to_val = self.0.id_to_pyval.read();
            id_to_val.get(&id).cloned()
--- a/nac3core/irrt/irrt.cpp
+++ b/nac3core/irrt/irrt.cpp
@ -1,10 +1,15 @@
 #include "irrt/exception.hpp"
 #include "irrt/list.hpp"
 #include "irrt/math.hpp"
-#include "irrt/ndarray.hpp"
 #include "irrt/range.hpp"
 #include "irrt/slice.hpp"
+#include "irrt/string.hpp"
 #include "irrt/ndarray/basic.hpp"
 #include "irrt/ndarray/def.hpp"
 #include "irrt/ndarray/iter.hpp"
 #include "irrt/ndarray/indexing.hpp"
+#include "irrt/ndarray/array.hpp"
+#include "irrt/ndarray/reshape.hpp"
+#include "irrt/ndarray/broadcast.hpp"
+#include "irrt/ndarray/transpose.hpp"
+#include "irrt/ndarray/matmul.hpp"
--- a/nac3core/irrt/irrt/int_types.hpp
+++ b/nac3core/irrt/irrt/int_types.hpp
@ -21,7 +21,5 @@ using uint64_t = unsigned _ExtInt(64);

 #endif

-// NDArray indices are always `uint32_t`.
-using NDIndexInt = uint32_t;
 // The type of an index or a value describing the length of a range/slice is always `int32_t`.
 using SliceIndex = int32_t;
--- a/nac3core/irrt/irrt/list.hpp
+++ b/nac3core/irrt/irrt/list.hpp
@ -2,6 +2,21 @@

 #include "irrt/int_types.hpp"
 #include "irrt/math_util.hpp"
+#include "irrt/slice.hpp"
+
+namespace {
+/**
+ * @brief A list in NAC3.
+ *
+ * The `items` field is opaque. You must rely on external contexts to
+ * know how to interpret it.
+ */
+template<typename SizeT>
+struct List {
+    uint8_t* items;
+    SizeT len;
+};
+}  // namespace

 extern "C" {
 // Handle list assignment and dropping part of the list when
--- a/nac3core/irrt/irrt/math.hpp
+++ b/nac3core/irrt/irrt/math.hpp
@ -1,5 +1,7 @@
 #pragma once

+#include "irrt/int_types.hpp"
+
 namespace {
 // adapted from GNU Scientific Library: https://git.savannah.gnu.org/cgit/gsl.git/tree/sys/pow_int.c
 // need to make sure `exp >= 0` before calling this function
--- a/nac3core/irrt/irrt/ndarray.hpp
+++ b/nac3core/irrt/irrt/ndarray.hpp
@ -1,151 +0,0 @@
-#pragma once
-
-#include "irrt/int_types.hpp"
-
-// TODO: To be deleted since NDArray with strides is done.
-
-namespace {
-template<typename SizeT>
-SizeT __nac3_ndarray_calc_size_impl(const SizeT* list_data, SizeT list_len, SizeT begin_idx, SizeT end_idx) {
-    __builtin_assume(end_idx <= list_len);
-
-    SizeT num_elems = 1;
-    for (SizeT i = begin_idx; i < end_idx; ++i) {
-        SizeT val = list_data[i];
-        __builtin_assume(val > 0);
-        num_elems *= val;
-    }
-    return num_elems;
-}
-
-template<typename SizeT>
-void __nac3_ndarray_calc_nd_indices_impl(SizeT index, const SizeT* dims, SizeT num_dims, NDIndexInt* idxs) {
-    SizeT stride = 1;
-    for (SizeT dim = 0; dim < num_dims; dim++) {
-        SizeT i = num_dims - dim - 1;
-        __builtin_assume(dims[i] > 0);
-        idxs[i] = (index / stride) % dims[i];
-        stride *= dims[i];
-    }
-}
-
-template<typename SizeT>
-SizeT __nac3_ndarray_flatten_index_impl(const SizeT* dims,
-                                        SizeT num_dims,
-                                        const NDIndexInt* indices,
-                                        SizeT num_indices) {
-    SizeT idx = 0;
-    SizeT stride = 1;
-    for (SizeT i = 0; i < num_dims; ++i) {
-        SizeT ri = num_dims - i - 1;
-        if (ri < num_indices) {
-            idx += stride * indices[ri];
-        }
-
-        __builtin_assume(dims[i] > 0);
-        stride *= dims[ri];
-    }
-    return idx;
-}
-
-template<typename SizeT>
-void __nac3_ndarray_calc_broadcast_impl(const SizeT* lhs_dims,
-                                        SizeT lhs_ndims,
-                                        const SizeT* rhs_dims,
-                                        SizeT rhs_ndims,
-                                        SizeT* out_dims) {
-    SizeT max_ndims = lhs_ndims > rhs_ndims ? lhs_ndims : rhs_ndims;
-
-    for (SizeT i = 0; i < max_ndims; ++i) {
-        const SizeT* lhs_dim_sz = i < lhs_ndims ? &lhs_dims[lhs_ndims - i - 1] : nullptr;
-        const SizeT* rhs_dim_sz = i < rhs_ndims ? &rhs_dims[rhs_ndims - i - 1] : nullptr;
-        SizeT* out_dim = &out_dims[max_ndims - i - 1];
-
-        if (lhs_dim_sz == nullptr) {
-            *out_dim = *rhs_dim_sz;
-        } else if (rhs_dim_sz == nullptr) {
-            *out_dim = *lhs_dim_sz;
-        } else if (*lhs_dim_sz == 1) {
-            *out_dim = *rhs_dim_sz;
-        } else if (*rhs_dim_sz == 1) {
-            *out_dim = *lhs_dim_sz;
-        } else if (*lhs_dim_sz == *rhs_dim_sz) {
-            *out_dim = *lhs_dim_sz;
-        } else {
-            __builtin_unreachable();
-        }
-    }
-}
-
-template<typename SizeT>
-void __nac3_ndarray_calc_broadcast_idx_impl(const SizeT* src_dims,
-                                            SizeT src_ndims,
-                                            const NDIndexInt* in_idx,
-                                            NDIndexInt* out_idx) {
-    for (SizeT i = 0; i < src_ndims; ++i) {
-        SizeT src_i = src_ndims - i - 1;
-        out_idx[src_i] = src_dims[src_i] == 1 ? 0 : in_idx[src_i];
-    }
-}
-}  // namespace
-
-extern "C" {
-uint32_t __nac3_ndarray_calc_size(const uint32_t* list_data, uint32_t list_len, uint32_t begin_idx, uint32_t end_idx) {
-    return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
-}
-
-uint64_t
-__nac3_ndarray_calc_size64(const uint64_t* list_data, uint64_t list_len, uint64_t begin_idx, uint64_t end_idx) {
-    return __nac3_ndarray_calc_size_impl(list_data, list_len, begin_idx, end_idx);
-}
-
-void __nac3_ndarray_calc_nd_indices(uint32_t index, const uint32_t* dims, uint32_t num_dims, NDIndexInt* idxs) {
-    __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
-}
-
-void __nac3_ndarray_calc_nd_indices64(uint64_t index, const uint64_t* dims, uint64_t num_dims, NDIndexInt* idxs) {
-    __nac3_ndarray_calc_nd_indices_impl(index, dims, num_dims, idxs);
-}
-
-uint32_t
-__nac3_ndarray_flatten_index(const uint32_t* dims, uint32_t num_dims, const NDIndexInt* indices, uint32_t num_indices) {
-    return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
-}
-
-uint64_t __nac3_ndarray_flatten_index64(const uint64_t* dims,
-                                        uint64_t num_dims,
-                                        const NDIndexInt* indices,
-                                        uint64_t num_indices) {
-    return __nac3_ndarray_flatten_index_impl(dims, num_dims, indices, num_indices);
-}
-
-void __nac3_ndarray_calc_broadcast(const uint32_t* lhs_dims,
-                                   uint32_t lhs_ndims,
-                                   const uint32_t* rhs_dims,
-                                   uint32_t rhs_ndims,
-                                   uint32_t* out_dims) {
-    return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
-}
-
-void __nac3_ndarray_calc_broadcast64(const uint64_t* lhs_dims,
-                                     uint64_t lhs_ndims,
-                                     const uint64_t* rhs_dims,
-                                     uint64_t rhs_ndims,
-                                     uint64_t* out_dims) {
-    return __nac3_ndarray_calc_broadcast_impl(lhs_dims, lhs_ndims, rhs_dims, rhs_ndims, out_dims);
-}
-
-void __nac3_ndarray_calc_broadcast_idx(const uint32_t* src_dims,
-                                       uint32_t src_ndims,
-                                       const NDIndexInt* in_idx,
-                                       NDIndexInt* out_idx) {
-    __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
-}
-
-void __nac3_ndarray_calc_broadcast_idx64(const uint64_t* src_dims,
-                                         uint64_t src_ndims,
-                                         const NDIndexInt* in_idx,
-                                         NDIndexInt* out_idx) {
-    __nac3_ndarray_calc_broadcast_idx_impl(src_dims, src_ndims, in_idx, out_idx);
-}
-}  // namespace
--- a/nac3core/irrt/irrt/ndarray/array.hpp
+++ b/nac3core/irrt/irrt/ndarray/array.hpp
@ -0,0 +1,132 @@
+#pragma once
+
+#include "irrt/debug.hpp"
+#include "irrt/exception.hpp"
+#include "irrt/int_types.hpp"
+#include "irrt/list.hpp"
+#include "irrt/ndarray/basic.hpp"
+#include "irrt/ndarray/def.hpp"
+
+namespace {
+namespace ndarray::array {
+/**
+ * @brief In the context of `np.array(<list>)`, deduce the ndarray's shape produced by `<list>` and raise
+ * an exception if there is anything wrong with `<shape>` (e.g., inconsistent dimensions `np.array([[1.0, 2.0],
+ * [3.0]])`)
+ *
+ * If this function finds no issues with `<list>`, the deduced shape is written to `shape`. The caller has the
+ * responsibility to allocate `[SizeT; ndims]` for `shape`. The caller must also initialize `shape` with `-1`s because
+ * of implementation details.
+ */
+template<typename SizeT>
+void set_and_validate_list_shape_helper(SizeT axis, List<SizeT>* list, SizeT ndims, SizeT* shape) {
+    if (shape[axis] == -1) {
+        // Dimension is unspecified. Set it.
+        shape[axis] = list->len;
+    } else {
+        // Dimension is specified. Check.
+        if (shape[axis] != list->len) {
+            // Mismatch, throw an error.
+            // NOTE: NumPy's error message is more complex and needs more PARAMS to display.
+            raise_exception(SizeT, EXN_VALUE_ERROR,
+                            "The requested array has an inhomogenous shape "
+                            "after {0} dimension(s).",
+                            axis, shape[axis], list->len);
+        }
+    }
+
+    if (axis + 1 == ndims) {
+        // `list` has type `list[ItemType]`
+        // Do nothing
+    } else {
+        // `list` has type `list[list[...]]`
+        List<SizeT>** lists = (List<SizeT>**)(list->items);
+        for (SizeT i = 0; i < list->len; i++) {
+            set_and_validate_list_shape_helper<SizeT>(axis + 1, lists[i], ndims, shape);
+        }
+    }
+}
+
+/**
+ * @brief See `set_and_validate_list_shape_helper`.
+ */
+template<typename SizeT>
+void set_and_validate_list_shape(List<SizeT>* list, SizeT ndims, SizeT* shape) {
+    for (SizeT axis = 0; axis < ndims; axis++) {
+        shape[axis] = -1;  // Sentinel to say this dimension is unspecified.
+    }
+    set_and_validate_list_shape_helper<SizeT>(0, list, ndims, shape);
+}
+
+/**
+ * @brief In the context of `np.array(<list>)`, copied the contents stored in `list` to `ndarray`.
+ *
+ * `list` is assumed to be "legal". (i.e., no inconsistent dimensions)
+ *
+ * # Notes on `ndarray`
+ * The caller is responsible for allocating space for `ndarray`.
+ * Here is what this function expects from `ndarray` when called:
+ *   - `ndarray->data` has to be allocated, contiguous, and may contain uninitialized values.
+ *   - `ndarray->itemsize` has to be initialized.
+ *   - `ndarray->ndims` has to be initialized.
+ *   - `ndarray->shape` has to be initialized.
+ *   - `ndarray->strides` is ignored, but note that `ndarray->data` is contiguous.
+ * When this function call ends:
+ *   - `ndarray->data` is written with contents from `<list>`.
+ */
+template<typename SizeT>
+void write_list_to_array_helper(SizeT axis, SizeT* index, List<SizeT>* list, NDArray<SizeT>* ndarray) {
+    debug_assert_eq(SizeT, list->len, ndarray->shape[axis]);
+    if (IRRT_DEBUG_ASSERT_BOOL) {
+        if (!ndarray::basic::is_c_contiguous(ndarray)) {
+            raise_debug_assert(SizeT, "ndarray is not C-contiguous", ndarray->strides[0], ndarray->strides[1],
+                               NO_PARAM);
+        }
+    }
+
+    if (axis + 1 == ndarray->ndims) {
+        // `list` has type `list[scalar]`
+        // `ndarray` is contiguous, so we can do this, and this is fast.
+        uint8_t* dst = static_cast<uint8_t*>(ndarray->data) + (ndarray->itemsize * (*index));
+        __builtin_memcpy(dst, list->items, ndarray->itemsize * list->len);
+        *index += list->len;
+    } else {
+        // `list` has type `list[list[...]]`
+        List<SizeT>** lists = (List<SizeT>**)(list->items);
+
+        for (SizeT i = 0; i < list->len; i++) {
+            write_list_to_array_helper<SizeT>(axis + 1, index, lists[i], ndarray);
+        }
+    }
+}
+
+/**
+ * @brief See `write_list_to_array_helper`.
+ */
+template<typename SizeT>
+void write_list_to_array(List<SizeT>* list, NDArray<SizeT>* ndarray) {
+    SizeT index = 0;
+    write_list_to_array_helper<SizeT>((SizeT)0, &index, list, ndarray);
+}
+}  // namespace ndarray::array
+}  // namespace
+
+extern "C" {
+using namespace ndarray::array;
+
+void __nac3_ndarray_array_set_and_validate_list_shape(List<int32_t>* list, int32_t ndims, int32_t* shape) {
+    set_and_validate_list_shape(list, ndims, shape);
+}
+
+void __nac3_ndarray_array_set_and_validate_list_shape64(List<int64_t>* list, int64_t ndims, int64_t* shape) {
+    set_and_validate_list_shape(list, ndims, shape);
+}
+
+void __nac3_ndarray_array_write_list_to_array(List<int32_t>* list, NDArray<int32_t>* ndarray) {
+    write_list_to_array(list, ndarray);
+}
+
+void __nac3_ndarray_array_write_list_to_array64(List<int64_t>* list, NDArray<int64_t>* ndarray) {
+    write_list_to_array(list, ndarray);
+}
+}
--- a/nac3core/irrt/irrt/ndarray/basic.hpp
+++ b/nac3core/irrt/irrt/ndarray/basic.hpp
@ -6,8 +6,7 @@
 #include "irrt/ndarray/def.hpp"

 namespace {
-namespace ndarray {
-namespace basic {
+namespace ndarray::basic {
 /**
 * @brief Assert that `shape` does not contain negative dimensions.
 *
@ -247,8 +246,7 @@ void copy_data(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray) {
        ndarray::basic::set_pelement_value(dst_ndarray, dst_element, src_element);
    }
 }
-}  // namespace basic
-}  // namespace ndarray
+}  // namespace ndarray::basic
 }  // namespace

 extern "C" {
--- a/nac3core/irrt/irrt/ndarray/broadcast.hpp
+++ b/nac3core/irrt/irrt/ndarray/broadcast.hpp
@ -0,0 +1,165 @@
+#pragma once
+
+#include "irrt/int_types.hpp"
+#include "irrt/ndarray/def.hpp"
+#include "irrt/slice.hpp"
+
+namespace {
+template<typename SizeT>
+struct ShapeEntry {
+    SizeT ndims;
+    SizeT* shape;
+};
+}  // namespace
+
+namespace {
+namespace ndarray::broadcast {
+/**
+ * @brief Return true if `src_shape` can broadcast to `dst_shape`.
+ *
+ * See https://numpy.org/doc/stable/user/basics.broadcasting.html
+ */
+template<typename SizeT>
+bool can_broadcast_shape_to(SizeT target_ndims, const SizeT* target_shape, SizeT src_ndims, const SizeT* src_shape) {
+    if (src_ndims > target_ndims) {
+        return false;
+    }
+
+    for (SizeT i = 0; i < src_ndims; i++) {
+        SizeT target_dim = target_shape[target_ndims - i - 1];
+        SizeT src_dim = src_shape[src_ndims - i - 1];
+        if (!(src_dim == 1 || target_dim == src_dim)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * @brief Performs `np.broadcast_shapes(<shapes>)`
+ *
+ * @param num_shapes Number of entries in `shapes`
+ * @param shapes The list of shape to do `np.broadcast_shapes` on.
+ * @param dst_ndims The length of `dst_shape`.
+ *   `dst_ndims` must be `max([shape.ndims for shape in shapes])`, but the caller has to calculate it/provide it.
+ *   for this function since they should already know in order to allocate `dst_shape` in the first place.
+ * @param dst_shape The resulting shape. Must be pre-allocated by the caller. This function calculate the result
+ *   of `np.broadcast_shapes` and write it here.
+ */
+template<typename SizeT>
+void broadcast_shapes(SizeT num_shapes, const ShapeEntry<SizeT>* shapes, SizeT dst_ndims, SizeT* dst_shape) {
+    for (SizeT dst_axis = 0; dst_axis < dst_ndims; dst_axis++) {
+        dst_shape[dst_axis] = 1;
+    }
+
+#ifdef IRRT_DEBUG_ASSERT
+    SizeT max_ndims_found = 0;
+#endif
+
+    for (SizeT i = 0; i < num_shapes; i++) {
+        ShapeEntry<SizeT> entry = shapes[i];
+
+        // Check pre-condition: `dst_ndims` must be `max([shape.ndims for shape in shapes])`
+        debug_assert(SizeT, entry.ndims <= dst_ndims);
+
+#ifdef IRRT_DEBUG_ASSERT
+        max_ndims_found = max(max_ndims_found, entry.ndims);
+#endif
+
+        for (SizeT j = 0; j < entry.ndims; j++) {
+            SizeT entry_axis = entry.ndims - j - 1;
+            SizeT dst_axis = dst_ndims - j - 1;
+
+            SizeT entry_dim = entry.shape[entry_axis];
+            SizeT dst_dim = dst_shape[dst_axis];
+
+            if (dst_dim == 1) {
+                dst_shape[dst_axis] = entry_dim;
+            } else if (entry_dim == 1 || entry_dim == dst_dim) {
+                // Do nothing
+            } else {
+                raise_exception(SizeT, EXN_VALUE_ERROR,
+                                "shape mismatch: objects cannot be broadcast "
+                                "to a single shape.",
+                                NO_PARAM, NO_PARAM, NO_PARAM);
+            }
+        }
+    }
+
+#ifdef IRRT_DEBUG_ASSERT
+    // Check pre-condition: `dst_ndims` must be `max([shape.ndims for shape in shapes])`
+    debug_assert_eq(SizeT, max_ndims_found, dst_ndims);
+#endif
+}
+
+/**
+ * @brief Perform `np.broadcast_to(<ndarray>, <target_shape>)` and appropriate assertions.
+ *
+ * This function attempts to broadcast `src_ndarray` to a new shape defined by `dst_ndarray.shape`,
+ * and return the result by modifying `dst_ndarray`.
+ *
+ * # Notes on `dst_ndarray`
+ * The caller is responsible for allocating space for the resulting ndarray.
+ * Here is what this function expects from `dst_ndarray` when called:
+ *   - `dst_ndarray->data` does not have to be initialized.
+ *   - `dst_ndarray->itemsize` does not have to be initialized.
+ *   - `dst_ndarray->ndims` must be initialized, determining the length of `dst_ndarray->shape`
+ *   - `dst_ndarray->shape` must be allocated, and must contain the desired target broadcast shape.
+ *   - `dst_ndarray->strides` must be allocated, through it can contain uninitialized values.
+ * When this function call ends:
+ *   - `dst_ndarray->data` is set to `src_ndarray->data` (`dst_ndarray` is just a view to `src_ndarray`)
+ *   - `dst_ndarray->itemsize` is set to `src_ndarray->itemsize`
+ *   - `dst_ndarray->ndims` is unchanged.
+ *   - `dst_ndarray->shape` is unchanged.
+ *   - `dst_ndarray->strides` is updated accordingly by how ndarray broadcast_to works.
+ */
+template<typename SizeT>
+void broadcast_to(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray) {
+    if (!ndarray::broadcast::can_broadcast_shape_to(dst_ndarray->ndims, dst_ndarray->shape, src_ndarray->ndims,
+                                                    src_ndarray->shape)) {
+        raise_exception(SizeT, EXN_VALUE_ERROR, "operands could not be broadcast together", NO_PARAM, NO_PARAM,
+                        NO_PARAM);
+    }
+
+    dst_ndarray->data = src_ndarray->data;
+    dst_ndarray->itemsize = src_ndarray->itemsize;
+
+    for (SizeT i = 0; i < dst_ndarray->ndims; i++) {
+        SizeT src_axis = src_ndarray->ndims - i - 1;
+        SizeT dst_axis = dst_ndarray->ndims - i - 1;
+        if (src_axis < 0 || (src_ndarray->shape[src_axis] == 1 && dst_ndarray->shape[dst_axis] != 1)) {
+            // Freeze the steps in-place
+            dst_ndarray->strides[dst_axis] = 0;
+        } else {
+            dst_ndarray->strides[dst_axis] = src_ndarray->strides[src_axis];
+        }
+    }
+}
+}  // namespace ndarray::broadcast
+}  // namespace
+
+extern "C" {
+using namespace ndarray::broadcast;
+
+void __nac3_ndarray_broadcast_to(NDArray<int32_t>* src_ndarray, NDArray<int32_t>* dst_ndarray) {
+    broadcast_to(src_ndarray, dst_ndarray);
+}
+
+void __nac3_ndarray_broadcast_to64(NDArray<int64_t>* src_ndarray, NDArray<int64_t>* dst_ndarray) {
+    broadcast_to(src_ndarray, dst_ndarray);
+}
+
+void __nac3_ndarray_broadcast_shapes(int32_t num_shapes,
+                                     const ShapeEntry<int32_t>* shapes,
+                                     int32_t dst_ndims,
+                                     int32_t* dst_shape) {
+    broadcast_shapes(num_shapes, shapes, dst_ndims, dst_shape);
+}
+
+void __nac3_ndarray_broadcast_shapes64(int64_t num_shapes,
+                                       const ShapeEntry<int64_t>* shapes,
+                                       int64_t dst_ndims,
+                                       int64_t* dst_shape) {
+    broadcast_shapes(num_shapes, shapes, dst_ndims, dst_shape);
+}
+}
--- a/nac3core/irrt/irrt/ndarray/indexing.hpp
+++ b/nac3core/irrt/irrt/ndarray/indexing.hpp
@ -65,8 +65,7 @@ struct NDIndex {
 }  // namespace

 namespace {
-namespace ndarray {
-namespace indexing {
+namespace ndarray::indexing {
 /**
 * @brief Perform ndarray "basic indexing" (https://numpy.org/doc/stable/user/basics.indexing.html#basic-indexing)
 *
@ -162,7 +161,8 @@ void index(SizeT num_indices, const NDIndex* indices, const NDArray<SizeT>* src_

            Range<int32_t> range = slice->indices_checked<SizeT>(src_ndarray->shape[src_axis]);

-            dst_ndarray->data = static_cast<uint8_t*>(dst_ndarray->data) + (SizeT)range.start * src_ndarray->strides[src_axis];
+            dst_ndarray->data =
+                static_cast<uint8_t*>(dst_ndarray->data) + (SizeT)range.start * src_ndarray->strides[src_axis];
            dst_ndarray->strides[dst_axis] = ((SizeT)range.step) * src_ndarray->strides[src_axis];
            dst_ndarray->shape[dst_axis] = (SizeT)range.len<SizeT>();

@ -197,8 +197,7 @@ void index(SizeT num_indices, const NDIndex* indices, const NDArray<SizeT>* src_
    debug_assert_eq(SizeT, src_ndarray->ndims, src_axis);
    debug_assert_eq(SizeT, dst_ndarray->ndims, dst_axis);
 }
-}  // namespace indexing
-}  // namespace ndarray
+}  // namespace ndarray::indexing
 }  // namespace

 extern "C" {
--- a/nac3core/irrt/irrt/ndarray/matmul.hpp
+++ b/nac3core/irrt/irrt/ndarray/matmul.hpp
@ -0,0 +1,98 @@
+#pragma once
+
+#include "irrt/debug.hpp"
+#include "irrt/exception.hpp"
+#include "irrt/int_types.hpp"
+#include "irrt/ndarray/basic.hpp"
+#include "irrt/ndarray/broadcast.hpp"
+#include "irrt/ndarray/iter.hpp"
+
+// NOTE: Everything would be much easier and elegant if einsum is implemented.
+
+namespace {
+namespace ndarray::matmul {
+
+/**
+ * @brief Perform the broadcast in `np.einsum("...ij,...jk->...ik", a, b)`.
+ *
+ * Example:
+ *   Suppose      `a_shape ==      [1, 97, 4, 2]`
+ *       and      `b_shape == [99, 98,  1, 2, 5]`,
+ *
+ *   ...then  `new_a_shape == [99, 98, 97, 4, 2]`,
+ *            `new_b_shape == [99, 98, 97, 2, 5]`,
+ *      and     `dst_shape == [99, 98, 97, 4, 5]`.
+ *                             ^^^^^^^^^^  ^^^^
+ *                          (broadcasted)  (4x2 @ 2x5 => 4x5)
+ *
+ * @param a_ndims Length of `a_shape`.
+ * @param a_shape Shape of `a`.
+ * @param b_ndims Length of `b_shape`.
+ * @param b_shape Shape of `b`.
+ * @param final_ndims Should be equal to `max(a_ndims, b_ndims)`. This is the length of `new_a_shape`,
+ * `new_b_shape`, and `dst_shape` - the number of dimensions after broadcasting.
+ */
+template<typename SizeT>
+void calculate_shapes(SizeT a_ndims,
+                      SizeT* a_shape,
+                      SizeT b_ndims,
+                      SizeT* b_shape,
+                      SizeT final_ndims,
+                      SizeT* new_a_shape,
+                      SizeT* new_b_shape,
+                      SizeT* dst_shape) {
+    debug_assert(SizeT, a_ndims >= 2);
+    debug_assert(SizeT, b_ndims >= 2);
+    debug_assert_eq(SizeT, max(a_ndims, b_ndims), final_ndims);
+
+    // Check that a and b are compatible for matmul
+    if (a_shape[a_ndims - 1] != b_shape[b_ndims - 2]) {
+        // This is a custom error message. Different from NumPy.
+        raise_exception(SizeT, EXN_VALUE_ERROR, "Cannot multiply LHS (shape ?x{0}) with RHS (shape {1}x?})",
+                        a_shape[a_ndims - 1], b_shape[b_ndims - 2], NO_PARAM);
+    }
+
+    const SizeT num_entries = 2;
+    ShapeEntry<SizeT> entries[num_entries] = {{.ndims = a_ndims - 2, .shape = a_shape},
+                                              {.ndims = b_ndims - 2, .shape = b_shape}};
+
+    // TODO: Optimize this
+    ndarray::broadcast::broadcast_shapes<SizeT>(num_entries, entries, final_ndims - 2, new_a_shape);
+    ndarray::broadcast::broadcast_shapes<SizeT>(num_entries, entries, final_ndims - 2, new_b_shape);
+    ndarray::broadcast::broadcast_shapes<SizeT>(num_entries, entries, final_ndims - 2, dst_shape);
+
+    new_a_shape[final_ndims - 2] = a_shape[a_ndims - 2];
+    new_a_shape[final_ndims - 1] = a_shape[a_ndims - 1];
+    new_b_shape[final_ndims - 2] = b_shape[b_ndims - 2];
+    new_b_shape[final_ndims - 1] = b_shape[b_ndims - 1];
+    dst_shape[final_ndims - 2] = a_shape[a_ndims - 2];
+    dst_shape[final_ndims - 1] = b_shape[b_ndims - 1];
+}
+}  // namespace ndarray::matmul
+}  // namespace
+
+extern "C" {
+using namespace ndarray::matmul;
+
+void __nac3_ndarray_matmul_calculate_shapes(int32_t a_ndims,
+                                            int32_t* a_shape,
+                                            int32_t b_ndims,
+                                            int32_t* b_shape,
+                                            int32_t final_ndims,
+                                            int32_t* new_a_shape,
+                                            int32_t* new_b_shape,
+                                            int32_t* dst_shape) {
+    calculate_shapes(a_ndims, a_shape, b_ndims, b_shape, final_ndims, new_a_shape, new_b_shape, dst_shape);
+}
+
+void __nac3_ndarray_matmul_calculate_shapes64(int64_t a_ndims,
+                                              int64_t* a_shape,
+                                              int64_t b_ndims,
+                                              int64_t* b_shape,
+                                              int64_t final_ndims,
+                                              int64_t* new_a_shape,
+                                              int64_t* new_b_shape,
+                                              int64_t* dst_shape) {
+    calculate_shapes(a_ndims, a_shape, b_ndims, b_shape, final_ndims, new_a_shape, new_b_shape, dst_shape);
+}
+}
--- a/nac3core/irrt/irrt/ndarray/reshape.hpp
+++ b/nac3core/irrt/irrt/ndarray/reshape.hpp
@ -0,0 +1,97 @@
+#pragma once
+
+#include "irrt/exception.hpp"
+#include "irrt/int_types.hpp"
+#include "irrt/ndarray/def.hpp"
+
+namespace {
+namespace ndarray::reshape {
+/**
+ * @brief Perform assertions on and resolve unknown dimensions in `new_shape` in `np.reshape(<ndarray>, new_shape)`
+ *
+ * If `new_shape` indeed contains unknown dimensions (specified with `-1`, just like numpy), `new_shape` will be
+ * modified to contain the resolved dimension.
+ *
+ * To perform assertions on and resolve unknown dimensions in `new_shape`, we don't need the actual
+ * `<ndarray>` object itself, but only the `.size` of the `<ndarray>`.
+ *
+ * @param size The `.size` of `<ndarray>`
+ * @param new_ndims Number of elements in `new_shape`
+ * @param new_shape Target shape to reshape to
+ */
+template<typename SizeT>
+void resolve_and_check_new_shape(SizeT size, SizeT new_ndims, SizeT* new_shape) {
+    // Is there a -1 in `new_shape`?
+    bool neg1_exists = false;
+    // Location of -1, only initialized if `neg1_exists` is true
+    SizeT neg1_axis_i;
+    // The computed ndarray size of `new_shape`
+    SizeT new_size = 1;
+
+    for (SizeT axis_i = 0; axis_i < new_ndims; axis_i++) {
+        SizeT dim = new_shape[axis_i];
+        if (dim < 0) {
+            if (dim == -1) {
+                if (neg1_exists) {
+                    // Multiple `-1` found. Throw an error.
+                    raise_exception(SizeT, EXN_VALUE_ERROR, "can only specify one unknown dimension", NO_PARAM,
+                                    NO_PARAM, NO_PARAM);
+                } else {
+                    neg1_exists = true;
+                    neg1_axis_i = axis_i;
+                }
+            } else {
+                // TODO: What? In `np.reshape` any negative dimensions is
+                // treated like its `-1`.
+                //
+                // Try running `np.zeros((3, 4)).reshape((-999, 2))`
+                //
+                // It is not documented by numpy.
+                // Throw an error for now...
+
+                raise_exception(SizeT, EXN_VALUE_ERROR, "Found non -1 negative dimension {0} on axis {1}", dim, axis_i,
+                                NO_PARAM);
+            }
+        } else {
+            new_size *= dim;
+        }
+    }
+
+    bool can_reshape;
+    if (neg1_exists) {
+        // Let `x` be the unknown dimension
+        // Solve `x * <new_size> = <size>`
+        if (new_size == 0 && size == 0) {
+            // `x` has infinitely many solutions
+            can_reshape = false;
+        } else if (new_size == 0 && size != 0) {
+            // `x` has no solutions
+            can_reshape = false;
+        } else if (size % new_size != 0) {
+            // `x` has no integer solutions
+            can_reshape = false;
+        } else {
+            can_reshape = true;
+            new_shape[neg1_axis_i] = size / new_size;  // Resolve dimension
+        }
+    } else {
+        can_reshape = (new_size == size);
+    }
+
+    if (!can_reshape) {
+        raise_exception(SizeT, EXN_VALUE_ERROR, "cannot reshape array of size {0} into given shape", size, NO_PARAM,
+                        NO_PARAM);
+    }
+}
+}  // namespace ndarray::reshape
+}  // namespace
+
+extern "C" {
+void __nac3_ndarray_reshape_resolve_and_check_new_shape(int32_t size, int32_t new_ndims, int32_t* new_shape) {
+    ndarray::reshape::resolve_and_check_new_shape(size, new_ndims, new_shape);
+}
+
+void __nac3_ndarray_reshape_resolve_and_check_new_shape64(int64_t size, int64_t new_ndims, int64_t* new_shape) {
+    ndarray::reshape::resolve_and_check_new_shape(size, new_ndims, new_shape);
+}
+}
--- a/nac3core/irrt/irrt/ndarray/transpose.hpp
+++ b/nac3core/irrt/irrt/ndarray/transpose.hpp
@ -0,0 +1,143 @@
+#pragma once
+
+#include "irrt/debug.hpp"
+#include "irrt/exception.hpp"
+#include "irrt/int_types.hpp"
+#include "irrt/ndarray/def.hpp"
+#include "irrt/slice.hpp"
+
+/*
+ * Notes on `np.transpose(<array>, <axes>)`
+ *
+ * TODO: `axes`, if specified, can actually contain negative indices,
+ * but it is not documented in numpy.
+ *
+ * Supporting it for now.
+ */
+
+namespace {
+namespace ndarray::transpose {
+/**
+ * @brief Do assertions on `<axes>` in `np.transpose(<array>, <axes>)`.
+ *
+ * Note that `np.transpose`'s `<axe>` argument is optional. If the argument
+ * is specified but the user, use this function to do assertions on it.
+ *
+ * @param ndims The number of dimensions of `<array>`
+ * @param num_axes Number of elements in `<axes>` as specified by the user.
+ *   This should be equal to `ndims`. If not, a "ValueError: axes don't match array" is thrown.
+ * @param axes The user specified `<axes>`.
+ */
+template<typename SizeT>
+void assert_transpose_axes(SizeT ndims, SizeT num_axes, const SizeT* axes) {
+    if (ndims != num_axes) {
+        raise_exception(SizeT, EXN_VALUE_ERROR, "axes don't match array", NO_PARAM, NO_PARAM, NO_PARAM);
+    }
+
+    // TODO: Optimize this
+    bool* axe_specified = (bool*)__builtin_alloca(sizeof(bool) * ndims);
+    for (SizeT i = 0; i < ndims; i++)
+        axe_specified[i] = false;
+
+    for (SizeT i = 0; i < ndims; i++) {
+        SizeT axis = slice::resolve_index_in_length(ndims, axes[i]);
+        if (axis == -1) {
+            // TODO: numpy actually throws a `numpy.exceptions.AxisError`
+            raise_exception(SizeT, EXN_VALUE_ERROR, "axis {0} is out of bounds for array of dimension {1}", axis, ndims,
+                            NO_PARAM);
+        }
+
+        if (axe_specified[axis]) {
+            raise_exception(SizeT, EXN_VALUE_ERROR, "repeated axis in transpose", NO_PARAM, NO_PARAM, NO_PARAM);
+        }
+
+        axe_specified[axis] = true;
+    }
+}
+
+/**
+ * @brief Create a transpose view of `src_ndarray` and perform proper assertions.
+ *
+ * This function is very similar to doing `dst_ndarray = np.transpose(src_ndarray, <axes>)`.
+ * If `<axes>` is supposed to be `None`, caller can pass in a `nullptr` to `<axes>`.
+ *
+ * The transpose view created is returned by modifying `dst_ndarray`.
+ *
+ * The caller is responsible for setting up `dst_ndarray` before calling this function.
+ * Here is what this function expects from `dst_ndarray` when called:
+ *   - `dst_ndarray->data` does not have to be initialized.
+ *   - `dst_ndarray->itemsize` does not have to be initialized.
+ *   - `dst_ndarray->ndims` must be initialized, must be equal to `src_ndarray->ndims`.
+ *   - `dst_ndarray->shape` must be allocated, through it can contain uninitialized values.
+ *   - `dst_ndarray->strides` must be allocated, through it can contain uninitialized values.
+ * When this function call ends:
+ *   - `dst_ndarray->data` is set to `src_ndarray->data` (`dst_ndarray` is just a view to `src_ndarray`)
+ *   - `dst_ndarray->itemsize` is set to `src_ndarray->itemsize`
+ *   - `dst_ndarray->ndims` is unchanged
+ *   - `dst_ndarray->shape` is updated according to how `np.transpose` works
+ *   - `dst_ndarray->strides` is updated according to how `np.transpose` works
+ *
+ * @param src_ndarray The NDArray to build a transpose view on
+ * @param dst_ndarray The resulting NDArray after transpose. Further details in the comments above,
+ * @param num_axes Number of elements in axes. Unused if `axes` is nullptr.
+ * @param axes Axes permutation. Set it to `nullptr` if `<axes>` is `None`.
+ */
+template<typename SizeT>
+void transpose(const NDArray<SizeT>* src_ndarray, NDArray<SizeT>* dst_ndarray, SizeT num_axes, const SizeT* axes) {
+    debug_assert_eq(SizeT, src_ndarray->ndims, dst_ndarray->ndims);
+    const auto ndims = src_ndarray->ndims;
+
+    if (axes != nullptr)
+        assert_transpose_axes(ndims, num_axes, axes);
+
+    dst_ndarray->data = src_ndarray->data;
+    dst_ndarray->itemsize = src_ndarray->itemsize;
+
+    // Check out https://ajcr.net/stride-guide-part-2/ to see how `np.transpose` works behind the scenes.
+    if (axes == nullptr) {
+        // `np.transpose(<array>, axes=None)`
+
+        /*
+         * Minor note: `np.transpose(<array>, axes=None)` is equivalent to
+         * `np.transpose(<array>, axes=[N-1, N-2, ..., 0])` - basically it
+         * is reversing the order of strides and shape.
+         *
+         * This is a fast implementation to handle this special (but very common) case.
+         */
+
+        for (SizeT axis = 0; axis < ndims; axis++) {
+            dst_ndarray->shape[axis] = src_ndarray->shape[ndims - axis - 1];
+            dst_ndarray->strides[axis] = src_ndarray->strides[ndims - axis - 1];
+        }
+    } else {
+        // `np.transpose(<array>, <axes>)`
+
+        // Permute strides and shape according to `axes`, while resolving negative indices in `axes`
+        for (SizeT axis = 0; axis < ndims; axis++) {
+            // `i` cannot be OUT_OF_BOUNDS because of assertions
+            SizeT i = slice::resolve_index_in_length(ndims, axes[axis]);
+
+            dst_ndarray->shape[axis] = src_ndarray->shape[i];
+            dst_ndarray->strides[axis] = src_ndarray->strides[i];
+        }
+    }
+}
+}  // namespace ndarray::transpose
+}  // namespace
+
+extern "C" {
+using namespace ndarray::transpose;
+void __nac3_ndarray_transpose(const NDArray<int32_t>* src_ndarray,
+                              NDArray<int32_t>* dst_ndarray,
+                              int32_t num_axes,
+                              const int32_t* axes) {
+    transpose(src_ndarray, dst_ndarray, num_axes, axes);
+}
+
+void __nac3_ndarray_transpose64(const NDArray<int64_t>* src_ndarray,
+                                NDArray<int64_t>* dst_ndarray,
+                                int64_t num_axes,
+                                const int64_t* axes) {
+    transpose(src_ndarray, dst_ndarray, num_axes, axes);
+}
+}
--- a/nac3core/irrt/irrt/string.hpp
+++ b/nac3core/irrt/irrt/string.hpp
@ -0,0 +1,23 @@
+#pragma once
+
+#include "irrt/int_types.hpp"
+
+namespace {
+template<typename SizeT>
+bool __nac3_str_eq_impl(const char* str1, SizeT len1, const char* str2, SizeT len2) {
+    if (len1 != len2) {
+        return 0;
+    }
+    return __builtin_memcmp(str1, str2, static_cast<SizeT>(len1)) == 0;
+}
+}  // namespace
+
+extern "C" {
+bool nac3_str_eq(const char* str1, uint32_t len1, const char* str2, uint32_t len2) {
+    return __nac3_str_eq_impl<uint32_t>(str1, len1, str2, len2);
+}
+
+bool nac3_str_eq64(const char* str1, uint64_t len1, const char* str2, uint64_t len2) {
+    return __nac3_str_eq_impl<uint64_t>(str1, len1, str2, len2);
+}
+}
--- a/nac3core/src/codegen/builtin_fns.rs
+++ b/nac3core/src/codegen/builtin_fns.rs
--- a/nac3core/src/codegen/concrete_type.rs
+++ b/nac3core/src/codegen/concrete_type.rs
@ -56,6 +56,10 @@ pub enum ConcreteTypeEnum {
        fields: HashMap<StrRef, (ConcreteType, bool)>,
        params: IndexMap<TypeVarId, ConcreteType>,
    },
+    TModule {
+        module_id: DefinitionId,
+        methods: HashMap<StrRef, (ConcreteType, bool)>,
+    },
    TVirtual {
        ty: ConcreteType,
    },
@ -205,6 +209,19 @@ impl ConcreteTypeStore {
                        })
                        .collect(),
                },
+                TypeEnum::TModule { module_id, attributes } => ConcreteTypeEnum::TModule {
+                    module_id: *module_id,
+                    methods: attributes
+                        .iter()
+                        .filter_map(|(name, ty)| match &*unifier.get_ty(ty.0) {
+                            TypeEnum::TFunc(..) | TypeEnum::TObj { .. } => None,
+                            _ => Some((
+                                *name,
+                                (self.from_unifier_type(unifier, primitives, ty.0, cache), ty.1),
+                            )),
+                        })
+                        .collect(),
+                },
                TypeEnum::TVirtual { ty } => ConcreteTypeEnum::TVirtual {
                    ty: self.from_unifier_type(unifier, primitives, *ty, cache),
                },
@ -284,6 +301,15 @@ impl ConcreteTypeStore {
                    TypeVar { id, ty }
                })),
            },
+            ConcreteTypeEnum::TModule { module_id, methods } => TypeEnum::TModule {
+                module_id: *module_id,
+                attributes: methods
+                    .iter()
+                    .map(|(name, cty)| {
+                        (*name, (self.to_unifier_type(unifier, primitives, cty.0, cache), cty.1))
+                    })
+                    .collect::<HashMap<_, _>>(),
+            },
            ConcreteTypeEnum::TFunc { args, ret, vars } => TypeEnum::TFunc(FunSignature {
                args: args
                    .iter()
--- a/nac3core/src/codegen/expr.rs
+++ b/nac3core/src/codegen/expr.rs
--- a/nac3core/src/codegen/generator.rs
+++ b/nac3core/src/codegen/generator.rs
@ -1,5 +1,6 @@
 use inkwell::{
    context::Context,
+    targets::TargetMachine,
    types::{BasicTypeEnum, IntType},
    values::{BasicValueEnum, IntValue, PointerValue},
 };
@ -17,6 +18,10 @@ pub trait CodeGenerator {
    /// Return the module name for the code generator.
    fn get_name(&self) -> &str;

+    /// Return an instance of [`IntType`] corresponding to the type of `size_t` for this instance.
+    ///
+    /// Prefer using [`CodeGenContext::get_size_type`] if [`CodeGenContext`] is available, as it is
+    /// equivalent to this function in a more concise syntax.
    fn get_size_type<'ctx>(&self, ctx: &'ctx Context) -> IntType<'ctx>;

    /// Generate function call and returns the function return value.
@ -269,19 +274,27 @@ pub struct DefaultCodeGenerator {

 impl DefaultCodeGenerator {
    #[must_use]
-    pub fn new(name: String, size_t: u32) -> DefaultCodeGenerator {
-        assert!(matches!(size_t, 32 | 64));
-        DefaultCodeGenerator { name, size_t }
+    pub fn new(name: String, size_t: IntType<'_>) -> DefaultCodeGenerator {
+        assert!(matches!(size_t.get_bit_width(), 32 | 64));
+        DefaultCodeGenerator { name, size_t: size_t.get_bit_width() }
+    }
+
+    #[must_use]
+    pub fn with_target_machine(
+        name: String,
+        ctx: &Context,
+        target_machine: &TargetMachine,
+    ) -> DefaultCodeGenerator {
+        let llvm_usize = ctx.ptr_sized_int_type(&target_machine.get_target_data(), None);
+        Self::new(name, llvm_usize)
    }
 }

 impl CodeGenerator for DefaultCodeGenerator {
-    /// Returns the name for this [`CodeGenerator`].
    fn get_name(&self) -> &str {
        &self.name
    }

-    /// Returns an LLVM integer type representing `size_t`.
    fn get_size_type<'ctx>(&self, ctx: &'ctx Context) -> IntType<'ctx> {
        // it should be unsigned, but we don't really need unsigned and this could save us from
        // having to do a bit cast...
--- a/nac3core/src/codegen/irrt/list.rs
+++ b/nac3core/src/codegen/irrt/list.rs
@ -24,42 +24,52 @@ pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
    src_arr: ListValue<'ctx>,
    src_idx: (IntValue<'ctx>, IntValue<'ctx>, IntValue<'ctx>),
 ) {
-    let size_ty = generator.get_size_type(ctx.ctx);
-    let int8_ptr = ctx.ctx.i8_type().ptr_type(AddressSpace::default());
-    let int32 = ctx.ctx.i32_type();
-    let (fun_symbol, elem_ptr_type) = ("__nac3_list_slice_assign_var_size", int8_ptr);
+    let llvm_usize = ctx.get_size_type();
+    let llvm_pi8 = ctx.ctx.i8_type().ptr_type(AddressSpace::default());
+    let llvm_i32 = ctx.ctx.i32_type();
+
+    assert_eq!(dest_idx.0.get_type(), llvm_i32);
+    assert_eq!(dest_idx.1.get_type(), llvm_i32);
+    assert_eq!(dest_idx.2.get_type(), llvm_i32);
+    assert_eq!(src_idx.0.get_type(), llvm_i32);
+    assert_eq!(src_idx.1.get_type(), llvm_i32);
+    assert_eq!(src_idx.2.get_type(), llvm_i32);
+
+    let (fun_symbol, elem_ptr_type) = ("__nac3_list_slice_assign_var_size", llvm_pi8);
    let slice_assign_fun = {
        let ty_vec = vec![
-            int32.into(),         // dest start idx
-            int32.into(),         // dest end idx
-            int32.into(),         // dest step
+            llvm_i32.into(),      // dest start idx
+            llvm_i32.into(),      // dest end idx
+            llvm_i32.into(),      // dest step
            elem_ptr_type.into(), // dest arr ptr
-            int32.into(),         // dest arr len
-            int32.into(),         // src start idx
-            int32.into(),         // src end idx
-            int32.into(),         // src step
+            llvm_i32.into(),      // dest arr len
+            llvm_i32.into(),      // src start idx
+            llvm_i32.into(),      // src end idx
+            llvm_i32.into(),      // src step
            elem_ptr_type.into(), // src arr ptr
-            int32.into(),         // src arr len
-            int32.into(),         // size
+            llvm_i32.into(),      // src arr len
+            llvm_i32.into(),      // size
        ];
        ctx.module.get_function(fun_symbol).unwrap_or_else(|| {
-            let fn_t = int32.fn_type(ty_vec.as_slice(), false);
+            let fn_t = llvm_i32.fn_type(ty_vec.as_slice(), false);
            ctx.module.add_function(fun_symbol, fn_t, None)
        })
    };

-    let zero = int32.const_zero();
-    let one = int32.const_int(1, false);
+    let zero = llvm_i32.const_zero();
+    let one = llvm_i32.const_int(1, false);
    let dest_arr_ptr = dest_arr.data().base_ptr(ctx, generator);
    let dest_arr_ptr =
        ctx.builder.build_pointer_cast(dest_arr_ptr, elem_ptr_type, "dest_arr_ptr_cast").unwrap();
    let dest_len = dest_arr.load_size(ctx, Some("dest.len"));
-    let dest_len = ctx.builder.build_int_truncate_or_bit_cast(dest_len, int32, "srclen32").unwrap();
+    let dest_len =
+        ctx.builder.build_int_truncate_or_bit_cast(dest_len, llvm_i32, "srclen32").unwrap();
    let src_arr_ptr = src_arr.data().base_ptr(ctx, generator);
    let src_arr_ptr =
        ctx.builder.build_pointer_cast(src_arr_ptr, elem_ptr_type, "src_arr_ptr_cast").unwrap();
    let src_len = src_arr.load_size(ctx, Some("src.len"));
-    let src_len = ctx.builder.build_int_truncate_or_bit_cast(src_len, int32, "srclen32").unwrap();
+    let src_len =
+        ctx.builder.build_int_truncate_or_bit_cast(src_len, llvm_i32, "srclen32").unwrap();

    // index in bound and positive should be done
    // assert if dest.step == 1 then len(src) <= len(dest) else len(src) == len(dest), and
@ -136,7 +146,7 @@ pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
                    BasicTypeEnum::StructType(t) => t.size_of().unwrap(),
                    _ => codegen_unreachable!(ctx),
                };
-                ctx.builder.build_int_truncate_or_bit_cast(s, int32, "size").unwrap()
+                ctx.builder.build_int_truncate_or_bit_cast(s, llvm_i32, "size").unwrap()
            }
            .into(),
        ];
@ -147,6 +157,7 @@ pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
            .map(Either::unwrap_left)
            .unwrap()
    };
+
    // update length
    let need_update =
        ctx.builder.build_int_compare(IntPredicate::NE, new_len, dest_len, "need_update").unwrap();
@ -155,8 +166,9 @@ pub fn list_slice_assignment<'ctx, G: CodeGenerator + ?Sized>(
    let cont_bb = ctx.ctx.append_basic_block(current, "cont");
    ctx.builder.build_conditional_branch(need_update, update_bb, cont_bb).unwrap();
    ctx.builder.position_at_end(update_bb);
-    let new_len = ctx.builder.build_int_z_extend_or_bit_cast(new_len, size_ty, "new_len").unwrap();
-    dest_arr.store_size(ctx, generator, new_len);
+    let new_len =
+        ctx.builder.build_int_z_extend_or_bit_cast(new_len, llvm_usize, "new_len").unwrap();
+    dest_arr.store_size(ctx, new_len);
    ctx.builder.build_unconditional_branch(cont_bb).unwrap();
    ctx.builder.position_at_end(cont_bb);
 }
--- a/nac3core/src/codegen/irrt/math.rs
+++ b/nac3core/src/codegen/irrt/math.rs
@ -62,8 +62,13 @@ pub fn call_isinf<'ctx, G: CodeGenerator + ?Sized>(
    ctx: &CodeGenContext<'ctx, '_>,
    v: FloatValue<'ctx>,
 ) -> IntValue<'ctx> {
+    let llvm_i32 = ctx.ctx.i32_type();
+    let llvm_f64 = ctx.ctx.f64_type();
+
+    assert_eq!(v.get_type(), llvm_f64);
+
    let intrinsic_fn = ctx.module.get_function("__nac3_isinf").unwrap_or_else(|| {
-        let fn_type = ctx.ctx.i32_type().fn_type(&[ctx.ctx.f64_type().into()], false);
+        let fn_type = llvm_i32.fn_type(&[llvm_f64.into()], false);
        ctx.module.add_function("__nac3_isinf", fn_type, None)
    });

@ -84,8 +89,13 @@ pub fn call_isnan<'ctx, G: CodeGenerator + ?Sized>(
    ctx: &CodeGenContext<'ctx, '_>,
    v: FloatValue<'ctx>,
 ) -> IntValue<'ctx> {
+    let llvm_i32 = ctx.ctx.i32_type();
+    let llvm_f64 = ctx.ctx.f64_type();
+
+    assert_eq!(v.get_type(), llvm_f64);
+
    let intrinsic_fn = ctx.module.get_function("__nac3_isnan").unwrap_or_else(|| {
-        let fn_type = ctx.ctx.i32_type().fn_type(&[ctx.ctx.f64_type().into()], false);
+        let fn_type = llvm_i32.fn_type(&[llvm_f64.into()], false);
        ctx.module.add_function("__nac3_isnan", fn_type, None)
    });

@ -104,6 +114,8 @@ pub fn call_isnan<'ctx, G: CodeGenerator + ?Sized>(
 pub fn call_gamma<'ctx>(ctx: &CodeGenContext<'ctx, '_>, v: FloatValue<'ctx>) -> FloatValue<'ctx> {
    let llvm_f64 = ctx.ctx.f64_type();

+    assert_eq!(v.get_type(), llvm_f64);
+
    let intrinsic_fn = ctx.module.get_function("__nac3_gamma").unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        ctx.module.add_function("__nac3_gamma", fn_type, None)
@ -121,6 +133,8 @@ pub fn call_gamma<'ctx>(ctx: &CodeGenContext<'ctx, '_>, v: FloatValue<'ctx>) ->
 pub fn call_gammaln<'ctx>(ctx: &CodeGenContext<'ctx, '_>, v: FloatValue<'ctx>) -> FloatValue<'ctx> {
    let llvm_f64 = ctx.ctx.f64_type();

+    assert_eq!(v.get_type(), llvm_f64);
+
    let intrinsic_fn = ctx.module.get_function("__nac3_gammaln").unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        ctx.module.add_function("__nac3_gammaln", fn_type, None)
@ -138,6 +152,8 @@ pub fn call_gammaln<'ctx>(ctx: &CodeGenContext<'ctx, '_>, v: FloatValue<'ctx>) -
 pub fn call_j0<'ctx>(ctx: &CodeGenContext<'ctx, '_>, v: FloatValue<'ctx>) -> FloatValue<'ctx> {
    let llvm_f64 = ctx.ctx.f64_type();

+    assert_eq!(v.get_type(), llvm_f64);
+
    let intrinsic_fn = ctx.module.get_function("__nac3_j0").unwrap_or_else(|| {
        let fn_type = llvm_f64.fn_type(&[llvm_f64.into()], false);
        ctx.module.add_function("__nac3_j0", fn_type, None)
--- a/nac3core/src/codegen/irrt/mod.rs
+++ b/nac3core/src/codegen/irrt/mod.rs
@ -15,12 +15,14 @@ pub use list::*;
 pub use math::*;
 pub use range::*;
 pub use slice::*;
+pub use string::*;

 mod list;
 mod math;
 pub mod ndarray;
 mod range;
 mod slice;
+mod string;

 #[must_use]
 pub fn load_irrt<'ctx>(ctx: &'ctx Context, symbol_resolver: &dyn SymbolResolver) -> Module<'ctx> {
@ -66,13 +68,9 @@ pub fn load_irrt<'ctx>(ctx: &'ctx Context, symbol_resolver: &dyn SymbolResolver)
 /// - When [`TypeContext::size_type`] is 32-bits, the function name is `fn_name}`.
 /// - When [`TypeContext::size_type`] is 64-bits, the function name is `{fn_name}64`.
 #[must_use]
-pub fn get_usize_dependent_function_name<G: CodeGenerator + ?Sized>(
-    generator: &G,
-    ctx: &CodeGenContext<'_, '_>,
-    name: &str,
-) -> String {
+pub fn get_usize_dependent_function_name(ctx: &CodeGenContext<'_, '_>, name: &str) -> String {
    let mut name = name.to_owned();
-    match generator.get_size_type(ctx.ctx).get_bit_width() {
+    match ctx.get_size_type().get_bit_width() {
        32 => {}
        64 => name.push_str("64"),
        bit_width => {
@ -130,10 +128,11 @@ pub fn handle_slice_indices<'ctx, G: CodeGenerator>(
    generator: &mut G,
    length: IntValue<'ctx>,
 ) -> Result<Option<(IntValue<'ctx>, IntValue<'ctx>, IntValue<'ctx>)>, String> {
-    let int32 = ctx.ctx.i32_type();
-    let zero = int32.const_zero();
-    let one = int32.const_int(1, false);
-    let length = ctx.builder.build_int_truncate_or_bit_cast(length, int32, "leni32").unwrap();
+    let llvm_i32 = ctx.ctx.i32_type();
+
+    let zero = llvm_i32.const_zero();
+    let one = llvm_i32.const_int(1, false);
+    let length = ctx.builder.build_int_truncate_or_bit_cast(length, llvm_i32, "leni32").unwrap();
    Ok(Some(match (start, end, step) {
        (s, e, None) => (
            if let Some(s) = s.as_ref() {
@ -142,7 +141,7 @@ pub fn handle_slice_indices<'ctx, G: CodeGenerator>(
                    None => return Ok(None),
                }
            } else {
-                int32.const_zero()
+                llvm_i32.const_zero()
            },
            {
                let e = if let Some(s) = e.as_ref() {
--- a/nac3core/src/codegen/irrt/ndarray/array.rs
+++ b/nac3core/src/codegen/irrt/ndarray/array.rs
@ -0,0 +1,72 @@
+use inkwell::{types::BasicTypeEnum, values::IntValue};
+
+use crate::codegen::{
+    expr::infer_and_call_function,
+    irrt::get_usize_dependent_function_name,
+    values::{ndarray::NDArrayValue, ListValue, ProxyValue, TypedArrayLikeAccessor},
+    CodeGenContext, CodeGenerator,
+};
+
+/// Generates a call to `__nac3_ndarray_array_set_and_validate_list_shape`.
+///
+/// Deduces the target shape of the `ndarray` from the provided `list`, raising an exception if
+/// there is any issue with the resultant `shape`.
+///
+/// `shape` must be pre-allocated by the caller of this function to `[usize; ndims]`, and must be
+/// initialized to all `-1`s.
+pub fn call_nac3_ndarray_array_set_and_validate_list_shape<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &G,
+    ctx: &CodeGenContext<'ctx, '_>,
+    list: ListValue<'ctx>,
+    ndims: IntValue<'ctx>,
+    shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+) {
+    let llvm_usize = ctx.get_size_type();
+    assert_eq!(list.get_type().element_type().unwrap(), ctx.ctx.i8_type().into());
+    assert_eq!(ndims.get_type(), llvm_usize);
+    assert_eq!(
+        BasicTypeEnum::try_from(shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+
+    let name =
+        get_usize_dependent_function_name(ctx, "__nac3_ndarray_array_set_and_validate_list_shape");
+
+    infer_and_call_function(
+        ctx,
+        &name,
+        None,
+        &[list.as_base_value().into(), ndims.into(), shape.base_ptr(ctx, generator).into()],
+        None,
+        None,
+    );
+}
+
+/// Generates a call to `__nac3_ndarray_array_write_list_to_array`.
+///
+/// Copies the contents stored in `list` into `ndarray`.
+///
+/// The `ndarray` must fulfill the following preconditions:
+///
+/// - `ndarray.itemsize`: Must be initialized.
+/// - `ndarray.ndims`: Must be initialized.
+/// - `ndarray.shape`: Must be initialized.
+/// - `ndarray.data`: Must be allocated and contiguous.
+pub fn call_nac3_ndarray_array_write_list_to_array<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    list: ListValue<'ctx>,
+    ndarray: NDArrayValue<'ctx>,
+) {
+    assert_eq!(list.get_type().element_type().unwrap(), ctx.ctx.i8_type().into());
+
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_array_write_list_to_array");
+
+    infer_and_call_function(
+        ctx,
+        &name,
+        None,
+        &[list.as_base_value().into(), ndarray.as_base_value().into()],
+        None,
+        None,
+    );
+}
--- a/nac3core/src/codegen/irrt/ndarray/basic.rs
+++ b/nac3core/src/codegen/irrt/ndarray/basic.rs
@ -1,4 +1,5 @@
 use inkwell::{
+    types::BasicTypeEnum,
    values::{BasicValueEnum, IntValue, PointerValue},
    AddressSpace,
 };
@ -7,76 +8,94 @@ use crate::codegen::{
    expr::{create_and_call_function, infer_and_call_function},
    irrt::get_usize_dependent_function_name,
    types::ProxyType,
-    values::{ndarray::NDArrayValue, ProxyValue},
+    values::{ndarray::NDArrayValue, ProxyValue, TypedArrayLikeAccessor},
    CodeGenContext, CodeGenerator,
 };

+/// Generates a call to `__nac3_ndarray_util_assert_shape_no_negative`.
+///
+/// Assets that `shape` does not contain negative dimensions.
 pub fn call_nac3_ndarray_util_assert_shape_no_negative<'ctx, G: CodeGenerator + ?Sized>(
    generator: &G,
    ctx: &CodeGenContext<'ctx, '_>,
-    ndims: IntValue<'ctx>,
-    shape: PointerValue<'ctx>,
+    shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
 ) {
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_usize = ctx.get_size_type();
    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());

-    let name = get_usize_dependent_function_name(
-        generator,
-        ctx,
-        "__nac3_ndarray_util_assert_shape_no_negative",
+    assert_eq!(
+        BasicTypeEnum::try_from(shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
    );

-    create_and_call_function(
-        ctx,
-        &name,
-        Some(llvm_usize.into()),
-        &[(llvm_usize.into(), ndims.into()), (llvm_pusize.into(), shape.into())],
-        None,
-        None,
-    );
-}
-
-pub fn call_nac3_ndarray_util_assert_output_shape_same<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &G,
-    ctx: &CodeGenContext<'ctx, '_>,
-    ndarray_ndims: IntValue<'ctx>,
-    ndarray_shape: PointerValue<'ctx>,
-    output_ndims: IntValue<'ctx>,
-    output_shape: IntValue<'ctx>,
-) {
-    let llvm_usize = generator.get_size_type(ctx.ctx);
-    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
-
-    let name = get_usize_dependent_function_name(
-        generator,
-        ctx,
-        "__nac3_ndarray_util_assert_output_shape_same",
-    );
+    let name =
+        get_usize_dependent_function_name(ctx, "__nac3_ndarray_util_assert_shape_no_negative");

    create_and_call_function(
        ctx,
        &name,
        Some(llvm_usize.into()),
        &[
-            (llvm_usize.into(), ndarray_ndims.into()),
-            (llvm_pusize.into(), ndarray_shape.into()),
-            (llvm_usize.into(), output_ndims.into()),
-            (llvm_pusize.into(), output_shape.into()),
+            (llvm_usize.into(), shape.size(ctx, generator).into()),
+            (llvm_pusize.into(), shape.base_ptr(ctx, generator).into()),
        ],
        None,
        None,
    );
 }

-pub fn call_nac3_ndarray_size<'ctx, G: CodeGenerator + ?Sized>(
+/// Generates a call to `__nac3_ndarray_util_assert_shape_output_shape_same`.
+///
+/// Asserts that `ndarray_shape` and `output_shape` are the same in the context of writing output to
+/// an `ndarray`.
+pub fn call_nac3_ndarray_util_assert_output_shape_same<'ctx, G: CodeGenerator + ?Sized>(
    generator: &G,
+    ctx: &CodeGenContext<'ctx, '_>,
+    ndarray_shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+    output_shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+) {
+    let llvm_usize = ctx.get_size_type();
+    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
+
+    assert_eq!(
+        BasicTypeEnum::try_from(ndarray_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+    assert_eq!(
+        BasicTypeEnum::try_from(output_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+
+    let name =
+        get_usize_dependent_function_name(ctx, "__nac3_ndarray_util_assert_output_shape_same");
+
+    create_and_call_function(
+        ctx,
+        &name,
+        Some(llvm_usize.into()),
+        &[
+            (llvm_usize.into(), ndarray_shape.size(ctx, generator).into()),
+            (llvm_pusize.into(), ndarray_shape.base_ptr(ctx, generator).into()),
+            (llvm_usize.into(), output_shape.size(ctx, generator).into()),
+            (llvm_pusize.into(), output_shape.base_ptr(ctx, generator).into()),
+        ],
+        None,
+        None,
+    );
+}
+
+/// Generates a call to `__nac3_ndarray_size`.
+///
+/// Returns a [`usize`][CodeGenerator::get_size_type] value of the number of elements of an
+/// `ndarray`, corresponding to the value of `ndarray.size`.
+pub fn call_nac3_ndarray_size<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    ndarray: NDArrayValue<'ctx>,
 ) -> IntValue<'ctx> {
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_usize = ctx.get_size_type();
    let llvm_ndarray = ndarray.get_type().as_base_type();

-    let name = get_usize_dependent_function_name(generator, ctx, "__nac3_ndarray_size");
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_size");

    create_and_call_function(
        ctx,
@ -90,15 +109,18 @@ pub fn call_nac3_ndarray_size<'ctx, G: CodeGenerator + ?Sized>(
    .unwrap()
 }

-pub fn call_nac3_ndarray_nbytes<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &G,
+/// Generates a call to `__nac3_ndarray_nbytes`.
+///
+/// Returns a [`usize`][CodeGenerator::get_size_type] value of the number of bytes consumed by the
+/// data of the `ndarray`, corresponding to the value of `ndarray.nbytes`.
+pub fn call_nac3_ndarray_nbytes<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    ndarray: NDArrayValue<'ctx>,
 ) -> IntValue<'ctx> {
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_usize = ctx.get_size_type();
    let llvm_ndarray = ndarray.get_type().as_base_type();

-    let name = get_usize_dependent_function_name(generator, ctx, "__nac3_ndarray_nbytes");
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_nbytes");

    create_and_call_function(
        ctx,
@ -112,15 +134,18 @@ pub fn call_nac3_ndarray_nbytes<'ctx, G: CodeGenerator + ?Sized>(
    .unwrap()
 }

-pub fn call_nac3_ndarray_len<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &G,
+/// Generates a call to `__nac3_ndarray_len`.
+///
+/// Returns a [`usize`][CodeGenerator::get_size_type] value of the size of the topmost dimension of
+/// the `ndarray`, corresponding to the value of `ndarray.__len__`.
+pub fn call_nac3_ndarray_len<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    ndarray: NDArrayValue<'ctx>,
 ) -> IntValue<'ctx> {
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_usize = ctx.get_size_type();
    let llvm_ndarray = ndarray.get_type().as_base_type();

-    let name = get_usize_dependent_function_name(generator, ctx, "__nac3_ndarray_len");
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_len");

    create_and_call_function(
        ctx,
@ -134,15 +159,17 @@ pub fn call_nac3_ndarray_len<'ctx, G: CodeGenerator + ?Sized>(
    .unwrap()
 }

-pub fn call_nac3_ndarray_is_c_contiguous<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &G,
+/// Generates a call to `__nac3_ndarray_is_c_contiguous`.
+///
+/// Returns an `i1` value indicating whether the `ndarray` is C-contiguous.
+pub fn call_nac3_ndarray_is_c_contiguous<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    ndarray: NDArrayValue<'ctx>,
 ) -> IntValue<'ctx> {
    let llvm_i1 = ctx.ctx.bool_type();
    let llvm_ndarray = ndarray.get_type().as_base_type();

-    let name = get_usize_dependent_function_name(generator, ctx, "__nac3_ndarray_is_c_contiguous");
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_is_c_contiguous");

    create_and_call_function(
        ctx,
@ -156,18 +183,22 @@ pub fn call_nac3_ndarray_is_c_contiguous<'ctx, G: CodeGenerator + ?Sized>(
    .unwrap()
 }

-pub fn call_nac3_ndarray_get_nth_pelement<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &G,
+/// Generates a call to `__nac3_ndarray_get_nth_pelement`.
+///
+/// Returns a [`PointerValue`] to the `index`-th flattened element of the `ndarray`.
+pub fn call_nac3_ndarray_get_nth_pelement<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    ndarray: NDArrayValue<'ctx>,
    index: IntValue<'ctx>,
 ) -> PointerValue<'ctx> {
    let llvm_i8 = ctx.ctx.i8_type();
    let llvm_pi8 = llvm_i8.ptr_type(AddressSpace::default());
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_usize = ctx.get_size_type();
    let llvm_ndarray = ndarray.get_type().as_base_type();

-    let name = get_usize_dependent_function_name(generator, ctx, "__nac3_ndarray_get_nth_pelement");
+    assert_eq!(index.get_type(), llvm_usize);
+
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_get_nth_pelement");

    create_and_call_function(
        ctx,
@ -181,20 +212,29 @@ pub fn call_nac3_ndarray_get_nth_pelement<'ctx, G: CodeGenerator + ?Sized>(
    .unwrap()
 }

+/// Generates a call to `__nac3_ndarray_get_pelement_by_indices`.
+///
+/// `indices` must have the same number of elements as the number of dimensions in `ndarray`.
+///
+/// Returns a [`PointerValue`] to the element indexed by `indices`.
 pub fn call_nac3_ndarray_get_pelement_by_indices<'ctx, G: CodeGenerator + ?Sized>(
    generator: &G,
    ctx: &CodeGenContext<'ctx, '_>,
    ndarray: NDArrayValue<'ctx>,
-    indices: PointerValue<'ctx>,
+    indices: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
 ) -> PointerValue<'ctx> {
    let llvm_i8 = ctx.ctx.i8_type();
    let llvm_pi8 = llvm_i8.ptr_type(AddressSpace::default());
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_usize = ctx.get_size_type();
    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
    let llvm_ndarray = ndarray.get_type().as_base_type();

-    let name =
-        get_usize_dependent_function_name(generator, ctx, "__nac3_ndarray_get_pelement_by_indices");
+    assert_eq!(
+        BasicTypeEnum::try_from(indices.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_get_pelement_by_indices");

    create_and_call_function(
        ctx,
@ -202,7 +242,7 @@ pub fn call_nac3_ndarray_get_pelement_by_indices<'ctx, G: CodeGenerator + ?Sized
        Some(llvm_pi8.into()),
        &[
            (llvm_ndarray.into(), ndarray.as_base_value().into()),
-            (llvm_pusize.into(), indices.into()),
+            (llvm_pusize.into(), indices.base_ptr(ctx, generator).into()),
        ],
        Some("pelement"),
        None,
@ -211,15 +251,16 @@ pub fn call_nac3_ndarray_get_pelement_by_indices<'ctx, G: CodeGenerator + ?Sized
    .unwrap()
 }

-pub fn call_nac3_ndarray_set_strides_by_shape<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &G,
+/// Generates a call to `__nac3_ndarray_set_strides_by_shape`.
+///
+/// Sets `ndarray.strides` assuming that `ndarray.shape` is C-contiguous.
+pub fn call_nac3_ndarray_set_strides_by_shape<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    ndarray: NDArrayValue<'ctx>,
 ) {
    let llvm_ndarray = ndarray.get_type().as_base_type();

-    let name =
-        get_usize_dependent_function_name(generator, ctx, "__nac3_ndarray_set_strides_by_shape");
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_set_strides_by_shape");

    create_and_call_function(
        ctx,
@ -231,13 +272,17 @@ pub fn call_nac3_ndarray_set_strides_by_shape<'ctx, G: CodeGenerator + ?Sized>(
    );
 }

-pub fn call_nac3_ndarray_copy_data<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &G,
+/// Generates a call to `__nac3_ndarray_copy_data`.
+///
+/// Copies all elements from `src_ndarray` to `dst_ndarray` using their flattened views. The number
+/// of elements in `src_ndarray` must be greater than or equal to the number of elements in
+/// `dst_ndarray`.
+pub fn call_nac3_ndarray_copy_data<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    src_ndarray: NDArrayValue<'ctx>,
    dst_ndarray: NDArrayValue<'ctx>,
 ) {
-    let name = get_usize_dependent_function_name(generator, ctx, "__nac3_ndarray_copy_data");
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_copy_data");

    infer_and_call_function(
        ctx,
--- a/nac3core/src/codegen/irrt/ndarray/broadcast.rs
+++ b/nac3core/src/codegen/irrt/ndarray/broadcast.rs
@ -0,0 +1,81 @@
+use inkwell::values::IntValue;
+
+use crate::codegen::{
+    expr::infer_and_call_function,
+    irrt::get_usize_dependent_function_name,
+    types::{ndarray::ShapeEntryType, ProxyType},
+    values::{
+        ndarray::NDArrayValue, ArrayLikeValue, ArraySliceValue, ProxyValue, TypedArrayLikeAccessor,
+        TypedArrayLikeMutator,
+    },
+    CodeGenContext, CodeGenerator,
+};
+
+/// Generates a call to `__nac3_ndarray_broadcast_to`.
+///
+/// Attempts to broadcast `src_ndarray` to the new shape defined by `dst_ndarray`.
+///
+/// `dst_ndarray` must meet the following preconditions:
+///
+/// - `dst_ndarray.ndims` must be initialized and matching the length of `dst_ndarray.shape`.
+/// - `dst_ndarray.shape` must be initialized and contains the target broadcast shape.
+/// - `dst_ndarray.strides` must be allocated and may contain uninitialized values.
+pub fn call_nac3_ndarray_broadcast_to<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    src_ndarray: NDArrayValue<'ctx>,
+    dst_ndarray: NDArrayValue<'ctx>,
+) {
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_broadcast_to");
+    infer_and_call_function(
+        ctx,
+        &name,
+        None,
+        &[src_ndarray.as_base_value().into(), dst_ndarray.as_base_value().into()],
+        None,
+        None,
+    );
+}
+
+/// Generates a call to `__nac3_ndarray_broadcast_shapes`.
+///
+/// Attempts to calculate the resultant shape from broadcasting all shapes in `shape_entries`,
+/// writing the result to `dst_shape`.
+pub fn call_nac3_ndarray_broadcast_shapes<'ctx, G, Shape>(
+    generator: &G,
+    ctx: &CodeGenContext<'ctx, '_>,
+    num_shape_entries: IntValue<'ctx>,
+    shape_entries: ArraySliceValue<'ctx>,
+    dst_ndims: IntValue<'ctx>,
+    dst_shape: &Shape,
+) where
+    G: CodeGenerator + ?Sized,
+    Shape: TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>
+        + TypedArrayLikeMutator<'ctx, G, IntValue<'ctx>>,
+{
+    let llvm_usize = ctx.get_size_type();
+
+    assert_eq!(num_shape_entries.get_type(), llvm_usize);
+    assert!(ShapeEntryType::is_type(
+        generator,
+        ctx.ctx,
+        shape_entries.base_ptr(ctx, generator).get_type()
+    )
+    .is_ok());
+    assert_eq!(dst_ndims.get_type(), llvm_usize);
+    assert_eq!(dst_shape.element_type(ctx, generator), llvm_usize.into());
+
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_broadcast_shapes");
+    infer_and_call_function(
+        ctx,
+        &name,
+        None,
+        &[
+            num_shape_entries.into(),
+            shape_entries.base_ptr(ctx, generator).into(),
+            dst_ndims.into(),
+            dst_shape.base_ptr(ctx, generator).into(),
+        ],
+        None,
+        None,
+    );
+}
--- a/nac3core/src/codegen/irrt/ndarray/indexing.rs
+++ b/nac3core/src/codegen/irrt/ndarray/indexing.rs
@ -5,6 +5,11 @@ use crate::codegen::{
    CodeGenContext, CodeGenerator,
 };

+/// Generates a call to `__nac3_ndarray_index`.
+///
+/// Performs [basic indexing](https://numpy.org/doc/stable/user/basics.indexing.html#basic-indexing)
+/// on `src_ndarray` using `indices`, writing the result to `dst_ndarray`, corresponding to the
+/// operation `dst_ndarray = src_ndarray[indices]`.
 pub fn call_nac3_ndarray_index<'ctx, G: CodeGenerator + ?Sized>(
    generator: &G,
    ctx: &CodeGenContext<'ctx, '_>,
@ -12,7 +17,7 @@ pub fn call_nac3_ndarray_index<'ctx, G: CodeGenerator + ?Sized>(
    src_ndarray: NDArrayValue<'ctx>,
    dst_ndarray: NDArrayValue<'ctx>,
 ) {
-    let name = get_usize_dependent_function_name(generator, ctx, "__nac3_ndarray_index");
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_index");
    infer_and_call_function(
        ctx,
        &name,
--- a/nac3core/src/codegen/irrt/ndarray/iter.rs
+++ b/nac3core/src/codegen/irrt/ndarray/iter.rs
@ -1,4 +1,5 @@
 use inkwell::{
+    types::BasicTypeEnum,
    values::{BasicValueEnum, IntValue},
    AddressSpace,
 };
@ -9,22 +10,30 @@ use crate::codegen::{
    types::ProxyType,
    values::{
        ndarray::{NDArrayValue, NDIterValue},
-        ArrayLikeValue, ArraySliceValue, ProxyValue,
+        ProxyValue, TypedArrayLikeAccessor,
    },
    CodeGenContext, CodeGenerator,
 };

+/// Generates a call to `__nac3_nditer_initialize`.
+///
+/// Initializes the `iter` object.
 pub fn call_nac3_nditer_initialize<'ctx, G: CodeGenerator + ?Sized>(
    generator: &G,
    ctx: &CodeGenContext<'ctx, '_>,
    iter: NDIterValue<'ctx>,
    ndarray: NDArrayValue<'ctx>,
-    indices: ArraySliceValue<'ctx>,
+    indices: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
 ) {
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_usize = ctx.get_size_type();
    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());

-    let name = get_usize_dependent_function_name(generator, ctx, "__nac3_nditer_initialize");
+    assert_eq!(
+        BasicTypeEnum::try_from(indices.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+
+    let name = get_usize_dependent_function_name(ctx, "__nac3_nditer_initialize");

    create_and_call_function(
        ctx,
@ -40,12 +49,15 @@ pub fn call_nac3_nditer_initialize<'ctx, G: CodeGenerator + ?Sized>(
    );
 }

-pub fn call_nac3_nditer_has_element<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &G,
+/// Generates a call to `__nac3_nditer_initialize_has_element`.
+///
+/// Returns an `i1` value indicating whether there are elements left to traverse for the `iter`
+/// object.
+pub fn call_nac3_nditer_has_element<'ctx>(
    ctx: &CodeGenContext<'ctx, '_>,
    iter: NDIterValue<'ctx>,
 ) -> IntValue<'ctx> {
-    let name = get_usize_dependent_function_name(generator, ctx, "__nac3_nditer_has_element");
+    let name = get_usize_dependent_function_name(ctx, "__nac3_nditer_has_element");

    infer_and_call_function(
        ctx,
@ -59,12 +71,11 @@ pub fn call_nac3_nditer_has_element<'ctx, G: CodeGenerator + ?Sized>(
    .unwrap()
 }

-pub fn call_nac3_nditer_next<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &G,
-    ctx: &CodeGenContext<'ctx, '_>,
-    iter: NDIterValue<'ctx>,
-) {
-    let name = get_usize_dependent_function_name(generator, ctx, "__nac3_nditer_next");
+/// Generates a call to `__nac3_nditer_next`.
+///
+/// Moves `iter` to point to the next element.
+pub fn call_nac3_nditer_next<'ctx>(ctx: &CodeGenContext<'ctx, '_>, iter: NDIterValue<'ctx>) {
+    let name = get_usize_dependent_function_name(ctx, "__nac3_nditer_next");

    infer_and_call_function(ctx, &name, None, &[iter.as_base_value().into()], None, None);
 }
--- a/nac3core/src/codegen/irrt/ndarray/matmul.rs
+++ b/nac3core/src/codegen/irrt/ndarray/matmul.rs
@ -0,0 +1,65 @@
+use inkwell::{types::BasicTypeEnum, values::IntValue};
+
+use crate::codegen::{
+    expr::infer_and_call_function, irrt::get_usize_dependent_function_name,
+    values::TypedArrayLikeAccessor, CodeGenContext, CodeGenerator,
+};
+
+/// Generates a call to `__nac3_ndarray_matmul_calculate_shapes`.
+///
+/// Calculates the broadcasted shapes for `a`, `b`, and the `ndarray` holding the final values of
+/// `a @ b`.
+#[allow(clippy::too_many_arguments)]
+pub fn call_nac3_ndarray_matmul_calculate_shapes<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &G,
+    ctx: &CodeGenContext<'ctx, '_>,
+    a_shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+    b_shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+    final_ndims: IntValue<'ctx>,
+    new_a_shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+    new_b_shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+    dst_shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+) {
+    let llvm_usize = ctx.get_size_type();
+
+    assert_eq!(
+        BasicTypeEnum::try_from(a_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+    assert_eq!(
+        BasicTypeEnum::try_from(b_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+    assert_eq!(
+        BasicTypeEnum::try_from(new_a_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+    assert_eq!(
+        BasicTypeEnum::try_from(new_b_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+    assert_eq!(
+        BasicTypeEnum::try_from(dst_shape.element_type(ctx, generator)).unwrap(),
+        llvm_usize.into()
+    );
+
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_matmul_calculate_shapes");
+
+    infer_and_call_function(
+        ctx,
+        &name,
+        None,
+        &[
+            a_shape.size(ctx, generator).into(),
+            a_shape.base_ptr(ctx, generator).into(),
+            b_shape.size(ctx, generator).into(),
+            b_shape.base_ptr(ctx, generator).into(),
+            final_ndims.into(),
+            new_a_shape.base_ptr(ctx, generator).into(),
+            new_b_shape.base_ptr(ctx, generator).into(),
+            dst_shape.base_ptr(ctx, generator).into(),
+        ],
+        None,
+        None,
+    );
+}
--- a/nac3core/src/codegen/irrt/ndarray/mod.rs
+++ b/nac3core/src/codegen/irrt/ndarray/mod.rs
@ -1,391 +1,17 @@
-use inkwell::{
-    types::IntType,
-    values::{BasicValueEnum, CallSiteValue, IntValue},
-    AddressSpace, IntPredicate,
-};
-use itertools::Either;
-
-use crate::codegen::{
-    llvm_intrinsics,
-    macros::codegen_unreachable,
-    stmt::gen_for_callback_incrementing,
-    values::{
-        ndarray::NDArrayValue, ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue,
-        TypedArrayLikeAccessor, TypedArrayLikeAdapter, UntypedArrayLikeAccessor,
-    },
-    CodeGenContext, CodeGenerator,
-};
+pub use array::*;
 pub use basic::*;
+pub use broadcast::*;
 pub use indexing::*;
 pub use iter::*;
+pub use matmul::*;
+pub use reshape::*;
+pub use transpose::*;

+mod array;
 mod basic;
+mod broadcast;
 mod indexing;
 mod iter;
-
-/// Generates a call to `__nac3_ndarray_calc_size`. Returns an [`IntValue`] representing the
-/// calculated total size.
-///
-/// * `dims` - An [`ArrayLikeIndexer`] containing the size of each dimension.
-/// * `range` - The dimension index to begin and end (exclusively) calculating the dimensions for,
-///   or [`None`] if starting from the first dimension and ending at the last dimension
-///   respectively.
-pub fn call_ndarray_calc_size<'ctx, G, Dims>(
-    generator: &G,
-    ctx: &CodeGenContext<'ctx, '_>,
-    dims: &Dims,
-    (begin, end): (Option<IntValue<'ctx>>, Option<IntValue<'ctx>>),
-) -> IntValue<'ctx>
-where
-    G: CodeGenerator + ?Sized,
-    Dims: ArrayLikeIndexer<'ctx>,
-{
-    let llvm_usize = generator.get_size_type(ctx.ctx);
-    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
-
-    let ndarray_calc_size_fn_name = match llvm_usize.get_bit_width() {
-        32 => "__nac3_ndarray_calc_size",
-        64 => "__nac3_ndarray_calc_size64",
-        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
-    };
-    let ndarray_calc_size_fn_t = llvm_usize.fn_type(
-        &[llvm_pusize.into(), llvm_usize.into(), llvm_usize.into(), llvm_usize.into()],
-        false,
-    );
-    let ndarray_calc_size_fn =
-        ctx.module.get_function(ndarray_calc_size_fn_name).unwrap_or_else(|| {
-            ctx.module.add_function(ndarray_calc_size_fn_name, ndarray_calc_size_fn_t, None)
-        });
-
-    let begin = begin.unwrap_or_else(|| llvm_usize.const_zero());
-    let end = end.unwrap_or_else(|| dims.size(ctx, generator));
-    ctx.builder
-        .build_call(
-            ndarray_calc_size_fn,
-            &[
-                dims.base_ptr(ctx, generator).into(),
-                dims.size(ctx, generator).into(),
-                begin.into(),
-                end.into(),
-            ],
-            "",
-        )
-        .map(CallSiteValue::try_as_basic_value)
-        .map(|v| v.map_left(BasicValueEnum::into_int_value))
-        .map(Either::unwrap_left)
-        .unwrap()
-}
-
-/// Generates a call to `__nac3_ndarray_calc_nd_indices`. Returns a [`TypeArrayLikeAdpater`]
-/// containing `i32` indices of the flattened index.
-///
-/// * `index` - The index to compute the multidimensional index for.
-/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an
-///   `NDArray`.
-pub fn call_ndarray_calc_nd_indices<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &G,
-    ctx: &CodeGenContext<'ctx, '_>,
-    index: IntValue<'ctx>,
-    ndarray: NDArrayValue<'ctx>,
-) -> TypedArrayLikeAdapter<'ctx, IntValue<'ctx>> {
-    let llvm_void = ctx.ctx.void_type();
-    let llvm_i32 = ctx.ctx.i32_type();
-    let llvm_usize = generator.get_size_type(ctx.ctx);
-    let llvm_pi32 = llvm_i32.ptr_type(AddressSpace::default());
-    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
-
-    let ndarray_calc_nd_indices_fn_name = match llvm_usize.get_bit_width() {
-        32 => "__nac3_ndarray_calc_nd_indices",
-        64 => "__nac3_ndarray_calc_nd_indices64",
-        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
-    };
-    let ndarray_calc_nd_indices_fn =
-        ctx.module.get_function(ndarray_calc_nd_indices_fn_name).unwrap_or_else(|| {
-            let fn_type = llvm_void.fn_type(
-                &[llvm_usize.into(), llvm_pusize.into(), llvm_usize.into(), llvm_pi32.into()],
-                false,
-            );
-
-            ctx.module.add_function(ndarray_calc_nd_indices_fn_name, fn_type, None)
-        });
-
-    let ndarray_num_dims = ndarray.load_ndims(ctx);
-    let ndarray_dims = ndarray.shape();
-
-    let indices = ctx.builder.build_array_alloca(llvm_i32, ndarray_num_dims, "").unwrap();
-
-    ctx.builder
-        .build_call(
-            ndarray_calc_nd_indices_fn,
-            &[
-                index.into(),
-                ndarray_dims.base_ptr(ctx, generator).into(),
-                ndarray_num_dims.into(),
-                indices.into(),
-            ],
-            "",
-        )
-        .unwrap();
-
-    TypedArrayLikeAdapter::from(
-        ArraySliceValue::from_ptr_val(indices, ndarray_num_dims, None),
-        Box::new(|_, v| v.into_int_value()),
-        Box::new(|_, v| v.into()),
-    )
-}
-
-fn call_ndarray_flatten_index_impl<'ctx, G, Indices>(
-    generator: &G,
-    ctx: &CodeGenContext<'ctx, '_>,
-    ndarray: NDArrayValue<'ctx>,
-    indices: &Indices,
-) -> IntValue<'ctx>
-where
-    G: CodeGenerator + ?Sized,
-    Indices: ArrayLikeIndexer<'ctx>,
-{
-    let llvm_i32 = ctx.ctx.i32_type();
-    let llvm_usize = generator.get_size_type(ctx.ctx);
-
-    let llvm_pi32 = llvm_i32.ptr_type(AddressSpace::default());
-    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
-
-    debug_assert_eq!(
-        IntType::try_from(indices.element_type(ctx, generator))
-            .map(IntType::get_bit_width)
-            .unwrap_or_default(),
-        llvm_i32.get_bit_width(),
-        "Expected i32 value for argument `indices` to `call_ndarray_flatten_index_impl`"
-    );
-    debug_assert_eq!(
-        indices.size(ctx, generator).get_type().get_bit_width(),
-        llvm_usize.get_bit_width(),
-        "Expected usize integer value for argument `indices_size` to `call_ndarray_flatten_index_impl`"
-    );
-
-    let ndarray_flatten_index_fn_name = match llvm_usize.get_bit_width() {
-        32 => "__nac3_ndarray_flatten_index",
-        64 => "__nac3_ndarray_flatten_index64",
-        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
-    };
-    let ndarray_flatten_index_fn =
-        ctx.module.get_function(ndarray_flatten_index_fn_name).unwrap_or_else(|| {
-            let fn_type = llvm_usize.fn_type(
-                &[llvm_pusize.into(), llvm_usize.into(), llvm_pi32.into(), llvm_usize.into()],
-                false,
-            );
-
-            ctx.module.add_function(ndarray_flatten_index_fn_name, fn_type, None)
-        });
-
-    let ndarray_num_dims = ndarray.load_ndims(ctx);
-    let ndarray_dims = ndarray.shape();
-
-    let index = ctx
-        .builder
-        .build_call(
-            ndarray_flatten_index_fn,
-            &[
-                ndarray_dims.base_ptr(ctx, generator).into(),
-                ndarray_num_dims.into(),
-                indices.base_ptr(ctx, generator).into(),
-                indices.size(ctx, generator).into(),
-            ],
-            "",
-        )
-        .map(CallSiteValue::try_as_basic_value)
-        .map(|v| v.map_left(BasicValueEnum::into_int_value))
-        .map(Either::unwrap_left)
-        .unwrap();
-
-    index
-}
-
-/// Generates a call to `__nac3_ndarray_flatten_index`. Returns the flattened index for the
-/// multidimensional index.
-///
-/// * `ndarray` - LLVM pointer to the `NDArray`. This value must be the LLVM representation of an
-///   `NDArray`.
-/// * `indices` - The multidimensional index to compute the flattened index for.
-pub fn call_ndarray_flatten_index<'ctx, G, Index>(
-    generator: &G,
-    ctx: &CodeGenContext<'ctx, '_>,
-    ndarray: NDArrayValue<'ctx>,
-    indices: &Index,
-) -> IntValue<'ctx>
-where
-    G: CodeGenerator + ?Sized,
-    Index: ArrayLikeIndexer<'ctx>,
-{
-    call_ndarray_flatten_index_impl(generator, ctx, ndarray, indices)
-}
-
-/// Generates a call to `__nac3_ndarray_calc_broadcast`. Returns a tuple containing the number of
-/// dimension and size of each dimension of the resultant `ndarray`.
-pub fn call_ndarray_calc_broadcast<'ctx, G: CodeGenerator + ?Sized>(
-    generator: &mut G,
-    ctx: &mut CodeGenContext<'ctx, '_>,
-    lhs: NDArrayValue<'ctx>,
-    rhs: NDArrayValue<'ctx>,
-) -> TypedArrayLikeAdapter<'ctx, IntValue<'ctx>> {
-    let llvm_usize = generator.get_size_type(ctx.ctx);
-    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
-
-    let ndarray_calc_broadcast_fn_name = match llvm_usize.get_bit_width() {
-        32 => "__nac3_ndarray_calc_broadcast",
-        64 => "__nac3_ndarray_calc_broadcast64",
-        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
-    };
-    let ndarray_calc_broadcast_fn =
-        ctx.module.get_function(ndarray_calc_broadcast_fn_name).unwrap_or_else(|| {
-            let fn_type = llvm_usize.fn_type(
-                &[
-                    llvm_pusize.into(),
-                    llvm_usize.into(),
-                    llvm_pusize.into(),
-                    llvm_usize.into(),
-                    llvm_pusize.into(),
-                ],
-                false,
-            );
-
-            ctx.module.add_function(ndarray_calc_broadcast_fn_name, fn_type, None)
-        });
-
-    let lhs_ndims = lhs.load_ndims(ctx);
-    let rhs_ndims = rhs.load_ndims(ctx);
-    let min_ndims = llvm_intrinsics::call_int_umin(ctx, lhs_ndims, rhs_ndims, None);
-
-    gen_for_callback_incrementing(
-        generator,
-        ctx,
-        None,
-        llvm_usize.const_zero(),
-        (min_ndims, false),
-        |generator, ctx, _, idx| {
-            let idx = ctx.builder.build_int_sub(min_ndims, idx, "").unwrap();
-            let (lhs_dim_sz, rhs_dim_sz) = unsafe {
-                (
-                    lhs.shape().get_typed_unchecked(ctx, generator, &idx, None),
-                    rhs.shape().get_typed_unchecked(ctx, generator, &idx, None),
-                )
-            };
-
-            let llvm_usize_const_one = llvm_usize.const_int(1, false);
-            let lhs_eqz = ctx
-                .builder
-                .build_int_compare(IntPredicate::EQ, lhs_dim_sz, llvm_usize_const_one, "")
-                .unwrap();
-            let rhs_eqz = ctx
-                .builder
-                .build_int_compare(IntPredicate::EQ, rhs_dim_sz, llvm_usize_const_one, "")
-                .unwrap();
-            let lhs_or_rhs_eqz = ctx.builder.build_or(lhs_eqz, rhs_eqz, "").unwrap();
-
-            let lhs_eq_rhs = ctx
-                .builder
-                .build_int_compare(IntPredicate::EQ, lhs_dim_sz, rhs_dim_sz, "")
-                .unwrap();
-
-            let is_compatible = ctx.builder.build_or(lhs_or_rhs_eqz, lhs_eq_rhs, "").unwrap();
-
-            ctx.make_assert(
-                generator,
-                is_compatible,
-                "0:ValueError",
-                "operands could not be broadcast together",
-                [None, None, None],
-                ctx.current_loc,
-            );
-
-            Ok(())
-        },
-        llvm_usize.const_int(1, false),
-    )
-    .unwrap();
-
-    let max_ndims = llvm_intrinsics::call_int_umax(ctx, lhs_ndims, rhs_ndims, None);
-    let lhs_dims = lhs.shape().base_ptr(ctx, generator);
-    let lhs_ndims = lhs.load_ndims(ctx);
-    let rhs_dims = rhs.shape().base_ptr(ctx, generator);
-    let rhs_ndims = rhs.load_ndims(ctx);
-    let out_dims = ctx.builder.build_array_alloca(llvm_usize, max_ndims, "").unwrap();
-    let out_dims = ArraySliceValue::from_ptr_val(out_dims, max_ndims, None);
-
-    ctx.builder
-        .build_call(
-            ndarray_calc_broadcast_fn,
-            &[
-                lhs_dims.into(),
-                lhs_ndims.into(),
-                rhs_dims.into(),
-                rhs_ndims.into(),
-                out_dims.base_ptr(ctx, generator).into(),
-            ],
-            "",
-        )
-        .unwrap();
-
-    TypedArrayLikeAdapter::from(
-        out_dims,
-        Box::new(|_, v| v.into_int_value()),
-        Box::new(|_, v| v.into()),
-    )
-}
-
-/// Generates a call to `__nac3_ndarray_calc_broadcast_idx`. Returns an [`ArrayAllocaValue`]
-/// containing the indices used for accessing `array` corresponding to the index of the broadcasted
-/// array `broadcast_idx`.
-pub fn call_ndarray_calc_broadcast_index<
-    'ctx,
-    G: CodeGenerator + ?Sized,
-    BroadcastIdx: UntypedArrayLikeAccessor<'ctx>,
->(
-    generator: &mut G,
-    ctx: &mut CodeGenContext<'ctx, '_>,
-    array: NDArrayValue<'ctx>,
-    broadcast_idx: &BroadcastIdx,
-) -> TypedArrayLikeAdapter<'ctx, IntValue<'ctx>> {
-    let llvm_i32 = ctx.ctx.i32_type();
-    let llvm_usize = generator.get_size_type(ctx.ctx);
-    let llvm_pi32 = llvm_i32.ptr_type(AddressSpace::default());
-    let llvm_pusize = llvm_usize.ptr_type(AddressSpace::default());
-
-    let ndarray_calc_broadcast_fn_name = match llvm_usize.get_bit_width() {
-        32 => "__nac3_ndarray_calc_broadcast_idx",
-        64 => "__nac3_ndarray_calc_broadcast_idx64",
-        bw => codegen_unreachable!(ctx, "Unsupported size type bit width: {}", bw),
-    };
-    let ndarray_calc_broadcast_fn =
-        ctx.module.get_function(ndarray_calc_broadcast_fn_name).unwrap_or_else(|| {
-            let fn_type = llvm_usize.fn_type(
-                &[llvm_pusize.into(), llvm_usize.into(), llvm_pi32.into(), llvm_pi32.into()],
-                false,
-            );
-
-            ctx.module.add_function(ndarray_calc_broadcast_fn_name, fn_type, None)
-        });
-
-    let broadcast_size = broadcast_idx.size(ctx, generator);
-    let out_idx = ctx.builder.build_array_alloca(llvm_i32, broadcast_size, "").unwrap();
-
-    let array_dims = array.shape().base_ptr(ctx, generator);
-    let array_ndims = array.load_ndims(ctx);
-    let broadcast_idx_ptr = unsafe {
-        broadcast_idx.ptr_offset_unchecked(ctx, generator, &llvm_usize.const_zero(), None)
-    };
-
-    ctx.builder
-        .build_call(
-            ndarray_calc_broadcast_fn,
-            &[array_dims.into(), array_ndims.into(), broadcast_idx_ptr.into(), out_idx.into()],
-            "",
-        )
-        .unwrap();
-
-    TypedArrayLikeAdapter::from(
-        ArraySliceValue::from_ptr_val(out_idx, broadcast_size, None),
-        Box::new(|_, v| v.into_int_value()),
-        Box::new(|_, v| v.into()),
-    )
-}
+mod matmul;
+mod reshape;
+mod transpose;
--- a/nac3core/src/codegen/irrt/ndarray/reshape.rs
+++ b/nac3core/src/codegen/irrt/ndarray/reshape.rs
@ -0,0 +1,39 @@
+use inkwell::values::IntValue;
+
+use crate::codegen::{
+    expr::infer_and_call_function,
+    irrt::get_usize_dependent_function_name,
+    values::{ArrayLikeValue, ArraySliceValue},
+    CodeGenContext, CodeGenerator,
+};
+
+/// Generates a call to `__nac3_ndarray_reshape_resolve_and_check_new_shape`.
+///
+/// Resolves unknown dimensions in `new_shape` for `numpy.reshape(<ndarray>, new_shape)`, raising an
+/// assertion if multiple dimensions are unknown (`-1`).
+pub fn call_nac3_ndarray_reshape_resolve_and_check_new_shape<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &G,
+    ctx: &CodeGenContext<'ctx, '_>,
+    size: IntValue<'ctx>,
+    new_ndims: IntValue<'ctx>,
+    new_shape: ArraySliceValue<'ctx>,
+) {
+    let llvm_usize = ctx.get_size_type();
+
+    assert_eq!(size.get_type(), llvm_usize);
+    assert_eq!(new_ndims.get_type(), llvm_usize);
+    assert_eq!(new_shape.element_type(ctx, generator), llvm_usize.into());
+
+    let name = get_usize_dependent_function_name(
+        ctx,
+        "__nac3_ndarray_reshape_resolve_and_check_new_shape",
+    );
+    infer_and_call_function(
+        ctx,
+        &name,
+        None,
+        &[size.into(), new_ndims.into(), new_shape.base_ptr(ctx, generator).into()],
+        None,
+        None,
+    );
+}
--- a/nac3core/src/codegen/irrt/ndarray/transpose.rs
+++ b/nac3core/src/codegen/irrt/ndarray/transpose.rs
@ -0,0 +1,48 @@
+use inkwell::{values::IntValue, AddressSpace};
+
+use crate::codegen::{
+    expr::infer_and_call_function,
+    irrt::get_usize_dependent_function_name,
+    values::{ndarray::NDArrayValue, ProxyValue, TypedArrayLikeAccessor},
+    CodeGenContext, CodeGenerator,
+};
+
+/// Generates a call to `__nac3_ndarray_transpose`.
+///
+/// Creates a transpose view of `src_ndarray` and writes the result to `dst_ndarray`.
+///
+/// `dst_ndarray` must fulfill the following preconditions:
+///
+/// - `dst_ndarray.ndims` must be initialized and must be equal to `src_ndarray.ndims`.
+/// - `dst_ndarray.shape` must be allocated and may contain uninitialized values.
+/// - `dst_ndarray.strides` must be allocated and may contain uninitialized values.
+pub fn call_nac3_ndarray_transpose<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &G,
+    ctx: &CodeGenContext<'ctx, '_>,
+    src_ndarray: NDArrayValue<'ctx>,
+    dst_ndarray: NDArrayValue<'ctx>,
+    axes: Option<&impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>>,
+) {
+    let llvm_usize = ctx.get_size_type();
+
+    assert!(axes.is_none_or(|axes| axes.size(ctx, generator).get_type() == llvm_usize));
+    assert!(axes.is_none_or(|axes| axes.element_type(ctx, generator) == llvm_usize.into()));
+
+    let name = get_usize_dependent_function_name(ctx, "__nac3_ndarray_transpose");
+    infer_and_call_function(
+        ctx,
+        &name,
+        None,
+        &[
+            src_ndarray.as_base_value().into(),
+            dst_ndarray.as_base_value().into(),
+            axes.map_or(llvm_usize.const_zero(), |axes| axes.size(ctx, generator)).into(),
+            axes.map_or(llvm_usize.ptr_type(AddressSpace::default()).const_null(), |axes| {
+                axes.base_ptr(ctx, generator)
+            })
+            .into(),
+        ],
+        None,
+        None,
+    );
+}
--- a/nac3core/src/codegen/irrt/range.rs
+++ b/nac3core/src/codegen/irrt/range.rs
@ -6,6 +6,13 @@ use itertools::Either;

 use crate::codegen::{CodeGenContext, CodeGenerator};

+/// Invokes the `__nac3_range_slice_len` in IRRT.
+///
+/// - `start`: The `i32` start value for the slice.
+/// - `end`: The `i32` end value for the slice.
+/// - `step`: The `i32` step value for the slice.
+///
+/// Returns an `i32` value of the length of the slice.
 pub fn calculate_len_for_slice_range<'ctx, G: CodeGenerator + ?Sized>(
    generator: &mut G,
    ctx: &mut CodeGenContext<'ctx, '_>,
@ -14,9 +21,15 @@ pub fn calculate_len_for_slice_range<'ctx, G: CodeGenerator + ?Sized>(
    step: IntValue<'ctx>,
 ) -> IntValue<'ctx> {
    const SYMBOL: &str = "__nac3_range_slice_len";
+
+    let llvm_i32 = ctx.ctx.i32_type();
+
+    assert_eq!(start.get_type(), llvm_i32);
+    assert_eq!(end.get_type(), llvm_i32);
+    assert_eq!(step.get_type(), llvm_i32);
+
    let len_func = ctx.module.get_function(SYMBOL).unwrap_or_else(|| {
-        let i32_t = ctx.ctx.i32_type();
-        let fn_t = i32_t.fn_type(&[i32_t.into(), i32_t.into(), i32_t.into()], false);
+        let fn_t = llvm_i32.fn_type(&[llvm_i32.into(), llvm_i32.into(), llvm_i32.into()], false);
        ctx.module.add_function(SYMBOL, fn_t, None)
    });

@ -33,6 +46,7 @@ pub fn calculate_len_for_slice_range<'ctx, G: CodeGenerator + ?Sized>(
        [None, None, None],
        ctx.current_loc,
    );
+
    ctx.builder
        .build_call(len_func, &[start.into(), end.into(), step.into()], "calc_len")
        .map(CallSiteValue::try_as_basic_value)
--- a/nac3core/src/codegen/irrt/string.rs
+++ b/nac3core/src/codegen/irrt/string.rs
@ -0,0 +1,45 @@
+use inkwell::values::{BasicValueEnum, CallSiteValue, IntValue, PointerValue};
+use itertools::Either;
+
+use super::get_usize_dependent_function_name;
+use crate::codegen::CodeGenContext;
+
+/// Generates a call to string equality comparison. Returns an `i1` representing whether the strings are equal.
+pub fn call_string_eq<'ctx>(
+    ctx: &CodeGenContext<'ctx, '_>,
+    str1_ptr: PointerValue<'ctx>,
+    str1_len: IntValue<'ctx>,
+    str2_ptr: PointerValue<'ctx>,
+    str2_len: IntValue<'ctx>,
+) -> IntValue<'ctx> {
+    let llvm_i1 = ctx.ctx.bool_type();
+
+    let func_name = get_usize_dependent_function_name(ctx, "nac3_str_eq");
+
+    let func = ctx.module.get_function(&func_name).unwrap_or_else(|| {
+        ctx.module.add_function(
+            &func_name,
+            llvm_i1.fn_type(
+                &[
+                    str1_ptr.get_type().into(),
+                    str1_len.get_type().into(),
+                    str2_ptr.get_type().into(),
+                    str2_len.get_type().into(),
+                ],
+                false,
+            ),
+            None,
+        )
+    });
+
+    ctx.builder
+        .build_call(
+            func,
+            &[str1_ptr.into(), str1_len.into(), str2_ptr.into(), str2_len.into()],
+            "str_eq_call",
+        )
+        .map(CallSiteValue::try_as_basic_value)
+        .map(|v| v.map_left(BasicValueEnum::into_int_value))
+        .map(Either::unwrap_left)
+        .unwrap()
+}
--- a/nac3core/src/codegen/llvm_intrinsics.rs
+++ b/nac3core/src/codegen/llvm_intrinsics.rs
@ -1,7 +1,6 @@
 use inkwell::{
-    context::Context,
    intrinsics::Intrinsic,
-    types::{AnyTypeEnum::IntType, FloatType},
+    types::AnyTypeEnum::IntType,
    values::{BasicValueEnum, CallSiteValue, FloatValue, IntValue, PointerValue},
    AddressSpace,
 };
@ -9,34 +8,6 @@ use itertools::Either;

 use super::CodeGenContext;

-/// Returns the string representation for the floating-point type `ft` when used in intrinsic
-/// functions.
-fn get_float_intrinsic_repr(ctx: &Context, ft: FloatType) -> &'static str {
-    // Standard LLVM floating-point types
-    if ft == ctx.f16_type() {
-        return "f16";
-    }
-    if ft == ctx.f32_type() {
-        return "f32";
-    }
-    if ft == ctx.f64_type() {
-        return "f64";
-    }
-    if ft == ctx.f128_type() {
-        return "f128";
-    }
-
-    // Non-standard floating-point types
-    if ft == ctx.x86_f80_type() {
-        return "f80";
-    }
-    if ft == ctx.ppc_f128_type() {
-        return "ppcf128";
-    }
-
-    unreachable!()
-}
-
 /// Invokes the [`llvm.va_start`](https://llvm.org/docs/LangRef.html#llvm-va-start-intrinsic)
 /// intrinsic.
 pub fn call_va_start<'ctx>(ctx: &CodeGenContext<'ctx, '_>, arglist: PointerValue<'ctx>) {
@ -54,7 +25,7 @@ pub fn call_va_start<'ctx>(ctx: &CodeGenContext<'ctx, '_>, arglist: PointerValue
    ctx.builder.build_call(intrinsic_fn, &[arglist.into()], "").unwrap();
 }

-/// Invokes the [`llvm.va_start`](https://llvm.org/docs/LangRef.html#llvm-va-start-intrinsic)
+/// Invokes the [`llvm.va_end`](https://llvm.org/docs/LangRef.html#llvm-va-end-intrinsic)
 /// intrinsic.
 pub fn call_va_end<'ctx>(ctx: &CodeGenContext<'ctx, '_>, arglist: PointerValue<'ctx>) {
    const FN_NAME: &str = "llvm.va_end";
--- a/nac3core/src/codegen/mod.rs
+++ b/nac3core/src/codegen/mod.rs
@ -1,4 +1,5 @@
 use std::{
+    cell::OnceCell,
    collections::{HashMap, HashSet},
    sync::{
        atomic::{AtomicBool, Ordering},
@ -19,7 +20,7 @@ use inkwell::{
    module::Module,
    passes::PassBuilderOptions,
    targets::{CodeModel, RelocMode, Target, TargetMachine, TargetTriple},
-    types::{AnyType, BasicType, BasicTypeEnum},
+    types::{AnyType, BasicType, BasicTypeEnum, IntType},
    values::{BasicValueEnum, FunctionValue, IntValue, PhiValue, PointerValue},
    AddressSpace, IntPredicate, OptimizationLevel,
 };
@ -42,7 +43,7 @@ use crate::{
 };
 use concrete_type::{ConcreteType, ConcreteTypeEnum, ConcreteTypeStore};
 pub use generator::{CodeGenerator, DefaultCodeGenerator};
-use types::{ndarray::NDArrayType, ListType, ProxyType, RangeType};
+use types::{ndarray::NDArrayType, ListType, ProxyType, RangeType, TupleType};

 pub mod builtin_fns;
 pub mod concrete_type;
@ -226,14 +227,33 @@ pub struct CodeGenContext<'ctx, 'a> {

    /// The current source location.
    pub current_loc: Location,
+
+    /// The cached type of `size_t`.
+    llvm_usize: OnceCell<IntType<'ctx>>,
 }

-impl<'ctx, 'a> CodeGenContext<'ctx, 'a> {
+impl<'ctx> CodeGenContext<'ctx, '_> {
    /// Whether the [current basic block][Builder::get_insert_block] referenced by `builder`
    /// contains a [terminator statement][BasicBlock::get_terminator].
    pub fn is_terminated(&self) -> bool {
        self.builder.get_insert_block().and_then(BasicBlock::get_terminator).is_some()
    }
+
+    /// Returns a [`IntType`] representing `size_t` for the compilation target as specified by
+    /// [`self.registry`][WorkerRegistry].
+    pub fn get_size_type(&self) -> IntType<'ctx> {
+        *self.llvm_usize.get_or_init(|| {
+            self.ctx.ptr_sized_int_type(
+                &self
+                    .registry
+                    .llvm_options
+                    .create_target_machine()
+                    .map(|tm| tm.get_target_data())
+                    .unwrap(),
+                None,
+            )
+        })
+    }
 }

 type Fp = Box<dyn Fn(&Module) + Send + Sync>;
@ -481,6 +501,38 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
    type_cache.get(&unifier.get_representative(ty)).copied().unwrap_or_else(|| {
        let ty_enum = unifier.get_ty(ty);
        let result = match &*ty_enum {
+            TModule {module_id, attributes} => {
+                let top_level_defs = top_level.definitions.read();
+                let definition = top_level_defs.get(module_id.0).unwrap();
+                let TopLevelDef::Module { name, attributes: attribute_fields, .. } = &*definition.read() else {
+                    unreachable!()
+                };
+                let ty: BasicTypeEnum<'_> = if let Some(t) = module.get_struct_type(&name.to_string()) {
+                    t.ptr_type(AddressSpace::default()).into()
+                } else {
+                    let struct_type = ctx.opaque_struct_type(&name.to_string());
+                    type_cache.insert(
+                        unifier.get_representative(ty),
+                        struct_type.ptr_type(AddressSpace::default()).into(),
+                    );
+                    let module_fields: Vec<BasicTypeEnum<'_>> = attribute_fields.iter()
+                    .map(|f| {
+                        get_llvm_type(
+                            ctx,
+                            module,
+                            generator,
+                            unifier,
+                            top_level,
+                            type_cache,
+                            attributes[&f.0].0,
+                        )
+                    })
+                    .collect_vec();
+                    struct_type.set_body(&module_fields, false);
+                    struct_type.ptr_type(AddressSpace::default()).into()
+                };
+                return ty;
+            },
            TObj { obj_id, fields, .. } => {
                // check to avoid treating non-class primitives as classes
                if PrimDef::contains_id(*obj_id) {
@ -510,7 +562,7 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                                *params.iter().next().unwrap().1,
                            );

-                            ListType::new(generator, ctx, element_type).as_base_type().into()
+                            ListType::new_with_generator(generator, ctx, element_type).as_base_type().into()
                        }

                        TObj { obj_id, .. } if *obj_id == PrimDef::NDArray.id() => {
@ -520,7 +572,7 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                                ctx, module, generator, unifier, top_level, type_cache, dtype,
                            );

-                            NDArrayType::new(generator, ctx, element_type, Some(ndims)).as_base_type().into()
+                            NDArrayType::new_with_generator(generator, ctx, element_type, ndims).as_base_type().into()
                        }

                        _ => unreachable!(
@ -574,7 +626,7 @@ fn get_llvm_type<'ctx, G: CodeGenerator + ?Sized>(
                        get_llvm_type(ctx, module, generator, unifier, top_level, type_cache, *ty)
                    })
                    .collect_vec();
-                ctx.struct_type(&fields, false).into()
+                TupleType::new_with_generator(generator, ctx, &fields).as_base_type().into()
            }
            TVirtual { .. } => unimplemented!(),
            _ => unreachable!("{}", ty_enum.get_type_name()),
@ -987,8 +1039,20 @@ pub fn gen_func_impl<
        need_sret: has_sret,
        current_loc: Location::default(),
        debug_info: (dibuilder, compile_unit, func_scope.as_debug_info_scope()),
+        llvm_usize: OnceCell::default(),
    };

+    let target_llvm_usize = context.ptr_sized_int_type(
+        &registry.llvm_options.create_target_machine().map(|tm| tm.get_target_data()).unwrap(),
+        None,
+    );
+    let generator_llvm_usize = generator.get_size_type(context);
+    assert_eq!(
+        generator_llvm_usize,
+        target_llvm_usize,
+        "CodeGenerator (size_t = {generator_llvm_usize}) is not compatible with CodeGen Target (size_t = {target_llvm_usize})",
+    );
+
    let loc = code_gen_context.debug_info.0.create_debug_location(
        context,
        row as u32,
@ -1180,7 +1244,7 @@ pub fn type_aligned_alloca<'ctx, G: CodeGenerator + ?Sized>(

    let llvm_i8 = ctx.ctx.i8_type();
    let llvm_pi8 = llvm_i8.ptr_type(AddressSpace::default());
-    let llvm_usize = generator.get_size_type(ctx.ctx);
+    let llvm_usize = ctx.get_size_type();
    let align_ty = align_ty.into();

    let size = ctx.builder.build_int_truncate_or_bit_cast(size, llvm_usize, "").unwrap();
--- a/nac3core/src/codegen/numpy.rs
+++ b/nac3core/src/codegen/numpy.rs
--- a/nac3core/src/codegen/stmt.rs
+++ b/nac3core/src/codegen/stmt.rs
@ -1,6 +1,7 @@
 use inkwell::{
    attributes::{Attribute, AttributeLoc},
    basic_block::BasicBlock,
+    builder::Builder,
    types::{BasicType, BasicTypeEnum},
    values::{BasicValue, BasicValueEnum, FunctionValue, IntValue, PointerValue},
    IntPredicate,
@ -16,7 +17,11 @@ use super::{
    gen_in_range_check,
    irrt::{handle_slice_indices, list_slice_assignment},
    macros::codegen_unreachable,
-    values::{ArrayLikeIndexer, ArraySliceValue, ListValue, RangeValue},
+    types::ndarray::NDArrayType,
+    values::{
+        ndarray::{RustNDIndex, ScalarOrNDArray},
+        ArrayLikeIndexer, ArraySliceValue, ListValue, ProxyValue, RangeValue,
+    },
    CodeGenContext, CodeGenerator,
 };
 use crate::{
@ -302,7 +307,7 @@ pub fn gen_setitem<'ctx, G: CodeGenerator>(
            if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
        {
            // Handle list item assignment
-            let llvm_usize = generator.get_size_type(ctx.ctx);
+            let llvm_usize = ctx.get_size_type();
            let target_item_ty = iter_type_vars(list_params).next().unwrap().ty;

            let target = generator
@ -363,10 +368,8 @@ pub fn gen_setitem<'ctx, G: CodeGenerator>(
                    .unwrap()
                    .to_basic_value_enum(ctx, generator, key_ty)?
                    .into_int_value();
-                let index = ctx
-                    .builder
-                    .build_int_s_extend(index, generator.get_size_type(ctx.ctx), "sext")
-                    .unwrap();
+                let index =
+                    ctx.builder.build_int_s_extend(index, ctx.get_size_type(), "sext").unwrap();

                // handle negative index
                let is_negative = ctx
@ -374,7 +377,7 @@ pub fn gen_setitem<'ctx, G: CodeGenerator>(
                    .build_int_compare(
                        IntPredicate::SLT,
                        index,
-                        generator.get_size_type(ctx.ctx).const_zero(),
+                        ctx.get_size_type().const_zero(),
                        "is_neg",
                    )
                    .unwrap();
@ -411,7 +414,51 @@ pub fn gen_setitem<'ctx, G: CodeGenerator>(
            if *obj_id == ctx.primitives.ndarray.obj_id(&ctx.unifier).unwrap() =>
        {
            // Handle NDArray item assignment
-            todo!("ndarray subscript assignment is not yet implemented");
+            // Process target
+            let target = generator
+                .gen_expr(ctx, target)?
+                .unwrap()
+                .to_basic_value_enum(ctx, generator, target_ty)?;
+
+            // Process key
+            let key = RustNDIndex::from_subscript_expr(generator, ctx, key)?;
+
+            // Process value
+            let value = value.to_basic_value_enum(ctx, generator, value_ty)?;
+
+            // Reference code:
+            // ```python
+            // target = target[key]
+            // value = np.asarray(value)
+            //
+            // shape = np.broadcast_shape((target, value))
+            //
+            // target = np.broadcast_to(target, shape)
+            // value = np.broadcast_to(value, shape)
+            //
+            // # ...and finally copy 1-1 from value to target.
+            // ```
+
+            let target = NDArrayType::from_unifier_type(generator, ctx, target_ty)
+                .map_value(target.into_pointer_value(), None);
+            let target = target.index(generator, ctx, &key);
+
+            let value = ScalarOrNDArray::from_value(generator, ctx, (value_ty, value))
+                .to_ndarray(generator, ctx);
+
+            let broadcast_ndims =
+                [target.get_type().ndims(), value.get_type().ndims()].into_iter().max().unwrap();
+            let broadcast_result = NDArrayType::new(
+                ctx,
+                value.get_type().element_type(),
+                broadcast_ndims,
+            )
+            .broadcast(generator, ctx, &[target, value]);
+
+            let target = broadcast_result.ndarrays[0];
+            let value = broadcast_result.ndarrays[1];
+
+            target.copy_data_from(ctx, value);
        }
        _ => {
            panic!("encountered unknown target type: {}", ctx.unifier.stringify(target_ty));
@ -435,7 +482,7 @@ pub fn gen_for<G: CodeGenerator>(
    let var_assignment = ctx.var_assignment.clone();

    let int32 = ctx.ctx.i32_type();
-    let size_t = generator.get_size_type(ctx.ctx);
+    let size_t = ctx.get_size_type();
    let zero = int32.const_zero();
    let current = ctx.builder.get_insert_block().and_then(BasicBlock::get_parent).unwrap();
    let body_bb = ctx.ctx.append_basic_block(current, "for.body");
@ -616,11 +663,25 @@ pub fn gen_for<G: CodeGenerator>(
 #[derive(PartialEq, Eq, Debug, Clone, Copy, Hash)]
 pub struct BreakContinueHooks<'ctx> {
    /// The [exit block][`BasicBlock`] to branch to when `break`-ing out of a loop.
-    pub exit_bb: BasicBlock<'ctx>,
+    exit_bb: BasicBlock<'ctx>,

    /// The [latch basic block][`BasicBlock`] to branch to for `continue`-ing to the next iteration
    /// of the loop.
-    pub latch_bb: BasicBlock<'ctx>,
+    latch_bb: BasicBlock<'ctx>,
+}
+
+impl<'ctx> BreakContinueHooks<'ctx> {
+    /// Creates a [`br` instruction][Builder::build_unconditional_branch] to the exit
+    /// [`BasicBlock`], as if by calling `break`.
+    pub fn build_break_branch(&self, builder: &Builder<'ctx>) {
+        builder.build_unconditional_branch(self.exit_bb).unwrap();
+    }
+
+    /// Creates a [`br` instruction][Builder::build_unconditional_branch] to the latch
+    /// [`BasicBlock`], as if by calling `continue`.
+    pub fn build_continue_branch(&self, builder: &Builder<'ctx>) {
+        builder.build_unconditional_branch(self.latch_bb).unwrap();
+    }
 }

 /// Generates a C-style `for` construct using lambdas, similar to the following C code:
--- a/nac3core/src/codegen/test.rs
+++ b/nac3core/src/codegen/test.rs
@ -36,7 +36,6 @@ use crate::{
 struct Resolver {
    id_to_type: HashMap<StrRef, Type>,
    id_to_def: RwLock<HashMap<StrRef, DefinitionId>>,
-    class_names: HashMap<StrRef, Type>,
 }

 impl Resolver {
@ -98,19 +97,18 @@ fn test_primitives() {
        "};
    let statements = parse_program(source, FileName::default()).unwrap();

-    let composer = TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 32).0;
+    let context = inkwell::context::Context::create();
+    let composer = TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;
    let mut unifier = composer.unifier.clone();
    let primitives = composer.primitives_ty;
    let top_level = Arc::new(composer.make_top_level_context());
    unifier.top_level = Some(top_level.clone());

-    let resolver = Arc::new(Resolver {
-        id_to_type: HashMap::new(),
-        id_to_def: RwLock::new(HashMap::new()),
-        class_names: HashMap::default(),
-    }) as Arc<dyn SymbolResolver + Send + Sync>;
+    let resolver =
+        Arc::new(Resolver { id_to_type: HashMap::new(), id_to_def: RwLock::new(HashMap::new()) })
+            as Arc<dyn SymbolResolver + Send + Sync>;

-    let threads = vec![DefaultCodeGenerator::new("test".into(), 32).into()];
+    let threads = vec![DefaultCodeGenerator::new("test".into(), context.i64_type()).into()];
    let signature = FunSignature {
        args: vec![
            FuncArg {
@ -263,7 +261,8 @@ fn test_simple_call() {
        "};
    let statements_2 = parse_program(source_2, FileName::default()).unwrap();

-    let composer = TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 32).0;
+    let context = inkwell::context::Context::create();
+    let composer = TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;
    let mut unifier = composer.unifier.clone();
    let primitives = composer.primitives_ty;
    let top_level = Arc::new(composer.make_top_level_context());
@ -298,11 +297,7 @@ fn test_simple_call() {
        loc: None,
    })));

-    let resolver = Resolver {
-        id_to_type: HashMap::new(),
-        id_to_def: RwLock::new(HashMap::new()),
-        class_names: HashMap::default(),
-    };
+    let resolver = Resolver { id_to_type: HashMap::new(), id_to_def: RwLock::new(HashMap::new()) };
    resolver.add_id_def("foo".into(), DefinitionId(foo_id));
    let resolver = Arc::new(resolver) as Arc<dyn SymbolResolver + Send + Sync>;

@ -314,7 +309,7 @@ fn test_simple_call() {
        unreachable!()
    }

-    let threads = vec![DefaultCodeGenerator::new("test".into(), 32).into()];
+    let threads = vec![DefaultCodeGenerator::new("test".into(), context.i64_type()).into()];
    let mut function_data = FunctionData {
        resolver: resolver.clone(),
        bound_variables: Vec::new(),
@ -446,12 +441,12 @@ fn test_simple_call() {
 #[test]
 fn test_classes_list_type_new() {
    let ctx = inkwell::context::Context::create();
-    let generator = DefaultCodeGenerator::new(String::new(), 64);
+    let generator = DefaultCodeGenerator::new(String::new(), ctx.i64_type());

    let llvm_i32 = ctx.i32_type();
    let llvm_usize = generator.get_size_type(&ctx);

-    let llvm_list = ListType::new(&generator, &ctx, llvm_i32.into());
+    let llvm_list = ListType::new_with_generator(&generator, &ctx, llvm_i32.into());
    assert!(ListType::is_representable(llvm_list.as_base_type(), llvm_usize).is_ok());
 }

@ -466,11 +461,11 @@ fn test_classes_range_type_new() {
 #[test]
 fn test_classes_ndarray_type_new() {
    let ctx = inkwell::context::Context::create();
-    let generator = DefaultCodeGenerator::new(String::new(), 64);
+    let generator = DefaultCodeGenerator::new(String::new(), ctx.i64_type());

    let llvm_i32 = ctx.i32_type();
    let llvm_usize = generator.get_size_type(&ctx);

-    let llvm_ndarray = NDArrayType::new(&generator, &ctx, llvm_i32.into(), None);
+    let llvm_ndarray = NDArrayType::new_with_generator(&generator, &ctx, llvm_i32.into(), 2);
    assert!(NDArrayType::is_representable(llvm_ndarray.as_base_type(), llvm_usize).is_ok());
 }
--- a/nac3core/src/codegen/types/list.rs
+++ b/nac3core/src/codegen/types/list.rs
@ -1,84 +1,184 @@
 use inkwell::{
-    context::Context,
+    context::{AsContextRef, Context},
    types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType},
-    values::IntValue,
-    AddressSpace,
+    values::{IntValue, PointerValue},
+    AddressSpace, IntPredicate, OptimizationLevel,
 };
+use itertools::Itertools;
+
+use nac3core_derive::StructFields;

 use super::ProxyType;
-use crate::codegen::{
-    values::{ArraySliceValue, ListValue, ProxyValue},
-    CodeGenContext, CodeGenerator,
+use crate::{
+    codegen::{
+        types::structure::{
+            check_struct_type_matches_fields, FieldIndexCounter, StructField, StructFields,
+        },
+        values::{ListValue, ProxyValue},
+        CodeGenContext, CodeGenerator,
+    },
+    typecheck::typedef::{iter_type_vars, Type, TypeEnum},
 };

 /// Proxy type for a `list` type in LLVM.
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 pub struct ListType<'ctx> {
    ty: PointerType<'ctx>,
+    item: Option<BasicTypeEnum<'ctx>>,
    llvm_usize: IntType<'ctx>,
 }

+#[derive(PartialEq, Eq, Clone, Copy, StructFields)]
+pub struct ListStructFields<'ctx> {
+    /// Array pointer to content.
+    #[value_type(i8_type().ptr_type(AddressSpace::default()))]
+    pub items: StructField<'ctx, PointerValue<'ctx>>,
+
+    /// Number of items in the array.
+    #[value_type(usize)]
+    pub len: StructField<'ctx, IntValue<'ctx>>,
+}
+
+impl<'ctx> ListStructFields<'ctx> {
+    #[must_use]
+    pub fn new_typed(item: BasicTypeEnum<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
+        let mut counter = FieldIndexCounter::default();
+
+        ListStructFields {
+            items: StructField::create(
+                &mut counter,
+                "items",
+                item.ptr_type(AddressSpace::default()),
+            ),
+            len: StructField::create(&mut counter, "len", llvm_usize),
+        }
+    }
+}
+
 impl<'ctx> ListType<'ctx> {
    /// Checks whether `llvm_ty` represents a `list` type, returning [Err] if it does not.
    pub fn is_representable(
        llvm_ty: PointerType<'ctx>,
        llvm_usize: IntType<'ctx>,
    ) -> Result<(), String> {
-        let llvm_list_ty = llvm_ty.get_element_type();
-        let AnyTypeEnum::StructType(llvm_list_ty) = llvm_list_ty else {
-            return Err(format!("Expected struct type for `list` type, got {llvm_list_ty}"));
-        };
-        if llvm_list_ty.count_fields() != 2 {
-            return Err(format!(
-                "Expected 2 fields in `list`, got {}",
-                llvm_list_ty.count_fields()
-            ));
-        }
+        let ctx = llvm_ty.get_context();

-        let list_size_ty = llvm_list_ty.get_field_type_at_index(0).unwrap();
-        let Ok(_) = PointerType::try_from(list_size_ty) else {
-            return Err(format!("Expected pointer type for `list.0`, got {list_size_ty}"));
+        let llvm_ty = llvm_ty.get_element_type();
+        let AnyTypeEnum::StructType(llvm_ty) = llvm_ty else {
+            return Err(format!("Expected struct type for `list` type, got {llvm_ty}"));
        };

-        let list_data_ty = llvm_list_ty.get_field_type_at_index(1).unwrap();
-        let Ok(list_data_ty) = IntType::try_from(list_data_ty) else {
-            return Err(format!("Expected int type for `list.1`, got {list_data_ty}"));
-        };
-        if list_data_ty.get_bit_width() != llvm_usize.get_bit_width() {
-            return Err(format!(
-                "Expected {}-bit int type for `list.1`, got {}-bit int",
-                llvm_usize.get_bit_width(),
-                list_data_ty.get_bit_width()
-            ));
-        }
+        let fields = ListStructFields::new(ctx, llvm_usize);

-        Ok(())
+        check_struct_type_matches_fields(
+            fields,
+            llvm_ty,
+            "list",
+            &[(fields.items.name(), &|ty| {
+                if ty.is_pointer_type() {
+                    Ok(())
+                } else {
+                    Err(format!("Expected T* for `list.items`, got {ty}"))
+                }
+            })],
+        )
+    }
+
+    /// Returns an instance of [`StructFields`] containing all field accessors for this type.
+    #[must_use]
+    fn fields(item: BasicTypeEnum<'ctx>, llvm_usize: IntType<'ctx>) -> ListStructFields<'ctx> {
+        ListStructFields::new_typed(item, llvm_usize)
+    }
+
+    /// See [`ListType::fields`].
+    // TODO: Move this into e.g. StructProxyType
+    #[must_use]
+    pub fn get_fields(&self, _ctx: &impl AsContextRef<'ctx>) -> ListStructFields<'ctx> {
+        Self::fields(self.item.unwrap_or(self.llvm_usize.into()), self.llvm_usize)
    }

    /// Creates an LLVM type corresponding to the expected structure of a `List`.
    #[must_use]
    fn llvm_type(
        ctx: &'ctx Context,
-        element_type: BasicTypeEnum<'ctx>,
+        element_type: Option<BasicTypeEnum<'ctx>>,
        llvm_usize: IntType<'ctx>,
    ) -> PointerType<'ctx> {
-        // struct List { data: T*, size: size_t }
-        let field_tys = [element_type.ptr_type(AddressSpace::default()).into(), llvm_usize.into()];
+        let element_type = element_type.map_or(llvm_usize.into(), |ty| ty.as_basic_type_enum());
+
+        let field_tys =
+            Self::fields(element_type, llvm_usize).into_iter().map(|field| field.1).collect_vec();

        ctx.struct_type(&field_tys, false).ptr_type(AddressSpace::default())
    }

+    fn new_impl(
+        ctx: &'ctx Context,
+        element_type: Option<BasicTypeEnum<'ctx>>,
+        llvm_usize: IntType<'ctx>,
+    ) -> Self {
+        let llvm_list = Self::llvm_type(ctx, element_type, llvm_usize);
+
+        Self { ty: llvm_list, item: element_type, llvm_usize }
+    }
+
    /// Creates an instance of [`ListType`].
    #[must_use]
-    pub fn new<G: CodeGenerator + ?Sized>(
+    pub fn new(ctx: &CodeGenContext<'ctx, '_>, element_type: &impl BasicType<'ctx>) -> Self {
+        Self::new_impl(ctx.ctx, Some(element_type.as_basic_type_enum()), ctx.get_size_type())
+    }
+
+    /// Creates an instance of [`ListType`].
+    #[must_use]
+    pub fn new_with_generator<G: CodeGenerator + ?Sized>(
        generator: &G,
        ctx: &'ctx Context,
        element_type: BasicTypeEnum<'ctx>,
    ) -> Self {
-        let llvm_usize = generator.get_size_type(ctx);
-        let llvm_list = Self::llvm_type(ctx, element_type, llvm_usize);
+        Self::new_impl(ctx, Some(element_type.as_basic_type_enum()), generator.get_size_type(ctx))
+    }

-        ListType::from_type(llvm_list, llvm_usize)
+    /// Creates an instance of [`ListType`] with an unknown element type.
+    #[must_use]
+    pub fn new_untyped(ctx: &CodeGenContext<'ctx, '_>) -> Self {
+        Self::new_impl(ctx.ctx, None, ctx.get_size_type())
+    }
+
+    /// Creates an instance of [`ListType`] with an unknown element type.
+    #[must_use]
+    pub fn new_untyped_with_generator<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> Self {
+        Self::new_impl(ctx, None, generator.get_size_type(ctx))
+    }
+
+    /// Creates an [`ListType`] from a [unifier type][Type].
+    #[must_use]
+    pub fn from_unifier_type<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        ty: Type,
+    ) -> Self {
+        // Check unifier type and extract `item_type`
+        let elem_type = match &*ctx.unifier.get_ty_immutable(ty) {
+            TypeEnum::TObj { obj_id, params, .. }
+                if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
+            {
+                iter_type_vars(params).next().unwrap().ty
+            }
+
+            _ => panic!("Expected `list` type, but got {}", ctx.unifier.stringify(ty)),
+        };
+
+        let llvm_usize = ctx.get_size_type();
+        let llvm_elem_type = if let TypeEnum::TVar { .. } = &*ctx.unifier.get_ty_immutable(ty) {
+            None
+        } else {
+            Some(ctx.get_llvm_type(generator, elem_type))
+        };
+
+        Self::new_impl(ctx.ctx, llvm_elem_type, llvm_usize)
    }

    /// Creates an [`ListType`] from a [`PointerType`].
@ -86,47 +186,141 @@ impl<'ctx> ListType<'ctx> {
    pub fn from_type(ptr_ty: PointerType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
        debug_assert!(Self::is_representable(ptr_ty, llvm_usize).is_ok());

-        ListType { ty: ptr_ty, llvm_usize }
+        let ctx = ptr_ty.get_context();
+
+        // We are just searching for the index off a field - Slot an arbitrary element type in.
+        let item_field_idx =
+            Self::fields(ctx.i8_type().into(), llvm_usize).index_of_field(|f| f.items);
+        let item = unsafe {
+            ptr_ty
+                .get_element_type()
+                .into_struct_type()
+                .get_field_type_at_index_unchecked(item_field_idx)
+                .into_pointer_type()
+                .get_element_type()
+        };
+        let item = BasicTypeEnum::try_from(item).unwrap_or_else(|()| {
+            panic!(
+                "Expected BasicTypeEnum for list element type, got {}",
+                ptr_ty.get_element_type().print_to_string()
+            )
+        });
+
+        ListType { ty: ptr_ty, item: Some(item), llvm_usize }
    }

    /// Returns the type of the `size` field of this `list` type.
    #[must_use]
    pub fn size_type(&self) -> IntType<'ctx> {
-        self.as_base_type()
-            .get_element_type()
-            .into_struct_type()
-            .get_field_type_at_index(1)
-            .map(BasicTypeEnum::into_int_type)
-            .unwrap()
+        self.llvm_usize
    }

    /// Returns the element type of this `list` type.
    #[must_use]
-    pub fn element_type(&self) -> AnyTypeEnum<'ctx> {
-        self.as_base_type()
-            .get_element_type()
-            .into_struct_type()
-            .get_field_type_at_index(0)
-            .map(BasicTypeEnum::into_pointer_type)
-            .map(PointerType::get_element_type)
-            .unwrap()
+    pub fn element_type(&self) -> Option<BasicTypeEnum<'ctx>> {
+        self.item
    }

    /// Allocates an instance of [`ListValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca`].
    #[must_use]
-    pub fn alloca<G: CodeGenerator + ?Sized>(
+    pub fn alloca(
+        &self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
+            self.raw_alloca(ctx, name),
+            self.llvm_usize,
+            name,
+        )
+    }
+
+    /// Allocates an instance of [`ListValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca_var`].
+    #[must_use]
+    pub fn alloca_var<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
-            self.raw_alloca(generator, ctx, name),
+            self.raw_alloca_var(generator, ctx, name),
            self.llvm_usize,
            name,
        )
    }

+    /// Allocates a [`ListValue`] on the stack using `item` of this [`ListType`] instance.
+    ///
+    /// The returned list will contain:
+    ///
+    /// - `data`: Allocated with `len` number of elements.
+    /// - `len`: Initialized to the value of `len` passed to this function.
+    #[must_use]
+    pub fn construct<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        len: IntValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        let len = ctx.builder.build_int_z_extend(len, self.llvm_usize, "").unwrap();
+
+        // Generate a runtime assertion if allocating a non-empty list with unknown element type
+        if ctx.registry.llvm_options.opt_level == OptimizationLevel::None && self.item.is_none() {
+            let len_eqz = ctx
+                .builder
+                .build_int_compare(IntPredicate::EQ, len, self.llvm_usize.const_zero(), "")
+                .unwrap();
+
+            ctx.make_assert(
+                generator,
+                len_eqz,
+                "0:AssertionError",
+                "Cannot allocate a non-empty list with unknown element type",
+                [None, None, None],
+                ctx.current_loc,
+            );
+        }
+
+        let plist = self.alloca_var(generator, ctx, name);
+        plist.store_size(ctx, len);
+
+        let item = self.item.unwrap_or(self.llvm_usize.into());
+        plist.create_data(ctx, item, None);
+
+        plist
+    }
+
+    /// Convenience function for creating a list with zero elements.
+    ///
+    /// This function is preferred over [`ListType::construct`] if the length is known to always be
+    /// 0, as this function avoids injecting an IR assertion for checking if a non-empty untyped
+    /// list is being allocated.
+    ///
+    /// The returned list will contain:
+    ///
+    /// - `data`: Initialized to `(T*) 0`.
+    /// - `len`: Initialized to `0`.
+    #[must_use]
+    pub fn construct_empty<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        let plist = self.alloca_var(generator, ctx, name);
+
+        plist.store_size(ctx, self.llvm_usize.const_zero());
+        plist.create_data(ctx, self.item.unwrap_or(self.llvm_usize.into()), None);
+
+        plist
+    }
+
    /// Converts an existing value into a [`ListValue`].
    #[must_use]
    pub fn map_value(
@ -162,36 +356,8 @@ impl<'ctx> ProxyType<'ctx> for ListType<'ctx> {
        Self::is_representable(llvm_ty, generator.get_size_type(ctx))
    }

-    fn raw_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        name: Option<&'ctx str>,
-    ) -> <Self::Value as ProxyValue<'ctx>>::Base {
-        generator
-            .gen_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                name,
-            )
-            .unwrap()
-    }
-
-    fn array_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        size: IntValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> ArraySliceValue<'ctx> {
-        generator
-            .gen_array_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                size,
-                name,
-            )
-            .unwrap()
+    fn alloca_type(&self) -> impl BasicType<'ctx> {
+        self.as_base_type().get_element_type().into_struct_type()
    }

    fn as_base_type(&self) -> Self::Base {
--- a/nac3core/src/codegen/types/mod.rs
+++ b/nac3core/src/codegen/types/mod.rs
@ -16,7 +16,11 @@
 //!   the returned object. This is similar to a `new` expression in C++ but the object is allocated
 //!   on the stack.

-use inkwell::{context::Context, types::BasicType, values::IntValue};
+use inkwell::{
+    context::Context,
+    types::BasicType,
+    values::{IntValue, PointerValue},
+};

 use super::{
    values::{ArraySliceValue, ProxyValue},
@ -24,11 +28,13 @@ use super::{
 };
 pub use list::*;
 pub use range::*;
+pub use tuple::*;

 mod list;
 pub mod ndarray;
 mod range;
 pub mod structure;
+mod tuple;
 pub mod utils;

 /// A LLVM type that is used to represent a corresponding type in NAC3.
@ -53,23 +59,66 @@ pub trait ProxyType<'ctx>: Into<Self::Base> {
        llvm_ty: Self::Base,
    ) -> Result<(), String>;

-    /// Creates a new value of this type, returning the LLVM instance of this value.
-    fn raw_alloca<G: CodeGenerator + ?Sized>(
+    /// Returns the type that should be used in `alloca` IR statements.
+    fn alloca_type(&self) -> impl BasicType<'ctx>;
+
+    /// Creates a new value of this type by invoking `alloca` at the current builder location,
+    /// returning a [`PointerValue`] instance representing the allocated value.
+    fn raw_alloca(
+        &self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> PointerValue<'ctx> {
+        ctx.builder
+            .build_alloca(self.alloca_type().as_basic_type_enum(), name.unwrap_or_default())
+            .unwrap()
+    }
+
+    /// Creates a new value of this type by invoking `alloca` at the beginning of the function,
+    /// returning a [`PointerValue`] instance representing the allocated value.
+    fn raw_alloca_var<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
        name: Option<&'ctx str>,
-    ) -> <Self::Value as ProxyValue<'ctx>>::Base;
+    ) -> PointerValue<'ctx> {
+        generator.gen_var_alloc(ctx, self.alloca_type().as_basic_type_enum(), name).unwrap()
+    }

-    /// Creates a new array value of this type, returning an [`ArraySliceValue`] encapsulating the
-    /// resulting array.
-    fn array_alloca<G: CodeGenerator + ?Sized>(
+    /// Creates a new array value of this type by invoking `alloca` at the current builder location,
+    /// returning an [`ArraySliceValue`] encapsulating the resulting array.
+    fn array_alloca(
+        &self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        size: IntValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> ArraySliceValue<'ctx> {
+        ArraySliceValue::from_ptr_val(
+            ctx.builder
+                .build_array_alloca(
+                    self.alloca_type().as_basic_type_enum(),
+                    size,
+                    name.unwrap_or_default(),
+                )
+                .unwrap(),
+            size,
+            name,
+        )
+    }
+
+    /// Creates a new array value of this type by invoking `alloca` at the beginning of the
+    /// function, returning an [`ArraySliceValue`] encapsulating the resulting array.
+    fn array_alloca_var<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
        size: IntValue<'ctx>,
        name: Option<&'ctx str>,
-    ) -> ArraySliceValue<'ctx>;
+    ) -> ArraySliceValue<'ctx> {
+        generator
+            .gen_array_var_alloc(ctx, self.alloca_type().as_basic_type_enum(), size, name)
+            .unwrap()
+    }

    /// Returns the [base type][Self::Base] of this proxy.
    fn as_base_type(&self) -> Self::Base;
--- a/nac3core/src/codegen/types/ndarray/array.rs
+++ b/nac3core/src/codegen/types/ndarray/array.rs
@ -0,0 +1,240 @@
+use inkwell::{
+    types::BasicTypeEnum,
+    values::{BasicValueEnum, IntValue},
+    AddressSpace,
+};
+
+use crate::{
+    codegen::{
+        irrt,
+        stmt::gen_if_else_expr_callback,
+        types::{ndarray::NDArrayType, ListType, ProxyType},
+        values::{
+            ndarray::NDArrayValue, ArrayLikeValue, ArraySliceValue, ListValue, ProxyValue,
+            TypedArrayLikeAdapter, TypedArrayLikeMutator,
+        },
+        CodeGenContext, CodeGenerator,
+    },
+    toplevel::helper::{arraylike_flatten_element_type, arraylike_get_ndims},
+    typecheck::typedef::{Type, TypeEnum},
+};
+
+/// Get the expected `dtype` and `ndims` of the ndarray returned by `np_array(<list>)`.
+fn get_list_object_dtype_and_ndims<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    list_ty: Type,
+) -> (BasicTypeEnum<'ctx>, u64) {
+    let dtype = arraylike_flatten_element_type(&mut ctx.unifier, list_ty);
+    let ndims = arraylike_get_ndims(&mut ctx.unifier, list_ty);
+
+    (ctx.get_llvm_type(generator, dtype), ndims)
+}
+
+impl<'ctx> NDArrayType<'ctx> {
+    /// Implementation of `np_array(<list>, copy=True)`
+    fn construct_numpy_array_from_list_copy_true_impl<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        (list_ty, list): (Type, ListValue<'ctx>),
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        let (dtype, ndims_int) = get_list_object_dtype_and_ndims(generator, ctx, list_ty);
+        assert!(self.ndims >= ndims_int);
+        assert_eq!(dtype, self.dtype);
+
+        let list_value = list.as_i8_list(ctx);
+
+        // Validate `list` has a consistent shape.
+        // Raise an exception if `list` is something abnormal like `[[1, 2], [3]]`.
+        // If `list` has a consistent shape, deduce the shape and write it to `shape`.
+        let ndims = self.llvm_usize.const_int(ndims_int, false);
+        let shape = ctx.builder.build_array_alloca(self.llvm_usize, ndims, "").unwrap();
+        let shape = ArraySliceValue::from_ptr_val(shape, ndims, None);
+        let shape = TypedArrayLikeAdapter::from(
+            shape,
+            |_, _, val| val.into_int_value(),
+            |_, _, val| val.into(),
+        );
+        irrt::ndarray::call_nac3_ndarray_array_set_and_validate_list_shape(
+            generator, ctx, list_value, ndims, &shape,
+        );
+
+        let ndarray =
+            Self::new(ctx, dtype, ndims_int).construct_uninitialized(generator, ctx, name);
+        ndarray.copy_shape_from_array(generator, ctx, shape.base_ptr(ctx, generator));
+        unsafe { ndarray.create_data(generator, ctx) };
+
+        // Copy all contents from the list.
+        irrt::ndarray::call_nac3_ndarray_array_write_list_to_array(ctx, list_value, ndarray);
+
+        ndarray
+    }
+
+    /// Implementation of `np_array(<list>, copy=None)`
+    fn construct_numpy_array_from_list_copy_none_impl<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        (list_ty, list): (Type, ListValue<'ctx>),
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        // np_array without copying is only possible `list` is not nested.
+        //
+        // If `list` is `list[T]`, we can create an ndarray with `data` set
+        // to the array pointer of `list`.
+        //
+        // If `list` is `list[list[T]]` or worse, copy.
+
+        let (dtype, ndims) = get_list_object_dtype_and_ndims(generator, ctx, list_ty);
+        if ndims == 1 {
+            // `list` is not nested
+            assert_eq!(ndims, 1);
+            assert!(self.ndims >= ndims);
+            assert_eq!(dtype, self.dtype);
+
+            let llvm_pi8 = ctx.ctx.i8_type().ptr_type(AddressSpace::default());
+
+            let ndarray = Self::new(ctx, dtype, 1).construct_uninitialized(generator, ctx, name);
+
+            // Set data
+            let data = ctx
+                .builder
+                .build_pointer_cast(list.data().base_ptr(ctx, generator), llvm_pi8, "")
+                .unwrap();
+            ndarray.store_data(ctx, data);
+
+            // ndarray->shape[0] = list->len;
+            let shape = ndarray.shape();
+            let list_len = list.load_size(ctx, None);
+            unsafe {
+                shape.set_typed_unchecked(ctx, generator, &self.llvm_usize.const_zero(), list_len);
+            }
+
+            // Set strides, the `data` is contiguous
+            ndarray.set_strides_contiguous(ctx);
+
+            ndarray
+        } else {
+            // `list` is nested, copy
+            self.construct_numpy_array_from_list_copy_true_impl(
+                generator,
+                ctx,
+                (list_ty, list),
+                name,
+            )
+        }
+    }
+
+    /// Implementation of `np_array(<list>, copy=copy)`
+    fn construct_numpy_array_list_impl<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        (list_ty, list): (Type, ListValue<'ctx>),
+        copy: IntValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        assert_eq!(copy.get_type(), ctx.ctx.bool_type());
+
+        let (dtype, ndims) = get_list_object_dtype_and_ndims(generator, ctx, list_ty);
+
+        let ndarray = gen_if_else_expr_callback(
+            generator,
+            ctx,
+            |_generator, _ctx| Ok(copy),
+            |generator, ctx| {
+                let ndarray = self.construct_numpy_array_from_list_copy_true_impl(
+                    generator,
+                    ctx,
+                    (list_ty, list),
+                    name,
+                );
+                Ok(Some(ndarray.as_base_value()))
+            },
+            |generator, ctx| {
+                let ndarray = self.construct_numpy_array_from_list_copy_none_impl(
+                    generator,
+                    ctx,
+                    (list_ty, list),
+                    name,
+                );
+                Ok(Some(ndarray.as_base_value()))
+            },
+        )
+        .unwrap()
+        .map(BasicValueEnum::into_pointer_value)
+        .unwrap();
+
+        NDArrayType::new(ctx, dtype, ndims).map_value(ndarray, None)
+    }
+
+    /// Implementation of `np_array(<ndarray>, copy=copy)`.
+    pub fn construct_numpy_array_ndarray_impl<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        ndarray: NDArrayValue<'ctx>,
+        copy: IntValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        assert_eq!(ndarray.get_type().dtype, self.dtype);
+        assert!(self.ndims >= ndarray.get_type().ndims);
+        assert_eq!(copy.get_type(), ctx.ctx.bool_type());
+
+        let ndarray_val = gen_if_else_expr_callback(
+            generator,
+            ctx,
+            |_generator, _ctx| Ok(copy),
+            |generator, ctx| {
+                let ndarray = ndarray.make_copy(generator, ctx); // Force copy
+                Ok(Some(ndarray.as_base_value()))
+            },
+            |_generator, _ctx| {
+                // No need to copy. Return `ndarray` itself.
+                Ok(Some(ndarray.as_base_value()))
+            },
+        )
+        .unwrap()
+        .map(BasicValueEnum::into_pointer_value)
+        .unwrap();
+
+        ndarray.get_type().map_value(ndarray_val, name)
+    }
+
+    /// Create a new ndarray like
+    /// [`np.array()`](https://numpy.org/doc/stable/reference/generated/numpy.array.html).
+    ///
+    /// Note that the returned [`NDArrayValue`] may have fewer dimensions than is specified by this
+    /// instance. Use [`NDArrayValue::atleast_nd`] on the returned value if an `ndarray` instance
+    /// with the exact number of dimensions is needed.
+    pub fn construct_numpy_array<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        (object_ty, object): (Type, BasicValueEnum<'ctx>),
+        copy: IntValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        match &*ctx.unifier.get_ty_immutable(object_ty) {
+            TypeEnum::TObj { obj_id, .. }
+                if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
+            {
+                let list = ListType::from_unifier_type(generator, ctx, object_ty)
+                    .map_value(object.into_pointer_value(), None);
+                self.construct_numpy_array_list_impl(generator, ctx, (object_ty, list), copy, name)
+            }
+
+            TypeEnum::TObj { obj_id, .. }
+                if *obj_id == ctx.primitives.ndarray.obj_id(&ctx.unifier).unwrap() =>
+            {
+                let ndarray = NDArrayType::from_unifier_type(generator, ctx, object_ty)
+                    .map_value(object.into_pointer_value(), None);
+                self.construct_numpy_array_ndarray_impl(generator, ctx, ndarray, copy, name)
+            }
+
+            _ => panic!("Unrecognized object type: {}", ctx.unifier.stringify(object_ty)), // Typechecker ensures this
+        }
+    }
+}
--- a/nac3core/src/codegen/types/ndarray/broadcast.rs
+++ b/nac3core/src/codegen/types/ndarray/broadcast.rs
@ -0,0 +1,188 @@
+use inkwell::{
+    context::{AsContextRef, Context},
+    types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType},
+    values::{IntValue, PointerValue},
+    AddressSpace,
+};
+use itertools::Itertools;
+
+use nac3core_derive::StructFields;
+
+use crate::codegen::{
+    types::{
+        structure::{check_struct_type_matches_fields, StructField, StructFields},
+        ProxyType,
+    },
+    values::{ndarray::ShapeEntryValue, ProxyValue},
+    CodeGenContext, CodeGenerator,
+};
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+pub struct ShapeEntryType<'ctx> {
+    ty: PointerType<'ctx>,
+    llvm_usize: IntType<'ctx>,
+}
+
+#[derive(PartialEq, Eq, Clone, Copy, StructFields)]
+pub struct ShapeEntryStructFields<'ctx> {
+    #[value_type(usize)]
+    pub ndims: StructField<'ctx, IntValue<'ctx>>,
+    #[value_type(usize.ptr_type(AddressSpace::default()))]
+    pub shape: StructField<'ctx, PointerValue<'ctx>>,
+}
+
+impl<'ctx> ShapeEntryType<'ctx> {
+    /// Checks whether `llvm_ty` represents a [`ShapeEntryType`], returning [Err] if it does not.
+    pub fn is_representable(
+        llvm_ty: PointerType<'ctx>,
+        llvm_usize: IntType<'ctx>,
+    ) -> Result<(), String> {
+        let ctx = llvm_ty.get_context();
+
+        let llvm_ndarray_ty = llvm_ty.get_element_type();
+        let AnyTypeEnum::StructType(llvm_ndarray_ty) = llvm_ndarray_ty else {
+            return Err(format!(
+                "Expected struct type for `ShapeEntry` type, got {llvm_ndarray_ty}"
+            ));
+        };
+
+        check_struct_type_matches_fields(
+            Self::fields(ctx, llvm_usize),
+            llvm_ndarray_ty,
+            "NDArray",
+            &[],
+        )
+    }
+
+    /// Returns an instance of [`StructFields`] containing all field accessors for this type.
+    #[must_use]
+    fn fields(
+        ctx: impl AsContextRef<'ctx>,
+        llvm_usize: IntType<'ctx>,
+    ) -> ShapeEntryStructFields<'ctx> {
+        ShapeEntryStructFields::new(ctx, llvm_usize)
+    }
+
+    /// See [`ShapeEntryStructFields::fields`].
+    // TODO: Move this into e.g. StructProxyType
+    #[must_use]
+    pub fn get_fields(&self, ctx: impl AsContextRef<'ctx>) -> ShapeEntryStructFields<'ctx> {
+        Self::fields(ctx, self.llvm_usize)
+    }
+
+    /// Creates an LLVM type corresponding to the expected structure of a `ShapeEntry`.
+    #[must_use]
+    fn llvm_type(ctx: &'ctx Context, llvm_usize: IntType<'ctx>) -> PointerType<'ctx> {
+        let field_tys =
+            Self::fields(ctx, llvm_usize).into_iter().map(|field| field.1).collect_vec();
+
+        ctx.struct_type(&field_tys, false).ptr_type(AddressSpace::default())
+    }
+
+    fn new_impl(ctx: &'ctx Context, llvm_usize: IntType<'ctx>) -> Self {
+        let llvm_ty = Self::llvm_type(ctx, llvm_usize);
+
+        Self { ty: llvm_ty, llvm_usize }
+    }
+
+    /// Creates an instance of [`ShapeEntryType`].
+    #[must_use]
+    pub fn new(ctx: &CodeGenContext<'ctx, '_>) -> Self {
+        Self::new_impl(ctx.ctx, ctx.get_size_type())
+    }
+
+    /// Creates an instance of [`ShapeEntryType`].
+    #[must_use]
+    pub fn new_with_generator<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> Self {
+        Self::new_impl(ctx, generator.get_size_type(ctx))
+    }
+
+    /// Creates a [`ShapeEntryType`] from a [`PointerType`] representing an `ShapeEntry`.
+    #[must_use]
+    pub fn from_type(ptr_ty: PointerType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
+        debug_assert!(Self::is_representable(ptr_ty, llvm_usize).is_ok());
+
+        Self { ty: ptr_ty, llvm_usize }
+    }
+
+    /// Allocates an instance of [`ShapeEntryValue`] as if by calling `alloca` on the base type.
+    #[must_use]
+    pub fn alloca(
+        &self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
+            self.raw_alloca(ctx, name),
+            self.llvm_usize,
+            name,
+        )
+    }
+
+    /// Allocates an instance of [`ShapeEntryValue`] as if by calling `alloca` on the base type.
+    #[must_use]
+    pub fn alloca_var<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
+            self.raw_alloca_var(generator, ctx, name),
+            self.llvm_usize,
+            name,
+        )
+    }
+
+    /// Converts an existing value into a [`ShapeEntryValue`].
+    #[must_use]
+    pub fn map_value(
+        &self,
+        value: <<Self as ProxyType<'ctx>>::Value as ProxyValue<'ctx>>::Base,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_pointer_value(value, self.llvm_usize, name)
+    }
+}
+
+impl<'ctx> ProxyType<'ctx> for ShapeEntryType<'ctx> {
+    type Base = PointerType<'ctx>;
+    type Value = ShapeEntryValue<'ctx>;
+
+    fn is_type<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+        llvm_ty: impl BasicType<'ctx>,
+    ) -> Result<(), String> {
+        if let BasicTypeEnum::PointerType(ty) = llvm_ty.as_basic_type_enum() {
+            <Self as ProxyType<'ctx>>::is_representable(generator, ctx, ty)
+        } else {
+            Err(format!("Expected pointer type, got {llvm_ty:?}"))
+        }
+    }
+
+    fn is_representable<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+        llvm_ty: Self::Base,
+    ) -> Result<(), String> {
+        Self::is_representable(llvm_ty, generator.get_size_type(ctx))
+    }
+
+    fn alloca_type(&self) -> impl BasicType<'ctx> {
+        self.as_base_type().get_element_type().into_struct_type()
+    }
+
+    fn as_base_type(&self) -> Self::Base {
+        self.ty
+    }
+}
+
+impl<'ctx> From<ShapeEntryType<'ctx>> for PointerType<'ctx> {
+    fn from(value: ShapeEntryType<'ctx>) -> Self {
+        value.as_base_type()
+    }
+}
--- a/nac3core/src/codegen/types/ndarray/contiguous.rs
+++ b/nac3core/src/codegen/types/ndarray/contiguous.rs
@ -16,7 +16,7 @@ use crate::{
            },
            ProxyType,
        },
-        values::{ndarray::ContiguousNDArrayValue, ArraySliceValue, ProxyValue},
+        values::{ndarray::ContiguousNDArrayValue, ProxyValue},
        CodeGenContext, CodeGenerator,
    },
    toplevel::numpy::unpack_ndarray_var_tys,
@ -31,7 +31,7 @@ pub struct ContiguousNDArrayType<'ctx> {
 }

 #[derive(PartialEq, Eq, Clone, Copy, StructFields)]
-pub struct ContiguousNDArrayFields<'ctx> {
+pub struct ContiguousNDArrayStructFields<'ctx> {
    #[value_type(usize)]
    pub ndims: StructField<'ctx, IntValue<'ctx>>,
    #[value_type(usize.ptr_type(AddressSpace::default()))]
@ -40,12 +40,12 @@ pub struct ContiguousNDArrayFields<'ctx> {
    pub data: StructField<'ctx, PointerValue<'ctx>>,
 }

-impl<'ctx> ContiguousNDArrayFields<'ctx> {
+impl<'ctx> ContiguousNDArrayStructFields<'ctx> {
    #[must_use]
    pub fn new_typed(item: BasicTypeEnum<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
        let mut counter = FieldIndexCounter::default();

-        ContiguousNDArrayFields {
+        ContiguousNDArrayStructFields {
            ndims: StructField::create(&mut counter, "ndims", llvm_usize),
            shape: StructField::create(
                &mut counter,
@ -72,7 +72,7 @@ impl<'ctx> ContiguousNDArrayType<'ctx> {
            ));
        };

-        let fields = ContiguousNDArrayFields::new(ctx, llvm_usize);
+        let fields = ContiguousNDArrayStructFields::new(ctx, llvm_usize);

        check_struct_type_matches_fields(
            fields,
@ -93,14 +93,14 @@ impl<'ctx> ContiguousNDArrayType<'ctx> {
    fn fields(
        item: BasicTypeEnum<'ctx>,
        llvm_usize: IntType<'ctx>,
-    ) -> ContiguousNDArrayFields<'ctx> {
-        ContiguousNDArrayFields::new_typed(item, llvm_usize)
+    ) -> ContiguousNDArrayStructFields<'ctx> {
+        ContiguousNDArrayStructFields::new_typed(item, llvm_usize)
    }

    /// See [`NDArrayType::fields`].
    // TODO: Move this into e.g. StructProxyType
    #[must_use]
-    pub fn get_fields(&self) -> ContiguousNDArrayFields<'ctx> {
+    pub fn get_fields(&self) -> ContiguousNDArrayStructFields<'ctx> {
        Self::fields(self.item, self.llvm_usize)
    }

@ -117,17 +117,26 @@ impl<'ctx> ContiguousNDArrayType<'ctx> {
        ctx.struct_type(&field_tys, false).ptr_type(AddressSpace::default())
    }

+    fn new_impl(ctx: &'ctx Context, item: BasicTypeEnum<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
+        let llvm_cndarray = Self::llvm_type(ctx, item, llvm_usize);
+
+        Self { ty: llvm_cndarray, item, llvm_usize }
+    }
+
    /// Creates an instance of [`ContiguousNDArrayType`].
    #[must_use]
-    pub fn new<G: CodeGenerator + ?Sized>(
+    pub fn new(ctx: &CodeGenContext<'ctx, '_>, item: &impl BasicType<'ctx>) -> Self {
+        Self::new_impl(ctx.ctx, item.as_basic_type_enum(), ctx.get_size_type())
+    }
+
+    /// Creates an instance of [`ContiguousNDArrayType`].
+    #[must_use]
+    pub fn new_with_generator<G: CodeGenerator + ?Sized>(
        generator: &G,
        ctx: &'ctx Context,
        item: BasicTypeEnum<'ctx>,
    ) -> Self {
-        let llvm_usize = generator.get_size_type(ctx);
-        let llvm_cndarray = Self::llvm_type(ctx, item, llvm_usize);
-
-        Self { ty: llvm_cndarray, item, llvm_usize }
+        Self::new_impl(ctx, item, generator.get_size_type(ctx))
    }

    /// Creates an [`ContiguousNDArrayType`] from a [unifier type][Type].
@ -140,9 +149,8 @@ impl<'ctx> ContiguousNDArrayType<'ctx> {
        let (dtype, _) = unpack_ndarray_var_tys(&mut ctx.unifier, ty);

        let llvm_dtype = ctx.get_llvm_type(generator, dtype);
-        let llvm_usize = generator.get_size_type(ctx.ctx);

-        Self { ty: Self::llvm_type(ctx.ctx, llvm_dtype, llvm_usize), item: llvm_dtype, llvm_usize }
+        Self::new_impl(ctx.ctx, llvm_dtype, ctx.get_size_type())
    }

    /// Creates an [`ContiguousNDArrayType`] from a [`PointerType`] representing an `NDArray`.
@ -157,16 +165,37 @@ impl<'ctx> ContiguousNDArrayType<'ctx> {
        Self { ty: ptr_ty, item, llvm_usize }
    }

-    /// Allocates an instance of [`ContiguousNDArrayValue`] as if by calling `alloca` on the base type.
+    /// Allocates an instance of [`ContiguousNDArrayValue`] as if by calling `alloca` on the base
+    /// type.
+    ///
+    /// See [`ProxyType::raw_alloca`].
    #[must_use]
-    pub fn alloca<G: CodeGenerator + ?Sized>(
+    pub fn alloca(
+        &self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
+            self.raw_alloca(ctx, name),
+            self.item,
+            self.llvm_usize,
+            name,
+        )
+    }
+
+    /// Allocates an instance of [`ContiguousNDArrayValue`] as if by calling `alloca` on the base
+    /// type.
+    ///
+    /// See [`ProxyType::raw_alloca_var`].
+    #[must_use]
+    pub fn alloca_var<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
-            self.raw_alloca(generator, ctx, name),
+            self.raw_alloca_var(generator, ctx, name),
            self.item,
            self.llvm_usize,
            name,
@ -213,36 +242,8 @@ impl<'ctx> ProxyType<'ctx> for ContiguousNDArrayType<'ctx> {
        Self::is_representable(llvm_ty, generator.get_size_type(ctx))
    }

-    fn raw_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        name: Option<&'ctx str>,
-    ) -> <Self::Value as ProxyValue<'ctx>>::Base {
-        generator
-            .gen_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                name,
-            )
-            .unwrap()
-    }
-
-    fn array_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        size: IntValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> ArraySliceValue<'ctx> {
-        generator
-            .gen_array_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                size,
-                name,
-            )
-            .unwrap()
+    fn alloca_type(&self) -> impl BasicType<'ctx> {
+        self.as_base_type().get_element_type().into_struct_type()
    }

    fn as_base_type(&self) -> Self::Base {
--- a/nac3core/src/codegen/types/ndarray/factory.rs
+++ b/nac3core/src/codegen/types/ndarray/factory.rs
@ -0,0 +1,236 @@
+use inkwell::{
+    values::{BasicValueEnum, IntValue},
+    IntPredicate,
+};
+
+use super::NDArrayType;
+use crate::{
+    codegen::{
+        irrt, types::ProxyType, values::TypedArrayLikeAccessor, CodeGenContext, CodeGenerator,
+    },
+    typecheck::typedef::Type,
+};
+
+/// Get the zero value in `np.zeros()` of a `dtype`.
+fn ndarray_zero_value<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    dtype: Type,
+) -> BasicValueEnum<'ctx> {
+    if [ctx.primitives.int32, ctx.primitives.uint32]
+        .iter()
+        .any(|ty| ctx.unifier.unioned(dtype, *ty))
+    {
+        ctx.ctx.i32_type().const_zero().into()
+    } else if [ctx.primitives.int64, ctx.primitives.uint64]
+        .iter()
+        .any(|ty| ctx.unifier.unioned(dtype, *ty))
+    {
+        ctx.ctx.i64_type().const_zero().into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.float) {
+        ctx.ctx.f64_type().const_zero().into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.bool) {
+        ctx.ctx.bool_type().const_zero().into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.str) {
+        ctx.gen_string(generator, "").into()
+    } else {
+        panic!("unrecognized dtype: {}", ctx.unifier.stringify(dtype));
+    }
+}
+
+/// Get the one value in `np.ones()` of a `dtype`.
+fn ndarray_one_value<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    dtype: Type,
+) -> BasicValueEnum<'ctx> {
+    if [ctx.primitives.int32, ctx.primitives.uint32]
+        .iter()
+        .any(|ty| ctx.unifier.unioned(dtype, *ty))
+    {
+        let is_signed = ctx.unifier.unioned(dtype, ctx.primitives.int32);
+        ctx.ctx.i32_type().const_int(1, is_signed).into()
+    } else if [ctx.primitives.int64, ctx.primitives.uint64]
+        .iter()
+        .any(|ty| ctx.unifier.unioned(dtype, *ty))
+    {
+        let is_signed = ctx.unifier.unioned(dtype, ctx.primitives.int64);
+        ctx.ctx.i64_type().const_int(1, is_signed).into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.float) {
+        ctx.ctx.f64_type().const_float(1.0).into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.bool) {
+        ctx.ctx.bool_type().const_int(1, false).into()
+    } else if ctx.unifier.unioned(dtype, ctx.primitives.str) {
+        ctx.gen_string(generator, "1").into()
+    } else {
+        panic!("unrecognized dtype: {}", ctx.unifier.stringify(dtype));
+    }
+}
+
+impl<'ctx> NDArrayType<'ctx> {
+    /// Create an ndarray like
+    /// [`np.empty`](https://numpy.org/doc/stable/reference/generated/numpy.empty.html).
+    pub fn construct_numpy_empty<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        let ndarray = self.construct_uninitialized(generator, ctx, name);
+
+        // Validate `shape`
+        irrt::ndarray::call_nac3_ndarray_util_assert_shape_no_negative(generator, ctx, shape);
+
+        ndarray.copy_shape_from_array(generator, ctx, shape.base_ptr(ctx, generator));
+        unsafe { ndarray.create_data(generator, ctx) };
+
+        ndarray
+    }
+
+    /// Create an ndarray like
+    /// [`np.full`](https://numpy.org/doc/stable/reference/generated/numpy.full.html).
+    pub fn construct_numpy_full<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+        fill_value: BasicValueEnum<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        let ndarray = self.construct_numpy_empty(generator, ctx, shape, name);
+        ndarray.fill(generator, ctx, fill_value);
+        ndarray
+    }
+
+    /// Create an ndarray like
+    /// [`np.zero`](https://numpy.org/doc/stable/reference/generated/numpy.zeros.html).
+    pub fn construct_numpy_zeros<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        assert_eq!(
+            ctx.get_llvm_type(generator, dtype),
+            self.dtype,
+            "Expected LLVM dtype={} but got {}",
+            self.dtype.print_to_string(),
+            ctx.get_llvm_type(generator, dtype).print_to_string(),
+        );
+
+        let fill_value = ndarray_zero_value(generator, ctx, dtype);
+        self.construct_numpy_full(generator, ctx, shape, fill_value, name)
+    }
+
+    /// Create an ndarray like
+    /// [`np.ones`](https://numpy.org/doc/stable/reference/generated/numpy.ones.html).
+    pub fn construct_numpy_ones<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        assert_eq!(
+            ctx.get_llvm_type(generator, dtype),
+            self.dtype,
+            "Expected LLVM dtype={} but got {}",
+            self.dtype.print_to_string(),
+            ctx.get_llvm_type(generator, dtype).print_to_string(),
+        );
+
+        let fill_value = ndarray_one_value(generator, ctx, dtype);
+        self.construct_numpy_full(generator, ctx, shape, fill_value, name)
+    }
+
+    /// Create an ndarray like
+    /// [`np.eye`](https://numpy.org/doc/stable/reference/generated/numpy.eye.html).
+    #[allow(clippy::too_many_arguments)]
+    pub fn construct_numpy_eye<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        nrows: IntValue<'ctx>,
+        ncols: IntValue<'ctx>,
+        offset: IntValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        assert_eq!(
+            ctx.get_llvm_type(generator, dtype),
+            self.dtype,
+            "Expected LLVM dtype={} but got {}",
+            self.dtype.print_to_string(),
+            ctx.get_llvm_type(generator, dtype).print_to_string(),
+        );
+        assert_eq!(nrows.get_type(), self.llvm_usize);
+        assert_eq!(ncols.get_type(), self.llvm_usize);
+        assert_eq!(offset.get_type(), self.llvm_usize);
+
+        let ndzero = ndarray_zero_value(generator, ctx, dtype);
+        let ndone = ndarray_one_value(generator, ctx, dtype);
+
+        let ndarray = self.construct_dyn_shape(generator, ctx, &[nrows, ncols], name);
+
+        // Create data and make the matrix like look np.eye()
+        unsafe {
+            ndarray.create_data(generator, ctx);
+        }
+        ndarray
+            .foreach(generator, ctx, |generator, ctx, _, nditer| {
+                // NOTE: rows and cols can never be zero here, since this ndarray's `np.size` would be zero
+                // and this loop would not execute.
+
+                let indices = nditer.get_indices();
+
+                let row_i = unsafe {
+                    indices.get_typed_unchecked(ctx, generator, &self.llvm_usize.const_zero(), None)
+                };
+                let col_i = unsafe {
+                    indices.get_typed_unchecked(
+                        ctx,
+                        generator,
+                        &self.llvm_usize.const_int(1, false),
+                        None,
+                    )
+                };
+
+                let be_one = ctx
+                    .builder
+                    .build_int_compare(
+                        IntPredicate::EQ,
+                        ctx.builder.build_int_add(row_i, offset, "").unwrap(),
+                        col_i,
+                        "",
+                    )
+                    .unwrap();
+                let value = ctx.builder.build_select(be_one, ndone, ndzero, "value").unwrap();
+
+                let p = nditer.get_pointer(ctx);
+                ctx.builder.build_store(p, value).unwrap();
+
+                Ok(())
+            })
+            .unwrap();
+
+        ndarray
+    }
+
+    /// Create an ndarray like
+    /// [`np.identity`](https://numpy.org/doc/stable/reference/generated/numpy.identity.html).
+    pub fn construct_numpy_identity<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        dtype: Type,
+        size: IntValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        let offset = self.llvm_usize.const_zero();
+        self.construct_numpy_eye(generator, ctx, dtype, size, size, offset, name)
+    }
+}
--- a/nac3core/src/codegen/types/ndarray/indexing.rs
+++ b/nac3core/src/codegen/types/ndarray/indexing.rs
@ -75,14 +75,25 @@ impl<'ctx> NDIndexType<'ctx> {
        ctx.struct_type(&field_tys, false).ptr_type(AddressSpace::default())
    }

-    #[must_use]
-    pub fn new<G: CodeGenerator + ?Sized>(generator: &G, ctx: &'ctx Context) -> Self {
-        let llvm_usize = generator.get_size_type(ctx);
+    fn new_impl(ctx: &'ctx Context, llvm_usize: IntType<'ctx>) -> Self {
        let llvm_ndindex = Self::llvm_type(ctx, llvm_usize);

        Self { ty: llvm_ndindex, llvm_usize }
    }

+    #[must_use]
+    pub fn new(ctx: &CodeGenContext<'ctx, '_>) -> Self {
+        Self::new_impl(ctx.ctx, ctx.get_size_type())
+    }
+
+    #[must_use]
+    pub fn new_with_generator<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> Self {
+        Self::new_impl(ctx, generator.get_size_type(ctx))
+    }
+
    #[must_use]
    pub fn from_type(ptr_ty: PointerType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
        debug_assert!(Self::is_representable(ptr_ty, llvm_usize).is_ok());
@ -90,15 +101,33 @@ impl<'ctx> NDIndexType<'ctx> {
        Self { ty: ptr_ty, llvm_usize }
    }

+    /// Allocates an instance of [`NDIndexValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca`].
    #[must_use]
-    pub fn alloca<G: CodeGenerator + ?Sized>(
+    pub fn alloca(
+        &self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
+            self.raw_alloca(ctx, name),
+            self.llvm_usize,
+            name,
+        )
+    }
+    /// Allocates an instance of [`NDIndexValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca_var`].
+    #[must_use]
+    pub fn alloca_var<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
-            self.raw_alloca(generator, ctx, name),
+            self.raw_alloca_var(generator, ctx, name),
            self.llvm_usize,
            name,
        )
@ -114,7 +143,7 @@ impl<'ctx> NDIndexType<'ctx> {
    ) -> ArraySliceValue<'ctx> {
        // Allocate the LLVM ndindices.
        let num_ndindices = self.llvm_usize.const_int(in_ndindices.len() as u64, false);
-        let ndindices = self.array_alloca(generator, ctx, num_ndindices, None);
+        let ndindices = self.array_alloca_var(generator, ctx, num_ndindices, None);

        // Initialize all of them.
        for (i, in_ndindex) in in_ndindices.iter().enumerate() {
@ -171,36 +200,8 @@ impl<'ctx> ProxyType<'ctx> for NDIndexType<'ctx> {
        Self::is_representable(llvm_ty, generator.get_size_type(ctx))
    }

-    fn raw_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        name: Option<&'ctx str>,
-    ) -> <Self::Value as ProxyValue<'ctx>>::Base {
-        generator
-            .gen_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                name,
-            )
-            .unwrap()
-    }
-
-    fn array_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        size: IntValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> ArraySliceValue<'ctx> {
-        generator
-            .gen_array_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                size,
-                name,
-            )
-            .unwrap()
+    fn alloca_type(&self) -> impl BasicType<'ctx> {
+        self.as_base_type().get_element_type().into_struct_type()
    }

    fn as_base_type(&self) -> Self::Base {
--- a/nac3core/src/codegen/types/ndarray/map.rs
+++ b/nac3core/src/codegen/types/ndarray/map.rs
@ -0,0 +1,183 @@
+use inkwell::{types::BasicTypeEnum, values::BasicValueEnum};
+use itertools::Itertools;
+
+use crate::codegen::{
+    stmt::gen_for_callback,
+    types::{
+        ndarray::{NDArrayType, NDIterType},
+        ProxyType,
+    },
+    values::{
+        ndarray::{NDArrayOut, NDArrayValue, ScalarOrNDArray},
+        ArrayLikeValue, ProxyValue,
+    },
+    CodeGenContext, CodeGenerator,
+};
+
+impl<'ctx> NDArrayType<'ctx> {
+    /// Generate LLVM IR to broadcast `ndarray`s together, and starmap through them with `mapping`
+    /// elementwise.
+    ///
+    /// `mapping` is an LLVM IR generator. The input of `mapping` is the list of elements when
+    /// iterating through the input `ndarrays` after broadcasting. The output of `mapping` is the
+    /// result of the elementwise operation.
+    ///
+    /// `out` specifies whether the result should be a new ndarray or to be written an existing
+    /// ndarray.
+    pub fn broadcast_starmap<'a, G, MappingFn>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, 'a>,
+        ndarrays: &[NDArrayValue<'ctx>],
+        out: NDArrayOut<'ctx>,
+        mapping: MappingFn,
+    ) -> Result<<Self as ProxyType<'ctx>>::Value, String>
+    where
+        G: CodeGenerator + ?Sized,
+        MappingFn: FnOnce(
+            &mut G,
+            &mut CodeGenContext<'ctx, 'a>,
+            &[BasicValueEnum<'ctx>],
+        ) -> Result<BasicValueEnum<'ctx>, String>,
+    {
+        // Broadcast inputs
+        let broadcast_result = self.broadcast(generator, ctx, ndarrays);
+
+        let out_ndarray = match out {
+            NDArrayOut::NewNDArray { dtype } => {
+                // Create a new ndarray based on the broadcast shape.
+                let result_ndarray = NDArrayType::new(ctx, dtype, broadcast_result.ndims)
+                    .construct_uninitialized(generator, ctx, None);
+                result_ndarray.copy_shape_from_array(
+                    generator,
+                    ctx,
+                    broadcast_result.shape.base_ptr(ctx, generator),
+                );
+                unsafe {
+                    result_ndarray.create_data(generator, ctx);
+                }
+                result_ndarray
+            }
+
+            NDArrayOut::WriteToNDArray { ndarray: result_ndarray } => {
+                // Use an existing ndarray.
+
+                // Check that its shape is compatible with the broadcast shape.
+                result_ndarray.assert_can_be_written_by_out(generator, ctx, broadcast_result.shape);
+                result_ndarray
+            }
+        };
+
+        // Map element-wise and store results into `mapped_ndarray`.
+        let nditer = NDIterType::new(ctx).construct(generator, ctx, out_ndarray);
+        gen_for_callback(
+            generator,
+            ctx,
+            Some("broadcast_starmap"),
+            |generator, ctx| {
+                // Create NDIters for all broadcasted input ndarrays.
+                let other_nditers = broadcast_result
+                    .ndarrays
+                    .iter()
+                    .map(|ndarray| NDIterType::new(ctx).construct(generator, ctx, *ndarray))
+                    .collect_vec();
+                Ok((nditer, other_nditers))
+            },
+            |_, ctx, (out_nditer, _in_nditers)| {
+                // We can simply use `out_nditer`'s `has_element()`.
+                // `in_nditers`' `has_element()`s should return the same value.
+                Ok(out_nditer.has_element(ctx))
+            },
+            |generator, ctx, _hooks, (out_nditer, in_nditers)| {
+                // Get all the scalars from the broadcasted input ndarrays, pass them to `mapping`,
+                // and write to `out_ndarray`.
+                let in_scalars =
+                    in_nditers.iter().map(|nditer| nditer.get_scalar(ctx)).collect_vec();
+
+                let result = mapping(generator, ctx, &in_scalars)?;
+
+                let p = out_nditer.get_pointer(ctx);
+                ctx.builder.build_store(p, result).unwrap();
+
+                Ok(())
+            },
+            |_, ctx, (out_nditer, in_nditers)| {
+                // Advance all iterators
+                out_nditer.next(ctx);
+                in_nditers.iter().for_each(|nditer| nditer.next(ctx));
+                Ok(())
+            },
+        )?;
+
+        Ok(out_ndarray)
+    }
+}
+
+impl<'ctx> ScalarOrNDArray<'ctx> {
+    /// Starmap through a list of inputs using `mapping`, where an input could be an ndarray, a
+    /// scalar.
+    ///
+    /// This function is very helpful when implementing NumPy functions that takes on either scalars
+    /// or ndarrays or a mix of them as their inputs and produces either an ndarray with broadcast,
+    /// or a scalar if all its inputs are all scalars.
+    ///
+    /// For example ,this function can be used to implement `np.add`, which has the following
+    /// behaviors:
+    ///
+    /// - `np.add(3, 4) = 7` # (scalar, scalar) -> scalar
+    /// - `np.add(3, np.array([4, 5, 6]))` # (scalar, ndarray) -> ndarray; the first `scalar` is
+    ///   converted into an ndarray and broadcasted.
+    /// - `np.add(np.array([[1], [2], [3]]), np.array([[4, 5, 6]]))` # (ndarray, ndarray) ->
+    ///   ndarray; there is broadcasting.
+    ///
+    /// ## Details:
+    ///
+    /// If `inputs` are all [`ScalarOrNDArray::Scalar`], the output will be a
+    /// [`ScalarOrNDArray::Scalar`] with type `ret_dtype`.
+    ///
+    /// Otherwise (if there are any [`ScalarOrNDArray::NDArray`] in `inputs`), all inputs will be
+    /// 'as-ndarray'-ed into ndarrays, then all inputs (now all ndarrays) will be passed to
+    /// [`NDArrayValue::broadcasting_starmap`] and **create** a new ndarray with dtype `ret_dtype`.
+    pub fn broadcasting_starmap<'a, G, MappingFn>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, 'a>,
+        inputs: &[ScalarOrNDArray<'ctx>],
+        ret_dtype: BasicTypeEnum<'ctx>,
+        mapping: MappingFn,
+    ) -> Result<ScalarOrNDArray<'ctx>, String>
+    where
+        G: CodeGenerator + ?Sized,
+        MappingFn: FnOnce(
+            &mut G,
+            &mut CodeGenContext<'ctx, 'a>,
+            &[BasicValueEnum<'ctx>],
+        ) -> Result<BasicValueEnum<'ctx>, String>,
+    {
+        // Check if all inputs are Scalars
+        let all_scalars: Option<Vec<_>> =
+            inputs.iter().map(BasicValueEnum::<'ctx>::try_from).try_collect().ok();
+
+        if let Some(scalars) = all_scalars {
+            let scalars = scalars.iter().copied().collect_vec();
+            let value = mapping(generator, ctx, &scalars)?;
+
+            Ok(ScalarOrNDArray::Scalar(value))
+        } else {
+            // Promote all input to ndarrays and map through them.
+            let inputs = inputs.iter().map(|input| input.to_ndarray(generator, ctx)).collect_vec();
+            let ndarray = NDArrayType::new_broadcast(
+                ctx,
+                ret_dtype,
+                &inputs.iter().map(NDArrayValue::get_type).collect_vec(),
+            )
+            .broadcast_starmap(
+                generator,
+                ctx,
+                &inputs,
+                NDArrayOut::NewNDArray { dtype: ret_dtype },
+                mapping,
+            )?;
+            Ok(ScalarOrNDArray::NDArray(ndarray))
+        }
+    }
+}
--- a/nac3core/src/codegen/types/ndarray/mod.rs
+++ b/nac3core/src/codegen/types/ndarray/mod.rs
@ -14,18 +14,23 @@ use super::{
 };
 use crate::{
    codegen::{
-        values::{ndarray::NDArrayValue, ArraySliceValue, ProxyValue, TypedArrayLikeMutator},
+        values::{ndarray::NDArrayValue, ProxyValue, TypedArrayLikeMutator},
        {CodeGenContext, CodeGenerator},
    },
    toplevel::{helper::extract_ndims, numpy::unpack_ndarray_var_tys},
    typecheck::typedef::Type,
 };
+pub use broadcast::*;
 pub use contiguous::*;
 pub use indexing::*;
 pub use nditer::*;

+mod array;
+mod broadcast;
 mod contiguous;
+pub mod factory;
 mod indexing;
+mod map;
 mod nditer;

 /// Proxy type for a `ndarray` type in LLVM.
@ -33,7 +38,7 @@ mod nditer;
 pub struct NDArrayType<'ctx> {
    ty: PointerType<'ctx>,
    dtype: BasicTypeEnum<'ctx>,
-    ndims: Option<u64>,
+    ndims: u64,
    llvm_usize: IntType<'ctx>,
 }

@ -102,31 +107,85 @@ impl<'ctx> NDArrayType<'ctx> {
        ctx.struct_type(&field_tys, false).ptr_type(AddressSpace::default())
    }

-    /// Creates an instance of [`NDArrayType`].
-    #[must_use]
-    pub fn new<G: CodeGenerator + ?Sized>(
-        generator: &G,
+    fn new_impl(
        ctx: &'ctx Context,
        dtype: BasicTypeEnum<'ctx>,
-        ndims: Option<u64>,
+        ndims: u64,
+        llvm_usize: IntType<'ctx>,
    ) -> Self {
-        let llvm_usize = generator.get_size_type(ctx);
        let llvm_ndarray = Self::llvm_type(ctx, llvm_usize);

        NDArrayType { ty: llvm_ndarray, dtype, ndims, llvm_usize }
    }

+    /// Creates an instance of [`NDArrayType`].
+    #[must_use]
+    pub fn new(ctx: &CodeGenContext<'ctx, '_>, dtype: BasicTypeEnum<'ctx>, ndims: u64) -> Self {
+        Self::new_impl(ctx.ctx, dtype, ndims, ctx.get_size_type())
+    }
+
+    /// Creates an instance of [`NDArrayType`].
+    #[must_use]
+    pub fn new_with_generator<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+        dtype: BasicTypeEnum<'ctx>,
+        ndims: u64,
+    ) -> Self {
+        Self::new_impl(ctx, dtype, ndims, generator.get_size_type(ctx))
+    }
+
+    /// Creates an instance of [`NDArrayType`] as a result of a broadcast operation over one or more
+    /// `ndarray` operands.
+    #[must_use]
+    pub fn new_broadcast(
+        ctx: &CodeGenContext<'ctx, '_>,
+        dtype: BasicTypeEnum<'ctx>,
+        inputs: &[NDArrayType<'ctx>],
+    ) -> Self {
+        assert!(!inputs.is_empty());
+
+        Self::new_impl(
+            ctx.ctx,
+            dtype,
+            inputs.iter().map(NDArrayType::ndims).max().unwrap(),
+            ctx.get_size_type(),
+        )
+    }
+
+    /// Creates an instance of [`NDArrayType`] as a result of a broadcast operation over one or more
+    /// `ndarray` operands.
+    #[must_use]
+    pub fn new_broadcast_with_generator<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+        dtype: BasicTypeEnum<'ctx>,
+        inputs: &[NDArrayType<'ctx>],
+    ) -> Self {
+        assert!(!inputs.is_empty());
+
+        Self::new_impl(
+            ctx,
+            dtype,
+            inputs.iter().map(NDArrayType::ndims).max().unwrap(),
+            generator.get_size_type(ctx),
+        )
+    }
+
    /// Creates an instance of [`NDArrayType`] with `ndims` of 0.
    #[must_use]
-    pub fn new_unsized<G: CodeGenerator + ?Sized>(
+    pub fn new_unsized(ctx: &CodeGenContext<'ctx, '_>, dtype: BasicTypeEnum<'ctx>) -> Self {
+        Self::new_impl(ctx.ctx, dtype, 0, ctx.get_size_type())
+    }
+
+    /// Creates an instance of [`NDArrayType`] with `ndims` of 0.
+    #[must_use]
+    pub fn new_unsized_with_generator<G: CodeGenerator + ?Sized>(
        generator: &G,
        ctx: &'ctx Context,
        dtype: BasicTypeEnum<'ctx>,
    ) -> Self {
-        let llvm_usize = generator.get_size_type(ctx);
-        let llvm_ndarray = Self::llvm_type(ctx, llvm_usize);
-
-        NDArrayType { ty: llvm_ndarray, dtype, ndims: Some(0), llvm_usize }
+        Self::new_impl(ctx, dtype, 0, generator.get_size_type(ctx))
    }

    /// Creates an [`NDArrayType`] from a [unifier type][Type].
@ -139,15 +198,9 @@ impl<'ctx> NDArrayType<'ctx> {
        let (dtype, ndims) = unpack_ndarray_var_tys(&mut ctx.unifier, ty);

        let llvm_dtype = ctx.get_llvm_type(generator, dtype);
-        let llvm_usize = generator.get_size_type(ctx.ctx);
        let ndims = extract_ndims(&ctx.unifier, ndims);

-        NDArrayType {
-            ty: Self::llvm_type(ctx.ctx, llvm_usize),
-            dtype: llvm_dtype,
-            ndims: Some(ndims),
-            llvm_usize,
-        }
+        Self::new_impl(ctx.ctx, llvm_dtype, ndims, ctx.get_size_type())
    }

    /// Creates an [`NDArrayType`] from a [`PointerType`] representing an `NDArray`.
@ -155,7 +208,7 @@ impl<'ctx> NDArrayType<'ctx> {
    pub fn from_type(
        ptr_ty: PointerType<'ctx>,
        dtype: BasicTypeEnum<'ctx>,
-        ndims: Option<u64>,
+        ndims: u64,
        llvm_usize: IntType<'ctx>,
    ) -> Self {
        debug_assert!(Self::is_representable(ptr_ty, llvm_usize).is_ok());
@ -177,20 +230,40 @@ impl<'ctx> NDArrayType<'ctx> {

    /// Returns the number of dimensions of this `ndarray` type.
    #[must_use]
-    pub fn ndims(&self) -> Option<u64> {
+    pub fn ndims(&self) -> u64 {
        self.ndims
    }

    /// Allocates an instance of [`NDArrayValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca`].
    #[must_use]
-    pub fn alloca<G: CodeGenerator + ?Sized>(
+    pub fn alloca(
+        &self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
+            self.raw_alloca(ctx, name),
+            self.dtype,
+            self.ndims,
+            self.llvm_usize,
+            name,
+        )
+    }
+
+    /// Allocates an instance of [`NDArrayValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca_var`].
+    #[must_use]
+    pub fn alloca_var<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
-            self.raw_alloca(generator, ctx, name),
+            self.raw_alloca_var(generator, ctx, name),
            self.dtype,
            self.ndims,
            self.llvm_usize,
@ -214,15 +287,15 @@ impl<'ctx> NDArrayType<'ctx> {
        ndims: IntValue<'ctx>,
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
-        let ndarray = self.alloca(generator, ctx, name);
+        let ndarray = self.alloca_var(generator, ctx, name);

        let itemsize = ctx
            .builder
            .build_int_truncate_or_bit_cast(self.dtype.size_of().unwrap(), self.llvm_usize, "")
            .unwrap();
-        ndarray.store_itemsize(ctx, generator, itemsize);
+        ndarray.store_itemsize(ctx, itemsize);

-        ndarray.store_ndims(ctx, generator, ndims);
+        ndarray.store_ndims(ctx, ndims);

        ndarray.create_shape(ctx, self.llvm_usize, ndims);
        ndarray.create_strides(ctx, self.llvm_usize, ndims);
@ -247,35 +320,7 @@ impl<'ctx> NDArrayType<'ctx> {
        ctx: &mut CodeGenContext<'ctx, '_>,
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
-        assert!(self.ndims.is_some(), "NDArrayType::construct can only be called on an instance with compile-time known ndims (self.ndims = Some(ndims))");
-
-        let Some(ndims) = self.ndims.map(|ndims| self.llvm_usize.const_int(ndims, false)) else {
-            unreachable!()
-        };
-
-        self.construct_impl(generator, ctx, ndims, name)
-    }
-
-    /// Allocate an [`NDArrayValue`] on the stack given its `ndims` and `dtype`.
-    ///
-    /// `shape` and `strides` will be automatically allocated onto the stack.
-    ///
-    /// The returned ndarray's content will be:
-    /// - `data`: uninitialized.
-    /// - `itemsize`: set to the size of `dtype`.
-    /// - `ndims`: set to the value of `ndims`.
-    /// - `shape`: allocated with an array of length `ndims` with uninitialized values.
-    /// - `strides`: allocated with an array of length `ndims` with uninitialized values.
-    #[deprecated = "Prefer construct_uninitialized or construct_*_shape."]
-    #[must_use]
-    pub fn construct_dyn_ndims<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        ndims: IntValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> <Self as ProxyType<'ctx>>::Value {
-        assert!(self.ndims.is_none(), "NDArrayType::construct_dyn_ndims can only be called on an instance with compile-time unknown ndims (self.ndims = None)");
+        let ndims = self.llvm_usize.const_int(self.ndims, false);

        self.construct_impl(generator, ctx, ndims, name)
    }
@ -291,12 +336,12 @@ impl<'ctx> NDArrayType<'ctx> {
        shape: &[u64],
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
-        assert!(self.ndims.is_none_or(|ndims| shape.len() as u64 == ndims));
+        assert_eq!(shape.len() as u64, self.ndims);

-        let ndarray = Self::new(generator, ctx.ctx, self.dtype, Some(shape.len() as u64))
+        let ndarray = Self::new(ctx, self.dtype, shape.len() as u64)
            .construct_uninitialized(generator, ctx, name);

-        let llvm_usize = generator.get_size_type(ctx.ctx);
+        let llvm_usize = ctx.get_size_type();

        // Write shape
        let ndarray_shape = ndarray.shape();
@ -326,12 +371,12 @@ impl<'ctx> NDArrayType<'ctx> {
        shape: &[IntValue<'ctx>],
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
-        assert!(self.ndims.is_none_or(|ndims| shape.len() as u64 == ndims));
+        assert_eq!(shape.len() as u64, self.ndims);

-        let ndarray = Self::new(generator, ctx.ctx, self.dtype, Some(shape.len() as u64))
+        let ndarray = Self::new(ctx, self.dtype, shape.len() as u64)
            .construct_uninitialized(generator, ctx, name);

-        let llvm_usize = generator.get_size_type(ctx.ctx);
+        let llvm_usize = ctx.get_size_type();

        // Write shape
        let ndarray_shape = ndarray.shape();
@ -368,7 +413,7 @@ impl<'ctx> NDArrayType<'ctx> {
        let value = value.as_basic_value_enum();

        assert_eq!(value.get_type(), self.dtype);
-        assert!(self.ndims.is_none_or(|ndims| ndims == 0));
+        assert_eq!(self.ndims, 0);

        // We have to put the value on the stack to get a data pointer.
        let data = ctx.builder.build_alloca(value.get_type(), "construct_unsized").unwrap();
@ -378,8 +423,8 @@ impl<'ctx> NDArrayType<'ctx> {
            .build_pointer_cast(data, ctx.ctx.i8_type().ptr_type(AddressSpace::default()), "")
            .unwrap();

-        let ndarray = Self::new_unsized(generator, ctx.ctx, value.get_type())
-            .construct_uninitialized(generator, ctx, name);
+        let ndarray =
+            Self::new_unsized(ctx, value.get_type()).construct_uninitialized(generator, ctx, name);
        ctx.builder.build_store(ndarray.ptr_to_data(ctx), data).unwrap();
        ndarray
    }
@ -425,36 +470,8 @@ impl<'ctx> ProxyType<'ctx> for NDArrayType<'ctx> {
        Self::is_representable(llvm_ty, generator.get_size_type(ctx))
    }

-    fn raw_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        name: Option<&'ctx str>,
-    ) -> <Self::Value as ProxyValue<'ctx>>::Base {
-        generator
-            .gen_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                name,
-            )
-            .unwrap()
-    }
-
-    fn array_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        size: IntValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> ArraySliceValue<'ctx> {
-        generator
-            .gen_array_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                size,
-                name,
-            )
-            .unwrap()
+    fn alloca_type(&self) -> impl BasicType<'ctx> {
+        self.as_base_type().get_element_type().into_struct_type()
    }

    fn as_base_type(&self) -> Self::Base {
--- a/nac3core/src/codegen/types/ndarray/nditer.rs
+++ b/nac3core/src/codegen/types/ndarray/nditer.rs
@ -14,7 +14,7 @@ use crate::codegen::{
    types::structure::{check_struct_type_matches_fields, StructField, StructFields},
    values::{
        ndarray::{NDArrayValue, NDIterValue},
-        ArraySliceValue, ProxyValue,
+        ArrayLikeValue, ArraySliceValue, ProxyValue, TypedArrayLikeAdapter,
    },
    CodeGenContext, CodeGenerator,
 };
@ -86,15 +86,27 @@ impl<'ctx> NDIterType<'ctx> {
        ctx.struct_type(&field_tys, false).ptr_type(AddressSpace::default())
    }

-    /// Creates an instance of [`NDIter`].
-    #[must_use]
-    pub fn new<G: CodeGenerator + ?Sized>(generator: &G, ctx: &'ctx Context) -> Self {
-        let llvm_usize = generator.get_size_type(ctx);
+    fn new_impl(ctx: &'ctx Context, llvm_usize: IntType<'ctx>) -> Self {
        let llvm_nditer = Self::llvm_type(ctx, llvm_usize);

        Self { ty: llvm_nditer, llvm_usize }
    }

+    /// Creates an instance of [`NDIter`].
+    #[must_use]
+    pub fn new(ctx: &CodeGenContext<'ctx, '_>) -> Self {
+        Self::new_impl(ctx.ctx, ctx.get_size_type())
+    }
+
+    /// Creates an instance of [`NDIter`].
+    #[must_use]
+    pub fn new_with_generator<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> Self {
+        Self::new_impl(ctx, generator.get_size_type(ctx))
+    }
+
    /// Creates an [`NDIterType`] from a [`PointerType`] representing an `NDIter`.
    #[must_use]
    pub fn from_type(ptr_ty: PointerType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
@ -109,8 +121,31 @@ impl<'ctx> NDIterType<'ctx> {
        self.llvm_usize
    }

+    /// Allocates an instance of [`NDIterValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca`].
    #[must_use]
-    pub fn alloca<G: CodeGenerator + ?Sized>(
+    pub fn alloca(
+        &self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        parent: NDArrayValue<'ctx>,
+        indices: ArraySliceValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
+            self.raw_alloca(ctx, name),
+            parent,
+            indices,
+            self.llvm_usize,
+            name,
+        )
+    }
+
+    /// Allocates an instance of [`NDIterValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca_var`].
+    #[must_use]
+    pub fn alloca_var<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
@ -119,7 +154,7 @@ impl<'ctx> NDIterType<'ctx> {
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
-            self.raw_alloca(generator, ctx, name),
+            self.raw_alloca_var(generator, ctx, name),
            parent,
            indices,
            self.llvm_usize,
@ -135,22 +170,18 @@ impl<'ctx> NDIterType<'ctx> {
        ctx: &mut CodeGenContext<'ctx, '_>,
        ndarray: NDArrayValue<'ctx>,
    ) -> <Self as ProxyType<'ctx>>::Value {
-        let nditer = self.raw_alloca(generator, ctx, None);
-        let ndims = ndarray.load_ndims(ctx);
+        let nditer = self.raw_alloca_var(generator, ctx, None);
+        let ndims = self.llvm_usize.const_int(ndarray.get_type().ndims(), false);

        // The caller has the responsibility to allocate 'indices' for `NDIter`.
        let indices =
            generator.gen_array_var_alloc(ctx, self.llvm_usize.into(), ndims, None).unwrap();
+        let indices =
+            TypedArrayLikeAdapter::from(indices, |_, _, v| v.into_int_value(), |_, _, v| v.into());

-        let nditer = <Self as ProxyType<'ctx>>::Value::from_pointer_value(
-            nditer,
-            ndarray,
-            indices,
-            self.llvm_usize,
-            None,
-        );
+        let nditer = self.map_value(nditer, ndarray, indices.as_slice_value(ctx, generator), None);

-        irrt::ndarray::call_nac3_nditer_initialize(generator, ctx, nditer, ndarray, indices);
+        irrt::ndarray::call_nac3_nditer_initialize(generator, ctx, nditer, ndarray, &indices);

        nditer
    }
@ -197,36 +228,8 @@ impl<'ctx> ProxyType<'ctx> for NDIterType<'ctx> {
        Self::is_representable(llvm_ty, generator.get_size_type(ctx))
    }

-    fn raw_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        name: Option<&'ctx str>,
-    ) -> <Self::Value as ProxyValue<'ctx>>::Base {
-        generator
-            .gen_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                name,
-            )
-            .unwrap()
-    }
-
-    fn array_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        size: IntValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> ArraySliceValue<'ctx> {
-        generator
-            .gen_array_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                size,
-                name,
-            )
-            .unwrap()
+    fn alloca_type(&self) -> impl BasicType<'ctx> {
+        self.as_base_type().get_element_type().into_struct_type()
    }

    fn as_base_type(&self) -> Self::Base {
--- a/nac3core/src/codegen/types/range.rs
+++ b/nac3core/src/codegen/types/range.rs
@ -1,13 +1,12 @@
 use inkwell::{
    context::Context,
    types::{AnyTypeEnum, BasicType, BasicTypeEnum, IntType, PointerType},
-    values::IntValue,
    AddressSpace,
 };

 use super::ProxyType;
 use crate::codegen::{
-    values::{ArraySliceValue, ProxyValue, RangeValue},
+    values::{ProxyValue, RangeValue},
    {CodeGenContext, CodeGenerator},
 };

@ -78,15 +77,29 @@ impl<'ctx> RangeType<'ctx> {
    }

    /// Allocates an instance of [`RangeValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca`].
    #[must_use]
    pub fn alloca<G: CodeGenerator + ?Sized>(
+        &self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_pointer_value(self.raw_alloca(ctx, name), name)
+    }
+
+    /// Allocates an instance of [`RangeValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca_var`].
+    #[must_use]
+    pub fn alloca_var<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
-            self.raw_alloca(generator, ctx, name),
+            self.raw_alloca_var(generator, ctx, name),
            name,
        )
    }
@ -126,36 +139,8 @@ impl<'ctx> ProxyType<'ctx> for RangeType<'ctx> {
        Self::is_representable(llvm_ty)
    }

-    fn raw_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        name: Option<&'ctx str>,
-    ) -> <Self::Value as ProxyValue<'ctx>>::Base {
-        generator
-            .gen_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                name,
-            )
-            .unwrap()
-    }
-
-    fn array_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        size: IntValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> ArraySliceValue<'ctx> {
-        generator
-            .gen_array_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                size,
-                name,
-            )
-            .unwrap()
+    fn alloca_type(&self) -> impl BasicType<'ctx> {
+        self.as_base_type().get_element_type().into_struct_type()
    }

    fn as_base_type(&self) -> Self::Base {
--- a/nac3core/src/codegen/types/structure.rs
+++ b/nac3core/src/codegen/types/structure.rs
@ -5,6 +5,7 @@ use inkwell::{
    types::{BasicTypeEnum, IntType, StructType},
    values::{BasicValue, BasicValueEnum, IntValue, PointerValue, StructValue},
 };
+use itertools::Itertools;

 use crate::codegen::CodeGenContext;

@ -55,6 +56,20 @@ pub trait StructFields<'ctx>: Eq + Copy {
    {
        self.into_vec().into_iter()
    }
+
+    /// Returns the field index of a field in this structure.
+    fn index_of_field<V>(&self, name: impl FnOnce(&Self) -> StructField<'ctx, V>) -> u32
+    where
+        V: BasicValue<'ctx> + TryFrom<BasicValueEnum<'ctx>, Error = ()>,
+    {
+        let field_name = name(self).name;
+        self.index_of_field_name(field_name).unwrap()
+    }
+
+    /// Returns the field index of a field with the given name in this structure.
+    fn index_of_field_name(&self, field_name: &str) -> Option<u32> {
+        self.iter().find_position(|(name, _)| *name == field_name).map(|(idx, _)| idx as u32)
+    }
 }

 /// A single field of an LLVM structure.
--- a/nac3core/src/codegen/types/tuple.rs
+++ b/nac3core/src/codegen/types/tuple.rs
@ -0,0 +1,201 @@
+use inkwell::{
+    context::Context,
+    types::{BasicType, BasicTypeEnum, IntType, StructType},
+    values::BasicValueEnum,
+};
+use itertools::Itertools;
+
+use super::ProxyType;
+use crate::{
+    codegen::{
+        values::{ProxyValue, TupleValue},
+        CodeGenContext, CodeGenerator,
+    },
+    typecheck::typedef::{Type, TypeEnum},
+};
+
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct TupleType<'ctx> {
+    ty: StructType<'ctx>,
+    llvm_usize: IntType<'ctx>,
+}
+
+impl<'ctx> TupleType<'ctx> {
+    /// Checks whether `llvm_ty` represents any tuple type, returning [Err] if it does not.
+    pub fn is_representable(_value: StructType<'ctx>) -> Result<(), String> {
+        Ok(())
+    }
+
+    /// Creates an LLVM type corresponding to the expected structure of a tuple.
+    #[must_use]
+    fn llvm_type(ctx: &'ctx Context, tys: &[BasicTypeEnum<'ctx>]) -> StructType<'ctx> {
+        ctx.struct_type(tys, false)
+    }
+
+    fn new_impl(
+        ctx: &'ctx Context,
+        tys: &[BasicTypeEnum<'ctx>],
+        llvm_usize: IntType<'ctx>,
+    ) -> Self {
+        let llvm_tuple = Self::llvm_type(ctx, tys);
+
+        Self { ty: llvm_tuple, llvm_usize }
+    }
+
+    /// Creates an instance of [`TupleType`].
+    #[must_use]
+    pub fn new(ctx: &CodeGenContext<'ctx, '_>, tys: &[impl BasicType<'ctx>]) -> Self {
+        Self::new_impl(
+            ctx.ctx,
+            &tys.iter().map(BasicType::as_basic_type_enum).collect_vec(),
+            ctx.get_size_type(),
+        )
+    }
+
+    /// Creates an instance of [`TupleType`].
+    #[must_use]
+    pub fn new_with_generator<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+        tys: &[BasicTypeEnum<'ctx>],
+    ) -> Self {
+        Self::new_impl(ctx, tys, generator.get_size_type(ctx))
+    }
+
+    /// Creates an [`TupleType`] from a [unifier type][Type].
+    #[must_use]
+    pub fn from_unifier_type<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        ty: Type,
+    ) -> Self {
+        let llvm_usize = ctx.get_size_type();
+
+        // Sanity check on object type.
+        let TypeEnum::TTuple { ty: tys, .. } = &*ctx.unifier.get_ty_immutable(ty) else {
+            panic!("Expected type to be a TypeEnum::TTuple, got {}", ctx.unifier.stringify(ty));
+        };
+
+        let llvm_tys = tys.iter().map(|ty| ctx.get_llvm_type(generator, *ty)).collect_vec();
+        Self { ty: Self::llvm_type(ctx.ctx, &llvm_tys), llvm_usize }
+    }
+
+    /// Creates an [`TupleType`] from a [`StructType`].
+    #[must_use]
+    pub fn from_type(struct_ty: StructType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
+        debug_assert!(Self::is_representable(struct_ty).is_ok());
+
+        TupleType { ty: struct_ty, llvm_usize }
+    }
+
+    /// Returns the number of elements present in this [`TupleType`].
+    #[must_use]
+    pub fn num_elements(&self) -> u32 {
+        self.ty.count_fields()
+    }
+
+    /// Returns the type of the tuple element at the given `index`, or [`None`] if `index` is out of
+    /// range.
+    #[must_use]
+    pub fn type_at_index(&self, index: u32) -> Option<BasicTypeEnum<'ctx>> {
+        if index < self.num_elements() {
+            Some(unsafe { self.type_at_index_unchecked(index) })
+        } else {
+            None
+        }
+    }
+
+    /// Returns the type of the tuple element at the given `index`.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the index is valid.
+    #[must_use]
+    pub unsafe fn type_at_index_unchecked(&self, index: u32) -> BasicTypeEnum<'ctx> {
+        self.ty.get_field_type_at_index_unchecked(index)
+    }
+
+    /// Constructs a [`TupleValue`] from this type by zero-initializing the tuple value.
+    #[must_use]
+    pub fn construct(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        self.map_value(Self::llvm_type(ctx.ctx, &self.ty.get_field_types()).const_zero(), name)
+    }
+
+    /// Constructs a [`TupleValue`] from `objects`. The resulting tuple preserves the order of
+    /// objects.
+    #[must_use]
+    pub fn construct_from_objects<I: IntoIterator<Item = BasicValueEnum<'ctx>>>(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        objects: I,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        let values = objects.into_iter().collect_vec();
+
+        assert_eq!(values.len(), self.num_elements() as usize);
+        assert!(values
+            .iter()
+            .enumerate()
+            .all(|(i, v)| { v.get_type() == unsafe { self.type_at_index_unchecked(i as u32) } }));
+
+        let mut value = self.construct(ctx, name);
+        for (i, val) in values.into_iter().enumerate() {
+            value.store_element(ctx, i as u32, val);
+        }
+
+        value
+    }
+
+    /// Converts an existing value into a [`ListValue`].
+    #[must_use]
+    pub fn map_value(
+        &self,
+        value: <<Self as ProxyType<'ctx>>::Value as ProxyValue<'ctx>>::Base,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_struct_value(value, self.llvm_usize, name)
+    }
+}
+
+impl<'ctx> ProxyType<'ctx> for TupleType<'ctx> {
+    type Base = StructType<'ctx>;
+    type Value = TupleValue<'ctx>;
+
+    fn is_type<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+        llvm_ty: impl BasicType<'ctx>,
+    ) -> Result<(), String> {
+        if let BasicTypeEnum::StructType(ty) = llvm_ty.as_basic_type_enum() {
+            <Self as ProxyType<'ctx>>::is_representable(generator, ctx, ty)
+        } else {
+            Err(format!("Expected struct type, got {llvm_ty:?}"))
+        }
+    }
+
+    fn is_representable<G: CodeGenerator + ?Sized>(
+        _generator: &G,
+        _ctx: &'ctx Context,
+        llvm_ty: Self::Base,
+    ) -> Result<(), String> {
+        Self::is_representable(llvm_ty)
+    }
+
+    fn alloca_type(&self) -> impl BasicType<'ctx> {
+        self.as_base_type()
+    }
+
+    fn as_base_type(&self) -> Self::Base {
+        self.ty
+    }
+}
+
+impl<'ctx> From<TupleType<'ctx>> for StructType<'ctx> {
+    fn from(value: TupleType<'ctx>) -> Self {
+        value.as_base_type()
+    }
+}
--- a/nac3core/src/codegen/types/utils/slice.rs
+++ b/nac3core/src/codegen/types/utils/slice.rs
@ -15,7 +15,7 @@ use crate::codegen::{
        },
        ProxyType,
    },
-    values::{utils::SliceValue, ArraySliceValue, ProxyValue},
+    values::{utils::SliceValue, ProxyValue},
    CodeGenContext, CodeGenerator,
 };

@ -122,19 +122,31 @@ impl<'ctx> SliceType<'ctx> {
        ctx.struct_type(&field_tys, false).ptr_type(AddressSpace::default())
    }

-    /// Creates an instance of [`SliceType`] with `int_ty` as its backing integer type.
-    #[must_use]
-    pub fn new(ctx: &'ctx Context, int_ty: IntType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
+    fn new_impl(ctx: &'ctx Context, int_ty: IntType<'ctx>, llvm_usize: IntType<'ctx>) -> Self {
        let llvm_ty = Self::llvm_type(ctx, int_ty);

        Self { ty: llvm_ty, int_ty, llvm_usize }
    }

+    /// Creates an instance of [`SliceType`] with `int_ty` as its backing integer type.
+    #[must_use]
+    pub fn new(ctx: &CodeGenContext<'ctx, '_>, int_ty: IntType<'ctx>) -> Self {
+        Self::new_impl(ctx.ctx, int_ty, ctx.get_size_type())
+    }
+
    /// Creates an instance of [`SliceType`] with `usize` as its backing integer type.
    #[must_use]
-    pub fn new_usize<G: CodeGenerator + ?Sized>(generator: &G, ctx: &'ctx Context) -> Self {
-        let llvm_usize = generator.get_size_type(ctx);
-        Self::new(ctx, llvm_usize, llvm_usize)
+    pub fn new_usize(ctx: &CodeGenContext<'ctx, '_>) -> Self {
+        Self::new_impl(ctx.ctx, ctx.get_size_type(), ctx.get_size_type())
+    }
+
+    /// Creates an instance of [`SliceType`] with `usize` as its backing integer type.
+    #[must_use]
+    pub fn new_usize_with_generator<G: CodeGenerator + ?Sized>(
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> Self {
+        Self::new_impl(ctx, generator.get_size_type(ctx), generator.get_size_type(ctx))
    }

    /// Creates an [`SliceType`] from a [`PointerType`] representing a `slice`.
@ -154,16 +166,35 @@ impl<'ctx> SliceType<'ctx> {
        self.int_ty
    }

-    /// Allocates an instance of [`ContiguousNDArrayValue`] as if by calling `alloca` on the base type.
+    /// Allocates an instance of [`SliceValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca`].
    #[must_use]
-    pub fn alloca<G: CodeGenerator + ?Sized>(
+    pub fn alloca(
+        &self,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> <Self as ProxyType<'ctx>>::Value {
+        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
+            self.raw_alloca(ctx, name),
+            self.int_ty,
+            self.llvm_usize,
+            name,
+        )
+    }
+
+    /// Allocates an instance of [`SliceValue`] as if by calling `alloca` on the base type.
+    ///
+    /// See [`ProxyType::raw_alloca_var`].
+    #[must_use]
+    pub fn alloca_var<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
        name: Option<&'ctx str>,
    ) -> <Self as ProxyType<'ctx>>::Value {
        <Self as ProxyType<'ctx>>::Value::from_pointer_value(
-            self.raw_alloca(generator, ctx, name),
+            self.raw_alloca_var(generator, ctx, name),
            self.int_ty,
            self.llvm_usize,
            name,
@ -210,36 +241,8 @@ impl<'ctx> ProxyType<'ctx> for SliceType<'ctx> {
        Self::is_representable(llvm_ty, generator.get_size_type(ctx))
    }

-    fn raw_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        name: Option<&'ctx str>,
-    ) -> <Self::Value as ProxyValue<'ctx>>::Base {
-        generator
-            .gen_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                name,
-            )
-            .unwrap()
-    }
-
-    fn array_alloca<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &mut G,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        size: IntValue<'ctx>,
-        name: Option<&'ctx str>,
-    ) -> ArraySliceValue<'ctx> {
-        generator
-            .gen_array_var_alloc(
-                ctx,
-                self.as_base_type().get_element_type().into_struct_type().into(),
-                size,
-                name,
-            )
-            .unwrap()
+    fn alloca_type(&self) -> impl BasicType<'ctx> {
+        self.as_base_type().get_element_type().into_struct_type()
    }

    fn as_base_type(&self) -> Self::Base {
--- a/nac3core/src/codegen/values/array.rs
+++ b/nac3core/src/codegen/values/array.rs
@ -51,8 +51,8 @@ pub trait ArrayLikeIndexer<'ctx, Index = IntValue<'ctx>>: ArrayLikeValue<'ctx> {
    /// This function should be called with a valid index.
    unsafe fn ptr_offset_unchecked<G: CodeGenerator + ?Sized>(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        idx: &Index,
        name: Option<&str>,
    ) -> PointerValue<'ctx>;
@ -76,8 +76,8 @@ pub trait UntypedArrayLikeAccessor<'ctx, Index = IntValue<'ctx>>:
    /// This function should be called with a valid index.
    unsafe fn get_unchecked<G: CodeGenerator + ?Sized>(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        idx: &Index,
        name: Option<&str>,
    ) -> BasicValueEnum<'ctx> {
@ -107,8 +107,8 @@ pub trait UntypedArrayLikeMutator<'ctx, Index = IntValue<'ctx>>:
    /// This function should be called with a valid index.
    unsafe fn set_unchecked<G: CodeGenerator + ?Sized>(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        idx: &Index,
        value: BasicValueEnum<'ctx>,
    ) {
@ -130,32 +130,33 @@ pub trait UntypedArrayLikeMutator<'ctx, Index = IntValue<'ctx>>:
 }

 /// An array-like value that can have its array elements accessed as an arbitrary type `T`.
-pub trait TypedArrayLikeAccessor<'ctx, T, Index = IntValue<'ctx>>:
+pub trait TypedArrayLikeAccessor<'ctx, G: CodeGenerator + ?Sized, T, Index = IntValue<'ctx>>:
    UntypedArrayLikeAccessor<'ctx, Index>
 {
    /// Casts an element from [`BasicValueEnum`] into `T`.
    fn downcast_to_type(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        value: BasicValueEnum<'ctx>,
    ) -> T;

    /// # Safety
    ///
    /// This function should be called with a valid index.
-    unsafe fn get_typed_unchecked<G: CodeGenerator + ?Sized>(
+    unsafe fn get_typed_unchecked(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        idx: &Index,
        name: Option<&str>,
    ) -> T {
        let value = unsafe { self.get_unchecked(ctx, generator, idx, name) };
-        self.downcast_to_type(ctx, value)
+        self.downcast_to_type(ctx, generator, value)
    }

    /// Returns the data at the `idx`-th index.
-    fn get_typed<G: CodeGenerator + ?Sized>(
+    fn get_typed(
        &self,
        ctx: &mut CodeGenContext<'ctx, '_>,
        generator: &mut G,
@ -163,62 +164,63 @@ pub trait TypedArrayLikeAccessor<'ctx, T, Index = IntValue<'ctx>>:
        name: Option<&str>,
    ) -> T {
        let value = self.get(ctx, generator, idx, name);
-        self.downcast_to_type(ctx, value)
+        self.downcast_to_type(ctx, generator, value)
    }
 }

 /// An array-like value that can have its array elements mutated as an arbitrary type `T`.
-pub trait TypedArrayLikeMutator<'ctx, T, Index = IntValue<'ctx>>:
+pub trait TypedArrayLikeMutator<'ctx, G: CodeGenerator + ?Sized, T, Index = IntValue<'ctx>>:
    UntypedArrayLikeMutator<'ctx, Index>
 {
    /// Casts an element from T into [`BasicValueEnum`].
    fn upcast_from_type(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        value: T,
    ) -> BasicValueEnum<'ctx>;

    /// # Safety
    ///
    /// This function should be called with a valid index.
-    unsafe fn set_typed_unchecked<G: CodeGenerator + ?Sized>(
+    unsafe fn set_typed_unchecked(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        idx: &Index,
        value: T,
    ) {
-        let value = self.upcast_from_type(ctx, value);
+        let value = self.upcast_from_type(ctx, generator, value);
        unsafe { self.set_unchecked(ctx, generator, idx, value) }
    }

    /// Sets the data at the `idx`-th index.
-    fn set_typed<G: CodeGenerator + ?Sized>(
+    fn set_typed(
        &self,
        ctx: &mut CodeGenContext<'ctx, '_>,
        generator: &mut G,
        idx: &Index,
        value: T,
    ) {
-        let value = self.upcast_from_type(ctx, value);
+        let value = self.upcast_from_type(ctx, generator, value);
        self.set(ctx, generator, idx, value);
    }
 }

-/// Type alias for a function that casts a [`BasicValueEnum`] into a `T`.
-type ValueDowncastFn<'ctx, T> =
-    Box<dyn Fn(&mut CodeGenContext<'ctx, '_>, BasicValueEnum<'ctx>) -> T + 'ctx>;
-/// Type alias for a function that casts a `T` into a [`BasicValueEnum`].
-type ValueUpcastFn<'ctx, T> = Box<dyn Fn(&mut CodeGenContext<'ctx, '_>, T) -> BasicValueEnum<'ctx>>;
-
 /// An adapter for constraining untyped array values as typed values.
-pub struct TypedArrayLikeAdapter<'ctx, T, Adapted: ArrayLikeValue<'ctx> = ArraySliceValue<'ctx>> {
+#[derive(Copy, Clone)]
+pub struct TypedArrayLikeAdapter<
+    'ctx,
+    G: CodeGenerator + ?Sized,
+    T,
+    Adapted: ArrayLikeValue<'ctx> = ArraySliceValue<'ctx>,
+> {
    adapted: Adapted,
-    downcast_fn: ValueDowncastFn<'ctx, T>,
-    upcast_fn: ValueUpcastFn<'ctx, T>,
+    downcast_fn: fn(&CodeGenContext<'ctx, '_>, &G, BasicValueEnum<'ctx>) -> T,
+    upcast_fn: fn(&CodeGenContext<'ctx, '_>, &G, T) -> BasicValueEnum<'ctx>,
 }

-impl<'ctx, T, Adapted> TypedArrayLikeAdapter<'ctx, T, Adapted>
+impl<'ctx, G: CodeGenerator + ?Sized, T, Adapted> TypedArrayLikeAdapter<'ctx, G, T, Adapted>
 where
    Adapted: ArrayLikeValue<'ctx>,
 {
@ -229,61 +231,70 @@ where
    /// * `upcast_fn` - The function converting a T into a [`BasicValueEnum`].
    pub fn from(
        adapted: Adapted,
-        downcast_fn: ValueDowncastFn<'ctx, T>,
-        upcast_fn: ValueUpcastFn<'ctx, T>,
+        downcast_fn: fn(&CodeGenContext<'ctx, '_>, &G, BasicValueEnum<'ctx>) -> T,
+        upcast_fn: fn(&CodeGenContext<'ctx, '_>, &G, T) -> BasicValueEnum<'ctx>,
    ) -> Self {
        TypedArrayLikeAdapter { adapted, downcast_fn, upcast_fn }
    }
 }

-impl<'ctx, T, Adapted> ArrayLikeValue<'ctx> for TypedArrayLikeAdapter<'ctx, T, Adapted>
+impl<'ctx, G: CodeGenerator + ?Sized, T, Adapted> ArrayLikeValue<'ctx>
+    for TypedArrayLikeAdapter<'ctx, G, T, Adapted>
 where
    Adapted: ArrayLikeValue<'ctx>,
 {
-    fn element_type<G: CodeGenerator + ?Sized>(
+    fn element_type<CG: CodeGenerator + ?Sized>(
        &self,
        ctx: &CodeGenContext<'ctx, '_>,
-        generator: &G,
+        generator: &CG,
    ) -> AnyTypeEnum<'ctx> {
        self.adapted.element_type(ctx, generator)
    }

-    fn base_ptr<G: CodeGenerator + ?Sized>(
+    fn base_ptr<CG: CodeGenerator + ?Sized>(
        &self,
        ctx: &CodeGenContext<'ctx, '_>,
-        generator: &G,
+        generator: &CG,
    ) -> PointerValue<'ctx> {
        self.adapted.base_ptr(ctx, generator)
    }

-    fn size<G: CodeGenerator + ?Sized>(
+    fn size<CG: CodeGenerator + ?Sized>(
        &self,
        ctx: &CodeGenContext<'ctx, '_>,
-        generator: &G,
+        generator: &CG,
    ) -> IntValue<'ctx> {
        self.adapted.size(ctx, generator)
    }
+
+    fn as_slice_value<CG: CodeGenerator + ?Sized>(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &CG,
+    ) -> ArraySliceValue<'ctx> {
+        self.adapted.as_slice_value(ctx, generator)
+    }
 }

-impl<'ctx, T, Index, Adapted> ArrayLikeIndexer<'ctx, Index>
-    for TypedArrayLikeAdapter<'ctx, T, Adapted>
+impl<'ctx, G: CodeGenerator + ?Sized, T, Index, Adapted> ArrayLikeIndexer<'ctx, Index>
+    for TypedArrayLikeAdapter<'ctx, G, T, Adapted>
 where
    Adapted: ArrayLikeIndexer<'ctx, Index>,
 {
-    unsafe fn ptr_offset_unchecked<G: CodeGenerator + ?Sized>(
+    unsafe fn ptr_offset_unchecked<CG: CodeGenerator + ?Sized>(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &CG,
        idx: &Index,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
        unsafe { self.adapted.ptr_offset_unchecked(ctx, generator, idx, name) }
    }

-    fn ptr_offset<G: CodeGenerator + ?Sized>(
+    fn ptr_offset<CG: CodeGenerator + ?Sized>(
        &self,
        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        generator: &mut CG,
        idx: &Index,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
@ -291,44 +302,46 @@ where
    }
 }

-impl<'ctx, T, Index, Adapted> UntypedArrayLikeAccessor<'ctx, Index>
-    for TypedArrayLikeAdapter<'ctx, T, Adapted>
+impl<'ctx, G: CodeGenerator + ?Sized, T, Index, Adapted> UntypedArrayLikeAccessor<'ctx, Index>
+    for TypedArrayLikeAdapter<'ctx, G, T, Adapted>
 where
    Adapted: UntypedArrayLikeAccessor<'ctx, Index>,
 {
 }
-impl<'ctx, T, Index, Adapted> UntypedArrayLikeMutator<'ctx, Index>
-    for TypedArrayLikeAdapter<'ctx, T, Adapted>
+impl<'ctx, G: CodeGenerator + ?Sized, T, Index, Adapted> UntypedArrayLikeMutator<'ctx, Index>
+    for TypedArrayLikeAdapter<'ctx, G, T, Adapted>
 where
    Adapted: UntypedArrayLikeMutator<'ctx, Index>,
 {
 }

-impl<'ctx, T, Index, Adapted> TypedArrayLikeAccessor<'ctx, T, Index>
-    for TypedArrayLikeAdapter<'ctx, T, Adapted>
+impl<'ctx, G: CodeGenerator + ?Sized, T, Index, Adapted> TypedArrayLikeAccessor<'ctx, G, T, Index>
+    for TypedArrayLikeAdapter<'ctx, G, T, Adapted>
 where
    Adapted: UntypedArrayLikeAccessor<'ctx, Index>,
 {
    fn downcast_to_type(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        value: BasicValueEnum<'ctx>,
    ) -> T {
-        (self.downcast_fn)(ctx, value)
+        (self.downcast_fn)(ctx, generator, value)
    }
 }

-impl<'ctx, T, Index, Adapted> TypedArrayLikeMutator<'ctx, T, Index>
-    for TypedArrayLikeAdapter<'ctx, T, Adapted>
+impl<'ctx, G: CodeGenerator + ?Sized, T, Index, Adapted> TypedArrayLikeMutator<'ctx, G, T, Index>
+    for TypedArrayLikeAdapter<'ctx, G, T, Adapted>
 where
    Adapted: UntypedArrayLikeMutator<'ctx, Index>,
 {
    fn upcast_from_type(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        value: T,
    ) -> BasicValueEnum<'ctx> {
-        (self.upcast_fn)(ctx, value)
+        (self.upcast_fn)(ctx, generator, value)
    }
 }

@ -384,12 +397,12 @@ impl<'ctx> ArrayLikeValue<'ctx> for ArraySliceValue<'ctx> {
 impl<'ctx> ArrayLikeIndexer<'ctx> for ArraySliceValue<'ctx> {
    unsafe fn ptr_offset_unchecked<G: CodeGenerator + ?Sized>(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        idx: &IntValue<'ctx>,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
-        let var_name = name.map(|v| format!("{v}.addr")).unwrap_or_default();
+        let var_name = name.or(self.2).map(|v| format!("{v}.addr")).unwrap_or_default();

        unsafe {
            ctx.builder
@ -405,7 +418,7 @@ impl<'ctx> ArrayLikeIndexer<'ctx> for ArraySliceValue<'ctx> {
        idx: &IntValue<'ctx>,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
-        debug_assert_eq!(idx.get_type(), generator.get_size_type(ctx.ctx));
+        debug_assert_eq!(idx.get_type(), ctx.get_size_type());

        let size = self.size(ctx, generator);
        let in_range = ctx.builder.build_int_compare(IntPredicate::ULT, *idx, size, "").unwrap();
--- a/nac3core/src/codegen/values/list.rs
+++ b/nac3core/src/codegen/values/list.rs
@ -8,7 +8,7 @@ use super::{
    ArrayLikeIndexer, ArrayLikeValue, ProxyValue, UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
 };
 use crate::codegen::{
-    types::ListType,
+    types::{structure::StructField, ListType, ProxyType},
    {CodeGenContext, CodeGenerator},
 };

@ -42,48 +42,26 @@ impl<'ctx> ListValue<'ctx> {
        ListValue { value: ptr, llvm_usize, name }
    }

+    fn items_field(&self, ctx: &CodeGenContext<'ctx, '_>) -> StructField<'ctx, PointerValue<'ctx>> {
+        self.get_type().get_fields(&ctx.ctx).items
+    }
+
    /// Returns the double-indirection pointer to the `data` array, as if by calling `getelementptr`
    /// on the field.
    fn pptr_to_data(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
-        let llvm_i32 = ctx.ctx.i32_type();
-        let var_name = self.name.map(|v| format!("{v}.data.addr")).unwrap_or_default();
-
-        unsafe {
-            ctx.builder
-                .build_in_bounds_gep(
-                    self.as_base_value(),
-                    &[llvm_i32.const_zero(), llvm_i32.const_zero()],
-                    var_name.as_str(),
-                )
-                .unwrap()
-        }
-    }
-
-    /// Returns the pointer to the field storing the size of this `list`.
-    fn ptr_to_size(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
-        let llvm_i32 = ctx.ctx.i32_type();
-        let var_name = self.name.map(|v| format!("{v}.size.addr")).unwrap_or_default();
-
-        unsafe {
-            ctx.builder
-                .build_in_bounds_gep(
-                    self.as_base_value(),
-                    &[llvm_i32.const_zero(), llvm_i32.const_int(1, true)],
-                    var_name.as_str(),
-                )
-                .unwrap()
-        }
+        self.items_field(ctx).ptr_by_gep(ctx, self.value, self.name)
    }

    /// Stores the array of data elements `data` into this instance.
    fn store_data(&self, ctx: &CodeGenContext<'ctx, '_>, data: PointerValue<'ctx>) {
-        ctx.builder.build_store(self.pptr_to_data(ctx), data).unwrap();
+        self.items_field(ctx).set(ctx, self.value, data, self.name);
    }

    /// Convenience method for creating a new array storing data elements with the given element
    /// type `elem_ty` and `size`.
    ///
-    /// If `size` is [None], the size stored in the field of this instance is used instead.
+    /// If `size` is [None], the size stored in the field of this instance is used instead. If
+    /// `size` is resolved to `0` at runtime, `(T*) 0` will be assigned to `data`.
    pub fn create_data(
        &self,
        ctx: &mut CodeGenContext<'ctx, '_>,
@ -114,31 +92,37 @@ impl<'ctx> ListValue<'ctx> {
        ListDataProxy(self)
    }

-    /// Stores the `size` of this `list` into this instance.
-    pub fn store_size<G: CodeGenerator + ?Sized>(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-        generator: &G,
-        size: IntValue<'ctx>,
-    ) {
-        debug_assert_eq!(size.get_type(), generator.get_size_type(ctx.ctx));
+    fn len_field(&self, ctx: &CodeGenContext<'ctx, '_>) -> StructField<'ctx, IntValue<'ctx>> {
+        self.get_type().get_fields(&ctx.ctx).len
+    }

-        let psize = self.ptr_to_size(ctx);
-        ctx.builder.build_store(psize, size).unwrap();
+    /// Stores the `size` of this `list` into this instance.
+    pub fn store_size(&self, ctx: &CodeGenContext<'ctx, '_>, size: IntValue<'ctx>) {
+        debug_assert_eq!(size.get_type(), ctx.get_size_type());
+
+        self.len_field(ctx).set(ctx, self.value, size, self.name);
    }

    /// Returns the size of this `list` as a value.
-    pub fn load_size(&self, ctx: &CodeGenContext<'ctx, '_>, name: Option<&str>) -> IntValue<'ctx> {
-        let psize = self.ptr_to_size(ctx);
-        let var_name = name
-            .map(ToString::to_string)
-            .or_else(|| self.name.map(|v| format!("{v}.size")))
-            .unwrap_or_default();
+    pub fn load_size(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        name: Option<&'ctx str>,
+    ) -> IntValue<'ctx> {
+        self.len_field(ctx).get(ctx, self.value, name)
+    }

-        ctx.builder
-            .build_load(psize, var_name.as_str())
-            .map(BasicValueEnum::into_int_value)
-            .unwrap()
+    /// Returns an instance of [`ListValue`] with the `items` pointer cast to `i8*`.
+    #[must_use]
+    pub fn as_i8_list(&self, ctx: &CodeGenContext<'ctx, '_>) -> ListValue<'ctx> {
+        let llvm_i8 = ctx.ctx.i8_type();
+        let llvm_list_i8 = <Self as ProxyValue>::Type::new(ctx, &llvm_i8);
+
+        Self::from_pointer_value(
+            ctx.builder.build_pointer_cast(self.value, llvm_list_i8.as_base_type(), "").unwrap(),
+            self.llvm_usize,
+            self.name,
+        )
    }
 }

@ -199,8 +183,8 @@ impl<'ctx> ArrayLikeValue<'ctx> for ListDataProxy<'ctx, '_> {
 impl<'ctx> ArrayLikeIndexer<'ctx> for ListDataProxy<'ctx, '_> {
    unsafe fn ptr_offset_unchecked<G: CodeGenerator + ?Sized>(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        idx: &IntValue<'ctx>,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
@ -220,7 +204,7 @@ impl<'ctx> ArrayLikeIndexer<'ctx> for ListDataProxy<'ctx, '_> {
        idx: &IntValue<'ctx>,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
-        debug_assert_eq!(idx.get_type(), generator.get_size_type(ctx.ctx));
+        debug_assert_eq!(idx.get_type(), ctx.get_size_type());

        let size = self.size(ctx, generator);
        let in_range = ctx.builder.build_int_compare(IntPredicate::ULT, *idx, size, "").unwrap();
--- a/nac3core/src/codegen/values/mod.rs
+++ b/nac3core/src/codegen/values/mod.rs
@ -5,11 +5,13 @@ use crate::codegen::CodeGenerator;
 pub use array::*;
 pub use list::*;
 pub use range::*;
+pub use tuple::*;

 mod array;
 mod list;
 pub mod ndarray;
 mod range;
+mod tuple;
 pub mod utils;

 /// A LLVM type that is used to represent a non-primitive value in NAC3.
--- a/nac3core/src/codegen/values/ndarray/broadcast.rs
+++ b/nac3core/src/codegen/values/ndarray/broadcast.rs
@ -0,0 +1,243 @@
+use inkwell::{
+    types::IntType,
+    values::{IntValue, PointerValue},
+};
+use itertools::Itertools;
+
+use crate::codegen::{
+    irrt,
+    types::{
+        ndarray::{NDArrayType, ShapeEntryType},
+        structure::StructField,
+        ProxyType,
+    },
+    values::{
+        ndarray::NDArrayValue, ArrayLikeIndexer, ArrayLikeValue, ArraySliceValue, ProxyValue,
+        TypedArrayLikeAccessor, TypedArrayLikeAdapter, TypedArrayLikeMutator,
+    },
+    CodeGenContext, CodeGenerator,
+};
+
+#[derive(Copy, Clone)]
+pub struct ShapeEntryValue<'ctx> {
+    value: PointerValue<'ctx>,
+    llvm_usize: IntType<'ctx>,
+    name: Option<&'ctx str>,
+}
+
+impl<'ctx> ShapeEntryValue<'ctx> {
+    /// Checks whether `value` is an instance of `ShapeEntry`, returning [Err] if `value` is
+    /// not an instance.
+    pub fn is_representable(
+        value: PointerValue<'ctx>,
+        llvm_usize: IntType<'ctx>,
+    ) -> Result<(), String> {
+        <Self as ProxyValue<'ctx>>::Type::is_representable(value.get_type(), llvm_usize)
+    }
+
+    /// Creates an [`ShapeEntryValue`] from a [`PointerValue`].
+    #[must_use]
+    pub fn from_pointer_value(
+        ptr: PointerValue<'ctx>,
+        llvm_usize: IntType<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> Self {
+        debug_assert!(Self::is_representable(ptr, llvm_usize).is_ok());
+
+        Self { value: ptr, llvm_usize, name }
+    }
+
+    fn ndims_field(&self) -> StructField<'ctx, IntValue<'ctx>> {
+        self.get_type().get_fields(self.value.get_type().get_context()).ndims
+    }
+
+    /// Stores the number of dimensions into this value.
+    pub fn store_ndims(&self, ctx: &CodeGenContext<'ctx, '_>, value: IntValue<'ctx>) {
+        self.ndims_field().set(ctx, self.value, value, self.name);
+    }
+
+    fn shape_field(&self) -> StructField<'ctx, PointerValue<'ctx>> {
+        self.get_type().get_fields(self.value.get_type().get_context()).shape
+    }
+
+    /// Stores the shape into this value.
+    pub fn store_shape(&self, ctx: &CodeGenContext<'ctx, '_>, value: PointerValue<'ctx>) {
+        self.shape_field().set(ctx, self.value, value, self.name);
+    }
+}
+
+impl<'ctx> ProxyValue<'ctx> for ShapeEntryValue<'ctx> {
+    type Base = PointerValue<'ctx>;
+    type Type = ShapeEntryType<'ctx>;
+
+    fn get_type(&self) -> Self::Type {
+        Self::Type::from_type(self.value.get_type(), self.llvm_usize)
+    }
+
+    fn as_base_value(&self) -> Self::Base {
+        self.value
+    }
+}
+
+impl<'ctx> From<ShapeEntryValue<'ctx>> for PointerValue<'ctx> {
+    fn from(value: ShapeEntryValue<'ctx>) -> Self {
+        value.as_base_value()
+    }
+}
+
+impl<'ctx> NDArrayValue<'ctx> {
+    /// Create a broadcast view on this ndarray with a target shape.
+    ///
+    /// The input shape will be checked to make sure that it contains no negative values.
+    ///
+    /// * `target_ndims` - The ndims type after broadcasting to the given shape.
+    ///   The caller has to figure this out for this function.
+    /// * `target_shape` - An array pointer pointing to the target shape.
+    #[must_use]
+    pub fn broadcast_to<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        target_ndims: u64,
+        target_shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+    ) -> Self {
+        assert!(self.ndims <= target_ndims);
+        assert_eq!(target_shape.element_type(ctx, generator), self.llvm_usize.into());
+
+        let broadcast_ndarray = NDArrayType::new(ctx, self.dtype, target_ndims)
+            .construct_uninitialized(generator, ctx, None);
+        broadcast_ndarray.copy_shape_from_array(
+            generator,
+            ctx,
+            target_shape.base_ptr(ctx, generator),
+        );
+
+        irrt::ndarray::call_nac3_ndarray_broadcast_to(ctx, *self, broadcast_ndarray);
+        broadcast_ndarray
+    }
+}
+
+/// A result produced by [`broadcast_all_ndarrays`]
+#[derive(Clone)]
+pub struct BroadcastAllResult<'ctx, G: CodeGenerator + ?Sized> {
+    /// The statically known `ndims` of the broadcast result.
+    pub ndims: u64,
+
+    /// The broadcasting shape.
+    pub shape: TypedArrayLikeAdapter<'ctx, G, IntValue<'ctx>>,
+
+    /// Broadcasted views on the inputs.
+    ///
+    /// All of them will have `shape` [`BroadcastAllResult::shape`] and
+    /// `ndims` [`BroadcastAllResult::ndims`]. The length of the vector
+    /// is the same as the input.
+    pub ndarrays: Vec<NDArrayValue<'ctx>>,
+}
+
+/// Helper function to call [`irrt::ndarray::call_nac3_ndarray_broadcast_shapes`].
+fn broadcast_shapes<'ctx, G, Shape>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    in_shape_entries: &[(ArraySliceValue<'ctx>, u64)], // (shape, shape's length/ndims)
+    broadcast_ndims: u64,
+    broadcast_shape: &Shape,
+) where
+    G: CodeGenerator + ?Sized,
+    Shape: TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>
+        + TypedArrayLikeMutator<'ctx, G, IntValue<'ctx>>,
+{
+    let llvm_usize = ctx.get_size_type();
+    let llvm_shape_ty = ShapeEntryType::new(ctx);
+
+    assert!(in_shape_entries
+        .iter()
+        .all(|entry| entry.0.element_type(ctx, generator) == llvm_usize.into()));
+    assert_eq!(broadcast_shape.element_type(ctx, generator), llvm_usize.into());
+
+    // Prepare input shape entries to be passed to `call_nac3_ndarray_broadcast_shapes`.
+    let num_shape_entries =
+        llvm_usize.const_int(u64::try_from(in_shape_entries.len()).unwrap(), false);
+    let shape_entries = llvm_shape_ty.array_alloca(ctx, num_shape_entries, None);
+    for (i, (in_shape, in_ndims)) in in_shape_entries.iter().enumerate() {
+        let pshape_entry = unsafe {
+            shape_entries.ptr_offset_unchecked(
+                ctx,
+                generator,
+                &llvm_usize.const_int(i as u64, false),
+                None,
+            )
+        };
+        let shape_entry = llvm_shape_ty.map_value(pshape_entry, None);
+
+        let in_ndims = llvm_usize.const_int(*in_ndims, false);
+        shape_entry.store_ndims(ctx, in_ndims);
+
+        shape_entry.store_shape(ctx, in_shape.base_ptr(ctx, generator));
+    }
+
+    let broadcast_ndims = llvm_usize.const_int(broadcast_ndims, false);
+    irrt::ndarray::call_nac3_ndarray_broadcast_shapes(
+        generator,
+        ctx,
+        num_shape_entries,
+        shape_entries,
+        broadcast_ndims,
+        broadcast_shape,
+    );
+}
+
+impl<'ctx> NDArrayType<'ctx> {
+    /// Broadcast all ndarrays according to
+    /// [`np.broadcast()`](https://numpy.org/doc/stable/reference/generated/numpy.broadcast.html)
+    /// and return a [`BroadcastAllResult`] containing all the information of the result of the
+    /// broadcast operation.
+    pub fn broadcast<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        ndarrays: &[NDArrayValue<'ctx>],
+    ) -> BroadcastAllResult<'ctx, G> {
+        assert!(!ndarrays.is_empty());
+
+        let llvm_usize = ctx.get_size_type();
+
+        // Infer the broadcast output ndims.
+        let broadcast_ndims_int =
+            ndarrays.iter().map(|ndarray| ndarray.get_type().ndims()).max().unwrap();
+        assert!(self.ndims() >= broadcast_ndims_int);
+
+        let broadcast_ndims = llvm_usize.const_int(broadcast_ndims_int, false);
+        let broadcast_shape = ArraySliceValue::from_ptr_val(
+            ctx.builder.build_array_alloca(llvm_usize, broadcast_ndims, "").unwrap(),
+            broadcast_ndims,
+            None,
+        );
+        let broadcast_shape = TypedArrayLikeAdapter::from(
+            broadcast_shape,
+            |_, _, val| val.into_int_value(),
+            |_, _, val| val.into(),
+        );
+
+        let shape_entries = ndarrays
+            .iter()
+            .map(|ndarray| {
+                (ndarray.shape().as_slice_value(ctx, generator), ndarray.get_type().ndims())
+            })
+            .collect_vec();
+        broadcast_shapes(generator, ctx, &shape_entries, broadcast_ndims_int, &broadcast_shape);
+
+        // Broadcast all the inputs to shape `dst_shape`.
+        let broadcast_ndarrays = ndarrays
+            .iter()
+            .map(|ndarray| {
+                ndarray.broadcast_to(generator, ctx, broadcast_ndims_int, &broadcast_shape)
+            })
+            .collect_vec();
+
+        BroadcastAllResult {
+            ndims: broadcast_ndims_int,
+            shape: broadcast_shape,
+            ndarrays: broadcast_ndarrays,
+        }
+    }
+}
--- a/nac3core/src/codegen/values/ndarray/contiguous.rs
+++ b/nac3core/src/codegen/values/ndarray/contiguous.rs
@ -117,13 +117,11 @@ impl<'ctx> NDArrayValue<'ctx> {
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
    ) -> ContiguousNDArrayValue<'ctx> {
-        let result = ContiguousNDArrayType::new(generator, ctx.ctx, self.dtype)
-            .alloca(generator, ctx, self.name);
+        let result =
+            ContiguousNDArrayType::new(ctx, &self.dtype).alloca_var(generator, ctx, self.name);

        // Set ndims and shape.
-        let ndims = self
-            .ndims
-            .map_or_else(|| self.load_ndims(ctx), |ndims| self.llvm_usize.const_int(ndims, false));
+        let ndims = self.llvm_usize.const_int(self.ndims, false);
        result.store_ndims(ctx, ndims);

        let shape = self.shape();
@ -132,7 +130,7 @@ impl<'ctx> NDArrayValue<'ctx> {
        gen_if_callback(
            generator,
            ctx,
-            |generator, ctx| Ok(self.is_c_contiguous(generator, ctx)),
+            |_, ctx| Ok(self.is_c_contiguous(ctx)),
            |_, ctx| {
                // This ndarray is contiguous.
                let data = self.data_field(ctx).get(ctx, self.as_base_value(), self.name);
@ -180,13 +178,16 @@ impl<'ctx> NDArrayValue<'ctx> {
        // TODO: Debug assert `ndims == carray.ndims` to catch bugs.

        // Allocate the resulting ndarray.
-        let ndarray = NDArrayType::new(generator, ctx.ctx, carray.item, Some(ndims))
-            .construct_uninitialized(generator, ctx, carray.name);
+        let ndarray = NDArrayType::new(ctx, carray.item, ndims).construct_uninitialized(
+            generator,
+            ctx,
+            carray.name,
+        );

        // Copy shape and update strides
        let shape = carray.load_shape(ctx);
        ndarray.copy_shape_from_array(generator, ctx, shape);
-        ndarray.set_strides_contiguous(generator, ctx);
+        ndarray.set_strides_contiguous(ctx);

        // Share data
        let data = carray.load_data(ctx);
--- a/nac3core/src/codegen/values/ndarray/fold.rs
+++ b/nac3core/src/codegen/values/ndarray/fold.rs
@ -0,0 +1,101 @@
+use inkwell::values::{BasicValue, BasicValueEnum};
+
+use super::{NDArrayValue, NDIterValue, ScalarOrNDArray};
+use crate::codegen::{
+    stmt::{gen_for_callback, BreakContinueHooks},
+    types::ndarray::NDIterType,
+    CodeGenContext, CodeGenerator,
+};
+
+impl<'ctx> NDArrayValue<'ctx> {
+    /// Folds the elements of this ndarray into an accumulator value by applying `f`, returning the
+    /// final value.
+    ///
+    /// `f` has access to [`BreakContinueHooks`] to short-circuit the `fold` operation, an instance
+    /// of `V` representing the current accumulated value, and an [`NDIterValue`] to get the
+    /// properties of the current iterated element.
+    pub fn fold<'a, G, V, F>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, 'a>,
+        init: V,
+        f: F,
+    ) -> Result<V, String>
+    where
+        G: CodeGenerator + ?Sized,
+        V: BasicValue<'ctx> + TryFrom<BasicValueEnum<'ctx>>,
+        <V as TryFrom<BasicValueEnum<'ctx>>>::Error: std::fmt::Debug,
+        F: FnOnce(
+            &mut G,
+            &mut CodeGenContext<'ctx, 'a>,
+            BreakContinueHooks<'ctx>,
+            V,
+            NDIterValue<'ctx>,
+        ) -> Result<V, String>,
+    {
+        let acc_ptr =
+            generator.gen_var_alloc(ctx, init.as_basic_value_enum().get_type(), None).unwrap();
+        ctx.builder.build_store(acc_ptr, init).unwrap();
+
+        gen_for_callback(
+            generator,
+            ctx,
+            Some("ndarray_fold"),
+            |generator, ctx| Ok(NDIterType::new(ctx).construct(generator, ctx, *self)),
+            |_, ctx, nditer| Ok(nditer.has_element(ctx)),
+            |generator, ctx, hooks, nditer| {
+                let acc = V::try_from(ctx.builder.build_load(acc_ptr, "").unwrap()).unwrap();
+                let acc = f(generator, ctx, hooks, acc, nditer)?;
+                ctx.builder.build_store(acc_ptr, acc).unwrap();
+                Ok(())
+            },
+            |_, ctx, nditer| {
+                nditer.next(ctx);
+                Ok(())
+            },
+        )?;
+
+        let acc = ctx.builder.build_load(acc_ptr, "").unwrap();
+        Ok(V::try_from(acc).unwrap())
+    }
+}
+
+impl<'ctx> ScalarOrNDArray<'ctx> {
+    /// See [`NDArrayValue::fold`].
+    ///
+    /// The primary differences between this function and `NDArrayValue::fold` are:
+    ///
+    /// - The 3rd parameter of `f` is an `Option` of hooks, since `break`/`continue` hooks are not
+    ///   available if this instance represents a scalar value.
+    /// - The 5th parameter of `f` is a [`BasicValueEnum`], since no [iterator][`NDIterValue`] will
+    ///   be created if this instance represents a scalar value.
+    pub fn fold<'a, G, V, F>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, 'a>,
+        init: V,
+        f: F,
+    ) -> Result<V, String>
+    where
+        G: CodeGenerator + ?Sized,
+        V: BasicValue<'ctx> + TryFrom<BasicValueEnum<'ctx>>,
+        <V as TryFrom<BasicValueEnum<'ctx>>>::Error: std::fmt::Debug,
+        F: FnOnce(
+            &mut G,
+            &mut CodeGenContext<'ctx, 'a>,
+            Option<&BreakContinueHooks<'ctx>>,
+            V,
+            BasicValueEnum<'ctx>,
+        ) -> Result<V, String>,
+    {
+        match self {
+            ScalarOrNDArray::Scalar(v) => f(generator, ctx, None, init, *v),
+            ScalarOrNDArray::NDArray(v) => {
+                v.fold(generator, ctx, init, |generator, ctx, hooks, acc, nditer| {
+                    let elem = nditer.get_scalar(ctx);
+                    f(generator, ctx, Some(&hooks), acc, elem)
+                })
+            }
+        }
+    }
+}
--- a/nac3core/src/codegen/values/ndarray/indexing.rs
+++ b/nac3core/src/codegen/values/ndarray/indexing.rs
@ -98,8 +98,8 @@ impl<'ctx> From<NDIndexValue<'ctx>> for PointerValue<'ctx> {
 impl<'ctx> NDArrayValue<'ctx> {
    /// Get the expected `ndims` after indexing with `indices`.
    #[must_use]
-    fn deduce_ndims_after_indexing_with(&self, indices: &[RustNDIndex<'ctx>]) -> Option<u64> {
-        let mut ndims = self.ndims?;
+    fn deduce_ndims_after_indexing_with(&self, indices: &[RustNDIndex<'ctx>]) -> u64 {
+        let mut ndims = self.ndims;

        for index in indices {
            match index {
@ -113,7 +113,7 @@ impl<'ctx> NDArrayValue<'ctx> {
            }
        }

-        Some(ndims)
+        ndims
    }

    /// Index into the ndarray, and return a newly-allocated view on this ndarray.
@ -127,14 +127,11 @@ impl<'ctx> NDArrayValue<'ctx> {
        ctx: &mut CodeGenContext<'ctx, '_>,
        indices: &[RustNDIndex<'ctx>],
    ) -> Self {
-        assert!(self.ndims.is_some(), "NDArrayValue::index is only supported for instances with compile-time known ndims (self.ndims = Some(...))");
-
        let dst_ndims = self.deduce_ndims_after_indexing_with(indices);
-        let dst_ndarray = NDArrayType::new(generator, ctx.ctx, self.dtype, dst_ndims)
+        let dst_ndarray = NDArrayType::new(ctx, self.dtype, dst_ndims)
            .construct_uninitialized(generator, ctx, None);

-        let indices =
-            NDIndexType::new(generator, ctx.ctx).construct_ndindices(generator, ctx, indices);
+        let indices = NDIndexType::new(ctx).construct_ndindices(generator, ctx, indices);
        irrt::ndarray::call_nac3_ndarray_index(generator, ctx, indices, *self, dst_ndarray);

        dst_ndarray
@ -247,8 +244,7 @@ impl<'ctx> RustNDIndex<'ctx> {
            }
            RustNDIndex::Slice(in_rust_slice) => {
                let user_slice_ptr =
-                    SliceType::new(ctx.ctx, ctx.ctx.i32_type(), generator.get_size_type(ctx.ctx))
-                        .alloca(generator, ctx, None);
+                    SliceType::new(ctx, ctx.ctx.i32_type()).alloca_var(generator, ctx, None);
                in_rust_slice.write_to_slice(ctx, user_slice_ptr);

                dst_ndindex.store_data(
--- a/nac3core/src/codegen/values/ndarray/map.rs
+++ b/nac3core/src/codegen/values/ndarray/map.rs
@ -0,0 +1,69 @@
+use inkwell::{types::BasicTypeEnum, values::BasicValueEnum};
+
+use crate::codegen::{
+    values::{
+        ndarray::{NDArrayOut, NDArrayValue, ScalarOrNDArray},
+        ProxyValue,
+    },
+    CodeGenContext, CodeGenerator,
+};
+
+impl<'ctx> NDArrayValue<'ctx> {
+    /// Map through this ndarray with an elementwise function.
+    pub fn map<'a, G, Mapping>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, 'a>,
+        out: NDArrayOut<'ctx>,
+        mapping: Mapping,
+    ) -> Result<Self, String>
+    where
+        G: CodeGenerator + ?Sized,
+        Mapping: FnOnce(
+            &mut G,
+            &mut CodeGenContext<'ctx, 'a>,
+            BasicValueEnum<'ctx>,
+        ) -> Result<BasicValueEnum<'ctx>, String>,
+    {
+        self.get_type().broadcast_starmap(
+            generator,
+            ctx,
+            &[*self],
+            out,
+            |generator, ctx, scalars| mapping(generator, ctx, scalars[0]),
+        )
+    }
+}
+
+impl<'ctx> ScalarOrNDArray<'ctx> {
+    /// Map through this [`ScalarOrNDArray`] with an elementwise function.
+    ///
+    /// If this is a scalar, `mapping` will directly act on the scalar. This function will return a
+    /// [`ScalarOrNDArray::Scalar`] of that result.
+    ///
+    /// If this is an ndarray, `mapping` will be applied to the elements of the ndarray. A new
+    /// ndarray of the results will be created and returned as a [`ScalarOrNDArray::NDArray`].
+    pub fn map<'a, G, Mapping>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, 'a>,
+        ret_dtype: BasicTypeEnum<'ctx>,
+        mapping: Mapping,
+    ) -> Result<ScalarOrNDArray<'ctx>, String>
+    where
+        G: CodeGenerator + ?Sized,
+        Mapping: FnOnce(
+            &mut G,
+            &mut CodeGenContext<'ctx, 'a>,
+            BasicValueEnum<'ctx>,
+        ) -> Result<BasicValueEnum<'ctx>, String>,
+    {
+        ScalarOrNDArray::broadcasting_starmap(
+            generator,
+            ctx,
+            &[*self],
+            ret_dtype,
+            |generator, ctx, scalars| mapping(generator, ctx, scalars[0]),
+        )
+    }
+}
--- a/nac3core/src/codegen/values/ndarray/matmul.rs
+++ b/nac3core/src/codegen/values/ndarray/matmul.rs
@ -0,0 +1,323 @@
+use std::cmp::max;
+
+use nac3parser::ast::Operator;
+
+use super::{NDArrayOut, NDArrayValue, RustNDIndex};
+use crate::{
+    codegen::{
+        expr::gen_binop_expr_with_values,
+        irrt,
+        stmt::gen_for_callback_incrementing,
+        types::ndarray::NDArrayType,
+        values::{
+            ArrayLikeValue, ArraySliceValue, TypedArrayLikeAccessor, TypedArrayLikeAdapter,
+            UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
+        },
+        CodeGenContext, CodeGenerator,
+    },
+    toplevel::helper::arraylike_flatten_element_type,
+    typecheck::{magic_methods::Binop, typedef::Type},
+};
+
+/// Perform `np.einsum("...ij,...jk->...ik", in_a, in_b)`.
+///
+/// `dst_dtype` defines the dtype of the returned ndarray.
+fn matmul_at_least_2d<'ctx, G: CodeGenerator>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    dst_dtype: Type,
+    (in_a_ty, in_a): (Type, NDArrayValue<'ctx>),
+    (in_b_ty, in_b): (Type, NDArrayValue<'ctx>),
+) -> NDArrayValue<'ctx> {
+    assert!(in_a.ndims >= 2, "in_a (which is {}) must be >= 2", in_a.ndims);
+    assert!(in_b.ndims >= 2, "in_b (which is {}) must be >= 2", in_b.ndims);
+
+    let lhs_dtype = arraylike_flatten_element_type(&mut ctx.unifier, in_a_ty);
+    let rhs_dtype = arraylike_flatten_element_type(&mut ctx.unifier, in_b_ty);
+
+    let llvm_usize = ctx.get_size_type();
+    let llvm_dst_dtype = ctx.get_llvm_type(generator, dst_dtype);
+
+    // Deduce ndims of the result of matmul.
+    let ndims_int = max(in_a.ndims, in_b.ndims);
+    let ndims = llvm_usize.const_int(ndims_int, false);
+
+    // Broadcasts `in_a.shape[:-2]` and `in_b.shape[:-2]` together and allocate the
+    // destination ndarray to store the result of matmul.
+    let (lhs, rhs, dst) = {
+        let in_lhs_ndims = llvm_usize.const_int(in_a.ndims, false);
+        let in_lhs_shape = TypedArrayLikeAdapter::from(
+            ArraySliceValue::from_ptr_val(
+                in_a.shape().base_ptr(ctx, generator),
+                in_lhs_ndims,
+                None,
+            ),
+            |_, _, val| val.into_int_value(),
+            |_, _, val| val.into(),
+        );
+        let in_rhs_ndims = llvm_usize.const_int(in_b.ndims, false);
+        let in_rhs_shape = TypedArrayLikeAdapter::from(
+            ArraySliceValue::from_ptr_val(
+                in_b.shape().base_ptr(ctx, generator),
+                in_rhs_ndims,
+                None,
+            ),
+            |_, _, val| val.into_int_value(),
+            |_, _, val| val.into(),
+        );
+        let lhs_shape = TypedArrayLikeAdapter::from(
+            ArraySliceValue::from_ptr_val(
+                ctx.builder.build_array_alloca(llvm_usize, ndims, "").unwrap(),
+                ndims,
+                None,
+            ),
+            |_, _, val| val.into_int_value(),
+            |_, _, val| val.into(),
+        );
+        let rhs_shape = TypedArrayLikeAdapter::from(
+            ArraySliceValue::from_ptr_val(
+                ctx.builder.build_array_alloca(llvm_usize, ndims, "").unwrap(),
+                ndims,
+                None,
+            ),
+            |_, _, val| val.into_int_value(),
+            |_, _, val| val.into(),
+        );
+        let dst_shape = TypedArrayLikeAdapter::from(
+            ArraySliceValue::from_ptr_val(
+                ctx.builder.build_array_alloca(llvm_usize, ndims, "").unwrap(),
+                ndims,
+                None,
+            ),
+            |_, _, val| val.into_int_value(),
+            |_, _, val| val.into(),
+        );
+
+        // Matmul dimension compatibility is checked here.
+        irrt::ndarray::call_nac3_ndarray_matmul_calculate_shapes(
+            generator,
+            ctx,
+            &in_lhs_shape,
+            &in_rhs_shape,
+            ndims,
+            &lhs_shape,
+            &rhs_shape,
+            &dst_shape,
+        );
+
+        let lhs = in_a.broadcast_to(generator, ctx, ndims_int, &lhs_shape);
+        let rhs = in_b.broadcast_to(generator, ctx, ndims_int, &rhs_shape);
+
+        let dst = NDArrayType::new(ctx, llvm_dst_dtype, ndims_int)
+            .construct_uninitialized(generator, ctx, None);
+        dst.copy_shape_from_array(generator, ctx, dst_shape.base_ptr(ctx, generator));
+        unsafe {
+            dst.create_data(generator, ctx);
+        }
+
+        (lhs, rhs, dst)
+    };
+
+    let len = unsafe {
+        lhs.shape().get_typed_unchecked(
+            ctx,
+            generator,
+            &llvm_usize.const_int(ndims_int - 1, false),
+            None,
+        )
+    };
+
+    let at_row = i64::try_from(ndims_int - 2).unwrap();
+    let at_col = i64::try_from(ndims_int - 1).unwrap();
+
+    let dst_dtype_llvm = ctx.get_llvm_type(generator, dst_dtype);
+    let dst_zero = dst_dtype_llvm.const_zero();
+
+    dst.foreach(generator, ctx, |generator, ctx, _, hdl| {
+        let pdst_ij = hdl.get_pointer(ctx);
+
+        ctx.builder.build_store(pdst_ij, dst_zero).unwrap();
+
+        let indices = hdl.get_indices::<G>();
+        let i = unsafe {
+            indices.get_unchecked(ctx, generator, &llvm_usize.const_int(at_row as u64, true), None)
+        };
+        let j = unsafe {
+            indices.get_unchecked(ctx, generator, &llvm_usize.const_int(at_col as u64, true), None)
+        };
+
+        let num_0 = llvm_usize.const_int(0, false);
+        let num_1 = llvm_usize.const_int(1, false);
+
+        gen_for_callback_incrementing(
+            generator,
+            ctx,
+            None,
+            num_0,
+            (len, false),
+            |generator, ctx, _, k| {
+                // `indices` is modified to index into `a` and `b`, and restored.
+                unsafe {
+                    indices.set_unchecked(
+                        ctx,
+                        generator,
+                        &llvm_usize.const_int(at_row as u64, true),
+                        i,
+                    );
+                    indices.set_unchecked(
+                        ctx,
+                        generator,
+                        &llvm_usize.const_int(at_col as u64, true),
+                        k.into(),
+                    );
+                }
+                let a_ik = unsafe { lhs.data().get_unchecked(ctx, generator, &indices, None) };
+
+                unsafe {
+                    indices.set_unchecked(
+                        ctx,
+                        generator,
+                        &llvm_usize.const_int(at_row as u64, true),
+                        k.into(),
+                    );
+                    indices.set_unchecked(
+                        ctx,
+                        generator,
+                        &llvm_usize.const_int(at_col as u64, true),
+                        j,
+                    );
+                }
+                let b_kj = unsafe { rhs.data().get_unchecked(ctx, generator, &indices, None) };
+
+                // Restore `indices`.
+                unsafe {
+                    indices.set_unchecked(
+                        ctx,
+                        generator,
+                        &llvm_usize.const_int(at_row as u64, true),
+                        i,
+                    );
+                    indices.set_unchecked(
+                        ctx,
+                        generator,
+                        &llvm_usize.const_int(at_col as u64, true),
+                        j,
+                    );
+                }
+
+                // x = a_[...]ik * b_[...]kj
+                let x = gen_binop_expr_with_values(
+                    generator,
+                    ctx,
+                    (&Some(lhs_dtype), a_ik),
+                    Binop::normal(Operator::Mult),
+                    (&Some(rhs_dtype), b_kj),
+                    ctx.current_loc,
+                )?
+                .unwrap()
+                .to_basic_value_enum(ctx, generator, dst_dtype)?;
+
+                // dst_[...]ij += x
+                let dst_ij = ctx.builder.build_load(pdst_ij, "").unwrap();
+                let dst_ij = gen_binop_expr_with_values(
+                    generator,
+                    ctx,
+                    (&Some(dst_dtype), dst_ij),
+                    Binop::normal(Operator::Add),
+                    (&Some(dst_dtype), x),
+                    ctx.current_loc,
+                )?
+                .unwrap()
+                .to_basic_value_enum(ctx, generator, dst_dtype)?;
+                ctx.builder.build_store(pdst_ij, dst_ij).unwrap();
+
+                Ok(())
+            },
+            num_1,
+        )
+    })
+    .unwrap();
+
+    dst
+}
+
+impl<'ctx> NDArrayValue<'ctx> {
+    /// Perform [`np.matmul`](https://numpy.org/doc/stable/reference/generated/numpy.matmul.html).
+    ///
+    /// This function always return an [`NDArrayValue`]. You may want to use
+    /// [`NDArrayValue::split_unsized`] to handle when the output could be a scalar.
+    ///
+    /// `dst_dtype` defines the dtype of the returned ndarray.
+    #[must_use]
+    pub fn matmul<G: CodeGenerator>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        self_ty: Type,
+        (other_ty, other): (Type, Self),
+        (out_dtype, out): (Type, NDArrayOut<'ctx>),
+    ) -> Self {
+        // Sanity check, but type inference should prevent this.
+        assert!(self.ndims > 0 && other.ndims > 0, "np.matmul disallows scalar input");
+
+        // If both arguments are 2-D they are multiplied like conventional matrices.
+        //
+        // If either argument is N-D, N > 2, it is treated as a stack of matrices residing in the
+        // last two indices and broadcast accordingly.
+        //
+        // If the first argument is 1-D, it is promoted to a matrix by prepending a 1 to its
+        // dimensions. After matrix multiplication the prepended 1 is removed.
+        //
+        // If the second argument is 1-D, it is promoted to a matrix by appending a 1 to its
+        // dimensions. After matrix multiplication the appended 1 is removed.
+
+        let new_a = if self.ndims == 1 {
+            // Prepend 1 to its dimensions
+            self.index(generator, ctx, &[RustNDIndex::NewAxis, RustNDIndex::Ellipsis])
+        } else {
+            *self
+        };
+
+        let new_b = if other.ndims == 1 {
+            // Append 1 to its dimensions
+            other.index(generator, ctx, &[RustNDIndex::Ellipsis, RustNDIndex::NewAxis])
+        } else {
+            other
+        };
+
+        // NOTE: `result` will always be a newly allocated ndarray.
+        // Current implementation cannot do in-place matrix muliplication.
+        let mut result =
+            matmul_at_least_2d(generator, ctx, out_dtype, (self_ty, new_a), (other_ty, new_b));
+
+        // Postprocessing on the result to remove prepended/appended axes.
+        let mut postindices = vec![];
+        let zero = ctx.ctx.i32_type().const_zero();
+
+        if self.ndims == 1 {
+            // Remove the prepended 1
+            postindices.push(RustNDIndex::SingleElement(zero));
+        }
+
+        if other.ndims == 1 {
+            // Remove the appended 1
+            postindices.push(RustNDIndex::Ellipsis);
+            postindices.push(RustNDIndex::SingleElement(zero));
+        }
+
+        if !postindices.is_empty() {
+            result = result.index(generator, ctx, &postindices);
+        }
+
+        match out {
+            NDArrayOut::NewNDArray { .. } => result,
+            NDArrayOut::WriteToNDArray { ndarray: out_ndarray } => {
+                let result_shape = result.shape();
+                out_ndarray.assert_can_be_written_by_out(generator, ctx, result_shape);
+
+                out_ndarray.copy_data_from(ctx, result);
+                out_ndarray
+            }
+        }
+    }
+}
--- a/nac3core/src/codegen/values/ndarray/mod.rs
+++ b/nac3core/src/codegen/values/ndarray/mod.rs
@ -1,29 +1,41 @@
+use std::iter::repeat_n;
+
 use inkwell::{
    types::{AnyType, AnyTypeEnum, BasicType, BasicTypeEnum, IntType},
-    values::{BasicValueEnum, IntValue, PointerValue},
+    values::{BasicValue, BasicValueEnum, IntValue, PointerValue},
    AddressSpace, IntPredicate,
 };
+use itertools::Itertools;

 use super::{
-    ArrayLikeIndexer, ArrayLikeValue, ProxyValue, TypedArrayLikeAccessor, TypedArrayLikeMutator,
-    UntypedArrayLikeAccessor, UntypedArrayLikeMutator,
+    ArrayLikeIndexer, ArrayLikeValue, ProxyValue, TupleValue, TypedArrayLikeAccessor,
+    TypedArrayLikeAdapter, TypedArrayLikeMutator, UntypedArrayLikeAccessor,
+    UntypedArrayLikeMutator,
 };
-use crate::codegen::{
-    irrt,
-    llvm_intrinsics::{call_int_umin, call_memcpy_generic_array},
-    stmt::gen_for_callback_incrementing,
-    type_aligned_alloca,
-    types::{ndarray::NDArrayType, structure::StructField},
-    CodeGenContext, CodeGenerator,
+use crate::{
+    codegen::{
+        irrt,
+        llvm_intrinsics::{call_int_umin, call_memcpy_generic_array},
+        stmt::gen_for_callback_incrementing,
+        type_aligned_alloca,
+        types::{ndarray::NDArrayType, structure::StructField, TupleType},
+        CodeGenContext, CodeGenerator,
+    },
+    typecheck::typedef::{Type, TypeEnum},
 };
+pub use broadcast::*;
 pub use contiguous::*;
 pub use indexing::*;
 pub use nditer::*;
-pub use view::*;

+mod broadcast;
 mod contiguous;
+mod fold;
 mod indexing;
+mod map;
+mod matmul;
 mod nditer;
+pub mod shape;
 mod view;

 /// Proxy type for accessing an `NDArray` value in LLVM.
@ -31,7 +43,7 @@ mod view;
 pub struct NDArrayValue<'ctx> {
    value: PointerValue<'ctx>,
    dtype: BasicTypeEnum<'ctx>,
-    ndims: Option<u64>,
+    ndims: u64,
    llvm_usize: IntType<'ctx>,
    name: Option<&'ctx str>,
 }
@ -51,7 +63,7 @@ impl<'ctx> NDArrayValue<'ctx> {
    pub fn from_pointer_value(
        ptr: PointerValue<'ctx>,
        dtype: BasicTypeEnum<'ctx>,
-        ndims: Option<u64>,
+        ndims: u64,
        llvm_usize: IntType<'ctx>,
        name: Option<&'ctx str>,
    ) -> Self {
@ -70,13 +82,8 @@ impl<'ctx> NDArrayValue<'ctx> {
    }

    /// Stores the number of dimensions `ndims` into this instance.
-    pub fn store_ndims<G: CodeGenerator + ?Sized>(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-        generator: &G,
-        ndims: IntValue<'ctx>,
-    ) {
-        debug_assert_eq!(ndims.get_type(), generator.get_size_type(ctx.ctx));
+    pub fn store_ndims(&self, ctx: &CodeGenContext<'ctx, '_>, ndims: IntValue<'ctx>) {
+        debug_assert_eq!(ndims.get_type(), ctx.get_size_type());

        let pndims = self.ptr_to_ndims(ctx);
        ctx.builder.build_store(pndims, ndims).unwrap();
@ -93,13 +100,8 @@ impl<'ctx> NDArrayValue<'ctx> {
    }

    /// Stores the size of each element `itemsize` into this instance.
-    pub fn store_itemsize<G: CodeGenerator + ?Sized>(
-        &self,
-        ctx: &CodeGenContext<'ctx, '_>,
-        generator: &G,
-        itemsize: IntValue<'ctx>,
-    ) {
-        debug_assert_eq!(itemsize.get_type(), generator.get_size_type(ctx.ctx));
+    pub fn store_itemsize(&self, ctx: &CodeGenContext<'ctx, '_>, itemsize: IntValue<'ctx>) {
+        debug_assert_eq!(itemsize.get_type(), ctx.get_size_type());

        self.itemsize_field(ctx).set(ctx, self.value, itemsize, self.name);
    }
@ -113,12 +115,6 @@ impl<'ctx> NDArrayValue<'ctx> {
        self.get_type().get_fields(ctx.ctx).shape
    }

-    /// Returns the double-indirection pointer to the `shape` array, as if by calling
-    /// `getelementptr` on the field.
-    fn ptr_to_shape(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
-        self.shape_field(ctx).ptr_by_gep(ctx, self.value, self.name)
-    }
-
    /// Stores the array of dimension sizes `dims` into this instance.
    fn store_shape(&self, ctx: &CodeGenContext<'ctx, '_>, dims: PointerValue<'ctx>) {
        self.shape_field(ctx).set(ctx, self.as_base_value(), dims, self.name);
@ -147,12 +143,6 @@ impl<'ctx> NDArrayValue<'ctx> {
        self.get_type().get_fields(ctx.ctx).strides
    }

-    /// Returns the double-indirection pointer to the `strides` array, as if by calling
-    /// `getelementptr` on the field.
-    fn ptr_to_strides(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
-        self.strides_field(ctx).ptr_by_gep(ctx, self.value, self.name)
-    }
-
    /// Stores the array of stride sizes `strides` into this instance.
    fn store_strides(&self, ctx: &CodeGenContext<'ctx, '_>, strides: PointerValue<'ctx>) {
        self.strides_field(ctx).set(ctx, self.as_base_value(), strides, self.name);
@ -185,7 +175,7 @@ impl<'ctx> NDArrayValue<'ctx> {
    }

    /// Stores the array of data elements `data` into this instance.
-    fn store_data(&self, ctx: &CodeGenContext<'ctx, '_>, data: PointerValue<'ctx>) {
+    pub fn store_data(&self, ctx: &CodeGenContext<'ctx, '_>, data: PointerValue<'ctx>) {
        let data = ctx
            .builder
            .build_bit_cast(data, ctx.ctx.i8_type().ptr_type(AddressSpace::default()), "")
@ -206,12 +196,12 @@ impl<'ctx> NDArrayValue<'ctx> {
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
    ) {
-        let nbytes = self.nbytes(generator, ctx);
+        let nbytes = self.nbytes(ctx);

        let data = type_aligned_alloca(generator, ctx, self.dtype, nbytes, None);
        self.store_data(ctx, data);

-        self.set_strides_contiguous(generator, ctx);
+        self.set_strides_contiguous(ctx);
    }

    /// Returns a proxy object to the field storing the data of this `NDArray`.
@ -246,26 +236,7 @@ impl<'ctx> NDArrayValue<'ctx> {
        ctx: &mut CodeGenContext<'ctx, '_>,
        src_ndarray: NDArrayValue<'ctx>,
    ) {
-        if self.ndims.is_some() && src_ndarray.ndims.is_some() {
-            assert_eq!(self.ndims, src_ndarray.ndims);
-        } else {
-            let self_ndims = self.load_ndims(ctx);
-            let src_ndims = src_ndarray.load_ndims(ctx);
-
-            ctx.make_assert(
-                generator,
-                ctx.builder.build_int_compare(
-                    IntPredicate::EQ,
-                    self_ndims,
-                    src_ndims,
-                    ""
-                ).unwrap(),
-                "0:AssertionError",
-                "NDArrayValue::copy_shape_from_ndarray: Expected self.ndims ({0}) == src_ndarray.ndims ({1})",
-                [Some(self_ndims), Some(src_ndims), None],
-                ctx.current_loc
-            );
-        }
+        assert_eq!(self.ndims, src_ndarray.ndims);

        let src_shape = src_ndarray.shape().base_ptr(ctx, generator);
        self.copy_shape_from_array(generator, ctx, src_shape);
@ -297,96 +268,57 @@ impl<'ctx> NDArrayValue<'ctx> {
        ctx: &mut CodeGenContext<'ctx, '_>,
        src_ndarray: NDArrayValue<'ctx>,
    ) {
-        if self.ndims.is_some() && src_ndarray.ndims.is_some() {
-            assert_eq!(self.ndims, src_ndarray.ndims);
-        } else {
-            let self_ndims = self.load_ndims(ctx);
-            let src_ndims = src_ndarray.load_ndims(ctx);
-
-            ctx.make_assert(
-                generator,
-                ctx.builder.build_int_compare(
-                    IntPredicate::EQ,
-                    self_ndims,
-                    src_ndims,
-                    ""
-                ).unwrap(),
-                "0:AssertionError",
-                "NDArrayValue::copy_shape_from_ndarray: Expected self.ndims ({0}) == src_ndarray.ndims ({1})",
-                [Some(self_ndims), Some(src_ndims), None],
-                ctx.current_loc
-            );
-        }
+        assert_eq!(self.ndims, src_ndarray.ndims);

        let src_strides = src_ndarray.strides().base_ptr(ctx, generator);
        self.copy_strides_from_array(generator, ctx, src_strides);
    }

    /// Get the `np.size()` of this ndarray.
-    pub fn size<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &CodeGenContext<'ctx, '_>,
-    ) -> IntValue<'ctx> {
-        irrt::ndarray::call_nac3_ndarray_size(generator, ctx, *self)
+    pub fn size(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
+        irrt::ndarray::call_nac3_ndarray_size(ctx, *self)
    }

    /// Get the `ndarray.nbytes` of this ndarray.
-    pub fn nbytes<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &CodeGenContext<'ctx, '_>,
-    ) -> IntValue<'ctx> {
-        irrt::ndarray::call_nac3_ndarray_nbytes(generator, ctx, *self)
+    pub fn nbytes(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
+        irrt::ndarray::call_nac3_ndarray_nbytes(ctx, *self)
    }

    /// Get the `len()` of this ndarray.
-    pub fn len<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &CodeGenContext<'ctx, '_>,
-    ) -> IntValue<'ctx> {
-        irrt::ndarray::call_nac3_ndarray_len(generator, ctx, *self)
+    pub fn len(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
+        irrt::ndarray::call_nac3_ndarray_len(ctx, *self)
    }

    /// Check if this ndarray is C-contiguous.
    ///
    /// See NumPy's `flags["C_CONTIGUOUS"]`: <https://numpy.org/doc/stable/reference/generated/numpy.ndarray.flags.html#numpy.ndarray.flags>
-    pub fn is_c_contiguous<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &CodeGenContext<'ctx, '_>,
-    ) -> IntValue<'ctx> {
-        irrt::ndarray::call_nac3_ndarray_is_c_contiguous(generator, ctx, *self)
+    pub fn is_c_contiguous(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
+        irrt::ndarray::call_nac3_ndarray_is_c_contiguous(ctx, *self)
    }

    /// Call [`call_nac3_ndarray_set_strides_by_shape`] on this ndarray to update `strides`.
    ///
    /// Update the ndarray's strides to make the ndarray contiguous.
-    pub fn set_strides_contiguous<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &CodeGenContext<'ctx, '_>,
-    ) {
-        irrt::ndarray::call_nac3_ndarray_set_strides_by_shape(generator, ctx, *self);
+    pub fn set_strides_contiguous(&self, ctx: &CodeGenContext<'ctx, '_>) {
+        irrt::ndarray::call_nac3_ndarray_set_strides_by_shape(ctx, *self);
    }

+    /// Clone/Copy this ndarray - Allocate a new ndarray with the same shape as this ndarray and
+    /// copy the contents over.
+    ///
+    /// The new ndarray will own its data and will be C-contiguous.
    #[must_use]
    pub fn make_copy<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
    ) -> Self {
-        let clone = if self.ndims.is_some() {
-            self.get_type().construct_uninitialized(generator, ctx, None)
-        } else {
-            self.get_type().construct_dyn_ndims(generator, ctx, self.load_ndims(ctx), None)
-        };
+        let clone = self.get_type().construct_uninitialized(generator, ctx, None);

        let shape = self.shape();
        clone.copy_shape_from_array(generator, ctx, shape.base_ptr(ctx, generator));
        unsafe { clone.create_data(generator, ctx) };
-        clone.copy_data_from(generator, ctx, *self);
+        clone.copy_data_from(ctx, *self);
        clone
    }

@ -396,42 +328,146 @@ impl<'ctx> NDArrayValue<'ctx> {
    /// do not matter. The copying order is determined by how their flattened views look.
    ///
    /// Panics if the `dtype`s of ndarrays are different.
-    pub fn copy_data_from<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &CodeGenContext<'ctx, '_>,
-        src: NDArrayValue<'ctx>,
-    ) {
+    pub fn copy_data_from(&self, ctx: &CodeGenContext<'ctx, '_>, src: NDArrayValue<'ctx>) {
        assert_eq!(self.dtype, src.dtype, "self and src dtype should match");
-        irrt::ndarray::call_nac3_ndarray_copy_data(generator, ctx, src, *self);
+        irrt::ndarray::call_nac3_ndarray_copy_data(ctx, src, *self);
+    }
+
+    /// Fill the ndarray with a scalar.
+    ///
+    /// `fill_value` must have the same LLVM type as the `dtype` of this ndarray.
+    pub fn fill<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        value: BasicValueEnum<'ctx>,
+    ) {
+        // TODO: It is possible to optimize this by exploiting contiguous strides with memset.
+        //       Probably best to implement in IRRT.
+        self.foreach(generator, ctx, |_, ctx, _, nditer| {
+            let p = nditer.get_pointer(ctx);
+            ctx.builder.build_store(p, value).unwrap();
+            Ok(())
+        })
+        .unwrap();
+    }
+
+    /// Create the shape tuple of this ndarray like
+    /// [`np.shape(<ndarray>)`](https://numpy.org/doc/stable/reference/generated/numpy.shape.html).
+    ///
+    /// All elements in the tuple are `i32`.
+    pub fn make_shape_tuple<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> TupleValue<'ctx> {
+        let llvm_i32 = ctx.ctx.i32_type();
+
+        let objects = (0..self.ndims)
+            .map(|i| {
+                let dim = unsafe {
+                    self.shape().get_typed_unchecked(
+                        ctx,
+                        generator,
+                        &self.llvm_usize.const_int(i, false),
+                        None,
+                    )
+                };
+                ctx.builder.build_int_truncate_or_bit_cast(dim, llvm_i32, "").unwrap()
+            })
+            .map(|obj| obj.as_basic_value_enum())
+            .collect_vec();
+
+        TupleType::new(ctx, &repeat_n(llvm_i32, self.ndims as usize).collect_vec())
+            .construct_from_objects(ctx, objects, None)
+    }
+
+    /// Create the strides tuple of this ndarray like
+    /// [`<ndarray>.strides`](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.strides.html).
+    ///
+    /// All elements in the tuple are `i32`.
+    pub fn make_strides_tuple<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> TupleValue<'ctx> {
+        let llvm_i32 = ctx.ctx.i32_type();
+
+        let objects = (0..self.ndims)
+            .map(|i| {
+                let dim = unsafe {
+                    self.strides().get_typed_unchecked(
+                        ctx,
+                        generator,
+                        &self.llvm_usize.const_int(i, false),
+                        None,
+                    )
+                };
+                ctx.builder.build_int_truncate_or_bit_cast(dim, llvm_i32, "").unwrap()
+            })
+            .map(|obj| obj.as_basic_value_enum())
+            .collect_vec();
+
+        TupleType::new(ctx, &repeat_n(llvm_i32, self.ndims as usize).collect_vec())
+            .construct_from_objects(ctx, objects, None)
    }

    /// Returns true if this ndarray is unsized - `ndims == 0` and only contains a scalar.
    #[must_use]
-    pub fn is_unsized(&self) -> Option<bool> {
-        self.ndims.map(|ndims| ndims == 0)
+    pub fn is_unsized(&self) -> bool {
+        self.ndims == 0
    }

-    /// If this ndarray is unsized, return its sole value as an [`AnyObject`].
+    /// Returns the element present in this `ndarray` if this is unsized.
+    pub fn get_unsized_element<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> Option<BasicValueEnum<'ctx>> {
+        if self.is_unsized() {
+            // NOTE: `np.size(self) == 0` here is never possible.
+            let zero = ctx.get_size_type().const_zero();
+            let value = unsafe { self.data().get_unchecked(ctx, generator, &zero, None) };
+
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    /// If this ndarray is unsized, return its sole value as an [`BasicValueEnum`].
    /// Otherwise, do nothing and return the ndarray itself.
-    // TODO: Rename to get_unsized_element
    pub fn split_unsized<G: CodeGenerator + ?Sized>(
        &self,
        generator: &mut G,
        ctx: &mut CodeGenContext<'ctx, '_>,
    ) -> ScalarOrNDArray<'ctx> {
-        let Some(is_unsized) = self.is_unsized() else { todo!() };
-
-        if is_unsized {
-            // NOTE: `np.size(self) == 0` here is never possible.
-            let zero = generator.get_size_type(ctx.ctx).const_zero();
-            let value = unsafe { self.data().get_unchecked(ctx, generator, &zero, None) };
-
-            ScalarOrNDArray::Scalar(value)
+        if let Some(unsized_elem) = self.get_unsized_element(generator, ctx) {
+            ScalarOrNDArray::Scalar(unsized_elem)
        } else {
            ScalarOrNDArray::NDArray(*self)
        }
    }
+
+    /// Check if this `NDArray` can be used as an `out` ndarray for an operation.
+    ///
+    /// Raise an exception if the shapes do not match.
+    pub fn assert_can_be_written_by_out<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        out_shape: impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+    ) {
+        let ndarray_shape = self.shape();
+        let output_shape = out_shape;
+
+        irrt::ndarray::call_nac3_ndarray_util_assert_output_shape_same(
+            generator,
+            ctx,
+            &ndarray_shape,
+            &output_shape,
+        );
+    }
 }

 impl<'ctx> ProxyValue<'ctx> for NDArrayValue<'ctx> {
@ -491,8 +527,8 @@ impl<'ctx> ArrayLikeValue<'ctx> for NDArrayShapeProxy<'ctx, '_> {
 impl<'ctx> ArrayLikeIndexer<'ctx, IntValue<'ctx>> for NDArrayShapeProxy<'ctx, '_> {
    unsafe fn ptr_offset_unchecked<G: CodeGenerator + ?Sized>(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        idx: &IntValue<'ctx>,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
@ -530,20 +566,26 @@ impl<'ctx> ArrayLikeIndexer<'ctx, IntValue<'ctx>> for NDArrayShapeProxy<'ctx, '_
 impl<'ctx> UntypedArrayLikeAccessor<'ctx, IntValue<'ctx>> for NDArrayShapeProxy<'ctx, '_> {}
 impl<'ctx> UntypedArrayLikeMutator<'ctx, IntValue<'ctx>> for NDArrayShapeProxy<'ctx, '_> {}

-impl<'ctx> TypedArrayLikeAccessor<'ctx, IntValue<'ctx>> for NDArrayShapeProxy<'ctx, '_> {
+impl<'ctx, G: CodeGenerator + ?Sized> TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>
+    for NDArrayShapeProxy<'ctx, '_>
+{
    fn downcast_to_type(
        &self,
-        _: &mut CodeGenContext<'ctx, '_>,
+        _: &CodeGenContext<'ctx, '_>,
+        _: &G,
        value: BasicValueEnum<'ctx>,
    ) -> IntValue<'ctx> {
        value.into_int_value()
    }
 }

-impl<'ctx> TypedArrayLikeMutator<'ctx, IntValue<'ctx>> for NDArrayShapeProxy<'ctx, '_> {
+impl<'ctx, G: CodeGenerator + ?Sized> TypedArrayLikeMutator<'ctx, G, IntValue<'ctx>>
+    for NDArrayShapeProxy<'ctx, '_>
+{
    fn upcast_from_type(
        &self,
-        _: &mut CodeGenContext<'ctx, '_>,
+        _: &CodeGenContext<'ctx, '_>,
+        _: &G,
        value: IntValue<'ctx>,
    ) -> BasicValueEnum<'ctx> {
        value.into()
@ -583,8 +625,8 @@ impl<'ctx> ArrayLikeValue<'ctx> for NDArrayStridesProxy<'ctx, '_> {
 impl<'ctx> ArrayLikeIndexer<'ctx, IntValue<'ctx>> for NDArrayStridesProxy<'ctx, '_> {
    unsafe fn ptr_offset_unchecked<G: CodeGenerator + ?Sized>(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        idx: &IntValue<'ctx>,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
@ -622,20 +664,26 @@ impl<'ctx> ArrayLikeIndexer<'ctx, IntValue<'ctx>> for NDArrayStridesProxy<'ctx,
 impl<'ctx> UntypedArrayLikeAccessor<'ctx, IntValue<'ctx>> for NDArrayStridesProxy<'ctx, '_> {}
 impl<'ctx> UntypedArrayLikeMutator<'ctx, IntValue<'ctx>> for NDArrayStridesProxy<'ctx, '_> {}

-impl<'ctx> TypedArrayLikeAccessor<'ctx, IntValue<'ctx>> for NDArrayStridesProxy<'ctx, '_> {
+impl<'ctx, G: CodeGenerator + ?Sized> TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>
+    for NDArrayStridesProxy<'ctx, '_>
+{
    fn downcast_to_type(
        &self,
-        _: &mut CodeGenContext<'ctx, '_>,
+        _: &CodeGenContext<'ctx, '_>,
+        _: &G,
        value: BasicValueEnum<'ctx>,
    ) -> IntValue<'ctx> {
        value.into_int_value()
    }
 }

-impl<'ctx> TypedArrayLikeMutator<'ctx, IntValue<'ctx>> for NDArrayStridesProxy<'ctx, '_> {
+impl<'ctx, G: CodeGenerator + ?Sized> TypedArrayLikeMutator<'ctx, G, IntValue<'ctx>>
+    for NDArrayStridesProxy<'ctx, '_>
+{
    fn upcast_from_type(
        &self,
-        _: &mut CodeGenContext<'ctx, '_>,
+        _: &CodeGenContext<'ctx, '_>,
+        _: &G,
        value: IntValue<'ctx>,
    ) -> BasicValueEnum<'ctx> {
        value.into()
@ -666,43 +714,21 @@ impl<'ctx> ArrayLikeValue<'ctx> for NDArrayDataProxy<'ctx, '_> {
    fn size<G: CodeGenerator + ?Sized>(
        &self,
        ctx: &CodeGenContext<'ctx, '_>,
-        generator: &G,
+        _: &G,
    ) -> IntValue<'ctx> {
-        irrt::ndarray::call_ndarray_calc_size(
-            generator,
-            ctx,
-            &self.as_slice_value(ctx, generator),
-            (None, None),
-        )
+        irrt::ndarray::call_nac3_ndarray_len(ctx, *self.0)
    }
 }

 impl<'ctx> ArrayLikeIndexer<'ctx> for NDArrayDataProxy<'ctx, '_> {
    unsafe fn ptr_offset_unchecked<G: CodeGenerator + ?Sized>(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        idx: &IntValue<'ctx>,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
-        let sizeof_elem = ctx
-            .builder
-            .build_int_truncate_or_bit_cast(
-                self.element_type(ctx, generator).size_of().unwrap(),
-                idx.get_type(),
-                "",
-            )
-            .unwrap();
-        let idx = ctx.builder.build_int_mul(*idx, sizeof_elem, "").unwrap();
-        let ptr = unsafe {
-            ctx.builder
-                .build_in_bounds_gep(
-                    self.base_ptr(ctx, generator),
-                    &[idx],
-                    name.unwrap_or_default(),
-                )
-                .unwrap()
-        };
+        let ptr = irrt::ndarray::call_nac3_ndarray_get_nth_pelement(ctx, *self.0, *idx);

        // Current implementation is transparent - The returned pointer type is
        // already cast into the expected type, allowing for immediately
@ -713,7 +739,7 @@ impl<'ctx> ArrayLikeIndexer<'ctx> for NDArrayDataProxy<'ctx, '_> {
                BasicTypeEnum::try_from(self.element_type(ctx, generator))
                    .unwrap()
                    .ptr_type(AddressSpace::default()),
-                "",
+                name.unwrap_or_default(),
            )
            .unwrap()
    }
@ -761,55 +787,33 @@ impl<'ctx, Index: UntypedArrayLikeAccessor<'ctx>> ArrayLikeIndexer<'ctx, Index>
 {
    unsafe fn ptr_offset_unchecked<G: CodeGenerator + ?Sized>(
        &self,
-        ctx: &mut CodeGenContext<'ctx, '_>,
-        generator: &mut G,
+        ctx: &CodeGenContext<'ctx, '_>,
+        generator: &G,
        indices: &Index,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
-        let llvm_usize = generator.get_size_type(ctx.ctx);
+        assert_eq!(indices.element_type(ctx, generator), ctx.get_size_type().into());

-        let indices_elem_ty = indices
-            .ptr_offset(ctx, generator, &llvm_usize.const_zero(), None)
-            .get_type()
-            .get_element_type();
-        let Ok(indices_elem_ty) = IntType::try_from(indices_elem_ty) else {
-            panic!("Expected list[int32] but got {indices_elem_ty}")
-        };
-        assert_eq!(
-            indices_elem_ty.get_bit_width(),
-            32,
-            "Expected list[int32] but got list[int{}]",
-            indices_elem_ty.get_bit_width()
+        let indices = TypedArrayLikeAdapter::from(
+            indices.as_slice_value(ctx, generator),
+            |_, _, v| v.into_int_value(),
+            |_, _, v| v.into(),
        );

-        let index = irrt::ndarray::call_ndarray_flatten_index(generator, ctx, *self.0, indices);
-        let sizeof_elem = ctx
-            .builder
-            .build_int_truncate_or_bit_cast(
-                self.element_type(ctx, generator).size_of().unwrap(),
-                index.get_type(),
-                "",
-            )
-            .unwrap();
-        let index = ctx.builder.build_int_mul(index, sizeof_elem, "").unwrap();
+        let ptr = irrt::ndarray::call_nac3_ndarray_get_pelement_by_indices(
+            generator, ctx, *self.0, &indices,
+        );

-        let ptr = unsafe {
-            ctx.builder
-                .build_in_bounds_gep(
-                    self.base_ptr(ctx, generator),
-                    &[index],
-                    name.unwrap_or_default(),
-                )
-                .unwrap()
-        };
-        // TODO: Current implementation is transparent
+        // Current implementation is transparent - The returned pointer type is
+        // already cast into the expected type, allowing for immediately
+        // load/store.
        ctx.builder
            .build_pointer_cast(
                ptr,
                BasicTypeEnum::try_from(self.element_type(ctx, generator))
                    .unwrap()
                    .ptr_type(AddressSpace::default()),
-                "",
+                name.unwrap_or_default(),
            )
            .unwrap()
    }
@ -821,7 +825,7 @@ impl<'ctx, Index: UntypedArrayLikeAccessor<'ctx>> ArrayLikeIndexer<'ctx, Index>
        indices: &Index,
        name: Option<&str>,
    ) -> PointerValue<'ctx> {
-        let llvm_usize = generator.get_size_type(ctx.ctx);
+        let llvm_usize = ctx.get_size_type();

        let indices_size = indices.size(ctx, generator);
        let nidx_leq_ndims = ctx
@ -904,10 +908,9 @@ impl<'ctx, Index: UntypedArrayLikeAccessor<'ctx>> UntypedArrayLikeMutator<'ctx,
 /// This function is used generating strides for globally defined contiguous ndarrays.
 #[must_use]
 pub fn make_contiguous_strides(itemsize: u64, ndims: u64, shape: &[u64]) -> Vec<u64> {
-    let mut strides = Vec::with_capacity(ndims as usize);
+    let mut strides = vec![0u64; ndims as usize];
    let mut stride_product = 1u64;
-    for i in 0..ndims {
-        let axis = ndims - i - 1;
+    for axis in (0..ndims).rev() {
        strides[axis as usize] = stride_product * itemsize;
        stride_product *= shape[axis as usize];
    }
@ -921,7 +924,52 @@ pub enum ScalarOrNDArray<'ctx> {
    NDArray(NDArrayValue<'ctx>),
 }

+impl<'ctx> TryFrom<&ScalarOrNDArray<'ctx>> for BasicValueEnum<'ctx> {
+    type Error = ();
+
+    fn try_from(value: &ScalarOrNDArray<'ctx>) -> Result<Self, Self::Error> {
+        match value {
+            ScalarOrNDArray::Scalar(scalar) => Ok(*scalar),
+            ScalarOrNDArray::NDArray(_) => Err(()),
+        }
+    }
+}
+
+impl<'ctx> TryFrom<&ScalarOrNDArray<'ctx>> for NDArrayValue<'ctx> {
+    type Error = ();
+
+    fn try_from(value: &ScalarOrNDArray<'ctx>) -> Result<Self, Self::Error> {
+        match value {
+            ScalarOrNDArray::Scalar(_) => Err(()),
+            ScalarOrNDArray::NDArray(ndarray) => Ok(*ndarray),
+        }
+    }
+}
+
 impl<'ctx> ScalarOrNDArray<'ctx> {
+    /// Split on `object` either into a scalar or an ndarray.
+    ///
+    /// If `object` is an ndarray, [`ScalarOrNDArray::NDArray`].
+    ///
+    /// For everything else, it is wrapped with [`ScalarOrNDArray::Scalar`].
+    pub fn from_value<G: CodeGenerator + ?Sized>(
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        (object_ty, object): (Type, BasicValueEnum<'ctx>),
+    ) -> ScalarOrNDArray<'ctx> {
+        match &*ctx.unifier.get_ty(object_ty) {
+            TypeEnum::TObj { obj_id, .. }
+                if *obj_id == ctx.primitives.ndarray.obj_id(&ctx.unifier).unwrap() =>
+            {
+                let ndarray = NDArrayType::from_unifier_type(generator, ctx, object_ty)
+                    .map_value(object.into_pointer_value(), None);
+                ScalarOrNDArray::NDArray(ndarray)
+            }
+
+            _ => ScalarOrNDArray::Scalar(object),
+        }
+    }
+
    /// Get the underlying [`BasicValueEnum<'ctx>`] of this [`ScalarOrNDArray`].
    #[must_use]
    pub fn to_basic_value_enum(self) -> BasicValueEnum<'ctx> {
@ -930,4 +978,55 @@ impl<'ctx> ScalarOrNDArray<'ctx> {
            ScalarOrNDArray::NDArray(ndarray) => ndarray.as_base_value().into(),
        }
    }
+
+    /// Convert this [`ScalarOrNDArray`] to an ndarray - behaves like `np.asarray`.
+    ///
+    /// - If this is an ndarray, the ndarray is returned.
+    /// - If this is a scalar, this function returns new ndarray created with
+    ///   [`NDArrayType::construct_unsized`].
+    pub fn to_ndarray<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+    ) -> NDArrayValue<'ctx> {
+        match self {
+            ScalarOrNDArray::NDArray(ndarray) => *ndarray,
+            ScalarOrNDArray::Scalar(scalar) => NDArrayType::new_unsized(ctx, scalar.get_type())
+                .construct_unsized(generator, ctx, scalar, None),
+        }
+    }
+
+    /// Get the dtype of the ndarray created if this were called with
+    /// [`ScalarOrNDArray::to_ndarray`].
+    #[must_use]
+    pub fn get_dtype(&self) -> BasicTypeEnum<'ctx> {
+        match self {
+            ScalarOrNDArray::NDArray(ndarray) => ndarray.dtype,
+            ScalarOrNDArray::Scalar(scalar) => scalar.get_type(),
+        }
+    }
+}
+
+/// An helper enum specifying how a function should produce its output.
+///
+/// Many functions in NumPy has an optional `out` parameter (e.g., `matmul`). If `out` is specified
+/// with an ndarray, the result of a function will be written to `out`. If `out` is not specified, a
+/// function will create a new ndarray and store the result in it.
+#[derive(Clone, Copy)]
+pub enum NDArrayOut<'ctx> {
+    /// Tell a function should create a new ndarray with the expected element type `dtype`.
+    NewNDArray { dtype: BasicTypeEnum<'ctx> },
+    /// Tell a function to write the result to `ndarray`.
+    WriteToNDArray { ndarray: NDArrayValue<'ctx> },
+}
+
+impl<'ctx> NDArrayOut<'ctx> {
+    /// Get the dtype of this output.
+    #[must_use]
+    pub fn get_dtype(&self) -> BasicTypeEnum<'ctx> {
+        match self {
+            NDArrayOut::NewNDArray { dtype } => *dtype,
+            NDArrayOut::WriteToNDArray { ndarray } => ndarray.dtype,
+        }
+    }
 }
--- a/nac3core/src/codegen/values/ndarray/nditer.rs
+++ b/nac3core/src/codegen/values/ndarray/nditer.rs
@ -4,7 +4,7 @@ use inkwell::{
    AddressSpace,
 };

-use super::{NDArrayValue, ProxyValue, TypedArrayLikeAccessor, TypedArrayLikeMutator};
+use super::{NDArrayValue, ProxyValue};
 use crate::codegen::{
    irrt,
    stmt::{gen_for_callback, BreakContinueHooks},
@ -53,23 +53,22 @@ impl<'ctx> NDIterValue<'ctx> {
    /// If `ndarray` is unsized, this returns true only for the first iteration.
    /// If `ndarray` is 0-sized, this always returns false.
    #[must_use]
-    pub fn has_element<G: CodeGenerator + ?Sized>(
-        &self,
-        generator: &G,
-        ctx: &CodeGenContext<'ctx, '_>,
-    ) -> IntValue<'ctx> {
-        irrt::ndarray::call_nac3_nditer_has_element(generator, ctx, *self)
+    pub fn has_element(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
+        irrt::ndarray::call_nac3_nditer_has_element(ctx, *self)
    }

    /// Go to the next element. If `has_element()` is false, then this has undefined behavior.
    ///
    /// If `ndarray` is unsized, this can only be called once.
    /// If `ndarray` is 0-sized, this can never be called.
-    pub fn next<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &CodeGenContext<'ctx, '_>) {
-        irrt::ndarray::call_nac3_nditer_next(generator, ctx, *self);
+    pub fn next(&self, ctx: &CodeGenContext<'ctx, '_>) {
+        irrt::ndarray::call_nac3_nditer_next(ctx, *self);
    }

-    fn element(&self, ctx: &CodeGenContext<'ctx, '_>) -> StructField<'ctx, PointerValue<'ctx>> {
+    fn element_field(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+    ) -> StructField<'ctx, PointerValue<'ctx>> {
        self.get_type().get_fields(ctx.ctx).element
    }

@ -78,7 +77,7 @@ impl<'ctx> NDIterValue<'ctx> {
    pub fn get_pointer(&self, ctx: &CodeGenContext<'ctx, '_>) -> PointerValue<'ctx> {
        let elem_ty = self.parent.dtype;

-        let p = self.element(ctx).get(ctx, self.as_base_value(), None);
+        let p = self.element_field(ctx).get(ctx, self.as_base_value(), self.name);
        ctx.builder
            .build_pointer_cast(p, elem_ty.ptr_type(AddressSpace::default()), "element")
            .unwrap()
@ -91,30 +90,25 @@ impl<'ctx> NDIterValue<'ctx> {
        ctx.builder.build_load(p, "value").unwrap()
    }

-    fn nth(&self, ctx: &CodeGenContext<'ctx, '_>) -> StructField<'ctx, IntValue<'ctx>> {
+    fn nth_field(&self, ctx: &CodeGenContext<'ctx, '_>) -> StructField<'ctx, IntValue<'ctx>> {
        self.get_type().get_fields(ctx.ctx).nth
    }

    /// Get the index of the current element if this ndarray were a flat ndarray.
    #[must_use]
    pub fn get_index(&self, ctx: &CodeGenContext<'ctx, '_>) -> IntValue<'ctx> {
-        self.nth(ctx).get(ctx, self.as_base_value(), None)
+        self.nth_field(ctx).get(ctx, self.as_base_value(), self.name)
    }

    /// Get the indices of the current element.
    #[must_use]
-    pub fn get_indices(
-        &'ctx self,
-    ) -> impl TypedArrayLikeAccessor<'ctx, IntValue<'ctx>> + TypedArrayLikeMutator<'ctx, IntValue<'ctx>>
-    {
+    pub fn get_indices<G: CodeGenerator + ?Sized>(
+        &self,
+    ) -> TypedArrayLikeAdapter<'ctx, G, IntValue<'ctx>> {
        TypedArrayLikeAdapter::from(
            self.indices,
-            Box::new(|ctx, val| {
-                ctx.builder
-                    .build_int_z_extend_or_bit_cast(val.into_int_value(), self.llvm_usize, "")
-                    .unwrap()
-            }),
-            Box::new(|_, val| val.into()),
+            |_, _, val| val.into_int_value(),
+            |_, _, val| val.into(),
        )
    }
 }
@ -162,13 +156,11 @@ impl<'ctx> NDArrayValue<'ctx> {
            generator,
            ctx,
            Some("ndarray_foreach"),
-            |generator, ctx| {
-                Ok(NDIterType::new(generator, ctx.ctx).construct(generator, ctx, *self))
-            },
-            |generator, ctx, nditer| Ok(nditer.has_element(generator, ctx)),
+            |generator, ctx| Ok(NDIterType::new(ctx).construct(generator, ctx, *self)),
+            |_, ctx, nditer| Ok(nditer.has_element(ctx)),
            |generator, ctx, hooks, nditer| body(generator, ctx, hooks, nditer),
-            |generator, ctx, nditer| {
-                nditer.next(generator, ctx);
+            |_, ctx, nditer| {
+                nditer.next(ctx);
                Ok(())
            },
        )
--- a/nac3core/src/codegen/values/ndarray/shape.rs
+++ b/nac3core/src/codegen/values/ndarray/shape.rs
@ -0,0 +1,152 @@
+use inkwell::values::{BasicValueEnum, IntValue};
+
+use crate::{
+    codegen::{
+        stmt::gen_for_callback_incrementing,
+        types::{ListType, TupleType},
+        values::{
+            ArraySliceValue, ProxyValue, TypedArrayLikeAccessor, TypedArrayLikeAdapter,
+            TypedArrayLikeMutator, UntypedArrayLikeAccessor,
+        },
+        CodeGenContext, CodeGenerator,
+    },
+    typecheck::typedef::{Type, TypeEnum},
+};
+
+/// Parse a NumPy-like "int sequence" input and return the int sequence as an array and its length.
+///
+/// * `sequence` - The `sequence` parameter.
+/// * `sequence_ty` - The typechecker type of `sequence`
+///
+/// The `sequence` argument type may only be one of the following:
+///   1. A list of `int32`;   e.g., `np.empty([600, 800, 3])`
+///   2. A tuple of `int32`;  e.g., `np.empty((600, 800, 3))`
+///   3. A scalar `int32`;    e.g., `np.empty(3)`, this is functionally equivalent to
+///      `np.empty([3])`
+///
+/// All `int32` values will be sign-extended to `SizeT`.
+pub fn parse_numpy_int_sequence<'ctx, G: CodeGenerator + ?Sized>(
+    generator: &mut G,
+    ctx: &mut CodeGenContext<'ctx, '_>,
+    (input_seq_ty, input_seq): (Type, BasicValueEnum<'ctx>),
+) -> impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>> {
+    let llvm_usize = ctx.get_size_type();
+    let zero = llvm_usize.const_zero();
+    let one = llvm_usize.const_int(1, false);
+
+    // The result `list` to return.
+    match &*ctx.unifier.get_ty_immutable(input_seq_ty) {
+        TypeEnum::TObj { obj_id, .. }
+            if *obj_id == ctx.primitives.list.obj_id(&ctx.unifier).unwrap() =>
+        {
+            // 1. A list of `int32`; e.g., `np.empty([600, 800, 3])`
+
+            let input_seq = ListType::from_unifier_type(generator, ctx, input_seq_ty)
+                .map_value(input_seq.into_pointer_value(), None);
+
+            let len = input_seq.load_size(ctx, None);
+            // TODO: Find a way to remove this mid-BB allocation
+            let result = ctx.builder.build_array_alloca(llvm_usize, len, "").unwrap();
+            let result = TypedArrayLikeAdapter::from(
+                ArraySliceValue::from_ptr_val(result, len, None),
+                |_, _, val| val.into_int_value(),
+                |_, _, val| val.into(),
+            );
+
+            // Load all the `int32`s from the input_sequence, cast them to `SizeT`, and store them into `result`
+            gen_for_callback_incrementing(
+                generator,
+                ctx,
+                None,
+                zero,
+                (len, false),
+                |generator, ctx, _, i| {
+                    // Load the i-th int32 in the input sequence
+                    let int = unsafe {
+                        input_seq.data().get_unchecked(ctx, generator, &i, None).into_int_value()
+                    };
+
+                    // Cast to SizeT
+                    let int =
+                        ctx.builder.build_int_s_extend_or_bit_cast(int, llvm_usize, "").unwrap();
+
+                    // Store
+                    unsafe { result.set_typed_unchecked(ctx, generator, &i, int) };
+
+                    Ok(())
+                },
+                one,
+            )
+            .unwrap();
+
+            result
+        }
+
+        TypeEnum::TTuple { .. } => {
+            // 2. A tuple of ints; e.g., `np.empty((600, 800, 3))`
+
+            let input_seq = TupleType::from_unifier_type(generator, ctx, input_seq_ty)
+                .map_value(input_seq.into_struct_value(), None);
+
+            let len = input_seq.get_type().num_elements();
+
+            let result = generator
+                .gen_array_var_alloc(
+                    ctx,
+                    llvm_usize.into(),
+                    llvm_usize.const_int(u64::from(len), false),
+                    None,
+                )
+                .unwrap();
+            let result = TypedArrayLikeAdapter::from(
+                result,
+                |_, _, val| val.into_int_value(),
+                |_, _, val| val.into(),
+            );
+
+            for i in 0..input_seq.get_type().num_elements() {
+                // Get the i-th element off of the tuple and load it into `result`.
+                let int = input_seq.load_element(ctx, i).into_int_value();
+                let int = ctx.builder.build_int_s_extend_or_bit_cast(int, llvm_usize, "").unwrap();
+
+                unsafe {
+                    result.set_typed_unchecked(
+                        ctx,
+                        generator,
+                        &llvm_usize.const_int(u64::from(i), false),
+                        int,
+                    );
+                }
+            }
+
+            result
+        }
+
+        TypeEnum::TObj { obj_id, .. }
+            if *obj_id == ctx.primitives.int32.obj_id(&ctx.unifier).unwrap() =>
+        {
+            // 3. A scalar int; e.g., `np.empty(3)`, this is functionally equivalent to `np.empty([3])`
+
+            let input_int = input_seq.into_int_value();
+
+            let len = one;
+            let result = generator.gen_array_var_alloc(ctx, llvm_usize.into(), len, None).unwrap();
+            let result = TypedArrayLikeAdapter::from(
+                result,
+                |_, _, val| val.into_int_value(),
+                |_, _, val| val.into(),
+            );
+            let int =
+                ctx.builder.build_int_s_extend_or_bit_cast(input_int, llvm_usize, "").unwrap();
+
+            // Storing into result[0]
+            unsafe {
+                result.set_typed_unchecked(ctx, generator, &zero, int);
+            }
+
+            result
+        }
+
+        _ => panic!("encountered unknown sequence type: {}", ctx.unifier.stringify(input_seq_ty)),
+    }
+}
--- a/nac3core/src/codegen/values/ndarray/view.rs
+++ b/nac3core/src/codegen/values/ndarray/view.rs
@ -1,9 +1,16 @@
 use std::iter::{once, repeat_n};

+use inkwell::values::{IntValue, PointerValue};
 use itertools::Itertools;

 use crate::codegen::{
-    values::ndarray::{NDArrayValue, RustNDIndex},
+    irrt,
+    stmt::gen_if_callback,
+    types::ndarray::NDArrayType,
+    values::{
+        ndarray::{NDArrayValue, RustNDIndex},
+        ArrayLikeValue, ArraySliceValue, ProxyValue, TypedArrayLikeAccessor, TypedArrayLikeAdapter,
+    },
    CodeGenContext, CodeGenerator,
 };

@ -19,9 +26,7 @@ impl<'ctx> NDArrayValue<'ctx> {
        ctx: &mut CodeGenContext<'ctx, '_>,
        ndmin: u64,
    ) -> Self {
-        assert!(self.ndims.is_some(), "NDArrayValue::atleast_nd is only supported for instances with compile-time known ndims (self.ndims = Some(...))");
-
-        let ndims = self.ndims.unwrap();
+        let ndims = self.ndims;

        if ndims < ndmin {
            // Extend the dimensions with np.newaxis.
@ -33,4 +38,117 @@ impl<'ctx> NDArrayValue<'ctx> {
            *self
        }
    }
+
+    /// Create a reshaped view on this ndarray like
+    /// [`np.reshape()`](https://numpy.org/doc/stable/reference/generated/numpy.reshape.html).
+    ///
+    /// If there is a `-1` in `new_shape`, it will be resolved; `new_shape` would **NOT** be
+    /// modified as a result.
+    ///
+    /// If reshape without copying is impossible, this function will allocate a new ndarray and copy
+    /// contents.
+    ///
+    /// * `new_ndims` - The number of dimensions of `new_shape` as a [`Type`].
+    /// * `new_shape` - The target shape to do `np.reshape()`.
+    #[must_use]
+    pub fn reshape_or_copy<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        new_ndims: u64,
+        new_shape: &impl TypedArrayLikeAccessor<'ctx, G, IntValue<'ctx>>,
+    ) -> Self {
+        assert_eq!(new_shape.element_type(ctx, generator), self.llvm_usize.into());
+
+        // TODO: The current criterion for whether to do a full copy or not is by checking
+        //       `is_c_contiguous`, but this is not optimal - there are cases when the ndarray is
+        //       not contiguous but could be reshaped without copying data. Look into how numpy does
+        //       it.
+
+        let dst_ndarray = NDArrayType::new(ctx, self.dtype, new_ndims)
+            .construct_uninitialized(generator, ctx, None);
+        dst_ndarray.copy_shape_from_array(generator, ctx, new_shape.base_ptr(ctx, generator));
+
+        // Resolve negative indices
+        let size = self.size(ctx);
+        let dst_ndims = self.llvm_usize.const_int(dst_ndarray.get_type().ndims(), false);
+        let dst_shape = dst_ndarray.shape();
+        irrt::ndarray::call_nac3_ndarray_reshape_resolve_and_check_new_shape(
+            generator,
+            ctx,
+            size,
+            dst_ndims,
+            dst_shape.as_slice_value(ctx, generator),
+        );
+
+        gen_if_callback(
+            generator,
+            ctx,
+            |_, ctx| Ok(self.is_c_contiguous(ctx)),
+            |generator, ctx| {
+                // Reshape is possible without copying
+                dst_ndarray.set_strides_contiguous(ctx);
+                dst_ndarray.store_data(ctx, self.data().base_ptr(ctx, generator));
+
+                Ok(())
+            },
+            |generator, ctx| {
+                // Reshape is impossible without copying
+                unsafe {
+                    dst_ndarray.create_data(generator, ctx);
+                }
+                dst_ndarray.copy_data_from(ctx, *self);
+
+                Ok(())
+            },
+        )
+        .unwrap();
+
+        dst_ndarray
+    }
+
+    /// Create a transposed view on this ndarray like
+    /// [`np.transpose(<ndarray>, <axes> = None)`](https://numpy.org/doc/stable/reference/generated/numpy.transpose.html).
+    ///
+    /// * `axes` - If specified, should be an array of the permutation (negative indices are
+    ///   **allowed**).
+    #[must_use]
+    pub fn transpose<G: CodeGenerator + ?Sized>(
+        &self,
+        generator: &mut G,
+        ctx: &mut CodeGenContext<'ctx, '_>,
+        axes: Option<PointerValue<'ctx>>,
+    ) -> Self {
+        assert!(
+            axes.is_none_or(|axes| axes.get_type().get_element_type() == self.llvm_usize.into())
+        );
+
+        // Define models
+        let transposed_ndarray = self.get_type().construct_uninitialized(generator, ctx, None);
+
+        let axes = if let Some(axes) = axes {
+            let num_axes = self.llvm_usize.const_int(self.ndims, false);
+
+            // `axes = nullptr` if `axes` is unspecified.
+            let axes = ArraySliceValue::from_ptr_val(axes, num_axes, None);
+
+            Some(TypedArrayLikeAdapter::from(
+                axes,
+                |_, _, val| val.into_int_value(),
+                |_, _, val| val.into(),
+            ))
+        } else {
+            None
+        };
+
+        irrt::ndarray::call_nac3_ndarray_transpose(
+            generator,
+            ctx,
+            *self,
+            transposed_ndarray,
+            axes.as_ref(),
+        );
+
+        transposed_ndarray
+    }
 }
--- a/nac3core/src/codegen/values/tuple.rs
+++ b/nac3core/src/codegen/values/tuple.rs
@ -0,0 +1,85 @@
+use inkwell::{
+    types::IntType,
+    values::{BasicValue, BasicValueEnum, StructValue},
+};
+
+use super::ProxyValue;
+use crate::codegen::{types::TupleType, CodeGenContext};
+
+#[derive(Copy, Clone)]
+pub struct TupleValue<'ctx> {
+    value: StructValue<'ctx>,
+    llvm_usize: IntType<'ctx>,
+    name: Option<&'ctx str>,
+}
+
+impl<'ctx> TupleValue<'ctx> {
+    /// Checks whether `value` is an instance of `tuple`, returning [Err] if `value` is not an
+    /// instance.
+    pub fn is_representable(
+        value: StructValue<'ctx>,
+        _llvm_usize: IntType<'ctx>,
+    ) -> Result<(), String> {
+        TupleType::is_representable(value.get_type())
+    }
+
+    /// Creates an [`TupleValue`] from a [`StructValue`].
+    #[must_use]
+    pub fn from_struct_value(
+        value: StructValue<'ctx>,
+        llvm_usize: IntType<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> Self {
+        debug_assert!(Self::is_representable(value, llvm_usize).is_ok());
+
+        Self { value, llvm_usize, name }
+    }
+
+    /// Stores a value into the tuple element at the given `index`.
+    pub fn store_element(
+        &mut self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        index: u32,
+        element: impl BasicValue<'ctx>,
+    ) {
+        assert_eq!(element.as_basic_value_enum().get_type(), unsafe {
+            self.get_type().type_at_index_unchecked(index)
+        });
+
+        let new_value = ctx
+            .builder
+            .build_insert_value(self.value, element, index, self.name.unwrap_or_default())
+            .unwrap();
+        self.value = new_value.into_struct_value();
+    }
+
+    /// Loads a value from the tuple element at the given `index`.
+    pub fn load_element(&self, ctx: &CodeGenContext<'ctx, '_>, index: u32) -> BasicValueEnum<'ctx> {
+        ctx.builder
+            .build_extract_value(
+                self.value,
+                index,
+                &format!("{}[{{i}}]", self.name.unwrap_or("tuple")),
+            )
+            .unwrap()
+    }
+}
+
+impl<'ctx> ProxyValue<'ctx> for TupleValue<'ctx> {
+    type Base = StructValue<'ctx>;
+    type Type = TupleType<'ctx>;
+
+    fn get_type(&self) -> Self::Type {
+        TupleType::from_type(self.as_base_value().get_type(), self.llvm_usize)
+    }
+
+    fn as_base_value(&self) -> Self::Base {
+        self.value
+    }
+}
+
+impl<'ctx> From<TupleValue<'ctx>> for StructValue<'ctx> {
+    fn from(value: TupleValue<'ctx>) -> Self {
+        value.as_base_value()
+    }
+}
--- a/nac3core/src/symbol_resolver.rs
+++ b/nac3core/src/symbol_resolver.rs
@ -6,7 +6,7 @@ use std::{
 };

 use inkwell::values::{BasicValueEnum, FloatValue, IntValue, PointerValue, StructValue};
-use itertools::{chain, izip, Itertools};
+use itertools::{izip, Itertools};
 use parking_lot::RwLock;

 use nac3parser::ast::{Constant, Expr, Location, StrRef};
@ -452,11 +452,11 @@ pub fn parse_type_annotation<T>(
                            type_vars.len()
                        )]));
                    }
-                    let fields = chain(
-                        fields.iter().map(|(k, v, m)| (*k, (*v, *m))),
-                        methods.iter().map(|(k, v, _)| (*k, (*v, false))),
-                    )
-                    .collect();
+                    let fields = fields
+                        .iter()
+                        .map(|(k, v, m)| (*k, (*v, *m)))
+                        .chain(methods.iter().map(|(k, v, _)| (*k, (*v, false))))
+                        .collect();
                    Ok(unifier.add_ty(TypeEnum::TObj { obj_id, fields, params: VarMap::default() }))
                } else {
                    Err(HashSet::from([format!("Cannot use function name as type at {loc}")]))
@ -598,10 +598,12 @@ impl dyn SymbolResolver + Send + Sync {
        unifier.internal_stringify(
            ty,
            &mut |id| {
-                let TopLevelDef::Class { name, .. } = &*top_level_defs[id].read() else {
-                    unreachable!("expected class definition")
+                let top_level_def = &*top_level_defs[id].read();
+                let (TopLevelDef::Class { name, .. } | TopLevelDef::Module { name, .. }) =
+                    top_level_def
+                else {
+                    unreachable!("expected class/module definition")
                };
-
                name.to_string()
            },
            &mut |id| format!("typevar{id}"),
--- a/nac3core/src/toplevel/builtins.rs
+++ b/nac3core/src/toplevel/builtins.rs
@ -1,26 +1,27 @@
 use std::iter::once;

 use indexmap::IndexMap;
-use inkwell::{
-    attributes::{Attribute, AttributeLoc},
-    types::{BasicMetadataTypeEnum, BasicType},
-    values::{BasicMetadataValueEnum, BasicValue, CallSiteValue},
-    IntPredicate,
-};
-use itertools::Either;
+use inkwell::{values::BasicValue, IntPredicate};
 use strum::IntoEnumIterator;

 use super::{
-    helper::{debug_assert_prim_is_allowed, make_exception_fields, PrimDef, PrimDefDetails},
-    numpy::make_ndarray_ty,
+    helper::{
+        arraylike_flatten_element_type, debug_assert_prim_is_allowed, extract_ndims,
+        make_exception_fields, PrimDef, PrimDefDetails,
+    },
+    numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
    *,
 };
 use crate::{
    codegen::{
        builtin_fns,
        numpy::*,
-        stmt::exn_constructor,
-        values::{ProxyValue, RangeValue},
+        stmt::{exn_constructor, gen_if_callback},
+        types::ndarray::NDArrayType,
+        values::{
+            ndarray::{shape::parse_numpy_int_sequence, ScalarOrNDArray},
+            ProxyValue, RangeValue,
+        },
    },
    symbol_resolver::SymbolValue,
    typecheck::typedef::{into_var_map, iter_type_vars, TypeVar, VarMap},
@ -148,144 +149,6 @@ fn create_fn_by_codegen(
    }
 }

-/// Creates a NumPy [`TopLevelDef`] function using an LLVM intrinsic.
-///
-/// * `name`: The name of the implemented NumPy function.
-/// * `ret_ty`: The return type of this function.
-/// * `param_ty`: The parameters accepted by this function, represented by a tuple of the
-///   [parameter type][Type] and the parameter symbol name.
-/// * `intrinsic_fn`: The fully-qualified name of the LLVM intrinsic function.
-fn create_fn_by_intrinsic(
-    unifier: &mut Unifier,
-    var_map: &VarMap,
-    name: &'static str,
-    ret_ty: Type,
-    params: &[(Type, &'static str)],
-    intrinsic_fn: &'static str,
-) -> TopLevelDef {
-    let param_tys = params.iter().map(|p| p.0).collect_vec();
-
-    create_fn_by_codegen(
-        unifier,
-        var_map,
-        name,
-        ret_ty,
-        params,
-        Box::new(move |ctx, _, fun, args, generator| {
-            let args_ty = fun.0.args.iter().map(|a| a.ty).collect_vec();
-
-            assert!(param_tys
-                .iter()
-                .zip(&args_ty)
-                .all(|(expected, actual)| ctx.unifier.unioned(*expected, *actual)));
-
-            let args_val = args_ty
-                .iter()
-                .zip_eq(args.iter())
-                .map(|(ty, arg)| arg.1.clone().to_basic_value_enum(ctx, generator, *ty).unwrap())
-                .map_into::<BasicMetadataValueEnum>()
-                .collect_vec();
-
-            let intrinsic_fn = ctx.module.get_function(intrinsic_fn).unwrap_or_else(|| {
-                let ret_llvm_ty = ctx.get_llvm_abi_type(generator, ret_ty);
-                let param_llvm_ty = param_tys
-                    .iter()
-                    .map(|p| ctx.get_llvm_abi_type(generator, *p))
-                    .map_into::<BasicMetadataTypeEnum>()
-                    .collect_vec();
-                let fn_type = ret_llvm_ty.fn_type(param_llvm_ty.as_slice(), false);
-
-                ctx.module.add_function(intrinsic_fn, fn_type, None)
-            });
-
-            let val = ctx
-                .builder
-                .build_call(intrinsic_fn, args_val.as_slice(), name)
-                .map(CallSiteValue::try_as_basic_value)
-                .map(Either::unwrap_left)
-                .unwrap();
-            Ok(val.into())
-        }),
-    )
-}
-
-/// Creates a unary NumPy [`TopLevelDef`] function using an extern function (e.g. from `libc` or
-/// `libm`).
-///
-/// * `name`: The name of the implemented NumPy function.
-/// * `ret_ty`: The return type of this function.
-/// * `param_ty`: The parameters accepted by this function, represented by a tuple of the
-///   [parameter type][Type] and the parameter symbol name.
-/// * `extern_fn`: The fully-qualified name of the extern function used as the implementation.
-/// * `attrs`: The list of attributes to apply to this function declaration. Note that `nounwind` is
-///   already implied by the C ABI.
-fn create_fn_by_extern(
-    unifier: &mut Unifier,
-    var_map: &VarMap,
-    name: &'static str,
-    ret_ty: Type,
-    params: &[(Type, &'static str)],
-    extern_fn: &'static str,
-    attrs: &'static [&str],
-) -> TopLevelDef {
-    let param_tys = params.iter().map(|p| p.0).collect_vec();
-
-    create_fn_by_codegen(
-        unifier,
-        var_map,
-        name,
-        ret_ty,
-        params,
-        Box::new(move |ctx, _, fun, args, generator| {
-            let args_ty = fun.0.args.iter().map(|a| a.ty).collect_vec();
-
-            assert!(param_tys
-                .iter()
-                .zip(&args_ty)
-                .all(|(expected, actual)| ctx.unifier.unioned(*expected, *actual)));
-
-            let args_val = args_ty
-                .iter()
-                .zip_eq(args.iter())
-                .map(|(ty, arg)| arg.1.clone().to_basic_value_enum(ctx, generator, *ty).unwrap())
-                .map_into::<BasicMetadataValueEnum>()
-                .collect_vec();
-
-            let intrinsic_fn = ctx.module.get_function(extern_fn).unwrap_or_else(|| {
-                let ret_llvm_ty = ctx.get_llvm_abi_type(generator, ret_ty);
-                let param_llvm_ty = param_tys
-                    .iter()
-                    .map(|p| ctx.get_llvm_abi_type(generator, *p))
-                    .map_into::<BasicMetadataTypeEnum>()
-                    .collect_vec();
-                let fn_type = ret_llvm_ty.fn_type(param_llvm_ty.as_slice(), false);
-                let func = ctx.module.add_function(extern_fn, fn_type, None);
-                func.add_attribute(
-                    AttributeLoc::Function,
-                    ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id("nounwind"), 0),
-                );
-
-                for attr in attrs {
-                    func.add_attribute(
-                        AttributeLoc::Function,
-                        ctx.ctx.create_enum_attribute(Attribute::get_named_enum_kind_id(attr), 0),
-                    );
-                }
-
-                func
-            });
-
-            let val = ctx
-                .builder
-                .build_call(intrinsic_fn, &args_val, name)
-                .map(CallSiteValue::try_as_basic_value)
-                .map(Either::unwrap_left)
-                .unwrap();
-            Ok(val.into())
-        }),
-    )
-}
-
 pub fn get_builtins(unifier: &mut Unifier, primitives: &PrimitiveStore) -> BuiltinInfo {
    BuiltinBuilder::new(unifier, primitives)
        .build_all_builtins()
@ -336,7 +199,6 @@ struct BuiltinBuilder<'a> {

    ndarray_float: Type,
    ndarray_float_2d: Type,
-    ndarray_num_ty: Type,

    float_or_ndarray_ty: TypeVar,
    float_or_ndarray_var_map: VarMap,
@ -450,7 +312,6 @@ impl<'a> BuiltinBuilder<'a> {

            ndarray_float,
            ndarray_float_2d,
-            ndarray_num_ty,

            float_or_ndarray_ty,
            float_or_ndarray_var_map,
@ -512,6 +373,14 @@ impl<'a> BuiltinBuilder<'a> {
            | PrimDef::FunNpEye
            | PrimDef::FunNpIdentity => self.build_ndarray_other_factory_function(prim),

+            PrimDef::FunNpSize | PrimDef::FunNpShape | PrimDef::FunNpStrides => {
+                self.build_ndarray_property_getter_function(prim)
+            }
+
+            PrimDef::FunNpBroadcastTo | PrimDef::FunNpTranspose | PrimDef::FunNpReshape => {
+                self.build_ndarray_view_function(prim)
+            }
+
            PrimDef::FunStr => self.build_str_function(),

            PrimDef::FunFloor | PrimDef::FunFloor64 | PrimDef::FunCeil | PrimDef::FunCeil64 => {
@ -540,6 +409,8 @@ impl<'a> BuiltinBuilder<'a> {

            PrimDef::FunNpIsNan | PrimDef::FunNpIsInf => self.build_np_float_to_bool_function(prim),

+            PrimDef::FunNpAny | PrimDef::FunNpAll => self.build_np_any_all_function(prim),
+
            PrimDef::FunNpSin
            | PrimDef::FunNpCos
            | PrimDef::FunNpTan
@ -577,10 +448,6 @@ impl<'a> BuiltinBuilder<'a> {
            | PrimDef::FunNpHypot
            | PrimDef::FunNpNextAfter => self.build_np_2ary_function(prim),

-            PrimDef::FunNpTranspose | PrimDef::FunNpReshape => {
-                self.build_np_sp_ndarray_function(prim)
-            }
-
            PrimDef::FunNpDot
            | PrimDef::FunNpLinalgCholesky
            | PrimDef::FunNpLinalgQr
@ -1386,6 +1253,172 @@ impl<'a> BuiltinBuilder<'a> {
        }
    }

+    fn build_ndarray_property_getter_function(&mut self, prim: PrimDef) -> TopLevelDef {
+        debug_assert_prim_is_allowed(
+            prim,
+            &[PrimDef::FunNpSize, PrimDef::FunNpShape, PrimDef::FunNpStrides],
+        );
+
+        let in_ndarray_ty = self.unifier.get_fresh_var_with_range(
+            &[self.primitives.ndarray],
+            Some("T".into()),
+            None,
+        );
+
+        match prim {
+            PrimDef::FunNpSize => create_fn_by_codegen(
+                self.unifier,
+                &into_var_map([in_ndarray_ty]),
+                prim.name(),
+                self.primitives.int32,
+                &[(in_ndarray_ty.ty, "a")],
+                Box::new(|ctx, obj, fun, args, generator| {
+                    assert!(obj.is_none());
+                    assert_eq!(args.len(), 1);
+
+                    let ndarray_ty = fun.0.args[0].ty;
+                    let ndarray =
+                        args[0].1.clone().to_basic_value_enum(ctx, generator, ndarray_ty)?;
+                    let ndarray = NDArrayType::from_unifier_type(generator, ctx, ndarray_ty)
+                        .map_value(ndarray.into_pointer_value(), None);
+
+                    let size = ctx
+                        .builder
+                        .build_int_truncate_or_bit_cast(ndarray.size(ctx), ctx.ctx.i32_type(), "")
+                        .unwrap();
+                    Ok(Some(size.into()))
+                }),
+            ),
+
+            PrimDef::FunNpShape | PrimDef::FunNpStrides => {
+                // The function signatures of `np_shape` an `np_size` are the same.
+                // Mixed together for convenience.
+
+                // The return type is a tuple of variable length depending on the ndims of the input ndarray.
+                let ret_ty = self.unifier.get_dummy_var().ty; // Handled by special folding
+
+                create_fn_by_codegen(
+                    self.unifier,
+                    &into_var_map([in_ndarray_ty]),
+                    prim.name(),
+                    ret_ty,
+                    &[(in_ndarray_ty.ty, "a")],
+                    Box::new(move |ctx, obj, fun, args, generator| {
+                        assert!(obj.is_none());
+                        assert_eq!(args.len(), 1);
+
+                        let ndarray_ty = fun.0.args[0].ty;
+                        let ndarray =
+                            args[0].1.clone().to_basic_value_enum(ctx, generator, ndarray_ty)?;
+
+                        let ndarray = NDArrayType::from_unifier_type(generator, ctx, ndarray_ty)
+                            .map_value(ndarray.into_pointer_value(), None);
+
+                        let result_tuple = match prim {
+                            PrimDef::FunNpShape => ndarray.make_shape_tuple(generator, ctx),
+                            PrimDef::FunNpStrides => ndarray.make_strides_tuple(generator, ctx),
+                            _ => unreachable!(),
+                        };
+
+                        Ok(Some(result_tuple.as_base_value().into()))
+                    }),
+                )
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    /// Build np/sp functions that take as input `NDArray` only
+    fn build_ndarray_view_function(&mut self, prim: PrimDef) -> TopLevelDef {
+        debug_assert_prim_is_allowed(
+            prim,
+            &[PrimDef::FunNpBroadcastTo, PrimDef::FunNpTranspose, PrimDef::FunNpReshape],
+        );
+
+        let in_ndarray_ty = self.unifier.get_fresh_var_with_range(
+            &[self.primitives.ndarray],
+            Some("T".into()),
+            None,
+        );
+
+        match prim {
+            PrimDef::FunNpTranspose => create_fn_by_codegen(
+                self.unifier,
+                &into_var_map([in_ndarray_ty]),
+                prim.name(),
+                in_ndarray_ty.ty,
+                &[(in_ndarray_ty.ty, "x")],
+                Box::new(move |ctx, _, fun, args, generator| {
+                    let arg_ty = fun.0.args[0].ty;
+                    let arg_val = args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
+
+                    let ndarray = NDArrayType::from_unifier_type(generator, ctx, arg_ty)
+                        .map_value(arg_val.into_pointer_value(), None);
+
+                    let ndarray = ndarray.transpose(generator, ctx, None); // TODO: Add axes argument
+                    Ok(Some(ndarray.as_base_value().into()))
+                }),
+            ),
+
+            // NOTE: on `ndarray_factory_fn_shape_arg_tvar` and
+            // the `param_ty` for `create_fn_by_codegen`.
+            //
+            // Similar to `build_ndarray_from_shape_factory_function` we delegate the responsibility of typechecking
+            // to [`typecheck::type_inferencer::Inferencer::fold_numpy_function_call_shape_argument`],
+            // and use a dummy [`TypeVar`] `ndarray_factory_fn_shape_arg_tvar` as a placeholder for `param_ty`.
+            PrimDef::FunNpBroadcastTo | PrimDef::FunNpReshape => {
+                // These two functions have the same function signature.
+                // Mixed together for convenience.
+
+                let ret_ty = self.unifier.get_dummy_var().ty; // Handled by special holding
+
+                create_fn_by_codegen(
+                    self.unifier,
+                    &VarMap::new(),
+                    prim.name(),
+                    ret_ty,
+                    &[
+                        (in_ndarray_ty.ty, "x"),
+                        (self.ndarray_factory_fn_shape_arg_tvar.ty, "shape"), // Handled by special folding
+                    ],
+                    Box::new(move |ctx, _, fun, args, generator| {
+                        let ndarray_ty = fun.0.args[0].ty;
+                        let ndarray_val =
+                            args[0].1.clone().to_basic_value_enum(ctx, generator, ndarray_ty)?;
+
+                        let shape_ty = fun.0.args[1].ty;
+                        let shape_val =
+                            args[1].1.clone().to_basic_value_enum(ctx, generator, shape_ty)?;
+
+                        let ndarray = NDArrayType::from_unifier_type(generator, ctx, ndarray_ty)
+                            .map_value(ndarray_val.into_pointer_value(), None);
+
+                        let shape = parse_numpy_int_sequence(generator, ctx, (shape_ty, shape_val));
+
+                        // The ndims after reshaping is gotten from the return type of the call.
+                        let (_, ndims) = unpack_ndarray_var_tys(&mut ctx.unifier, fun.0.ret);
+                        let ndims = extract_ndims(&ctx.unifier, ndims);
+
+                        let new_ndarray = match prim {
+                            PrimDef::FunNpBroadcastTo => {
+                                ndarray.broadcast_to(generator, ctx, ndims, &shape)
+                            }
+
+                            PrimDef::FunNpReshape => {
+                                ndarray.reshape_or_copy(generator, ctx, ndims, &shape)
+                            }
+
+                            _ => unreachable!(),
+                        };
+                        Ok(Some(new_ndarray.as_base_value().as_basic_value_enum()))
+                    }),
+                )
+            }
+
+            _ => unreachable!(),
+        }
+    }
+
    /// Build the `str()` function.
    fn build_str_function(&mut self) -> TopLevelDef {
        let prim = PrimDef::FunStr;
@ -1693,6 +1726,64 @@ impl<'a> BuiltinBuilder<'a> {
        )
    }

+    fn build_np_any_all_function(&mut self, prim: PrimDef) -> TopLevelDef {
+        debug_assert_prim_is_allowed(prim, &[PrimDef::FunNpAny, PrimDef::FunNpAll]);
+
+        let param_ty = &[(self.num_or_ndarray_ty.ty, "a")];
+        let ret_ty = self.primitives.bool;
+        let var_map = &self.num_or_ndarray_var_map;
+        let codegen_callback: Box<GenCallCallback> =
+            Box::new(move |ctx, _, fun, args, generator| {
+                let llvm_i1 = ctx.ctx.bool_type();
+                let llvm_i1_k0 = llvm_i1.const_zero();
+                let llvm_i1_k1 = llvm_i1.const_all_ones();
+
+                let a_ty = fun.0.args[0].ty;
+                let a_val = args[0].1.clone().to_basic_value_enum(ctx, generator, a_ty)?;
+                let a = ScalarOrNDArray::from_value(generator, ctx, (a_ty, a_val));
+                let a_elem_ty = arraylike_flatten_element_type(&mut ctx.unifier, a_ty);
+
+                let (init, sc_val) = match prim {
+                    PrimDef::FunNpAny => (llvm_i1_k0, llvm_i1_k1),
+                    PrimDef::FunNpAll => (llvm_i1_k1, llvm_i1_k0),
+                    _ => unreachable!(),
+                };
+
+                let acc = a.fold(generator, ctx, init, |generator, ctx, hooks, acc, elem| {
+                    gen_if_callback(
+                        generator,
+                        ctx,
+                        |_, ctx| {
+                            Ok(ctx
+                                .builder
+                                .build_int_compare(IntPredicate::EQ, acc, sc_val, "")
+                                .unwrap())
+                        },
+                        |_, ctx| {
+                            if let Some(hooks) = hooks {
+                                hooks.build_break_branch(&ctx.builder);
+                            }
+                            Ok(())
+                        },
+                        |_, _| Ok(()),
+                    )?;
+
+                    let is_truthy =
+                        builtin_fns::call_bool(generator, ctx, (a_elem_ty, elem))?.into_int_value();
+
+                    Ok(match prim {
+                        PrimDef::FunNpAny => ctx.builder.build_or(acc, is_truthy, "").unwrap(),
+                        PrimDef::FunNpAll => ctx.builder.build_and(acc, is_truthy, "").unwrap(),
+                        _ => unreachable!(),
+                    })
+                })?;
+
+                Ok(Some(acc.as_basic_value_enum()))
+            });
+
+        create_fn_by_codegen(self.unifier, var_map, prim.name(), ret_ty, param_ty, codegen_callback)
+    }
+
    /// Build 1-ary numpy/scipy functions that take in a float or an ndarray and return a value of the same type as the input.
    fn build_np_sp_float_or_ndarray_1ary_function(&mut self, prim: PrimDef) -> TopLevelDef {
        debug_assert_prim_is_allowed(
@ -1873,57 +1964,6 @@ impl<'a> BuiltinBuilder<'a> {
        }
    }

-    /// Build np/sp functions that take as input `NDArray` only
-    fn build_np_sp_ndarray_function(&mut self, prim: PrimDef) -> TopLevelDef {
-        debug_assert_prim_is_allowed(prim, &[PrimDef::FunNpTranspose, PrimDef::FunNpReshape]);
-
-        match prim {
-            PrimDef::FunNpTranspose => {
-                let ndarray_ty = self.unifier.get_fresh_var_with_range(
-                    &[self.ndarray_num_ty],
-                    Some("T".into()),
-                    None,
-                );
-                create_fn_by_codegen(
-                    self.unifier,
-                    &into_var_map([ndarray_ty]),
-                    prim.name(),
-                    ndarray_ty.ty,
-                    &[(ndarray_ty.ty, "x")],
-                    Box::new(move |ctx, _, fun, args, generator| {
-                        let arg_ty = fun.0.args[0].ty;
-                        let arg_val =
-                            args[0].1.clone().to_basic_value_enum(ctx, generator, arg_ty)?;
-                        Ok(Some(ndarray_transpose(generator, ctx, (arg_ty, arg_val))?))
-                    }),
-                )
-            }
-
-            // NOTE: on `ndarray_factory_fn_shape_arg_tvar` and
-            // the `param_ty` for `create_fn_by_codegen`.
-            //
-            // Similar to `build_ndarray_from_shape_factory_function` we delegate the responsibility of typechecking
-            // to [`typecheck::type_inferencer::Inferencer::fold_numpy_function_call_shape_argument`],
-            // and use a dummy [`TypeVar`] `ndarray_factory_fn_shape_arg_tvar` as a placeholder for `param_ty`.
-            PrimDef::FunNpReshape => create_fn_by_codegen(
-                self.unifier,
-                &VarMap::new(),
-                prim.name(),
-                self.ndarray_num_ty,
-                &[(self.ndarray_num_ty, "x"), (self.ndarray_factory_fn_shape_arg_tvar.ty, "shape")],
-                Box::new(move |ctx, _, fun, args, generator| {
-                    let x1_ty = fun.0.args[0].ty;
-                    let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
-                    let x2_ty = fun.0.args[1].ty;
-                    let x2_val = args[1].1.clone().to_basic_value_enum(ctx, generator, x2_ty)?;
-                    Ok(Some(ndarray_reshape(generator, ctx, (x1_ty, x1_val), (x2_ty, x2_val))?))
-                }),
-            ),
-
-            _ => unreachable!(),
-        }
-    }
-
    /// Build `np_linalg` and `sp_linalg` functions
    ///
    /// The input to these functions must be floating point `NDArray`
@ -1955,10 +1995,12 @@ impl<'a> BuiltinBuilder<'a> {
                Box::new(move |ctx, _, fun, args, generator| {
                    let x1_ty = fun.0.args[0].ty;
                    let x1_val = args[0].1.clone().to_basic_value_enum(ctx, generator, x1_ty)?;
+
                    let x2_ty = fun.0.args[1].ty;
                    let x2_val = args[1].1.clone().to_basic_value_enum(ctx, generator, x2_ty)?;

-                    Ok(Some(ndarray_dot(generator, ctx, (x1_ty, x1_val), (x2_ty, x2_val))?))
+                    let result = ndarray_dot(generator, ctx, (x1_ty, x1_val), (x2_ty, x2_val))?;
+                    Ok(Some(result))
                }),
            ),

--- a/nac3core/src/toplevel/composer.rs
+++ b/nac3core/src/toplevel/composer.rs
@ -101,7 +101,9 @@ impl TopLevelComposer {
        let builtin_name_list = definition_ast_list
            .iter()
            .map(|def_ast| match *def_ast.0.read() {
-                TopLevelDef::Class { name, .. } => name.to_string(),
+                TopLevelDef::Class { name, .. } | TopLevelDef::Module { name, .. } => {
+                    name.to_string()
+                }
                TopLevelDef::Function { simple_name, .. }
                | TopLevelDef::Variable { simple_name, .. } => simple_name.to_string(),
            })
@ -201,6 +203,43 @@ impl TopLevelComposer {
        self.definition_ast_list.iter().map(|(def, ..)| def.clone()).collect_vec()
    }

+    /// register top level modules
+    pub fn register_top_level_module(
+        &mut self,
+        module_name: &str,
+        name_to_pyid: &Rc<HashMap<StrRef, u64>>,
+        resolver: Arc<dyn SymbolResolver + Send + Sync>,
+        location: Option<Location>,
+    ) -> Result<DefinitionId, String> {
+        let mut methods: HashMap<StrRef, DefinitionId> = HashMap::new();
+        let mut attributes: Vec<(StrRef, DefinitionId)> = Vec::new();
+
+        for (name, _) in name_to_pyid.iter() {
+            if let Ok(def_id) = resolver.get_identifier_def(*name) {
+                // Avoid repeated attribute instances resulting from multiple imports of same module
+                if self.defined_names.contains(&format!("{module_name}.{name}")) {
+                    match &*self.definition_ast_list[def_id.0].0.read() {
+                        TopLevelDef::Class { .. } | TopLevelDef::Function { .. } => {
+                            methods.insert(*name, def_id);
+                        }
+                        _ => attributes.push((*name, def_id)),
+                    }
+                }
+            };
+        }
+        let module_def = TopLevelDef::Module {
+            name: module_name.to_string().into(),
+            module_id: DefinitionId(self.definition_ast_list.len()),
+            methods,
+            attributes,
+            resolver: Some(resolver),
+            loc: location,
+        };
+
+        self.definition_ast_list.push((Arc::new(RwLock::new(module_def)), None));
+        Ok(DefinitionId(self.definition_ast_list.len() - 1))
+    }
+
    /// register, just remember the names of top level classes/function
    /// and check duplicate class/method/function definition
    pub fn register_top_level(
@ -469,10 +508,10 @@ impl TopLevelComposer {
        self.analyze_top_level_class_definition()?;
        self.analyze_top_level_class_fields_methods()?;
        self.analyze_top_level_function()?;
+        self.analyze_top_level_variables()?;
        if inference {
            self.analyze_function_instance()?;
        }
-        self.analyze_top_level_variables()?;
        Ok(())
    }

@ -1052,7 +1091,7 @@ impl TopLevelComposer {
                        }
                        let mut result = Vec::new();
                        let no_defaults = args.args.len() - args.defaults.len() - 1;
-                        for (idx, x) in itertools::enumerate(args.args.iter().skip(1)) {
+                        for (idx, x) in args.args.iter().skip(1).enumerate() {
                            let type_ann = {
                                let Some(annotation_expr) = x.node.annotation.as_ref() else {return Err(HashSet::from([format!("type annotation needed for `{}` (at {})", x.node.arg, x.location)]));};
                                parse_ast_to_type_annotation_kinds(
@ -1410,7 +1449,7 @@ impl TopLevelComposer {
        Ok(())
    }

-    /// step 4, analyze and call type inferencer to fill the `instance_to_stmt` of
+    /// step 5, analyze and call type inferencer to fill the `instance_to_stmt` of
    /// [`TopLevelDef::Function`]
    fn analyze_function_instance(&mut self) -> Result<(), HashSet<String>> {
        // first get the class constructor type correct for the following type check in function body
@ -1941,7 +1980,7 @@ impl TopLevelComposer {
        Ok(())
    }

-    /// Step 5. Analyze and populate the types of global variables.
+    /// Step 4. Analyze and populate the types of global variables.
    fn analyze_top_level_variables(&mut self) -> Result<(), HashSet<String>> {
        let def_list = &self.definition_ast_list;
        let temp_def_list = self.extract_def_list();
@ -1959,6 +1998,19 @@ impl TopLevelComposer {
            let resolver = &**resolver.as_ref().unwrap();

            if let Some(ty_decl) = ty_decl {
+                let ty_decl = match &ty_decl.node {
+                    ExprKind::Subscript { value, slice, .. }
+                        if matches!(
+                            &value.node,
+                            ast::ExprKind::Name { id, .. } if self.core_config.kernel_ann.map_or(false, |c| id == &c.into())
+                        ) =>
+                    {
+                        slice
+                    }
+                    _ if self.core_config.kernel_ann.is_none() => ty_decl,
+                    _ => unreachable!("Global variables should be annotated with Kernel[]"), // ignore fields annotated otherwise
+                };
+
                let ty_annotation = parse_ast_to_type_annotation_kinds(
                    resolver,
                    &temp_def_list,
--- a/nac3core/src/toplevel/helper.rs
+++ b/nac3core/src/toplevel/helper.rs
@ -54,6 +54,16 @@ pub enum PrimDef {
    FunNpEye,
    FunNpIdentity,

+    // NumPy ndarray property getters
+    FunNpSize,
+    FunNpShape,
+    FunNpStrides,
+
+    // NumPy ndarray view functions
+    FunNpBroadcastTo,
+    FunNpTranspose,
+    FunNpReshape,
+
    // Miscellaneous NumPy & SciPy functions
    FunNpRound,
    FunNpFloor,
@ -101,8 +111,8 @@ pub enum PrimDef {
    FunNpLdExp,
    FunNpHypot,
    FunNpNextAfter,
-    FunNpTranspose,
-    FunNpReshape,
+    FunNpAny,
+    FunNpAll,

    // Linalg functions
    FunNpDot,
@ -240,6 +250,16 @@ impl PrimDef {
            PrimDef::FunNpEye => fun("np_eye", None),
            PrimDef::FunNpIdentity => fun("np_identity", None),

+            // NumPy NDArray property getters,
+            PrimDef::FunNpSize => fun("np_size", None),
+            PrimDef::FunNpShape => fun("np_shape", None),
+            PrimDef::FunNpStrides => fun("np_strides", None),
+
+            // NumPy NDArray view functions
+            PrimDef::FunNpBroadcastTo => fun("np_broadcast_to", None),
+            PrimDef::FunNpTranspose => fun("np_transpose", None),
+            PrimDef::FunNpReshape => fun("np_reshape", None),
+
            // Miscellaneous NumPy & SciPy functions
            PrimDef::FunNpRound => fun("np_round", None),
            PrimDef::FunNpFloor => fun("np_floor", None),
@ -287,8 +307,8 @@ impl PrimDef {
            PrimDef::FunNpLdExp => fun("np_ldexp", None),
            PrimDef::FunNpHypot => fun("np_hypot", None),
            PrimDef::FunNpNextAfter => fun("np_nextafter", None),
-            PrimDef::FunNpTranspose => fun("np_transpose", None),
-            PrimDef::FunNpReshape => fun("np_reshape", None),
+            PrimDef::FunNpAny => fun("np_any", None),
+            PrimDef::FunNpAll => fun("np_all", None),

            // Linalg functions
            PrimDef::FunNpDot => fun("np_dot", None),
@ -359,21 +379,37 @@ pub fn make_exception_fields(int32: Type, int64: Type, str: Type) -> Vec<(StrRef
 impl TopLevelDef {
    pub fn to_string(&self, unifier: &mut Unifier) -> String {
        match self {
-            TopLevelDef::Class { name, ancestors, fields, methods, type_vars, .. } => {
+            TopLevelDef::Module { name, attributes, methods, .. } => {
+                format!(
+                    "Module {{\nname: {:?},\nattributes: {:?}\nmethods: {:?}\n}}",
+                    name,
+                    attributes.iter().map(|(n, _)| n.to_string()).collect_vec(),
+                    methods.iter().map(|(n, _)| n.to_string()).collect_vec()
+                )
+            }
+            TopLevelDef::Class {
+                name, ancestors, fields, methods, attributes, type_vars, ..
+            } => {
                let fields_str = fields
                    .iter()
                    .map(|(n, ty, _)| (n.to_string(), unifier.stringify(*ty)))
                    .collect_vec();

+                let attributes_str = attributes
+                    .iter()
+                    .map(|(n, ty, _)| (n.to_string(), unifier.stringify(*ty)))
+                    .collect_vec();
+
                let methods_str = methods
                    .iter()
                    .map(|(n, ty, id)| (n.to_string(), unifier.stringify(*ty), *id))
                    .collect_vec();
                format!(
-                    "Class {{\nname: {:?},\nancestors: {:?},\nfields: {:?},\nmethods: {:?},\ntype_vars: {:?}\n}}",
+                    "Class {{\nname: {:?},\nancestors: {:?},\nfields: {:?},\nattributes: {:?},\nmethods: {:?},\ntype_vars: {:?}\n}}",
                    name,
                    ancestors.iter().map(|ancestor| ancestor.stringify(unifier)).collect_vec(),
                    fields_str.iter().map(|(a, _)| a).collect_vec(),
+                    attributes_str.iter().map(|(a, _)| a).collect_vec(),
                    methods_str.iter().map(|(a, b, _)| (a, b)).collect_vec(),
                    type_vars.iter().map(|id| unifier.stringify(*id)).collect_vec(),
                )
--- a/nac3core/src/toplevel/mod.rs
+++ b/nac3core/src/toplevel/mod.rs
@ -92,6 +92,20 @@ pub struct FunInstance {

 #[derive(Debug, Clone)]
 pub enum TopLevelDef {
+    Module {
+        /// Name of the module
+        name: StrRef,
+        /// Module ID used for [`TypeEnum`]
+        module_id: DefinitionId,
+        /// `DefinitionId` of `TopLevelDef::{Class, Function}` within the module
+        methods: HashMap<StrRef, DefinitionId>,
+        /// `DefinitionId` of `TopLevelDef::{Variable}` within the module
+        attributes: Vec<(StrRef, DefinitionId)>,
+        /// Symbol resolver of the module defined the class.
+        resolver: Option<Arc<dyn SymbolResolver + Send + Sync>>,
+        /// Definition location.
+        loc: Option<Location>,
+    },
    Class {
        /// Name for error messages and symbols.
        name: StrRef,
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__generic_class.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__generic_class.snap
@ -3,10 +3,10 @@ source: nac3core/src/toplevel/test.rs
 expression: res_vec
 ---
 [
-    "Class {\nname: \"B\",\nancestors: [\"B\"],\nfields: [\"aa\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"foo\", \"fn[[b:T], none]\")],\ntype_vars: []\n}\n",
+    "Class {\nname: \"B\",\nancestors: [\"B\"],\nfields: [\"aa\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"foo\", \"fn[[b:T], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"B.foo\",\nsig: \"fn[[b:T], none]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"Generic_A\",\nancestors: [\"Generic_A[V]\", \"B\"],\nfields: [\"aa\", \"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"foo\", \"fn[[b:T], none]\"), (\"fun\", \"fn[[a:int32], V]\")],\ntype_vars: [\"V\"]\n}\n",
+    "Class {\nname: \"Generic_A\",\nancestors: [\"Generic_A[V]\", \"B\"],\nfields: [\"aa\", \"a\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"foo\", \"fn[[b:T], none]\"), (\"fun\", \"fn[[a:int32], V]\")],\ntype_vars: [\"V\"]\n}\n",
    "Function {\nname: \"Generic_A.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"Generic_A.fun\",\nsig: \"fn[[a:int32], V]\",\nvar_id: [TypeVarId(246)]\n}\n",
+    "Function {\nname: \"Generic_A.fun\",\nsig: \"fn[[a:int32], V]\",\nvar_id: [TypeVarId(261)]\n}\n",
 ]
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__inheritance_override.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__inheritance_override.snap
@ -3,13 +3,13 @@ source: nac3core/src/toplevel/test.rs
 expression: res_vec
 ---
 [
-    "Class {\nname: \"A\",\nancestors: [\"A[T]\"],\nfields: [\"a\", \"b\", \"c\"],\nmethods: [(\"__init__\", \"fn[[t:T], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: [\"T\"]\n}\n",
+    "Class {\nname: \"A\",\nancestors: [\"A[T]\"],\nfields: [\"a\", \"b\", \"c\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[t:T], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: [\"T\"]\n}\n",
    "Function {\nname: \"A.__init__\",\nsig: \"fn[[t:T], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.foo\",\nsig: \"fn[[c:C], none]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"B\",\nancestors: [\"B[typevar230]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: [\"typevar230\"]\n}\n",
+    "Class {\nname: \"B\",\nancestors: [\"B[typevar245]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: [\"typevar245\"]\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"B.fun\",\nsig: \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"C\",\nancestors: [\"C\", \"B[bool]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\", \"e\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: []\n}\n",
+    "Class {\nname: \"C\",\nancestors: [\"C\", \"B[bool]\", \"A[float]\"],\nfields: [\"a\", \"b\", \"c\", \"d\", \"e\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:int32, b:T], list[virtual[B[bool]]]]\"), (\"foo\", \"fn[[c:C], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"C.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
 ]
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__list_tuple_generic.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__list_tuple_generic.snap
@ -4,10 +4,10 @@ expression: res_vec
 ---
 [
    "Function {\nname: \"foo\",\nsig: \"fn[[a:list[int32], b:tuple[T, float]], A[B, bool]]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"A\",\nancestors: [\"A[T, V]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[v:V], none]\"), (\"fun\", \"fn[[a:T], V]\")],\ntype_vars: [\"T\", \"V\"]\n}\n",
-    "Function {\nname: \"A.__init__\",\nsig: \"fn[[v:V], none]\",\nvar_id: [TypeVarId(243)]\n}\n",
-    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(248)]\n}\n",
+    "Class {\nname: \"A\",\nancestors: [\"A[T, V]\"],\nfields: [\"a\", \"b\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[v:V], none]\"), (\"fun\", \"fn[[a:T], V]\")],\ntype_vars: [\"T\", \"V\"]\n}\n",
+    "Function {\nname: \"A.__init__\",\nsig: \"fn[[v:V], none]\",\nvar_id: [TypeVarId(258)]\n}\n",
+    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(263)]\n}\n",
    "Function {\nname: \"gfun\",\nsig: \"fn[[a:A[list[float], int32]], none]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"B\",\nancestors: [\"B\"],\nfields: [],\nmethods: [(\"__init__\", \"fn[[], none]\")],\ntype_vars: []\n}\n",
+    "Class {\nname: \"B\",\nancestors: [\"B\"],\nfields: [],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
 ]
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__self1.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__self1.snap
@ -3,10 +3,10 @@ source: nac3core/src/toplevel/test.rs
 expression: res_vec
 ---
 [
-    "Class {\nname: \"A\",\nancestors: [\"A[typevar229, typevar230]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[a:A[float, bool], b:B], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\")],\ntype_vars: [\"typevar229\", \"typevar230\"]\n}\n",
+    "Class {\nname: \"A\",\nancestors: [\"A[typevar244, typevar245]\"],\nfields: [\"a\", \"b\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[a:A[float, bool], b:B], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\")],\ntype_vars: [\"typevar244\", \"typevar245\"]\n}\n",
    "Function {\nname: \"A.__init__\",\nsig: \"fn[[a:A[float, bool], b:B], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.fun\",\nsig: \"fn[[a:A[float, bool]], A[bool, int32]]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"B\",\nancestors: [\"B\", \"A[int64, bool]\"],\nfields: [\"a\", \"b\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\"), (\"foo\", \"fn[[b:B], B]\"), (\"bar\", \"fn[[a:A[list[B], int32]], tuple[A[virtual[A[B, int32]], bool], B]]\")],\ntype_vars: []\n}\n",
+    "Class {\nname: \"B\",\nancestors: [\"B\", \"A[int64, bool]\"],\nfields: [\"a\", \"b\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[a:A[float, bool]], A[bool, int32]]\"), (\"foo\", \"fn[[b:B], B]\"), (\"bar\", \"fn[[a:A[list[B], int32]], tuple[A[virtual[A[B, int32]], bool], B]]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"B.foo\",\nsig: \"fn[[b:B], B]\",\nvar_id: []\n}\n",
    "Function {\nname: \"B.bar\",\nsig: \"fn[[a:A[list[B], int32]], tuple[A[virtual[A[B, int32]], bool], B]]\",\nvar_id: []\n}\n",
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__simple_class_compose.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__simple_class_compose.snap
@ -3,15 +3,15 @@ source: nac3core/src/toplevel/test.rs
 expression: res_vec
 ---
 [
-    "Class {\nname: \"A\",\nancestors: [\"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
+    "Class {\nname: \"A\",\nancestors: [\"A\"],\nfields: [\"a\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"A.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"A.fun\",\nsig: \"fn[[b:B], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"A.foo\",\nsig: \"fn[[a:T, b:V], none]\",\nvar_id: [TypeVarId(249)]\n}\n",
-    "Class {\nname: \"C\",\nancestors: [\"C\", \"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
+    "Function {\nname: \"A.foo\",\nsig: \"fn[[a:T, b:V], none]\",\nvar_id: [TypeVarId(264)]\n}\n",
+    "Class {\nname: \"C\",\nancestors: [\"C\", \"A\"],\nfields: [\"a\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"C.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"C.fun\",\nsig: \"fn[[b:B], none]\",\nvar_id: []\n}\n",
-    "Class {\nname: \"B\",\nancestors: [\"B\", \"C\", \"A\"],\nfields: [\"a\"],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
+    "Class {\nname: \"B\",\nancestors: [\"B\", \"C\", \"A\"],\nfields: [\"a\"],\nattributes: [],\nmethods: [(\"__init__\", \"fn[[], none]\"), (\"fun\", \"fn[[b:B], none]\"), (\"foo\", \"fn[[a:T, b:V], none]\")],\ntype_vars: []\n}\n",
    "Function {\nname: \"B.__init__\",\nsig: \"fn[[], none]\",\nvar_id: []\n}\n",
    "Function {\nname: \"foo\",\nsig: \"fn[[a:A], none]\",\nvar_id: []\n}\n",
-    "Function {\nname: \"ff\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(257)]\n}\n",
+    "Function {\nname: \"ff\",\nsig: \"fn[[a:T], V]\",\nvar_id: [TypeVarId(272)]\n}\n",
 ]
--- a/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__simple_pass_in_class.snap
+++ b/nac3core/src/toplevel/snapshots/nac3coretopleveltest__test_analyze__simple_pass_in_class.snap
@ -1,9 +1,7 @@
 ---
 source: nac3core/src/toplevel/test.rs
-assertion_line: 549
 expression: res_vec
-
 ---
 [
-    "Class {\nname: \"A\",\nancestors: [\"A\"],\nfields: [],\nmethods: [],\ntype_vars: []\n}\n",
+    "Class {\nname: \"A\",\nancestors: [\"A\"],\nfields: [],\nattributes: [],\nmethods: [],\ntype_vars: []\n}\n",
 ]
--- a/nac3core/src/toplevel/test.rs
+++ b/nac3core/src/toplevel/test.rs
@ -15,14 +15,13 @@ use crate::{
    symbol_resolver::{SymbolResolver, ValueEnum},
    typecheck::{
        type_inferencer::PrimitiveStore,
-        typedef::{into_var_map, Type, Unifier},
+        typedef::{Type, Unifier},
    },
 };

 struct ResolverInternal {
    id_to_type: Mutex<HashMap<StrRef, Type>>,
    id_to_def: Mutex<HashMap<StrRef, DefinitionId>>,
-    class_names: Mutex<HashMap<StrRef, Type>>,
 }

 impl ResolverInternal {
@ -179,11 +178,8 @@ fn test_simple_function_analyze(source: &[&str], tys: &[&str], names: &[&str]) {
    let mut composer =
        TopLevelComposer::new(Vec::new(), Vec::new(), ComposerConfig::default(), 64).0;

-    let internal_resolver = Arc::new(ResolverInternal {
-        id_to_def: Mutex::default(),
-        id_to_type: Mutex::default(),
-        class_names: Mutex::default(),
-    });
+    let internal_resolver =
+        Arc::new(ResolverInternal { id_to_def: Mutex::default(), id_to_type: Mutex::default() });
    let resolver =
        Arc::new(Resolver(internal_resolver.clone())) as Arc<dyn SymbolResolver + Send + Sync>;

@ -784,13 +780,6 @@ fn make_internal_resolver_with_tvar(
    unifier: &mut Unifier,
    print: bool,
 ) -> Arc<ResolverInternal> {
-    let list_elem_tvar = unifier.get_fresh_var(Some("list_elem".into()), None);
-    let list = unifier.add_ty(TypeEnum::TObj {
-        obj_id: PrimDef::List.id(),
-        fields: HashMap::new(),
-        params: into_var_map([list_elem_tvar]),
-    });
-
    let res: Arc<ResolverInternal> = ResolverInternal {
        id_to_def: Mutex::new(HashMap::from([("list".into(), PrimDef::List.id())])),
        id_to_type: tvars
@ -806,7 +795,6 @@ fn make_internal_resolver_with_tvar(
            })
            .collect::<HashMap<_, _>>()
            .into(),
-        class_names: Mutex::new(HashMap::from([("list".into(), list)])),
    }
    .into();
    if print {
@ -819,7 +807,7 @@ struct TypeToStringFolder<'a> {
    unifier: &'a mut Unifier,
 }

-impl<'a> Fold<Option<Type>> for TypeToStringFolder<'a> {
+impl Fold<Option<Type>> for TypeToStringFolder<'_> {
    type TargetU = String;
    type Error = String;
    fn map_user(&mut self, user: Option<Type>) -> Result<Self::TargetU, Self::Error> {
--- a/nac3core/src/typecheck/function_check.rs
+++ b/nac3core/src/typecheck/function_check.rs
@ -15,7 +15,7 @@ use super::{
 };
 use crate::toplevel::helper::PrimDef;

-impl<'a> Inferencer<'a> {
+impl Inferencer<'_> {
    fn should_have_value(&mut self, expr: &Expr<Option<Type>>) -> Result<(), HashSet<String>> {
        if matches!(expr.custom, Some(ty) if self.unifier.unioned(ty, self.primitives.none)) {
            Err(HashSet::from([format!("Error at {}: cannot have value none", expr.location)]))
@ -94,7 +94,7 @@ impl<'a> Inferencer<'a> {
        // there are some cases where the custom field is None
        if let Some(ty) = &expr.custom {
            if !matches!(&expr.node, ExprKind::Constant { value: Constant::Ellipsis, .. })
-                && !ty.obj_id(self.unifier).is_some_and(|id| id == PrimDef::List.id())
+                && ty.obj_id(self.unifier).is_none_or(|id| id != PrimDef::List.id())
                && !self.unifier.is_concrete(*ty, &self.function_data.bound_variables)
            {
                return Err(HashSet::from([format!(
--- a/nac3core/src/typecheck/magic_methods.rs
+++ b/nac3core/src/typecheck/magic_methods.rs
@ -7,12 +7,12 @@ use nac3parser::ast::{Cmpop, Operator, StrRef, Unaryop};

 use super::{
    type_inferencer::*,
-    typedef::{FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
+    typedef::{into_var_map, FunSignature, FuncArg, Type, TypeEnum, Unifier, VarMap},
 };
 use crate::{
    symbol_resolver::SymbolValue,
    toplevel::{
-        helper::PrimDef,
+        helper::{extract_ndims, PrimDef},
        numpy::{make_ndarray_ty, unpack_ndarray_var_tys},
    },
 };
@ -175,19 +175,8 @@ pub fn impl_binop(
    ops: &[Operator],
 ) {
    with_fields(unifier, ty, |unifier, fields| {
-        let (other_ty, other_var_id) = if other_ty.len() == 1 {
-            (other_ty[0], None)
-        } else {
-            let tvar = unifier.get_fresh_var_with_range(other_ty, Some("N".into()), None);
-            (tvar.ty, Some(tvar.id))
-        };
-
-        let function_vars = if let Some(var_id) = other_var_id {
-            vec![(var_id, other_ty)].into_iter().collect::<VarMap>()
-        } else {
-            VarMap::new()
-        };
-
+        let other_tvar = unifier.get_fresh_var_with_range(other_ty, Some("N".into()), None);
+        let function_vars = into_var_map([other_tvar]);
        let ret_ty = ret_ty.unwrap_or_else(|| unifier.get_fresh_var(None, None).ty);

        for (base_op, variant) in iproduct!(ops, [BinopVariant::Normal, BinopVariant::AugAssign]) {
@ -198,7 +187,7 @@ pub fn impl_binop(
                        ret: ret_ty,
                        vars: function_vars.clone(),
                        args: vec![FuncArg {
-                            ty: other_ty,
+                            ty: other_tvar.ty,
                            default_value: None,
                            name: "other".into(),
                            is_vararg: false,
@ -541,36 +530,43 @@ pub fn typeof_binop(
                }
            }

-            let (_, lhs_ndims) = unpack_ndarray_var_tys(unifier, lhs);
-            let lhs_ndims = match &*unifier.get_ty_immutable(lhs_ndims) {
-                TypeEnum::TLiteral { values, .. } => {
-                    assert_eq!(values.len(), 1);
-                    u64::try_from(values[0].clone()).unwrap()
+            let (lhs_dtype, lhs_ndims) = unpack_ndarray_var_tys(unifier, lhs);
+            let lhs_ndims = extract_ndims(unifier, lhs_ndims);
+
+            let (rhs_dtype, rhs_ndims) = unpack_ndarray_var_tys(unifier, rhs);
+            let rhs_ndims = extract_ndims(unifier, rhs_ndims);
+
+            if !(unifier.unioned(lhs_dtype, primitives.float)
+                && unifier.unioned(rhs_dtype, primitives.float))
+            {
+                return Err(format!(
+                    "ndarray.__matmul__ only supports float64 operations, but LHS has type {} and RHS has type {}",
+                    unifier.stringify(lhs),
+                    unifier.stringify(rhs)
+                ));
+            }
+
+            // Deduce the ndims of the resulting ndarray.
+            // If this is 0 (an unsized ndarray), matmul returns a scalar just like NumPy.
+            let result_ndims = match (lhs_ndims, rhs_ndims) {
+                (0, _) | (_, 0) => {
+                    return Err(
+                        "ndarray.__matmul__ does not allow unsized ndarray input".to_string()
+                    )
                }
-                _ => unreachable!(),
-            };
-            let (_, rhs_ndims) = unpack_ndarray_var_tys(unifier, rhs);
-            let rhs_ndims = match &*unifier.get_ty_immutable(rhs_ndims) {
-                TypeEnum::TLiteral { values, .. } => {
-                    assert_eq!(values.len(), 1);
-                    u64::try_from(values[0].clone()).unwrap()
-                }
-                _ => unreachable!(),
+                (1, 1) => 0,
+                (1, _) => rhs_ndims - 1,
+                (_, 1) => lhs_ndims - 1,
+                (m, n) => max(m, n),
            };

-            match (lhs_ndims, rhs_ndims) {
-                (2, 2) => typeof_ndarray_broadcast(unifier, primitives, lhs, rhs)?,
-                (lhs, rhs) if lhs == 0 || rhs == 0 => {
-                    return Err(format!(
-                    "Input operand {} does not have enough dimensions (has {lhs}, requires {rhs})",
-                    u8::from(rhs == 0)
-                ))
-                }
-                (lhs, rhs) => {
-                    return Err(format!(
-                        "ndarray.__matmul__ on {lhs}D and {rhs}D operands not supported"
-                    ))
-                }
+            if result_ndims == 0 {
+                // If the result is unsized, NumPy returns a scalar.
+                primitives.float
+            } else {
+                let result_ndims_ty =
+                    unifier.get_fresh_literal(vec![SymbolValue::U64(result_ndims)], None);
+                make_ndarray_ty(unifier, primitives, Some(primitives.float), Some(result_ndims_ty))
            }
        }

@ -773,7 +769,7 @@ pub fn set_primitives_magic_methods(store: &PrimitiveStore, unifier: &mut Unifie
    impl_div(unifier, store, ndarray_t, &[ndarray_t, ndarray_dtype_t], None);
    impl_floordiv(unifier, store, ndarray_t, &[ndarray_unsized_t, ndarray_unsized_dtype_t], None);
    impl_mod(unifier, store, ndarray_t, &[ndarray_unsized_t, ndarray_unsized_dtype_t], None);
-    impl_matmul(unifier, store, ndarray_t, &[ndarray_t], Some(ndarray_t));
+    impl_matmul(unifier, store, ndarray_t, &[ndarray_unsized_t], None);
    impl_sign(unifier, store, ndarray_t, Some(ndarray_t));
    impl_invert(unifier, store, ndarray_t, Some(ndarray_t));
    impl_eq(unifier, store, ndarray_t, &[ndarray_unsized_t, ndarray_unsized_dtype_t], None);
--- a/nac3core/src/typecheck/type_error.rs
+++ b/nac3core/src/typecheck/type_error.rs
@ -94,7 +94,7 @@ fn loc_to_str(loc: Option<Location>) -> String {
    }
 }

-impl<'a> Display for DisplayTypeError<'a> {
+impl Display for DisplayTypeError<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        use TypeErrorKind::*;
        let mut notes = Some(HashMap::new());
--- a/nac3core/src/typecheck/type_inferencer/mod.rs
+++ b/nac3core/src/typecheck/type_inferencer/mod.rs
@ -3,7 +3,7 @@ use std::{
    cmp::max,
    collections::{HashMap, HashSet},
    convert::{From, TryInto},
-    iter::once,
+    iter::{once, repeat_n},
    sync::Arc,
 };

@ -187,7 +187,7 @@ fn fix_assignment_target_context(node: &mut ast::Located<ExprKind>) {
    }
 }

-impl<'a> Fold<()> for Inferencer<'a> {
+impl Fold<()> for Inferencer<'_> {
    type TargetU = Option<Type>;
    type Error = InferenceError;

@ -657,7 +657,7 @@ impl<'a> Fold<()> for Inferencer<'a> {

 type InferenceResult = Result<Type, InferenceError>;

-impl<'a> Inferencer<'a> {
+impl Inferencer<'_> {
    /// Constrain a <: b
    /// Currently implemented as unification
    fn constrain(&mut self, a: Type, b: Type, location: &Location) -> Result<(), InferenceError> {
@ -1234,6 +1234,45 @@ impl<'a> Inferencer<'a> {
            }));
        }

+        if ["np_shape".into(), "np_strides".into()].contains(id) && args.len() == 1 {
+            let ndarray = self.fold_expr(args.remove(0))?;
+
+            let ndims = arraylike_get_ndims(self.unifier, ndarray.custom.unwrap());
+
+            // Make a tuple of size `ndims` full of int32 (TODO: Make it usize)
+            let ret_ty = TypeEnum::TTuple {
+                ty: repeat_n(self.primitives.int32, ndims as usize).collect_vec(),
+                is_vararg_ctx: false,
+            };
+            let ret_ty = self.unifier.add_ty(ret_ty);
+
+            let func_ty = TypeEnum::TFunc(FunSignature {
+                args: vec![FuncArg {
+                    name: "a".into(),
+                    default_value: None,
+                    ty: ndarray.custom.unwrap(),
+                    is_vararg: false,
+                }],
+                ret: ret_ty,
+                vars: VarMap::new(),
+            });
+            let func_ty = self.unifier.add_ty(func_ty);
+
+            return Ok(Some(Located {
+                location,
+                custom: Some(ret_ty),
+                node: ExprKind::Call {
+                    func: Box::new(Located {
+                        custom: Some(func_ty),
+                        location: func.location,
+                        node: ExprKind::Name { id: *id, ctx: *ctx },
+                    }),
+                    args: vec![ndarray],
+                    keywords: vec![],
+                },
+            }));
+        }
+
        if id == &"np_dot".into() {
            let arg0 = self.fold_expr(args.remove(0))?;
            let arg1 = self.fold_expr(args.remove(0))?;
@ -1555,7 +1594,7 @@ impl<'a> Inferencer<'a> {
            }));
        }
        // 2-argument ndarray n-dimensional factory functions
-        if id == &"np_reshape".into() && args.len() == 2 {
+        if ["np_reshape".into(), "np_broadcast_to".into()].contains(id) && args.len() == 2 {
            let arg0 = self.fold_expr(args.remove(0))?;

            let shape_expr = args.remove(0);
@ -1969,72 +2008,90 @@ impl<'a> Inferencer<'a> {
        ctx: ExprContext,
    ) -> InferenceResult {
        let ty = value.custom.unwrap();
-        if let TypeEnum::TObj { obj_id, fields, .. } = &*self.unifier.get_ty(ty) {
-            // just a fast path
-            match (fields.get(&attr), ctx == ExprContext::Store) {
-                (Some((ty, true)), _) | (Some((ty, false)), false) => Ok(*ty),
-                (Some((ty, false)), true) => report_type_error(
-                    TypeErrorKind::MutationError(RecordKey::Str(attr), *ty),
-                    Some(value.location),
-                    self.unifier,
-                ),
-                (None, mutable) => {
-                    // Check whether it is a class attribute
-                    let defs = self.top_level.definitions.read();
-                    let result = {
-                        if let TopLevelDef::Class { attributes, .. } = &*defs[obj_id.0].read() {
-                            attributes.iter().find_map(|f| {
-                                if f.0 == attr {
-                                    return Some(f.1);
-                                }
-                                None
-                            })
-                        } else {
-                            None
-                        }
-                    };
-                    match result {
-                        Some(res) if !mutable => Ok(res),
-                        Some(_) => report_error(
-                            &format!("Class Attribute `{attr}` is immutable"),
-                            value.location,
-                        ),
-                        None => report_type_error(
-                            TypeErrorKind::NoSuchField(RecordKey::Str(attr), ty),
-                            Some(value.location),
-                            self.unifier,
-                        ),
-                    }
-                }
-            }
-        } else if let TypeEnum::TFunc(sign) = &*self.unifier.get_ty(ty) {
-            // Access Class Attributes of classes with __init__ function using Class names e.g. Foo.ATTR1
-            let result = {
-                self.top_level.definitions.read().iter().find_map(|def| {
-                    if let Some(rear_guard) = def.try_read() {
-                        if let TopLevelDef::Class { name, attributes, .. } = &*rear_guard {
-                            if name.to_string() == self.unifier.stringify(sign.ret) {
-                                return attributes.iter().find_map(|f| {
+        match &*self.unifier.get_ty(ty) {
+            TypeEnum::TObj { obj_id, fields, .. } => {
+                // just a fast path
+                match (fields.get(&attr), ctx == ExprContext::Store) {
+                    (Some((ty, true)), _) | (Some((ty, false)), false) => Ok(*ty),
+                    (Some((ty, false)), true) => report_type_error(
+                        TypeErrorKind::MutationError(RecordKey::Str(attr), *ty),
+                        Some(value.location),
+                        self.unifier,
+                    ),
+                    (None, mutable) => {
+                        // Check whether it is a class attribute
+                        let defs = self.top_level.definitions.read();
+                        let result = {
+                            if let TopLevelDef::Class { attributes, .. } = &*defs[obj_id.0].read() {
+                                attributes.iter().find_map(|f| {
                                    if f.0 == attr {
-                                        return Some(f.clone().1);
+                                        return Some(f.1);
                                    }
                                    None
-                                });
+                                })
+                            } else {
+                                None
                            }
+                        };
+                        match result {
+                            Some(res) if !mutable => Ok(res),
+                            Some(_) => report_error(
+                                &format!("Class Attribute `{attr}` is immutable"),
+                                value.location,
+                            ),
+                            None => report_type_error(
+                                TypeErrorKind::NoSuchField(RecordKey::Str(attr), ty),
+                                Some(value.location),
+                                self.unifier,
+                            ),
                        }
                    }
-                    None
-                })
-            };
-            match result {
-                Some(f) if ctx != ExprContext::Store => Ok(f),
-                Some(_) => {
-                    report_error(&format!("Class Attribute `{attr}` is immutable"), value.location)
                }
-                None => self.infer_general_attribute(value, attr, ctx),
            }
-        } else {
-            self.infer_general_attribute(value, attr, ctx)
+            TypeEnum::TFunc(sign) => {
+                // Access Class Attributes of classes with __init__ function using Class names e.g. Foo.ATTR1
+                let result = {
+                    self.top_level.definitions.read().iter().find_map(|def| {
+                        if let Some(rear_guard) = def.try_read() {
+                            if let TopLevelDef::Class { name, attributes, .. } = &*rear_guard {
+                                if name.to_string() == self.unifier.stringify(sign.ret) {
+                                    return attributes.iter().find_map(|f| {
+                                        if f.0 == attr {
+                                            return Some(f.clone().1);
+                                        }
+                                        None
+                                    });
+                                }
+                            }
+                        }
+                        None
+                    })
+                };
+                match result {
+                    Some(f) if ctx != ExprContext::Store => Ok(f),
+                    Some(_) => report_error(
+                        &format!("Class Attribute `{attr}` is immutable"),
+                        value.location,
+                    ),
+                    None => self.infer_general_attribute(value, attr, ctx),
+                }
+            }
+            TypeEnum::TModule { attributes, .. } => {
+                match (attributes.get(&attr), ctx == ExprContext::Load) {
+                    (Some((ty, _)), true) | (Some((ty, false)), false) => Ok(*ty),
+                    (Some((ty, true)), false) => report_type_error(
+                        TypeErrorKind::MutationError(RecordKey::Str(attr), *ty),
+                        Some(value.location),
+                        self.unifier,
+                    ),
+                    (None, _) => report_type_error(
+                        TypeErrorKind::NoSuchField(RecordKey::Str(attr), ty),
+                        Some(value.location),
+                        self.unifier,
+                    ),
+                }
+            }
+            _ => self.infer_general_attribute(value, attr, ctx),
        }
    }

@ -2695,7 +2752,7 @@ impl<'a> Inferencer<'a> {
            .read()
            .iter()
            .map(|def| match *def.read() {
-                TopLevelDef::Class { name, .. } => (name, false),
+                TopLevelDef::Class { name, .. } | TopLevelDef::Module { name, .. } => (name, false),
                TopLevelDef::Function { simple_name, .. } => (simple_name, false),
                TopLevelDef::Variable { simple_name, .. } => (simple_name, true),
            })
--- a/nac3core/src/typecheck/type_inferencer/test.rs
+++ b/nac3core/src/typecheck/type_inferencer/test.rs
@ -18,7 +18,6 @@ use crate::{
 struct Resolver {
    id_to_type: HashMap<StrRef, Type>,
    id_to_def: HashMap<StrRef, DefinitionId>,
-    class_names: HashMap<StrRef, Type>,
 }

 impl SymbolResolver for Resolver {
@ -198,7 +197,6 @@ impl TestEnvironment {
        let resolver = Arc::new(Resolver {
            id_to_type: identifier_mapping.clone(),
            id_to_def: HashMap::default(),
-            class_names: HashMap::default(),
        }) as Arc<dyn SymbolResolver + Send + Sync>;

        TestEnvironment {
@ -454,7 +452,6 @@ impl TestEnvironment {
                vars: IndexMap::default(),
            })),
        );
-        let class_names: HashMap<_, _> = [("Bar".into(), bar), ("Bar2".into(), bar2)].into();

        let id_to_name = [
            "int32".into(),
@ -492,7 +489,6 @@ impl TestEnvironment {
                ("Bar2".into(), DefinitionId(defs + 3)),
            ]
            .into(),
-            class_names,
        }) as Arc<dyn SymbolResolver + Send + Sync>;

        TestEnvironment {
--- a/nac3core/src/typecheck/typedef/mod.rs
+++ b/nac3core/src/typecheck/typedef/mod.rs
@ -3,13 +3,13 @@ use std::{
    cell::RefCell,
    collections::{HashMap, HashSet},
    fmt::{self, Display},
-    iter::{repeat, zip},
+    iter::{repeat, repeat_n, zip},
    rc::Rc,
    sync::{Arc, Mutex},
 };

 use indexmap::IndexMap;
-use itertools::{repeat_n, Itertools};
+use itertools::Itertools;

 use nac3parser::ast::{Cmpop, Location, StrRef, Unaryop};

@ -270,6 +270,19 @@ pub enum TypeEnum {

    /// A function type.
    TFunc(FunSignature),
+
+    /// Module Type
+    TModule {
+        /// The [`DefinitionId`] of this object type.
+        module_id: DefinitionId,
+
+        /// The attributes present in this object type.
+        ///
+        /// The key of the [Mapping] is the identifier of the field, while the value is a tuple
+        /// containing the [Type] of the field, and a `bool` indicating whether the field is a
+        /// variable (as opposed to a function).
+        attributes: Mapping<StrRef, (Type, bool)>,
+    },
 }

 impl TypeEnum {
@ -284,6 +297,7 @@ impl TypeEnum {
            TypeEnum::TVirtual { .. } => "TVirtual",
            TypeEnum::TCall { .. } => "TCall",
            TypeEnum::TFunc { .. } => "TFunc",
+            TypeEnum::TModule { .. } => "TModule",
        }
    }
 }
@ -593,7 +607,8 @@ impl Unifier {
            | TLiteral { .. }
            // functions are instantiated for each call sites, so the function type can contain
            // type variables.
-            | TFunc { .. } => true,
+            | TFunc { .. }
+            | TModule { .. } => true,

            TVar { .. } => allowed_typevars.iter().any(|b| self.unification_table.unioned(a, *b)),
            TCall { .. } => false,
@ -1315,10 +1330,12 @@ impl Unifier {
                    || format!("{id}"),
                    |top_level| {
                        let top_level_def = &top_level.definitions.read()[id];
-                        let TopLevelDef::Class { name, .. } = &*top_level_def.read() else {
-                            unreachable!("expected class definition")
+                        let top_level_def = top_level_def.read();
+                        let (TopLevelDef::Class { name, .. } | TopLevelDef::Module { name, .. }) =
+                            &*top_level_def
+                        else {
+                            unreachable!("expected module/class definition")
                        };
-
                        name.to_string()
                    },
                )
@ -1446,6 +1463,10 @@ impl Unifier {
                let ret = self.internal_stringify(signature.ret, obj_to_name, var_to_name, notes);
                format!("fn[[{params}], {ret}]")
            }
+            TypeEnum::TModule { module_id, .. } => {
+                let name = obj_to_name(module_id.0);
+                name.to_string()
+            }
        }
    }

@ -1521,7 +1542,9 @@ impl Unifier {
        // variables, i.e. things like TRecord, TCall should not occur, and we
        // should be safe to not implement the substitution for those variants.
        match &*ty {
-            TypeEnum::TRigidVar { .. } | TypeEnum::TLiteral { .. } => None,
+            TypeEnum::TRigidVar { .. } | TypeEnum::TLiteral { .. } | TypeEnum::TModule { .. } => {
+                None
+            }
            TypeEnum::TVar { id, .. } => mapping.get(id).copied(),
            TypeEnum::TTuple { ty, is_vararg_ctx } => {
                let mut new_ty = Cow::from(ty);
--- a/nac3ld/src/dwarf.rs
+++ b/nac3ld/src/dwarf.rs
@ -30,7 +30,7 @@ pub struct DwarfReader<'a> {
    pub virt_addr: u32,
 }

-impl<'a> DwarfReader<'a> {
+impl DwarfReader<'_> {
    pub fn new(slice: &[u8], virt_addr: u32) -> DwarfReader {
        DwarfReader { slice, virt_addr }
    }
@ -113,7 +113,7 @@ pub struct DwarfWriter<'a> {
    pub offset: usize,
 }

-impl<'a> DwarfWriter<'a> {
+impl DwarfWriter<'_> {
    pub fn new(slice: &mut [u8]) -> DwarfWriter {
        DwarfWriter { slice, offset: 0 }
    }
@ -375,7 +375,7 @@ pub struct FDE_Records<'a> {
    available: usize,
 }

-impl<'a> Iterator for FDE_Records<'a> {
+impl Iterator for FDE_Records<'_> {
    type Item = (u32, u32);

    fn next(&mut self) -> Option<Self::Item> {
@ -423,7 +423,7 @@ pub struct EH_Frame_Hdr<'a> {
    fdes: Vec<(u32, u32)>,
 }

-impl<'a> EH_Frame_Hdr<'a> {
+impl EH_Frame_Hdr<'_> {
    /// Create a [EH_Frame_Hdr] object, and write out the fixed fields of `.eh_frame_hdr` to memory.
    ///
    /// Load address is not known at this point.
--- a/nac3ld/src/lib.rs
+++ b/nac3ld/src/lib.rs
@ -159,7 +159,7 @@ struct SymbolTableReader<'a> {
    strtab: &'a [u8],
 }

-impl<'a> SymbolTableReader<'a> {
+impl SymbolTableReader<'_> {
    pub fn find_index_by_name(&self, sym_name: &[u8]) -> Option<usize> {
        self.symtab.iter().position(|sym| {
            if let Ok(dynsym_name) = name_starting_at_slice(self.strtab, sym.st_name as usize) {
--- a/nac3standalone/demo/interpret_demo.py
+++ b/nac3standalone/demo/interpret_demo.py
@ -67,7 +67,7 @@ def _bool(x):

 def _float(x):
    if isinstance(x, np.ndarray):
-        return np.float_(x)
+        return np.float64(x)
    else:
        return float(x)

@ -111,6 +111,9 @@ def patch(module):
    def output_strln(x):
        print(x, end='')

+    def output_int32_list(x):
+        print([int(e) for e in x])
+
    def dbg_stack_address(_):
        return 0

@ -126,11 +129,12 @@ def patch(module):
            return output_float
        elif name == "output_str":
            return output_strln
+        elif name == "output_int32_list":
+            return output_int32_list
        elif name in {
            "output_bool",
            "output_int32",
            "output_int64",
-            "output_int32_list",
            "output_uint32",
            "output_uint64",
            "output_strln",
@ -179,6 +183,16 @@ def patch(module):
    module.np_identity = np.identity
    module.np_array = np.array

+    # NumPy NDArray view functions
+    module.np_broadcast_to = np.broadcast_to
+    module.np_transpose = np.transpose
+    module.np_reshape = np.reshape
+
+    # NumPy NDArray property getters
+    module.np_size = np.size
+    module.np_shape = np.shape
+    module.np_strides = lambda ndarray: ndarray.strides
+
    # NumPy Math functions
    module.np_isnan = np.isnan
    module.np_isinf = np.isinf
@ -218,8 +232,8 @@ def patch(module):
    module.np_ldexp = np.ldexp
    module.np_hypot = np.hypot
    module.np_nextafter = np.nextafter
-    module.np_transpose = np.transpose
-    module.np_reshape = np.reshape
+    module.np_any = np.any
+    module.np_all = np.all

    # SciPy Math functions
    module.sp_spec_erf = special.erf
--- a/nac3standalone/demo/src/class_attributes.py
+++ b/nac3standalone/demo/src/class_attributes.py
@ -0,0 +1,35 @@
+@extern
+def output_int32(x: int32):
+    ...
+
+@extern
+def output_strln(x: str):
+    ...
+
+
+class A:
+    a: int32 = 1
+    b: int32
+    c: str = "test"
+    d: str
+
+    def __init__(self):
+        self.b = 2
+        self.d = "test"
+
+        output_int32(self.a)  # Attributes can be accessed within class        
+
+
+def run() -> int32:
+    output_int32(A.a)  # Attributes can be directly accessed with class name
+    # A.b # Only attributes can be accessed in this way
+    # A.a = 2  # Attributes are immutable
+
+    obj = A()
+    output_int32(obj.a)  # Attributes can be accessed by class objects
+
+    output_strln(obj.c)
+    output_strln(obj.d)
+
+    return 0
+
--- a/nac3standalone/demo/src/ndarray.py
+++ b/nac3standalone/demo/src/ndarray.py
@ -68,6 +68,19 @@ def output_ndarray_float_2(n: ndarray[float, Literal[2]]):
        for c in range(len(n[r])):
            output_float64(n[r][c])

+def output_ndarray_float_3(n: ndarray[float, Literal[3]]):
+    for d in range(len(n)):
+        for r in range(len(n[d])):
+            for c in range(len(n[d][r])):
+                output_float64(n[d][r][c])
+
+def output_ndarray_float_4(n: ndarray[float, Literal[4]]):
+    for x in range(len(n)):
+        for y in range(len(n[x])):
+            for z in range(len(n[x][y])):
+                for w in range(len(n[x][y][z])):
+                    output_float64(n[x][y][z][w])
+
 def consume_ndarray_1(n: ndarray[float, Literal[1]]):
    pass

@ -197,6 +210,104 @@ def test_ndarray_nd_idx():
    output_float64(x[1, 0])
    output_float64(x[1, 1])

+def test_ndarray_transpose():
+    x: ndarray[float, 2] = np_array([[1., 2., 3.], [4., 5., 6.]])
+    y = np_transpose(x)
+    z = np_transpose(y)
+
+    output_int32(np_shape(x)[0])
+    output_int32(np_shape(x)[1])
+    output_ndarray_float_2(x)
+
+    output_int32(np_shape(y)[0])
+    output_int32(np_shape(y)[1])
+    output_ndarray_float_2(y)
+
+    output_int32(np_shape(z)[0])
+    output_int32(np_shape(z)[1])
+    output_ndarray_float_2(z)
+
+def test_ndarray_reshape():
+    w: ndarray[float, 1] = np_array([1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
+    x = np_reshape(w, (1, 2, 1, -1))
+    y = np_reshape(x, [2, -1])
+    z = np_reshape(y, 10)
+
+    output_int32(np_shape(w)[0])
+    output_ndarray_float_1(w)
+
+    output_int32(np_shape(x)[0])
+    output_int32(np_shape(x)[1])
+    output_int32(np_shape(x)[2])
+    output_int32(np_shape(x)[3])
+    output_ndarray_float_4(x)
+
+    output_int32(np_shape(y)[0])
+    output_int32(np_shape(y)[1])
+    output_ndarray_float_2(y)
+
+    output_int32(np_shape(z)[0])
+    output_ndarray_float_1(z)
+
+    x1: ndarray[int32, 1] = np_array([1, 2, 3, 4])
+    x2: ndarray[int32, 2] = np_reshape(x1, (2, 2))
+
+    output_int32(np_shape(x1)[0])
+    output_ndarray_int32_1(x1)
+
+    output_int32(np_shape(x2)[0])
+    output_int32(np_shape(x2)[1])
+    output_ndarray_int32_2(x2)
+
+def test_ndarray_broadcast_to():
+    xs = np_array([1.0, 2.0, 3.0])
+    ys = np_broadcast_to(xs, (1, 3))
+    zs = np_broadcast_to(ys, (2, 4, 3))
+
+    output_int32(np_shape(xs)[0])
+    output_ndarray_float_1(xs)
+
+    output_int32(np_shape(ys)[0])
+    output_int32(np_shape(ys)[1])
+    output_ndarray_float_2(ys)
+
+    output_int32(np_shape(zs)[0])
+    output_int32(np_shape(zs)[1])
+    output_int32(np_shape(zs)[2])
+    output_ndarray_float_3(zs)
+
+def test_ndarray_subscript_assignment():
+    xs = np_array([[11.0, 22.0, 33.0, 44.0], [55.0, 66.0, 77.0, 88.0]])
+
+    xs[0, 0] = 99.0
+    output_ndarray_float_2(xs)
+
+    xs[0] = 100.0
+    output_ndarray_float_2(xs)
+
+    xs[:, ::2] = 101.0
+    output_ndarray_float_2(xs)
+
+    xs[1:, 0] = 102.0
+    output_ndarray_float_2(xs)
+
+    xs[0] = np_array([-1.0, -2.0, -3.0, -4.0])
+    output_ndarray_float_2(xs)
+
+    xs[:] = np_array([-5.0, -6.0, -7.0, -8.0])
+    output_ndarray_float_2(xs)
+
+    # Test assignment with memory sharing
+    ys1 = np_reshape(xs, (2, 4))
+    ys2 = np_transpose(ys1)
+    ys3 = ys2[::-1, 0]
+    ys3[0] = -999.0
+
+    output_ndarray_float_2(xs)
+    output_ndarray_float_2(ys1)
+    output_ndarray_float_2(ys2)
+    output_ndarray_float_1(ys3)
+
 def test_ndarray_add():
    x = np_identity(2)
    y = x + np_ones([2, 2])
@ -1440,26 +1551,58 @@ def test_ndarray_nextafter_broadcast_rhs_scalar():
    output_ndarray_float_2(nextafter_x_zeros)
    output_ndarray_float_2(nextafter_x_ones)

-def test_ndarray_transpose():
-    x: ndarray[float, 2] = np_array([[1., 2., 3.], [4., 5., 6.]])
-    y = np_transpose(x)
-    z = np_transpose(y)

-    output_ndarray_float_2(x)
-    output_ndarray_float_2(y)
+def test_ndarray_any():
+    s0 = 0
+    output_bool(np_any(s0))
+    s1 = 1
+    output_bool(np_any(s1))

-def test_ndarray_reshape():
-    w: ndarray[float, 1] = np_array([1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])
-    x = np_reshape(w, (1, 2, 1, -1))
-    y = np_reshape(x, [2, -1])
-    z = np_reshape(y, 10)
+    x1 = np_identity(5)
+    y1 = np_any(x1)
+    output_ndarray_float_2(x1)
+    output_bool(y1)

-    x1: ndarray[int32, 1] = np_array([1, 2, 3, 4])
-    x2: ndarray[int32, 2] = np_reshape(x1, (2, 2))
+    x2 = np_identity(1)
+    y2 = np_any(x2)
+    output_ndarray_float_2(x2)
+    output_bool(y2)

-    output_ndarray_float_1(w)
-    output_ndarray_float_2(y)
-    output_ndarray_float_1(z)
+    x3 = np_array([[1.0, 2.0], [3.0, 4.0]])
+    y3 = np_any(x3)
+    output_ndarray_float_2(x3)
+    output_bool(y3)
+
+    x4 = np_zeros([3, 5])
+    y4 = np_any(x4)
+    output_ndarray_float_2(x4)
+    output_bool(y4)
+
+def test_ndarray_all():
+    s0 = 0
+    output_bool(np_all(s0))
+    s1 = 1
+    output_bool(np_all(s1))
+
+    x1 = np_identity(5)
+    y1 = np_all(x1)
+    output_ndarray_float_2(x1)
+    output_bool(y1)
+
+    x2 = np_identity(1)
+    y2 = np_all(x2)
+    output_ndarray_float_2(x2)
+    output_bool(y2)
+
+    x3 = np_array([[1.0, 2.0], [3.0, 4.0]])
+    y3 = np_all(x3)
+    output_ndarray_float_2(x3)
+    output_bool(y3)
+
+    x4 = np_zeros([3, 5])
+    y4 = np_all(x4)
+    output_ndarray_float_2(x4)
+    output_bool(y4)

 def test_ndarray_dot():
    x1: ndarray[float, 1] = np_array([5.0, 1.0, 4.0, 2.0])
@ -1592,6 +1735,11 @@ def run() -> int32:
    test_ndarray_slices()
    test_ndarray_nd_idx()

+    test_ndarray_transpose()
+    test_ndarray_reshape()
+    test_ndarray_broadcast_to()
+    test_ndarray_subscript_assignment()
+
    test_ndarray_add()
    test_ndarray_add_broadcast()
    test_ndarray_add_broadcast_lhs_scalar()
@ -1755,8 +1903,9 @@ def run() -> int32:
    test_ndarray_nextafter_broadcast()
    test_ndarray_nextafter_broadcast_lhs_scalar()
    test_ndarray_nextafter_broadcast_rhs_scalar()
-    test_ndarray_transpose()
-    test_ndarray_reshape()
+
+    test_ndarray_any()
+    test_ndarray_all()

    test_ndarray_dot()
    test_ndarray_cholesky()
--- a/nac3standalone/demo/src/numeric_primitives.py
+++ b/nac3standalone/demo/src/numeric_primitives.py
@ -29,10 +29,10 @@ def u32_max() -> uint32:
    return ~uint32(0)

 def i32_min() -> int32:
-    return int32(1 << 31)
+    return int32(-(1 << 31))

 def i32_max() -> int32:
-    return int32(~(1 << 31))
+    return int32((1 << 31)-1)

 def u64_min() -> uint64:
    return uint64(0)
@ -63,8 +63,9 @@ def test_conv_from_i32():
        i32_max()
    ]:
        output_int64(int64(x))
-        output_uint32(uint32(x))
-        output_uint64(uint64(x))
+        if x >= 0:
+            output_uint32(uint32(x))
+            output_uint64(uint64(x))
        output_float64(float(x))

 def test_conv_from_u32():
@ -108,7 +109,6 @@ def test_conv_from_u64():

 def test_f64toi32():
    for x in [
-        float(i32_min()) - 1.0,
        float(i32_min()),
        float(i32_min()) + 1.0,
        -1.5,
@ -117,7 +117,6 @@ def test_f64toi32():
        1.5,
        float(i32_max()) - 1.0,
        float(i32_max()),
-        float(i32_max()) + 1.0
    ]:
        output_int32(int32(x))

@ -138,24 +137,17 @@ def test_f64toi64():

 def test_f64tou32():
    for x in [
-        -1.5,
-        float(u32_min()) - 1.0,
-        -0.5,
        float(u32_min()),
        0.5,
        float(u32_min()) + 1.0,
        1.5,
        float(u32_max()) - 1.0,
        float(u32_max()),
-        float(u32_max()) + 1.0
    ]:
        output_uint32(uint32(x))

 def test_f64tou64():
    for x in [
-        -1.5,
-        float(u64_min()) - 1.0,
-        -0.5,
        float(u64_min()),
        0.5,
        float(u64_min()) + 1.0,
@ -181,4 +173,4 @@ def run() -> int32:
    test_f64tou32()
    test_f64tou64()

-    return 0
+    return 0
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
abdul124	f817d3347b	[artiq] cleanup module functionality tests	2025-01-20 10:24:08 +08:00
abdul124	2d275949b8	move tests from artiq to standalone	2025-01-17 13:10:35 +08:00
Sébastien Bourdeauducq	2783834cb1	nac3artiq/demo: merge EmbeddingMap into min_artiq	2025-01-17 12:45:51 +08:00
abdul124	879b063968	[artiq] add tests for module support	2025-01-16 12:42:13 +08:00
abdul124	14e80dfab7	update snapshots	2025-01-16 12:41:30 +08:00
abdul124	5fdbc34b43	[core] implement codegen for modules	2025-01-16 12:40:56 +08:00
abdul124	32f24261f2	[artiq] add global variables to modules	2025-01-16 12:40:14 +08:00
abdul124	ce40a46f8a	[core] add module type	2025-01-16 12:40:06 +08:00
abdul124	f15a64cc1b	[artiq] register modules	2025-01-16 11:13:04 +08:00
abdul124	7fac801936	[artiq] add module primitive type	2025-01-16 11:13:04 +08:00
abdul124	febfd1241d	[core] add module type	2025-01-16 11:13:04 +08:00
abdul124	4bd5349381	[core] add attributes to class string	2025-01-16 11:13:04 +08:00
Sebastien Bourdeauducq	c15062ab4c	msys2: update	2025-01-15 21:33:58 +08:00
Sebastien Bourdeauducq	933804e270	update dependencies	2025-01-15 21:18:45 +08:00
David Mak	1cfaa1a779	[core] toplevel: Implement np_{any,all}	2025-01-15 16:09:32 +08:00
David Mak	18e8e5269f	[core] codegen/values/ndarray: Add fold utilities Needed for np_{any,all}.	2025-01-15 16:09:32 +08:00
David Mak	357970a793	[core] codegen/stmt: Add build_{break,continue}_branch functions	2025-01-15 16:09:32 +08:00
David Mak	762a2447c3	[core] codegen: Remove obsolete comments Comments regarding the need for `llvm.stack{save,restore}` is obsolete now that `NDIter::indices` is allocated at the beginning of the function.	2025-01-15 16:09:32 +08:00
David Mak	8e614d83de	[core] codegen: Add ProxyType::new overloads and refactor to use them	2025-01-15 13:23:19 +08:00
David Mak	bd66fe48d8	[core] codegen: Refactor to use CodeGenContext::get_size_type Simplifies a lot of API usage.	2025-01-15 13:23:19 +08:00
David Mak	c59fd286ff	[artiq] Move `get_llvm_*` to Isa, use `TargetMachine` to infer size_t	2025-01-15 13:23:19 +08:00
David Mak	f8530e0ef6	[core] codegen: Add CodeGenContext::get_size_type Convenience method for getting the `size_t` LLVM type without the use of `CodeGenerator`.	2025-01-15 13:22:50 +08:00
David Mak	3ebd4ba5d1	[core] codegen: Add assertion verifying size_t is compatible	2025-01-14 18:25:00 +08:00
David Mak	d1dcfa19ff	CodeGenerator: Add with_target_machine factory function Allows creating CodeGenerator with the LLVM target machine to infer the expected type for size_t.	2025-01-13 14:55:33 +08:00
David Mak	8baf111734	[meta] Apply clippy suggestions	2025-01-06 17:11:31 +08:00
David Mak	eaaa194a87	[artiq] symbol_resolver: Cast ndarray.{shape,strides} globals to usize* This is needed as ndarray.{shapes,strides} are ArrayValues, and so a GEP operation is required to convert them into pointers to their first elements.	2025-01-06 16:53:33 +08:00
David Mak	352c7c880b	[artiq] symbol_resolver: Fix incorrect global type for ndarray.strides	2025-01-06 16:53:33 +08:00
David Mak	3c5e247195	[artiq] symbol_resolver: Use TargetData to get size of dtype dtype.size_of() may not return a constant value.	2025-01-06 16:53:33 +08:00
David Mak	4e21def1a0	[artiq] symbol_resolver: Add missing promotion for host compilation Shape tuple is always in i32, so a zero-extension to i64 is necessary when assigning the shape tuple into the shape field of the ndarray.	2025-01-06 16:53:33 +08:00
David Mak	2271b46b96	[core] codegen/values/ndarray: Fix Vec allocation	2025-01-06 16:53:33 +08:00
David Mak	d9c180ed13	[artiq] symbol_resolver: Fix support for np.bool_ -> bool decay	2025-01-06 16:53:33 +08:00
Sebastien Bourdeauducq	8322d457c6	standalone/demo: numpy2 compatibility	2025-01-04 15:30:24 +08:00
Sebastien Bourdeauducq	e480081e4b	update dependencies	2025-01-04 10:28:41 +08:00
David Mak	12fddc3533	[core] codegen/ndarray: Make ndims non-optional Now that everything is ported to use strided impl, dynamic-ndim ndarray instances do not exist anymore.	2025-01-03 15:43:08 +08:00
David Mak	3ac1083734	[core] codegen: Reimplement np_dot() for scalars and 1D Based on `693b7f37`: core/ndstrides: implement np_dot() for scalars and 1D	2025-01-03 15:43:08 +08:00
David Mak	66b8a5e01d	[core] codegen/ndarray: Reimplement matmul Based on `73c2203b`: core/ndstrides: implement general matmul	2025-01-03 15:43:06 +08:00
David Mak	ebbadc2d74	[core] codegen: Reimplement ndarray cmpop Based on `56cccce1`: core/ndstrides: implement cmpop	2025-01-03 15:15:13 +08:00
David Mak	a2f1b25fd8	[core] codegen: Reimplement ndarray unary op Based on `bb992704`: core/ndstrides: implement unary op	2025-01-03 15:15:12 +08:00
David Mak	59f19e29df	[core] codegen: Reimplement ndarray binop Based on `9e40c834`: core/ndstrides: implement binop	2025-01-03 15:15:12 +08:00
David Mak	6cbba8fdde	[core] codegen: Reimplement builtin funcs to support strided ndarrays Based on `7f3c4530`: core/ndstrides: update builtin_fns to use ndarray with strides	2025-01-03 15:15:12 +08:00
David Mak	e6dab25a57	[core] codegen/ndarray: Add NDArrayOut, broadcast_map, map Based on `fbfc0b29`: core/ndstrides: add NDArrayOut, broadcast_map and map	2025-01-03 15:15:11 +08:00
David Mak	2dc5e79a23	[core] codegen/ndarray: Implement subscript assignment Based on `5bed394e`: core/ndstrides: implement subscript assignment Overlapping is not handled. Currently it has undefined behavior.	2025-01-03 15:15:11 +08:00
David Mak	dcde1d9c87	[core] codegen/values/ndarray: Add more ScalarOrNDArray utils Based on `f731e604`: core/ndstrides: add more ScalarOrNDArray and NDArrayObject utils	2025-01-03 15:15:10 +08:00
David Mak	7375983e0c	[core] codegen/ndarray: Implement np_transpose without axes argument Based on `052b67c8`: core/ndstrides: implement np_transpose() (no axes argument) The IRRT implementation knows how to handle axes. But the argument is not in NAC3 yet.	2025-01-03 15:15:08 +08:00
David Mak	43e440d2fd	[core] codegen/ndarray: Reimplement broadcasting Based on `9359ed96`: core/ndstrides: implement broadcasting & np_broadcast_to()	2025-01-03 15:14:59 +08:00
David Mak	8d975b5ff3	[core] codegen/ndarray: Implement np_reshape Based on `926e7e93`: core/ndstrides: implement np_reshape()	2025-01-03 14:56:16 +08:00
David Mak	aae41eef6a	[core] toplevel: Add view functions category Based on `9e0f636d`: core: categorize np_{transpose,reshape} as 'view functions'	2025-01-03 14:47:59 +08:00
David Mak	132ba1942f	[core] toplevel: Implement np_size Based on `2c1030d1`: core/ndstrides: implement np_size()	2025-01-03 14:16:29 +08:00
David Mak	12358c57b1	[core] codegen/ndarray: Implement np_{shape,strides} Based on `40c24486`: core/ndstrides: implement np_shape() and np_strides() These functions are not important, but they are handy for debugging. `np.strides()` is not an actual NumPy function, but `ndarray.strides` is used.	2025-01-03 13:58:47 +08:00
David Mak	9ffa2d6552	[core] codegen/ndarray: Reimplement np_{copy,fill} Based on `18db85fa`: core/ndstrides: implement ndarray.fill() and .copy()	2025-01-03 13:58:47 +08:00
David Mak	acb437919d	[core] codegen/ndarray: Reimplement np_{eye,identity} Based on `fa047d50`: core/ndstrides: implement np_identity() and np_eye()	2025-01-03 13:58:47 +08:00
David Mak	fadadd7505	[core] codegen/ndarray: Reimplement np_array() Based on `8f0084ac`: core/ndstrides: implement np_array() It also checks for inconsistent dimensions if the input is a list. e.g., rejecting `[[1.0, 2.0], [3.0]]`. However, currently only `np_array(<input>, copy=False)` and `np_array (<input>, copy=True)` are supported. In NumPy, copy could be false, true, or None. Right now, NAC3's `np_array(<input>, copy=False)` behaves like NumPy's `np.array(<input>, copy=None)`.	2025-01-03 13:58:47 +08:00
David Mak	26f1428739	[core] codegen: Refactor len() Based on `54a842a9`: core/ndstrides: implement len(ndarray) & refactor len()	2025-01-03 13:58:47 +08:00
David Mak	5880f964bb	[core] codegen/ndarray: Reimplement np_{zeros,ones,full,empty} Based on `792374fa`: core/ndstrides: implement np_{zeros,ones,full,empty}.	2025-01-03 13:58:47 +08:00
David Mak	7d02f5833d	[core] codegen: Implement Tuple{Type,Value}	2025-01-03 13:58:47 +08:00
David Mak	822f9d33f8	[core] codegen: Refactor ListType to use derive(StructFields)	2025-01-03 13:58:47 +08:00
David Mak	805a9d23b3	[core] codegen: Add derive(Copy, Clone) to TypedArrayLikeAdapter	2025-01-03 13:58:46 +08:00
David Mak	1ffe2fcc7f	[core] irrt: Minor reformat	2025-01-03 13:26:51 +08:00
David Mak	2f0847d77b	[core] codegen/types: Refactor ProxyType - Add alloca_type() function to obtain the type that should be passed into a `build_alloca` call - Provide default implementations for raw_alloca and array_alloca - Add raw_alloca_var and array_alloca_var to distinguish alloca instructions placed at the front of the function vs at the current builder location	2024-12-30 17:00:17 +08:00
David Mak	dc9efa9e8c	[core] codegen/ndarray: Use IRRT for size() and indexing operations Also refactor some usages of call_ndarray_calc_size with ndarray.size().	2024-12-30 16:58:33 +08:00
David Mak	3c0ce3031f	[core] codegen: Update raw_alloca to return PointerValue Better match the expected behavior of alloca.	2024-12-30 16:51:34 +08:00
David Mak	d5e8df070a	[core] Minor improvements to IRRT and add missing documentation	2024-12-30 16:51:17 +08:00
David Mak	dc413dfa43	[core] codegen: Refactor TypedArrayLikeAdapter to use fn Allows for greater flexibility when TypedArrayLikeAdapter is used with custom value types.	2024-12-30 16:50:22 +08:00
David Mak	19122e2905	[core] codegen: Rename classes/functions for consistency - ContiguousNDArrayFields -> ContiguousNDArrayStructFields - ndarray/nditer: Add _field suffix to field accessors	2024-12-30 16:50:18 +08:00
David Mak	318371a509	[core] irrt: Minor cleanup	2024-12-30 14:13:48 +08:00
David Mak	35e3042435	[core] Refactor/Remove redundant and unused constructs - Use ProxyValue.name where necessary - Remove NDArrayValue::ptr_to_{shape,strides} - Remove functions made obsolete by ndstrides - Remove use statement for ndarray::views as it only contain an impl block. - Remove class_names field in Resolvers of test sources	2024-12-30 14:13:48 +08:00
David Mak	0e5940c49d	[meta] Refactor itertools::{chain,enumerate,repeat_n} with std equiv	2024-12-30 14:13:48 +08:00
David Mak	fbf0053c24	[core] irrt/string: Minor cleanup - Refactor __nac3_str_eq to always return bool - Use `get_usize_dependent_function_name` to get IRRT func name	2024-12-30 14:04:42 +08:00
Sébastien Bourdeauducq	456aefa6ee	clean up duplicate include	2024-12-30 13:03:31 +08:00
ram	49a7469b4a	use memcmp for string comparison Co-authored-by: ram <RAMTEJ001@e.ntu.edu.sg> Co-committed-by: ram <RAMTEJ001@e.ntu.edu.sg>	2024-12-30 13:02:09 +08:00