Textures are objects that contain image data that can be sampled by a shader. An obvious application of this is texture mapping, but there are many other uses for textures. The image data doesn't have to be an image at all, it can represent anything.

Each sampler uniform in your shader points to a texture unit (zero by default). This texture unit is where it will read texture data from. To assign a texture to a texture unit, use setActiveTextureUnit then bind a texture. This will not only bind it to the relevant texture binding target but also to the active texture unit. You can change which unit a sampler points to by setting it using the setUniform1i command.

You can avoid dealing with active texture units if theres only one sampler because the default unit is zero.

This example loads a PNG file with JuicyPixels and displays the image on a square. Since the window is not square and no aspect ratio transformation was applied, the picture is squished.

module Main where

import Control.Monad.Loops (whileM_)
import qualified Data.Vector.Storable as V
import Codec.Picture
import Data.Word

import qualified Graphics.UI.GLFW as GLFW
import Linear
import Graphics.GL.Low

main = do
  GLFW.init
  GLFW.windowHint (GLFW.WindowHint'ContextVersionMajor 3)
  GLFW.windowHint (GLFW.WindowHint'ContextVersionMinor 2)
  GLFW.windowHint (GLFW.WindowHint'OpenGLForwardCompat True)
  GLFW.windowHint (GLFW.WindowHint'OpenGLProfile GLFW.OpenGLProfile'Core)
  mwin <- GLFW.createWindow 640 480 "Texture" Nothing Nothing
  case mwin of
    Nothing  -> putStrLn "createWindow failed"
    Just win -> do
      GLFW.makeContextCurrent (Just win)
      GLFW.swapInterval 1
      (vao, prog, texture) <- setup
      whileM_ (not <$> GLFW.windowShouldClose win) $ do
        GLFW.pollEvents
        draw vao prog texture
        GLFW.swapBuffers win

setup = do
  -- establish a VAO
  vao <- newVAO
  bindVAO vao
  -- load the shader
  vsource <- readFile "texture.vert"
  fsource <- readFile "texture.frag"
  prog <- newProgram vsource fsource
  useProgram prog
  -- load the vertices
  let blob = V.fromList -- a quad has four vertices
        [ -0.5, -0.5, 0, 1
        , -0.5,  0.5, 0, 0
        ,  0.5, -0.5, 1, 1
        ,  0.5,  0.5, 1, 0 ] :: V.Vector Float
  vbo <- newBufferObject blob StaticDraw
  bindVBO vbo
  setVertexLayout [ Attrib "position" 2 GLFloat
                  , Attrib "texcoord" 2 GLFloat ]
  -- load the element array to draw a quad with two triangles
  indices <- newElementArray (V.fromList [0,1,2,3,2,1] :: V.Vector Word8) StaticDraw
  bindElementArray indices
  -- load the texture with JuicyPixels
  let fromRight (Right x) = x
  ImageRGBA8 (Image w h image) <- fromRight <$> readImage "logo.png"
  texture <- newTexture2D image (w,h) RGBA 
  setTex2DFiltering Linear
  return (vao, prog, texture)

draw vao prog texture = do
  clearColorBuffer (0.5, 0.5, 0.5)
  bindVAO vao
  useProgram prog
  bindTexture2D texture
  drawIndexedTriangles 6 UByteIndices

The vertex shader for this example looks like

#version 150
in vec2 position;
in vec2 texcoord;
out vec2 Texcoord;
void main()
{
    gl_Position = vec4(position, 0.0, 1.0);
    Texcoord = texcoord;
}

And the fragment shader looks like

#version 150
in vec2 Texcoord;
out vec4 outColor;
uniform sampler2D tex;
void main()
{
  outColor = texture(tex, Texcoord);
}