diff --git a/lib/Hawk.cpp b/lib/Hawk.cpp
index db80e31b..11e8cb6c 100644
--- a/lib/Hawk.cpp
+++ b/lib/Hawk.cpp
@@ -865,7 +865,7 @@ int Hawk::Value::scaleArrayed (Run* r, hawk_ooi_t size)
 	{
 		// the previous value is not a arr.
 		// a new arr value needs to be created first.
-		hawk_val_t* arr = hawk_rtx_makearrval(r->rtx, size); // TODO: can we change this to accept the initial value in the constructor
+		hawk_val_t* arr = hawk_rtx_makearrval(r->rtx, size);
 		if (arr == HAWK_NULL)
 		{
 			r->hawk->retrieveError(r);
@@ -899,14 +899,12 @@ int Hawk::Value::scaleArrayed (Run* r, hawk_ooi_t size)
 			return -1;
 		}
 
-/* TODO: RESIZE THE EXISTING ARRAY...
-		// update the arr with a given value
-		if (hawk_rtx_setarrvalfld(r->rtx, val, idx, v) == HAWK_NULL)
+		// update the capacity of an array
+		if (hawk_rtx_scalearrval(r->rtx, this->val, size) <= -1)
 		{
 			r->hawk->retrieveError(r);
 			return -1;
 		}
-*/
 	}
 
 	return 0;
@@ -918,12 +916,16 @@ hawk_ooi_t Hawk::Value::getArrayedLength () const
 	return (hawk_ooi_t)HAWK_ARR_TALLY(((hawk_val_arr_t*)this->val)->arr);
 }
 
-
 hawk_ooi_t Hawk::Value::getArrayedSize () const
 {
 	if (HAWK_RTX_GETVALTYPE(r->rtx, this->val) != HAWK_VAL_ARR) return -1;
 	return (hawk_ooi_t)HAWK_ARR_SIZE(((hawk_val_arr_t*)this->val)->arr);
+}
 
+hawk_ooi_t Hawk::Value::getArrayedCapa () const
+{
+	if (HAWK_RTX_GETVALTYPE(r->rtx, this->val) != HAWK_VAL_ARR) return -1;
+	return (hawk_ooi_t)HAWK_ARR_CAPA(((hawk_val_arr_t*)this->val)->arr);
 }
 
 int Hawk::Value::setArrayedVal (hawk_ooi_t idx, hawk_val_t* v)
@@ -1027,6 +1029,24 @@ int Hawk::Value::getArrayed (hawk_ooi_t idx, Value* v) const
 
 ///////////////////////////////////////////////////////////////////
 
+hawk_ooi_t Hawk::Value::getIndexedLength () const
+{
+	if (HAWK_RTX_GETVALTYPE(r->rtx, this->val) != HAWK_VAL_MAP) return -1;
+	return (hawk_ooi_t)HAWK_MAP_SIZE(((hawk_val_map_t*)this->val)->map);
+}
+
+hawk_ooi_t Hawk::Value::getIndexedSize () const
+{
+	if (HAWK_RTX_GETVALTYPE(r->rtx, this->val) != HAWK_VAL_MAP) return -1;
+	return (hawk_ooi_t)HAWK_MAP_SIZE(((hawk_val_map_t*)this->val)->map);
+}
+
+hawk_ooi_t Hawk::Value::getIndexedCapa () const
+{
+	if (HAWK_RTX_GETVALTYPE(r->rtx, this->val) != HAWK_VAL_MAP) return -1;
+	return (hawk_ooi_t)hawk_map_getcapa(((hawk_val_map_t*)this->val)->map);
+}
+
 int Hawk::Value::setIndexedVal (const Index& idx, hawk_val_t* v)
 {
 	if (HAWK_UNLIKELY(!this->run)) return -1;
diff --git a/lib/Hawk.hpp b/lib/Hawk.hpp
index fc2a1370..780f13d1 100644
--- a/lib/Hawk.hpp
+++ b/lib/Hawk.hpp
@@ -1111,6 +1111,7 @@ public:
 
 		hawk_ooi_t getArrayedSize () const; // same value as hawk::size() for an array
 		hawk_ooi_t getArrayedLength () const; // same value as hawk::length() for an array
+		hawk_ooi_t getArrayedCapa () const;
 
 		bool isArrayed () const;
 		int getArrayed (
@@ -1140,6 +1141,10 @@ public:
 		int setIndexedMbs (const Index& idx, const hawk_bch_t* str);
 		int setIndexedMbs (Run* r, const Index&  idx, const hawk_bch_t* str);
 
+		hawk_ooi_t getIndexedSize () const; // same value as hawk::size() for a map
+		hawk_ooi_t getIndexedLength () const; // same value as hawk::length() for a map
+		hawk_ooi_t getIndexedCapa () const;
+
 		///
 		/// The isIndexed() function determines if a value is a map.
 		/// \return true if indexed, false if not.
diff --git a/lib/arr.c b/lib/arr.c
index 58dacea6..a01d4633 100644
--- a/lib/arr.c
+++ b/lib/arr.c
@@ -85,7 +85,7 @@ static HAWK_INLINE slot_t* alloc_slot (hawk_arr_t* arr, void* dptr, hawk_oow_t d
 		DPTR(n) = arr->style->copier(arr, dptr, dlen); /* call the custom copier */
 		if (HAWK_UNLIKELY(!DPTR(n)))
 		{
-			hawk_gem_freemem (arr->gem, n);
+			hawk_gem_freemem(arr->gem, n);
 			return HAWK_NULL;
 		}
 	}
@@ -115,7 +115,7 @@ hawk_arr_t* hawk_arr_open (hawk_gem_t* gem, hawk_oow_t xtnsize, hawk_oow_t capa)
 void hawk_arr_close (hawk_arr_t* arr)
 {
 	hawk_arr_fini (arr);
-	hawk_gem_freemem (arr->gem, arr);
+	hawk_gem_freemem(arr->gem, arr);
 }
 
 
@@ -165,7 +165,7 @@ void hawk_arr_fini (hawk_arr_t* arr)
 
 	if (arr->slot)
 	{
-		hawk_gem_freemem (arr->gem, arr->slot);
+		hawk_gem_freemem(arr->gem, arr->slot);
 		arr->slot = HAWK_NULL;
 		arr->capa = 0;
 		arr->size = 0 ;
@@ -220,8 +220,8 @@ hawk_arr_t* hawk_arr_setcapa (hawk_arr_t* arr, hawk_oow_t capa)
 	if (capa < arr->size)
 	{
 		/* to trigger freeers on the items truncated */
-		hawk_arr_delete (arr, capa, arr->size - capa);
-		HAWK_ASSERT (arr->size <= capa);
+		hawk_arr_delete(arr, capa, arr->size - capa);
+		HAWK_ASSERT(arr->size <= capa);
 	}
 
 	if (capa > 0)
@@ -233,8 +233,8 @@ hawk_arr_t* hawk_arr_setcapa (hawk_arr_t* arr, hawk_oow_t capa)
 	{
 		if (arr->slot)
 		{
-			hawk_arr_clear (arr);
-			hawk_gem_freemem (arr->gem, arr->slot);
+			hawk_arr_clear(arr);
+			hawk_gem_freemem(arr->gem, arr->slot);
 		}
 
 		tmp = HAWK_NULL;
@@ -332,8 +332,8 @@ hawk_oow_t hawk_arr_insert (hawk_arr_t* arr, hawk_oow_t pos, void* dptr, hawk_oo
 
 			if (capa <= mincapa)
 			{
-				if (arr->style->freeer) arr->style->freeer (arr, DPTR(slot), DLEN(slot));
-				hawk_gem_freemem (arr->gem, slot);
+				if (arr->style->freeer) arr->style->freeer(arr, DPTR(slot), DLEN(slot));
+				hawk_gem_freemem(arr->gem, slot);
 				return HAWK_ARR_NIL;
 			}
 
@@ -344,8 +344,8 @@ hawk_oow_t hawk_arr_insert (hawk_arr_t* arr, hawk_oow_t pos, void* dptr, hawk_oo
 		if (pos >= arr->capa || arr->size >= arr->capa)  /* can happen if the sizer() callback isn't good enough */
 		{
 			/* the buffer is not still enough after resizing */
-			if (arr->style->freeer) arr->style->freeer (arr, DPTR(slot), DLEN(slot));
-			hawk_gem_freemem (arr->gem, slot);
+			if (arr->style->freeer) arr->style->freeer(arr, DPTR(slot), DLEN(slot));
+			hawk_gem_freemem(arr->gem, slot);
 			hawk_gem_seterrnum (arr->gem, HAWK_NULL, HAWK_EBUFFULL);
 			return HAWK_ARR_NIL;
 		}
@@ -398,8 +398,8 @@ hawk_oow_t hawk_arr_update (hawk_arr_t* arr, hawk_oow_t pos, void* dptr, hawk_oo
 			slot_t* slot = alloc_slot(arr, dptr, dlen);
 			if (HAWK_UNLIKELY(!slot)) return HAWK_ARR_NIL;
 
-			if (arr->style->freeer) arr->style->freeer (arr, DPTR(c), DLEN(c));
-			hawk_gem_freemem (arr->gem, c);
+			if (arr->style->freeer) arr->style->freeer(arr, DPTR(c), DLEN(c));
+			hawk_gem_freemem(arr->gem, c);
 
 			arr->slot[pos] = slot;
 		}
@@ -422,8 +422,8 @@ hawk_oow_t hawk_arr_delete (hawk_arr_t* arr, hawk_oow_t index, hawk_oow_t count)
 		slot_t* c = arr->slot[i];
 		if (c)
 		{
-			if (arr->style->freeer) arr->style->freeer (arr, DPTR(c), DLEN(c));
-			hawk_gem_freemem (arr->gem, c);
+			if (arr->style->freeer) arr->style->freeer(arr, DPTR(c), DLEN(c));
+			hawk_gem_freemem(arr->gem, c);
 			arr->slot[i] = HAWK_NULL;
 			arr->tally--;
 		}
@@ -453,8 +453,8 @@ hawk_oow_t hawk_arr_uplete (hawk_arr_t* arr, hawk_oow_t index, hawk_oow_t count)
 		slot_t* c = arr->slot[i];
 		if (c)
 		{
-			if (arr->style->freeer) arr->style->freeer (arr, DPTR(c), DLEN(c));
-			hawk_gem_freemem (arr->gem, c);
+			if (arr->style->freeer) arr->style->freeer(arr, DPTR(c), DLEN(c));
+			hawk_gem_freemem(arr->gem, c);
 			arr->slot[i] = HAWK_NULL;
 			arr->tally--;
 		}
@@ -472,8 +472,8 @@ void hawk_arr_clear (hawk_arr_t* arr)
 		slot_t* c = arr->slot[i];
 		if (c != HAWK_NULL)
 		{
-			if (arr->style->freeer) arr->style->freeer (arr, DPTR(c), DLEN(c));
-			hawk_gem_freemem (arr->gem, c);
+			if (arr->style->freeer) arr->style->freeer(arr, DPTR(c), DLEN(c));
+			hawk_gem_freemem(arr->gem, c);
 			arr->slot[i] = HAWK_NULL;
 		}
 	}
@@ -702,8 +702,8 @@ void hawk_arr_deleteheap (hawk_arr_t* arr, hawk_oow_t index)
 	}
 
 	/* destroy the actual item */
-	if (arr->style->freeer) arr->style->freeer (arr, DPTR(tmp), DLEN(tmp));
-	hawk_gem_freemem (arr->gem, tmp);
+	if (arr->style->freeer) arr->style->freeer(arr, DPTR(tmp), DLEN(tmp));
+	hawk_gem_freemem(arr->gem, tmp);
 
 	/* empty the last slot */
 	arr->slot[arr->size] = HAWK_NULL;
diff --git a/lib/hawk.h b/lib/hawk.h
index 7d7e447a..4262e651 100644
--- a/lib/hawk.h
+++ b/lib/hawk.h
@@ -3129,7 +3129,7 @@ HAWK_EXPORT hawk_val_map_itr_t* hawk_rtx_getfirstmapvalitr (
 );
 
 /**
- * The hawk_rtx_getnextmapvalitr() returns the iterator to the
+ * The hawk_rtx_getnextmapvalitr() function returns the iterator to the
  * next pair to \a itr in the map. It returns #HAWK_NULL and sets the pair
  * field of \a itr to #HAWK_NULL if \a itr points to the last pair.
  * Otherwise, it returns \a itr pointing to the next pair.
@@ -3140,6 +3140,14 @@ HAWK_EXPORT hawk_val_map_itr_t* hawk_rtx_getnextmapvalitr (
 	hawk_val_map_itr_t* itr
 );
 
+/**
+ * The hawk_rtx_scalearrval() function changes the capacity of an array value
+ */
+HAWK_EXPORT int hawk_rtx_scalearrval (
+	hawk_rtx_t* rtx,
+	hawk_val_t* arr,
+	hawk_ooi_t  capa
+);
 
 HAWK_EXPORT hawk_val_t* hawk_rtx_setarrvalfld (
 	hawk_rtx_t* rtx,
diff --git a/lib/val.c b/lib/val.c
index 7c1c47cb..9418b133 100644
--- a/lib/val.c
+++ b/lib/val.c
@@ -1412,6 +1412,13 @@ hawk_val_map_itr_t* hawk_rtx_getnextmapvalitr (hawk_rtx_t* rtx, hawk_val_t* map,
 	return itr->pair? itr: HAWK_NULL;
 }
 
+int hawk_rtx_scalearrval (hawk_rtx_t* rtx, hawk_val_t* arr, hawk_ooi_t capa)
+{
+	HAWK_ASSERT (HAWK_RTX_GETVALTYPE(rtx, arr) == HAWK_VAL_ARR);
+	if (!hawk_arr_setcapa(((hawk_val_arr_t*)arr)->arr, capa)) return -1;
+	return 0;
+}
+
 hawk_val_t* hawk_rtx_setarrvalfld (hawk_rtx_t* rtx, hawk_val_t* arr, hawk_ooi_t index, hawk_val_t* v)
 {
 	HAWK_ASSERT (HAWK_RTX_GETVALTYPE(rtx, arr) == HAWK_VAL_ARR);
diff --git a/t/t-101.cpp b/t/t-101.cpp
index 559f890b..dadbe8c4 100644
--- a/t/t-101.cpp
+++ b/t/t-101.cpp
@@ -19,6 +19,8 @@ static void test1()
 
 	HAWK::Hawk::Value v(rtx);
 	HAWK::Hawk::Value vi(rtx);
+	HAWK::Hawk::Value vx(rtx);
+	hawk_int_t vvx;
 
 	vi.setInt(1010);
 	OK_X(vi.getType() == HAWK_VAL_INT);
@@ -30,6 +32,22 @@ static void test1()
 	OK_X(v.getType() == HAWK_VAL_ARR);
 	OK_X(v.getArrayedSize() == 5);
 	OK_X(v.getArrayedLength() == 1);
+	// no way to know the capacity as it's internally set
+	OK_X(v.getArrayed(4, &vx) == 0);
+	OK_X(vx.getType() == HAWK_VAL_INT && vx.getInt(&vvx) == 0);
+	OK_X(vvx == 1010);
+
+	OK_X(v.scaleArrayed(10) == 0);
+	OK_X(v.getType() == HAWK_VAL_ARR);
+	OK_X(v.getArrayedSize() == 5);
+	OK_X(v.getArrayedLength() == 1);
+	OK_X(v.getArrayedCapa() == 10); // capacity must be known after it's set explicitly set
+
+	HAWK::Hawk::Value x(rtx);
+	OK_X(x.scaleArrayed(3) == 0);
+	OK_X(x.getArrayedSize() == 0);
+	OK_X(x.getArrayedLength() == 0);
+	OK_X(x.getArrayedCapa() == 3);
 
 	// i must not call hawk.close() to ensure that v is destroyed first.
 	//hawk.close();