ArraysBasics
An array is a fixedsize data structure that supports O(1) access to any element.
Recommendations
The vector package is what you should reach for if you only need single dimensional arrays, a beginner friendly introduction can be found here. If you need multidimensional arrays, use array, repa, or accelerate. If you need arrays of bytes specifically, use bytestring.
Notes on performance:

You should almost always use the unboxed version of the data structure unless you need lazily computed content.
ByteString
is already unboxed. 
Benchmarks of various sequencelike data structured can be found here.

If you want speed, use accelerate. It generates parallel SIMDvectorised code for multicore CPUs and CUDA GPUs.
 For a lighterweight alternative to
accelerate
, with still pretty good performance, use repa.
 For a lighterweight alternative to
The de facto standard array type used in Haskell. Fast. Used by many libraries.
Note that it's not quite like C++ vector
. (For instance, it doesn't support fast append.)
A tutorial can be found at https://haskelllang.org/library/vector.

vectoralgorithms (sorting, binary search), vectorrandom (generate vectors with random values), hybridvectors (mix boxed and unboxed elements), patchesvector (diff 2 vectors)

vectorthunbox (a helper for defining unboxed vector instances)

vectorinstances (orphan instances), cerealvector, vectorbinaryinstances
Arrays of bytes. (You could use Vector Word8
instead, but most applications don't.)
Useful whenever you need, well, arrays of bytes. Can be faster than Vector
(at least it was true in 2011).

Parsing: most parsing libraries can parse bytestrings, but attoparsec is most commonly used, and
Data.Attoparsec.Zepto
is even faster for some kinds of parsing. There are also binaryparser and scanner (which I haven't tried) 
Fast builders: bytestringtreebuilder, fastbuilder, bufferbuilder

Encoding: base64bytestring, base32bytestring, base16bytestring (hex encoding)

Replacements for
Read
/Show
: bytestringshow, readable 
Streaming: pipesbytestring, quiverbytestring

Data structures: rope (for manipulating very long strings efficiently, i.e. the rope data structure), bytestringtrie (trees of bytestrings with common prefixes, i.e. the trie data structure)

Various: bytestringdelta (diffing bytestrings / producing patches and applying them to bytestrings), bytestringmmap (accessing files/devices as bytestrings, see mmap), stringsearch (splitting/search/replacement), bytestringplain (compact representation for short bytestrings, claimed to be better than
Data.ByteString.Short
)
<notes are empty>
Data.Array.Accelerate
defines an embedded array language for computations for highperformance computing in Haskell. Computations on multidimensional, regular arrays are expressed in the form of parameterised collective operations, such as maps, reductions, and permutations. These computations may then be online compiled and executed on a range of architectures.
A short tutorial on how to implement the Mandelbrot set in Accelerate is available here.
A simple example:
As a simple example, consider the computation of a dot product of two vectors of floating point numbers:
dotp :: Acc (Vector Float) > Acc (Vector Float) > Acc (Scalar Float)
dotp xs ys = fold (+) 0 (zipWith (*) xs ys)
Except for the type, this code is almost the same as the corresponding Haskell code on lists of floats. The types indicate that the computation may be onlinecompiled for performance  for example, using Data.Array.Accelerate.LLVM.PTX
it may be onthefly offloaded to the GPU.
Larger example: LULESH
LULESHaccelerate is in implementation of the Livermore Unstructured Lagrangian Explicit Shock Hydrodynamics (LULESH) miniapp. LULESH represents a typical hydrodynamics code such as ALE3D, but is simplified and hardcoded to solve the Sedov blast problem on an unstructured hexahedron mesh.
The Accelerate implementation remains highlevel while maintaining excellent performance compared to the reference C+OpenMP (> 2x faster) and CUDA (same performance) implementations.

acceleratellvmnative: Backend supporting parallel execution on multicore CPUs.

acceleratellvmptx: Backend supporting parallel execution on CUDAcapable NVIDIA GPUs. Requires a GPU with compute capability 2.0 or greater. See this table of supported GPUs.

accelerateexamples: Computational kernels and applications showcasing the use of Accelerate as well as a regression test suite, supporting function and performance testing. Examples include:
 An implementation of the Canny edge detection algorithm
 An interactive Mandelbrot set generator
 A particlebased simulation of stable fluid flows
 An nbody simulation of gravitational attraction between solid particles
 An implementation of the PageRank algorithm
 A simple interactive ray tracer
 A cellular automata simulation
 A "password recovery" tool, for dictionary lookup of MD5 hashes

accelerateio: Fast conversions between Accelerate arrays and other array formats (including vector and repa).

acceleratefft: Discrete Fourier transforms, with FFI bindings to optimised implementations.

acceleratebignum: Fixedwidth large integer arithmetic.

accelerateblas: Linear systems, matrix decompositions, and other numerical computations for use in Accelerate. Most operations are implemented efficiently via FFI calls to BLAS and LAPACK

colouraccelerate: Colour representations in Accelerate (RGB, sRGB, HSV, and HSL).

glossaccelerate: Generate gloss pictures from Accelerate.

glossrasteraccelerate: Parallel rendering of raster images and animations.

lensaccelerate: Lens operators for Accelerate types.

linearaccelerate: Linear vector spaces in Accelerate.

mwcrandomaccelerate: Generate Accelerate arrays filled with high quality pseudorandom numbers.

Like vector, does fusion – when you apply several operations to an array, it doesn't necessarily create intermediate arrays.

Autoparallelizable – pass
+RTS N
to your program and it'll probably become faster. (You can control the way parallelization happens.) 
Supports advanced operations with multidimensional arrays (slicing, reshaping, transposition, etc).

Overall performance is almost Clike.

Elements in the array are saved in a flat structure, even when the array is multidimensional

Algorithms: repaalgorithms (DFT, FFT, randomness, and some other algorithms), repalinearalgebra, hmatrixrepa, repafftw (bindings for fftw to do FFT/DFT)

Working with files: repaio (read/write arrays as text, binary, or BMP), repadevil (process images with repa), repasndfile (read/write sound files), JuicyPixelsrepa (images)
This library is in the Haskell report, but it's used less often than vector. You might want to use it if you're on a new machine and don't have vector installed yet, or if you want multidimensional arrays (or arrays with indexing that doesn't start from 0).