@@ -0,0 +11,4 @@
+use super::*;
+
+/// Trait for Rust structs identifying length values for [`Array`].
+pub trait LenKind: fmt::Debug + Clone + Copy {

@@ -0,0 +12,4 @@
+
+/// Trait for Rust structs identifying length values for [`Array`].
+pub trait LenKind: fmt::Debug + Clone + Copy {
+    fn get_length(&self) -> u32;

@@ -0,0 +39,4 @@
+///
+/// `Len` should be of a [`LenKind`] and `Item` should be a of [`Model`].
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Array<Len, Item> {

@@ -0,0 +88,4 @@
+        ctx: &CodeGenContext<'ctx, '_>,
+        i: IntValue<'ctx>,
+    ) -> Instance<'ctx, Ptr<Item>> {
+        let zero = ctx.ctx.i32_type().const_zero();

@@ -0,0 +95,4 @@
+    }
+
+    /// Like `gep` but `i` is a constant.
+    pub fn gep_const(&self, ctx: &CodeGenContext<'ctx, '_>, i: u64) -> Instance<'ctx, Ptr<Item>> {

@@ -0,0 +102,4 @@
+            self.model.0.len.get_length()
+        );
+
+        let i = ctx.ctx.i32_type().const_int(i, false);

@@ -0,0 +11,4 @@
+pub struct ModelError(pub String);
+
+impl ModelError {
+    // Append a context message to the error.

@@ -0,0 +68,4 @@
+
+    /// Return the [`BasicType`] of this model.
+    #[must_use]
+    fn get_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context) -> Self::Type;

@@ -0,0 +71,4 @@
+    fn get_type<G: CodeGenerator + ?Sized>(&self, generator: &G, ctx: &'ctx Context) -> Self::Type;
+
+    /// Get the number of bytes of the [`BasicType`] of this model.
+    fn sizeof<G: CodeGenerator + ?Sized>(

@@ -0,0 +91,4 @@
+    ///
+    /// Caller must make sure the type of `value` and the type of this `model` are equivalent.
+    #[must_use]
+    fn believe_value(&self, value: Self::Value) -> Instance<'ctx, Self> {

@@ -0,0 +152,4 @@
+        len: IntValue<'ctx>,
+        name: Option<&'ctx str>,
+    ) -> Result<Instance<'ctx, Ptr<Self>>, String> {
+        // TODO: Remove ArraySliceValue

@@ -0,0 +195,4 @@
+pub struct Instance<'ctx, M: Model<'ctx>> {
+    /// The model of this instance.
+    pub model: M,
+    /// The value of this instance.

@@ -0,0 +57,4 @@
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Float<N>(pub N);

@@ -0,0 +80,4 @@
+
+        let exp_ty = self.0.get_float_type(generator, ctx);
+
+        // TODO: Inkwell does not have get_bit_width for FloatType?

@@ -0,0 +35,4 @@
+/// If `my_function_name` has not been declared in `ctx.module`, once `.returning()` is called, a function
+/// declaration of `my_function_name` is added to `ctx.module`, where the [`FunctionType`] is deduced from
+/// the argument types and returning type.
+pub struct CallFunction<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> {

@@ -0,0 +47,4 @@
+}
+
+impl<'ctx, 'a, 'b, 'c, 'd, G: CodeGenerator + ?Sized> CallFunction<'ctx, 'a, 'b, 'c, 'd, G> {
+    pub fn begin(generator: &'d mut G, ctx: &'b CodeGenContext<'ctx, 'a>, name: &'c str) -> Self {

@@ -0,0 +72,4 @@
+
+    /// Call the function and expect the function to return a value of type of `return_model`.
+    #[must_use]
+    pub fn returning<M: Model<'ctx>>(self, name: &str, return_model: M) -> Instance<'ctx, M> {

@@ -0,0 +94,4 @@
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct Int<N>(pub N);

@@ -0,0 +129,4 @@
+}
+
+impl<'ctx, N: IntKind<'ctx>> Int<N> {
+    pub fn const_int<G: CodeGenerator + ?Sized>(

@@ -0,0 +388,4 @@
+    }
+
+    #[must_use]
+    pub fn add(&self, ctx: &CodeGenContext<'ctx, '_>, other: Self) -> Self {

@@ -0,0 +110,4 @@
+    pub fn offset_const(
+        &self,
+        ctx: &CodeGenContext<'ctx, '_>,
+        offset: u64,

@@ -0,0 +112,4 @@
+        ctx: &CodeGenContext<'ctx, '_>,
+        offset: u64,
+    ) -> Instance<'ctx, Ptr<Item>> {
+        let offset = ctx.ctx.i32_type().const_int(offset, false);

@@ -0,0 +198,4 @@
+        source: Self,
+        num_items: IntValue<'ctx>,
+    ) {
+        // Force extend `num_items` and `itemsize` to `i64` so their types would match.

@@ -0,0 +11,4 @@
+use super::*;
+
+/// A traveral that traverses a Rust `struct` that is used to declare an LLVM's struct's field types.
+pub trait FieldTraversal<'ctx> {

@@ -0,0 +13,4 @@
+/// A traveral that traverses a Rust `struct` that is used to declare an LLVM's struct's field types.
+pub trait FieldTraversal<'ctx> {
+    /// Output type of [`FieldTraversal::add`].
+    type Out<M>;

@@ -0,0 +39,4 @@
+}
+
+/// A traversal to calculate the GEP index of fields.
+pub struct GepFieldTraversal {

@@ -0,0 +41,4 @@
+/// A traversal to calculate the GEP index of fields.
+pub struct GepFieldTraversal {
+    /// The current GEP index.
+    gep_index_counter: u64,

@@ -0,0 +100,4 @@
+                self.errors
+                    .push(err.under_context(format!("field #{gep_index} '{name}'").as_str()));
+            }
+        } // Otherwise, it will be caught by Struct's `check_type`.

@@ -0,0 +161,4 @@
+/// let ndarray: Instance<'ctx, Ptr<F64NDArray>> = model.alloca(generator, ctx);
+/// ```
+///
+/// ...and here is how you may manipulate/access `ndarray`:

@@ -0,0 +192,4 @@
+    /// Traverse through all fields of this [`StructKind`].
+    ///
+    /// Only used internally in this module for implementing other components.
+    fn traverse_fields<F: FieldTraversal<'ctx>>(&self, traversal: &mut F) -> Self::Fields<F>;

@@ -0,0 +198,4 @@
+    ///
+    /// Only used internally in this module for implementing other components.
+    fn fields(&self) -> Self::Fields<GepFieldTraversal> {
+        self.traverse_fields(&mut GepFieldTraversal { gep_index_counter: 0 })

@@ -0,0 +207,4 @@
+        generator: &G,
+        ctx: &'ctx Context,
+    ) -> StructType<'ctx> {
+        let mut traversal = TypeFieldTraversal { generator, ctx, field_types: Vec::new() };

@@ -0,0 +258,4 @@
+        };
+
+        // Check each field individually.
+        let mut traversal = CheckTypeFieldTraversal {