diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.1.2
+
+- Everything runs in `(MonadIO m) => m a` instead of `IO a` now on.
+
 ## 0.1.1.3
 
 - Relaxed upper bounds on c2hs to enable the use of c2hs-0.24.*.
diff --git a/al.cabal b/al.cabal
--- a/al.cabal
+++ b/al.cabal
@@ -1,5 +1,5 @@
 name:                al
-version:             0.1.1.3
+version:             0.1.2
 synopsis:            OpenAL 1.1 raw API.
 description:         OpenAL is a minimalistic sound API that aims to provide
                      bare features for /spacialized audio/. The API looks like
@@ -8,12 +8,12 @@
                      Up to now, no OpenAL extension is supported. You're highly
                      invited to contribute ;).
 
-                     EAX is not supported yet eiher. It'll be embedded in
+                     EAX is not supported yet either. It'll be embedded in
                      future releases, soon.
 
                      IMPORTANT: In order to build and install "al", you'll
                      need to pass the path of the /include/ and /libs/ directory
-                     of your OpenAL installation.
+                     of your OpenAL installation if you get errors.
 
                      Then use this to install:
 
@@ -88,6 +88,7 @@
                      , ForeignFunctionInterface
 
   build-depends:       base >= 4.7 && < 4.8
+                     , mtl >= 2.1 && < 2.2
 
   hs-source-dirs:      src
 
diff --git a/src/Sound/AL/Buffer.chs b/src/Sound/AL/Buffer.chs
--- a/src/Sound/AL/Buffer.chs
+++ b/src/Sound/AL/Buffer.chs
@@ -8,17 +8,42 @@
 -- Portability : portable
 ----------------------------------------------------------------------------
 
-module Sound.AL.Buffer where
+module Sound.AL.Buffer (
+    alGenBuffers
+  , alDeleteBuffers
+  , alIsBuffer
+  , alBufferData
+  , alGetBufferf
+  , alGetBufferi
+  ) where
 
+import Control.Monad.Trans ( MonadIO(..) )
 import Foreign.C.Types
 import Foreign.Ptr ( Ptr )
 import Sound.AL.Types
 
 #include <al.h>
 
-foreign import CALLCV "alGenBuffers" alGenBuffers :: ALsizei -> Ptr ALuint -> IO ()
-foreign import CALLCV "alDeleteBuffers" alDeleteBuffers :: ALsizei -> Ptr ALuint -> IO ()
-foreign import CALLCV "alIsBuffer" alIsBuffer :: ALuint -> IO ALboolean
-foreign import CALLCV "alBufferData" alBufferData :: ALuint -> ALenum -> Ptr a -> ALsizei -> ALsizei -> IO ()
-foreign import CALLCV "alGetBufferf" alGetBufferf :: ALuint -> ALenum -> Ptr ALfloat -> IO ()
-foreign import CALLCV "alGetBufferi" alGetBufferi :: ALuint -> ALenum -> Ptr ALint -> IO ()
+foreign import CALLCV "alGenBuffers" alGenBuffers_ :: ALsizei -> Ptr ALuint -> IO ()
+alGenBuffers :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()
+alGenBuffers a b = liftIO $ alGenBuffers_ a b
+
+foreign import CALLCV "alDeleteBuffers" alDeleteBuffers_ :: ALsizei -> Ptr ALuint -> IO ()
+alDeleteBuffers :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()
+alDeleteBuffers a b = liftIO $ alDeleteBuffers_ a b
+
+foreign import CALLCV "alIsBuffer" alIsBuffer_ :: ALuint -> IO ALboolean
+alIsBuffer :: (MonadIO m) => ALuint -> m ALboolean
+alIsBuffer = liftIO . alIsBuffer_
+
+foreign import CALLCV "alBufferData" alBufferData_ :: ALuint -> ALenum -> Ptr a -> ALsizei -> ALsizei -> IO ()
+alBufferData :: (MonadIO m) => ALuint -> ALenum -> Ptr a -> ALsizei -> ALsizei -> m ()
+alBufferData a b c d e = liftIO $ alBufferData_ a b c d e
+
+foreign import CALLCV "alGetBufferf" alGetBufferf_ :: ALuint -> ALenum -> Ptr ALfloat -> IO ()
+alGetBufferf :: (MonadIO m) => ALuint -> ALenum -> Ptr ALfloat -> m ()
+alGetBufferf a b c = liftIO $ alGetBufferf_ a b c
+
+foreign import CALLCV "alGetBufferi" alGetBufferi_ :: ALuint -> ALenum -> Ptr ALint -> IO ()
+alGetBufferi :: (MonadIO m) => ALuint -> ALenum -> Ptr ALint -> m ()
+alGetBufferi a b c = liftIO $ alGetBufferi_ a b c
diff --git a/src/Sound/AL/Errors.chs b/src/Sound/AL/Errors.chs
--- a/src/Sound/AL/Errors.chs
+++ b/src/Sound/AL/Errors.chs
@@ -10,9 +10,12 @@
 
 module Sound.AL.Errors where
 
+import Control.Monad.Trans ( MonadIO(..) )
 import Foreign.C.Types
 import Sound.AL.Types
 
 #include <al.h>
 
-foreign import CALLCV "alGetError" alGetError :: IO ALenum
+foreign import CALLCV "alGetError" alGetError_ :: IO ALenum
+alGetError :: (MonadIO m) => m ALenum
+alGetError = liftIO alGetError_
diff --git a/src/Sound/AL/Extensions.chs b/src/Sound/AL/Extensions.chs
--- a/src/Sound/AL/Extensions.chs
+++ b/src/Sound/AL/Extensions.chs
@@ -10,12 +10,21 @@
 
 module Sound.AL.Extensions where
 
+import Control.Monad.Trans ( MonadIO(..) ) 
 import Foreign.C.Types
 import Foreign.Ptr ( Ptr )
 import Sound.AL.Types
 
 #include <al.h>
 
-foreign import CALLCV "alIsExtensionPresent" alIsExtensionPresent :: Ptr ALubyte -> IO ALboolean
-foreign import CALLCV "alGetProcAddress" alGetProcAddress :: Ptr ALubyte -> IO (Ptr ALvoid)
-foreign import CALLCV "alGetEnumValue" alGetEnumValue :: Ptr ALubyte -> IO ALenum
+foreign import CALLCV "alIsExtensionPresent" alIsExtensionPresent_ :: Ptr ALubyte -> IO ALboolean
+alIsExtensionPresent :: (MonadIO m) => Ptr ALubyte -> m ALboolean
+alIsExtensionPresent = liftIO . alIsExtensionPresent
+
+foreign import CALLCV "alGetProcAddress" alGetProcAddress_ :: Ptr ALubyte -> IO (Ptr ALvoid)
+alGetProcAddress :: (MonadIO m) => Ptr ALubyte -> m (Ptr ALvoid)
+alGetProcAddress = liftIO . alGetProcAddress_
+
+foreign import CALLCV "alGetEnumValue" alGetEnumValue_ :: Ptr ALubyte -> IO ALenum
+alGetEnumValue :: (MonadIO m) => Ptr ALubyte -> m ALenum
+alGetEnumValue = liftIO . alGetEnumValue
diff --git a/src/Sound/AL/Listener.chs b/src/Sound/AL/Listener.chs
--- a/src/Sound/AL/Listener.chs
+++ b/src/Sound/AL/Listener.chs
@@ -10,17 +10,41 @@
 
 module Sound.AL.Listener where
 
+import Control.Monad.Trans ( MonadIO(..) )
 import Foreign.C.Types
 import Foreign.Ptr ( Ptr )
 import Sound.AL.Types
 
 #include <al.h>
 
-foreign import CALLCV "alListenerf" alListenerf :: ALenum -> ALfloat -> IO ()
-foreign import CALLCV "alListener3f" alListener3f :: ALenum -> ALfloat -> ALfloat -> ALfloat -> IO ()
-foreign import CALLCV "alListenerfv" alListenerfv :: ALenum -> Ptr ALfloat -> IO ()
-foreign import CALLCV "alListeneri" alListeneri :: ALenum -> ALint -> IO ()
-foreign import CALLCV "alGetListenerf" alGetListenerf :: ALenum -> Ptr ALfloat -> IO ()
-foreign import CALLCV "alGetListener3f" alGetListener3f :: ALenum -> Ptr ALfloat -> Ptr ALfloat -> Ptr ALfloat -> IO ()
-foreign import CALLCV "alGetListenerfv" alGetListenerfv :: ALenum -> Ptr ALfloat -> IO ()
-foreign import CALLCV "alGetListeneri" alGetListeneri :: ALenum -> Ptr ALint -> IO ()
+foreign import CALLCV "alListenerf" alListenerf_ :: ALenum -> ALfloat -> IO ()
+alListenerf :: (MonadIO m) => ALenum -> ALfloat -> m ()
+alListenerf a b = liftIO $ alListenerf_ a b
+
+foreign import CALLCV "alListener3f" alListener3f_ :: ALenum -> ALfloat -> ALfloat -> ALfloat -> IO ()
+alListener3f :: (MonadIO m) => ALenum -> ALfloat -> ALfloat -> ALfloat -> m ()
+alListener3f a b c d = liftIO $ alListener3f_ a b c d
+
+foreign import CALLCV "alListenerfv" alListenerfv_ :: ALenum -> Ptr ALfloat -> IO ()
+alListenerfv :: (MonadIO m) => ALenum -> Ptr ALfloat -> m ()
+alListenerfv a b = liftIO $ alListenerfv_ a b
+
+foreign import CALLCV "alListeneri" alListeneri_ :: ALenum -> ALint -> IO ()
+alListeneri :: (MonadIO m) => ALenum -> ALint -> m ()
+alListeneri a b = liftIO $ alListeneri_ a b
+
+foreign import CALLCV "alGetListenerf" alGetListenerf_ :: ALenum -> Ptr ALfloat -> IO ()
+alGetListenerf :: (MonadIO m) => ALenum -> Ptr ALfloat -> m ()
+alGetListenerf a b = liftIO $ alGetListenerf_ a b
+
+foreign import CALLCV "alGetListener3f" alGetListener3f_ :: ALenum -> Ptr ALfloat -> Ptr ALfloat -> Ptr ALfloat -> IO ()
+alGetListener3f :: (MonadIO m) => ALenum -> Ptr ALfloat -> Ptr ALfloat -> Ptr ALfloat -> m ()
+alGetListener3f a b c d = liftIO $ alGetListener3f_ a b c d
+
+foreign import CALLCV "alGetListenerfv" alGetListenerfv_ :: ALenum -> Ptr ALfloat -> IO ()
+alGetListenerfv :: (MonadIO m) => ALenum -> Ptr ALfloat -> m ()
+alGetListenerfv a b = liftIO $ alGetListenerfv_ a b
+
+foreign import CALLCV "alGetListeneri" alGetListeneri_ :: ALenum -> Ptr ALint -> IO ()
+alGetListeneri :: (MonadIO m) => ALenum -> Ptr ALint -> m ()
+alGetListeneri a b = liftIO $ alGetListeneri_ a b
diff --git a/src/Sound/AL/Source.chs b/src/Sound/AL/Source.chs
--- a/src/Sound/AL/Source.chs
+++ b/src/Sound/AL/Source.chs
@@ -10,29 +10,89 @@
 
 module Sound.AL.Source where
 
+import Control.Monad.Trans ( MonadIO(..) )
 import Foreign.C.Types
 import Foreign.Ptr ( Ptr )
 import Sound.AL.Types
 
 #include <al.h>
 
-foreign import CALLCV "alGenSources" alGenSources :: ALsizei -> Ptr ALuint -> IO ()
-foreign import CALLCV "alDeleteSources" alDeleteSources :: ALsizei -> Ptr ALuint -> IO ()
-foreign import CALLCV "alIsSource" alIsSource :: ALuint -> IO ALboolean
-foreign import CALLCV "alSourcef" alSourcef :: ALuint -> ALenum -> ALfloat -> IO ()
-foreign import CALLCV "alSourcefv" alSourcefv :: ALuint -> ALenum -> Ptr ALfloat -> IO ()
-foreign import CALLCV "alSource3f" alSource3f :: ALuint -> ALenum -> ALfloat -> ALfloat -> ALfloat -> IO ()
-foreign import CALLCV "alSourcei" alSourcei :: ALuint -> ALenum -> ALint -> IO ()
-foreign import CALLCV "alGetSourcef" alGetSourcef :: ALuint -> ALenum -> Ptr ALfloat -> IO ()
-foreign import CALLCV "alGetSourcefv" alGetSourcefv :: ALuint -> ALenum -> Ptr ALfloat -> IO ()
-foreign import CALLCV "alGetSourcei" alGetSourcei :: ALuint -> ALenum -> Ptr ALint -> IO ()
-foreign import CALLCV "alSourcePlay" alSourcePlay :: ALuint -> IO ()
-foreign import CALLCV "alSourcePlayv" alSourcePlayv :: ALsizei -> Ptr ALuint -> IO ()
-foreign import CALLCV "alSourcePause" alSourcePause :: ALuint -> IO ()
-foreign import CALLCV "alSourcePausev" alSourcePausev :: ALsizei -> Ptr ALuint -> IO ()
-foreign import CALLCV "alSourceStop" alSourceStop :: ALuint -> IO ()
-foreign import CALLCV "alSourceStopv" alSourceStopv :: ALsizei -> Ptr ALuint -> IO ()
-foreign import CALLCV "alSourceRewind" alSourceRewind :: ALuint -> IO ()
-foreign import CALLCV "alSourceRewindv" alSourceRewindv :: ALsizei -> Ptr ALuint -> IO ()
-foreign import CALLCV "alSourceQueueBuffers" alSourceQueueBuffers :: ALuint -> ALsizei -> Ptr ALuint -> IO ()
-foreign import CALLCV "alSourceUnqueueBuffers" alSourceUnqueueBuffers :: ALuint -> ALsizei -> Ptr ALuint -> IO ()
+foreign import CALLCV "alGenSources" alGenSources_ :: ALsizei -> Ptr ALuint -> IO ()
+alGenSources :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()
+alGenSources a b = liftIO $ alGenSources_ a b
+
+foreign import CALLCV "alDeleteSources" alDeleteSources_ :: ALsizei -> Ptr ALuint -> IO ()
+alDeleteSources :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()
+alDeleteSources a b = liftIO $ alDeleteSources_ a b
+
+foreign import CALLCV "alIsSource" alIsSource_ :: ALuint -> IO ALboolean
+alIsSource :: (MonadIO m) => ALuint -> m ALboolean
+alIsSource = liftIO . alIsSource_
+
+foreign import CALLCV "alSourcef" alSourcef_ :: ALuint -> ALenum -> ALfloat -> IO ()
+alSourcef :: (MonadIO m) => ALuint -> ALenum -> ALfloat -> m ()
+alSourcef a b c = liftIO $ alSourcef_ a b c
+
+foreign import CALLCV "alSourcefv" alSourcefv_ :: ALuint -> ALenum -> Ptr ALfloat -> IO ()
+alSourcefv :: (MonadIO m) => ALuint -> ALenum -> Ptr ALfloat -> m ()
+alSourcefv a b c = liftIO $ alSourcefv_ a b c
+
+foreign import CALLCV "alSource3f" alSource3f_ :: ALuint -> ALenum -> ALfloat -> ALfloat -> ALfloat -> IO ()
+alSource3f :: (MonadIO m) => ALuint -> ALenum -> ALfloat -> ALfloat -> ALfloat -> m ()
+alSource3f a b c d e = liftIO $ alSource3f_ a b c d e
+
+foreign import CALLCV "alSourcei" alSourcei_ :: ALuint -> ALenum -> ALint -> IO ()
+alSourcei :: (MonadIO m) => ALuint -> ALenum -> ALint -> m ()
+alSourcei a b c = liftIO $ alSourcei_ a b c
+
+foreign import CALLCV "alGetSourcef" alGetSourcef_ :: ALuint -> ALenum -> Ptr ALfloat -> IO ()
+alGetSourcef :: (MonadIO m) => ALuint -> ALenum -> Ptr ALfloat -> m ()
+alGetSourcef a b c = liftIO $ alGetSourcef_ a b c
+
+foreign import CALLCV "alGetSourcefv" alGetSourcefv_ :: ALuint -> ALenum -> Ptr ALfloat -> IO ()
+alGetSourcefv :: (MonadIO m) => ALuint -> ALenum -> Ptr ALfloat -> m ()
+alGetSourcefv a b c = liftIO $ alGetSourcefv_ a b c
+
+foreign import CALLCV "alGetSourcei" alGetSourcei_ :: ALuint -> ALenum -> Ptr ALint -> IO ()
+alGetSourcei :: (MonadIO m) => ALuint -> ALenum -> Ptr ALint -> m ()
+alGetSourcei a b c = liftIO $ alGetSourcei_ a b c
+
+foreign import CALLCV "alSourcePlay" alSourcePlay_ :: ALuint -> IO ()
+alSourcePlay :: (MonadIO m) => ALuint -> m ()
+alSourcePlay = liftIO . alSourcePlay_
+
+foreign import CALLCV "alSourcePlayv" alSourcePlayv_ :: ALsizei -> Ptr ALuint -> IO ()
+alSourcePlayv :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()
+alSourcePlayv a b = liftIO $ alSourcePlayv_ a b
+
+foreign import CALLCV "alSourcePause" alSourcePause_ :: ALuint -> IO ()
+alSourcePause :: (MonadIO m) => ALuint -> m ()
+alSourcePause = liftIO . alSourcePause_
+
+foreign import CALLCV "alSourcePausev" alSourcePausev_ :: ALsizei -> Ptr ALuint -> IO ()
+alSourcePausev :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()
+alSourcePausev a b = liftIO $ alSourcePausev_ a b
+
+foreign import CALLCV "alSourceStop" alSourceStop_ :: ALuint -> IO ()
+alSourceStop :: (MonadIO m) => ALuint -> m ()
+alSourceStop = liftIO . alSourceStop_
+
+foreign import CALLCV "alSourceStopv" alSourceStopv_ :: ALsizei -> Ptr ALuint -> IO ()
+alSourceStopv :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()
+alSourceStopv a b = liftIO $ alSourceStopv_ a b
+
+foreign import CALLCV "alSourceRewind" alSourceRewind_ :: ALuint -> IO ()
+alSourceRewind :: (MonadIO m) => ALuint -> m ()
+alSourceRewind = liftIO . alSourceRewind_
+
+foreign import CALLCV "alSourceRewindv" alSourceRewindv_ :: ALsizei -> Ptr ALuint -> IO ()
+alSourceRewindv :: (MonadIO m) => ALsizei -> Ptr ALuint -> m ()
+alSourceRewindv a b = liftIO $ alSourceRewindv_ a b
+
+foreign import CALLCV "alSourceQueueBuffers" alSourceQueueBuffers_ :: ALuint -> ALsizei -> Ptr ALuint -> IO ()
+alSourceQueueBuffers :: (MonadIO m) => ALuint -> ALsizei -> Ptr ALuint -> m ()
+alSourceQueueBuffers a b c = liftIO $ alSourceQueueBuffers_ a b c
+
+foreign import CALLCV "alSourceUnqueueBuffers" alSourceUnqueueBuffers_ :: ALuint -> ALsizei -> Ptr ALuint -> IO ()
+alSourceUnqueueBuffers :: (MonadIO m) => ALuint -> ALsizei -> Ptr ALuint -> m ()
+alSourceUnqueueBuffers a b c = liftIO $ alSourceUnqueueBuffers a b c
diff --git a/src/Sound/AL/State.chs b/src/Sound/AL/State.chs
--- a/src/Sound/AL/State.chs
+++ b/src/Sound/AL/State.chs
@@ -10,24 +10,69 @@
 
 module Sound.AL.State where
 
+import Control.Monad.Trans ( MonadIO(..) ) 
 import Foreign.C.Types
 import Foreign.Ptr ( Ptr )
 import Sound.AL.Types
 
 #include <al.h>
 
-foreign import CALLCV "alEnable" alEnable :: ALenum -> IO ()
-foreign import CALLCV "alDisable" alDisable :: ALenum -> IO ()
-foreign import CALLCV "alIsEnabled" alIsEnabled :: ALenum -> IO ALboolean
-foreign import CALLCV "alGetBoolean" alGetBoolean :: ALenum -> IO ALboolean
-foreign import CALLCV "alGetDouble" alGetDouble :: ALenum -> IO ALdouble
-foreign import CALLCV "alGetFloat" alGetFloat :: ALenum -> IO ALfloat
-foreign import CALLCV "alGetInteger" alGetInteger :: ALenum -> IO ALint
-foreign import CALLCV "alGetBooleanv" alGetBooleanv :: ALenum -> Ptr ALboolean -> IO ()
-foreign import CALLCV "alGetDoublev" alGetDoublev :: ALenum -> Ptr ALdouble -> IO ()
-foreign import CALLCV "alGetFloatv" alGetFloatv :: ALenum -> Ptr ALfloat -> IO ()
-foreign import CALLCV "alGetIntegerv" alGetIntegerv :: ALenum -> Ptr ALint -> IO ()
-foreign import CALLCV "alGetString" alGetString :: ALenum -> Ptr ALubyte
-foreign import CALLCV "alDistanceModel" alDistanceModel :: ALenum -> IO ()
-foreign import CALLCV "alDopplerFactor" alDopplerFactor :: ALfloat -> IO ()
-foreign import CALLCV "alDopplerVelocity" alDopplerVelocity :: ALfloat -> IO ()
+foreign import CALLCV "alEnable" alEnable_ :: ALenum -> IO ()
+alEnable :: (MonadIO m) => ALenum -> m ()
+alEnable = liftIO . alEnable_
+
+foreign import CALLCV "alDisable" alDisable_ :: ALenum -> IO ()
+alDisable :: (MonadIO m) => ALenum -> m ()
+alDisable = liftIO . alDisable_
+
+foreign import CALLCV "alIsEnabled" alIsEnabled_ :: ALenum -> IO ALboolean
+alIsEnabled :: (MonadIO m) => ALenum -> m ALboolean
+alIsEnabled = liftIO . alIsEnabled_
+
+foreign import CALLCV "alGetBoolean" alGetBoolean_ :: ALenum -> IO ALboolean
+alGetBoolean :: (MonadIO m) => ALenum -> m ALboolean
+alGetBoolean = liftIO . alGetBoolean_
+
+foreign import CALLCV "alGetDouble" alGetDouble_ :: ALenum -> IO ALdouble
+alGetDouble :: (MonadIO m) => ALenum -> m ALdouble
+alGetDouble = liftIO . alGetDouble_
+
+foreign import CALLCV "alGetFloat" alGetFloat_ :: ALenum -> IO ALfloat
+alGetFloat :: (MonadIO m) => ALenum -> m ALfloat
+alGetFloat = liftIO . alGetFloat_
+
+foreign import CALLCV "alGetInteger" alGetInteger_ :: ALenum -> IO ALint
+alGetInteger :: (MonadIO m) => ALenum -> m ALint
+alGetInteger = liftIO . alGetInteger_
+
+foreign import CALLCV "alGetBooleanv" alGetBooleanv_ :: ALenum -> Ptr ALboolean -> IO ()
+alGetBooleanv :: (MonadIO m) => ALenum -> Ptr ALboolean -> m ()
+alGetBooleanv a b = liftIO $ alGetBooleanv_ a b
+
+foreign import CALLCV "alGetDoublev" alGetDoublev_ :: ALenum -> Ptr ALdouble -> IO ()
+alGetDoublev :: (MonadIO m) => ALenum -> Ptr ALdouble -> m ()
+alGetDoublev a b = liftIO $ alGetDoublev_ a b
+
+foreign import CALLCV "alGetFloatv" alGetFloatv_ :: ALenum -> Ptr ALfloat -> IO ()
+alGetFloatv :: (MonadIO m) => ALenum -> Ptr ALfloat -> m ()
+alGetFloatv a b = liftIO $ alGetFloatv_ a b
+
+foreign import CALLCV "alGetIntegerv" alGetIntegerv_ :: ALenum -> Ptr ALint -> IO ()
+alGetIntegerv :: (MonadIO m) => ALenum -> Ptr ALint -> m ()
+alGetIntegerv a b = liftIO $ alGetIntegerv_ a b
+
+foreign import CALLCV "alGetString" alGetString_ :: ALenum -> IO (Ptr ALubyte)
+alGetString :: (MonadIO m) => ALenum -> m (Ptr ALubyte)
+alGetString = liftIO . alGetString_
+
+foreign import CALLCV "alDistanceModel" alDistanceModel_ :: ALenum -> IO ()
+alDistanceModel :: (MonadIO m) => ALenum -> m ()
+alDistanceModel = liftIO . alDistanceModel_
+
+foreign import CALLCV "alDopplerFactor" alDopplerFactor_ :: ALfloat -> IO ()
+alDopplerFactor :: (MonadIO m) => ALfloat -> m ()
+alDopplerFactor = liftIO . alDopplerFactor_
+
+foreign import CALLCV "alDopplerVelocity" alDopplerVelocity_ :: ALfloat -> IO ()
+alDopplerVelocity :: (MonadIO m) => ALfloat -> m ()
+alDopplerVelocity = liftIO . alDopplerVelocity_
diff --git a/src/Sound/ALC/Context.chs b/src/Sound/ALC/Context.chs
--- a/src/Sound/ALC/Context.chs
+++ b/src/Sound/ALC/Context.chs
@@ -10,14 +10,32 @@
 
 module Sound.ALC.Context where
 
+import Control.Monad.Trans ( MonadIO(..) )
 import Foreign.C.Types
 import Foreign.Ptr ( Ptr )
 import Sound.AL.Types
 import Sound.ALC.Types
 
-foreign import CALLCV "alcCreateContext" alcCreateContext :: Ptr ALCdevice -> Ptr ALint -> IO (Ptr ALvoid)
-foreign import CALLCV "alcMakeContextCurrent" alcMakeContextCurrent :: Ptr ALvoid -> IO ALCenum
-foreign import CALLCV "alcProcessContext" alcProcessContext :: Ptr ALvoid -> IO ()
-foreign import CALLCV "alcSuspendContext" alcSuspendContext :: Ptr ALvoid -> IO ()
-foreign import CALLCV "alcDestroyContext" alcDestroyContext :: Ptr ALvoid -> IO ALCenum
-foreign import CALLCV "alcGetCurrentContext" alcGetCurrentContext :: IO (Ptr ALvoid)
+foreign import CALLCV "alcCreateContext" alcCreateContext_ :: Ptr ALCdevice -> Ptr ALint -> IO (Ptr ALvoid)
+alcCreateContext :: (MonadIO m) => Ptr ALCdevice -> Ptr ALint -> m (Ptr ALvoid)
+alcCreateContext a b = liftIO $ alcCreateContext_ a b
+
+foreign import CALLCV "alcMakeContextCurrent" alcMakeContextCurrent_ :: Ptr ALvoid -> IO ALCenum
+alcMakeContextCurrent :: (MonadIO m) => Ptr ALvoid -> m ALCenum
+alcMakeContextCurrent = liftIO . alcMakeContextCurrent_
+
+foreign import CALLCV "alcProcessContext" alcProcessContext_ :: Ptr ALvoid -> IO ()
+alcProcessContext :: (MonadIO m) => Ptr ALvoid -> m ()
+alcProcessContext = liftIO . alcProcessContext_
+
+foreign import CALLCV "alcSuspendContext" alcSuspendContext_ :: Ptr ALvoid -> IO ()
+alcSuspendContext :: (MonadIO m) => Ptr ALvoid -> m ()
+alcSuspendContext = liftIO . alcSuspendContext_
+
+foreign import CALLCV "alcDestroyContext" alcDestroyContext_ :: Ptr ALvoid -> IO ALCenum
+alcDestroyContext :: (MonadIO m) => Ptr ALvoid -> m ALCenum
+alcDestroyContext = liftIO . alcDestroyContext_
+
+foreign import CALLCV "alcGetCurrentContext" alcGetCurrentContext_ :: IO (Ptr ALvoid)
+alcGetCurrentContext :: (MonadIO m) => m (Ptr ALvoid)
+alcGetCurrentContext = liftIO alcGetCurrentContext_
diff --git a/src/Sound/ALC/Device.chs b/src/Sound/ALC/Device.chs
--- a/src/Sound/ALC/Device.chs
+++ b/src/Sound/ALC/Device.chs
@@ -10,10 +10,15 @@
 
 module Sound.ALC.Device where
 
-import Foreign.C.Types
+import Control.Monad.Trans ( MonadIO(..) )
 import Foreign.Ptr ( Ptr )
 import Sound.AL.Types
 import Sound.ALC.Types
 
-foreign import CALLCV alcOpenDevice :: Ptr ALubyte -> IO (Ptr ALCdevice)
-foreign import CALLCV alcCloseDevice :: Ptr ALCdevice -> IO ()
+foreign import CALLCV "alcOpenDevice" alcOpenDevice_ :: Ptr ALubyte -> IO (Ptr ALCdevice)
+alcOpenDevice :: (MonadIO m) => Ptr ALubyte -> m (Ptr ALCdevice)
+alcOpenDevice = liftIO . alcOpenDevice_
+
+foreign import CALLCV "alcCloseDevice" alcCloseDevice_ :: Ptr ALCdevice -> IO ()
+alcCloseDevice  :: (MonadIO m) => Ptr ALCdevice -> m ()
+alcCloseDevice = liftIO . alcCloseDevice_
diff --git a/src/Sound/ALC/Errors.chs b/src/Sound/ALC/Errors.chs
--- a/src/Sound/ALC/Errors.chs
+++ b/src/Sound/ALC/Errors.chs
@@ -10,7 +10,10 @@
 
 module Sound.ALC.Errors where
 
+import Control.Monad.Trans ( MonadIO(..) )
 import Foreign.C.Types
 import Sound.ALC.Types
 
-foreign import CALLCV "alcGetError" alcGetError :: IO ALCenum
+foreign import CALLCV "alcGetError" alcGetError_ :: IO ALCenum
+alcGetError :: (MonadIO m) => m ALCenum
+alcGetError = liftIO alcGetError_
diff --git a/src/Sound/ALC/Extensions.chs b/src/Sound/ALC/Extensions.chs
--- a/src/Sound/ALC/Extensions.chs
+++ b/src/Sound/ALC/Extensions.chs
@@ -10,11 +10,20 @@
 
 module Sound.ALC.Extensions where
 
+import Control.Monad.Trans ( MonadIO(..) )
 import Foreign.C.Types
 import Foreign.Ptr ( Ptr )
 import Sound.AL.Types
 import Sound.ALC.Types
 
-foreign import CALLCV "alcIsExtensionPresent" alcIsExtensionPresent :: Ptr ALCdevice -> Ptr ALubyte -> IO ALboolean
-foreign import CALLCV "alcGetProcAddress" alcGetProcAddress :: Ptr ALCdevice -> Ptr ALubyte -> IO (Ptr ALvoid)
-foreign import CALLCV "alcGetEnumValue" alcGetEnumValue :: Ptr ALCdevice -> Ptr ALubyte -> IO ALenum
+foreign import CALLCV "alcIsExtensionPresent" alcIsExtensionPresent_ :: Ptr ALCdevice -> Ptr ALubyte -> IO ALboolean
+alcIsExtensionPresent :: (MonadIO m) => Ptr ALCdevice -> Ptr ALubyte -> m ALboolean
+alcIsExtensionPresent a b = liftIO $ alcIsExtensionPresent_ a b
+
+foreign import CALLCV "alcGetProcAddress" alcGetProcAddress_ :: Ptr ALCdevice -> Ptr ALubyte -> IO (Ptr ALvoid)
+alcGetProcAddress :: (MonadIO m) => Ptr ALCdevice -> Ptr ALubyte -> m (Ptr ALvoid)
+alcGetProcAddress a b = liftIO $ alcGetProcAddress_ a b
+
+foreign import CALLCV "alcGetEnumValue" alcGetEnumValue_ :: Ptr ALCdevice -> Ptr ALubyte -> IO ALenum
+alcGetEnumValue :: (MonadIO m) => Ptr ALCdevice -> Ptr ALubyte -> m ALenum
+alcGetEnumValue a b = liftIO $ alcGetEnumValue_ a b
diff --git a/src/Sound/ALC/State.chs b/src/Sound/ALC/State.chs
--- a/src/Sound/ALC/State.chs
+++ b/src/Sound/ALC/State.chs
@@ -10,10 +10,16 @@
 
 module Sound.ALC.State where
 
+import Control.Monad.Trans ( MonadIO(..) ) 
 import Foreign.C.Types
 import Foreign.Ptr ( Ptr )
 import Sound.AL.Types
 import Sound.ALC.Types
 
-foreign import CALLCV "alcGetString" alcGetString :: Ptr ALCdevice -> ALenum -> IO (Ptr ALubyte)
-foreign import CALLCV "alcGetIntegerv" alcGetIntegerv :: Ptr ALCdevice -> ALenum -> ALsizei -> Ptr ALint -> IO ()
+foreign import CALLCV "alcGetString" alcGetString_ :: Ptr ALCdevice -> ALenum -> IO (Ptr ALubyte)
+alcGetString :: (MonadIO m) => Ptr ALCdevice -> ALenum -> m (Ptr ALubyte)
+alcGetString a b = liftIO $ alcGetString_ a b
+
+foreign import CALLCV "alcGetIntegerv" alcGetIntegerv_ :: Ptr ALCdevice -> ALenum -> ALsizei -> Ptr ALint -> IO ()
+alcGetIntegerv :: (MonadIO m) => Ptr ALCdevice -> ALenum -> ALsizei -> Ptr ALint -> m ()
+alcGetIntegerv a b c d = liftIO $ alcGetIntegerv_ a b c d