How can I determine the type of a packed array?

We can use one of several ways. First, let us create some test data:

arr = Range[10]; (* this is an Integer packed array *)
unpacked = {1, 2, 3} (* this is an Integer array that is NOT packed *)

---

Since Mathematica 10.4, Internal`PackedArrayType directly returns the type:

Internal`PackedArrayType[arr]
(* Integer *)

Internal`PackedArrayType[unpacked]
(* $Failed *)

---

Developer`PackedArrayQ has a second argument, which is the type of the array. This way we can test both for the type and "packedness" at the same time.

Developer`PackedArrayQ[arr, Integer]
(* True *)

Developer`PackedArrayQ[arr, Real]
(* False *)

Developer`PackedArrayQ[unpacked, Integer]
(* False *)

This function is useful in specializing functions for processing packed array of various types, e.g. to dispatch to the appropriate LibraryLink function. A third argument allows testing for the array depth as well.

---

To get the type directly in versions of Mathematica prior to 10.4, without testing for each possible type using PackedArrayQ, we can extract an element and check its head:

packedArrayType[arr_?Developer`PackedArrayQ] := Head@Extract[arr, Table[1, {ArrayDepth[arr]}]]
packedArrayType[___] := $Failed

This is roughly what NDSolve`FEM`PackedArrayType does, which confirms to me that this is the appropriate way. In a package, I would define packedArrayType in a version-dependent manner as

If[$VersionNumber >= 10.4, 
  packedArrayType = Internal`PackedArrayType,
  packedArrayType[...] := (* manual method from above *)
]

There's another useful function for this kind of thing

arr = RandomReal[1, 10^8];
Developer`PackedArrayForm[arr]

"PackedArray"[Real, "<" 100000000 ">"]

The drawback is that this is for display purposes only, it doesn't seem to be possible to extract the Real from this.

on second thoughts, this seems to work:

Developer`PackedArrayForm[Range[10]] // ToBoxes // MakeExpression // #[[1, 1]] &

Integer