How to initialize downvalues from a list?

Question

The For expression below initializes downvalues of a variable a from the values in a list list:

Module[
 {   a
   , list = {3, 1, 4}
 }
 , For[i = 1, i <= Length[list], i++, a[i] = list[[i]]]
 ; a[3]
]
(* 4 *)

---

Is there a simpler way to implement such an assignment? In particular, I'm looking for a way that does not explicitly iterate over the list.

---

The naive attempt below fails, but at least shows the sort of expression I'm hoping to find:

Module[
 {   a
   , list = {3, 1, 4}
 }
 , Array[a, Length[list]] = list
 ; a[3]
]
(* a$941099[3] *)

Answer 1

Set has the HoldFirst attribute. You need to use Evaluate if you want to do this the way you suggest in your question:

Module[{array, list = {3, 1, 4}},
 Evaluate[Array[array, Length[list]]] = list;
 {array[1], array[2], array[3]}
 ]
(* Out: {3, 1, 4} *)

Answer 2

If I understand your question correctly you want to transform a list e.g. {a,b,c,d} into DownValues of a Symbol with some name e.g. array1. Sometimes this is called an indexed variable (although I think this term is misleading). The following function does just that:

toDownvalues[name_, list_] := MapIndexed[(name[First@#2] = #1) &, list]

ClearAll@array1
toDownvalues[array1, {a, b, c, d}]

Table[array1[i], {i, 1, 4}]
(* {a, b, c, d} *)

Answer 3

If you are looking for a solution that doesn't iterate over a list, you may be interested by what is called "memoization". The target of memoization is not to assign DownValues to a symbol as you ask. Memoization is a optimization for speed. Assignment of Dowvalues to a symbol is a "side effect" (in all meanings of the term), which is not recommended, but here, that may correspond to your need.

The idea of Memoization is that your array is built more and more each time you call array[index] whith a new index :

Here is the intialisation :

list = {3, 1, 4, 8};
array[i_] := (array[i] = list[[i]])

Definition[array]

The array definition is no more than array[i]=list[i]. This is a parasitic term that may annoy you, depending of your application.

Then if you call array[index] with say, index=1, then the DownValue 3 is added to the definiton of array (array[1]=3) :

array[1]
Definition[array]

and so on ...

array[2]
Definition[array]

Of course, if you want to load the entire array in one time at the beginning, you need to do something similar to a iteration, for example :

array /@ Range[Length[list]]
Definition[array]