diff --git a/lib/exirc/client.ex b/lib/exirc/client.ex
index 47f1532..acdc3a4 100644
--- a/lib/exirc/client.ex
+++ b/lib/exirc/client.ex
@@ -1,634 +1,646 @@
 defmodule ExIrc.Client do
   @moduledoc """
   Maintains the state and behaviour for individual IRC client connections
   """
   use    Irc.Commands
   import ExIrc.Logger
   import String, only: [to_char_list!: 1, from_char_list!: 1]
 
   alias ExIrc.Channels, as: Channels
   alias ExIrc.Utils,    as: Utils
 
   # Records
   defrecord ClientState,
     event_handlers:   [],
     server:           "localhost",
     port:             6667,
     socket:           nil,
     nick:             "",
     pass:             "",
     user:             "",
     name:             "",
     connected?:       false,
     logged_on?:       false,
     autoping:         true,
     channel_prefixes: "",
     network:          "",
     user_prefixes:    "",
     login_time:       "",
     channels:         [],
     debug?:           false
 
   #################
   # External API
   #################
 
   @doc """
   Start a new IRC client process
 
   Returns either {:ok, pid} or {:error, reason}
   """
   @spec start!(options :: list() | nil) :: {:ok, pid} | {:error, term}
   def start!(options \\ []) do
     start_link(options)
   end
   @doc """
   Start a new IRC client process.
 
   Returns either {:ok, pid} or {:error, reason}
   """
   @spec start!(options :: list() | nil) :: {:ok, pid} | {:error, term}
   def start_link(options \\ []) do
     :gen_server.start_link(__MODULE__, options, [])
   end
   @doc """
   Stop the IRC client process
   """
   @spec stop!(client :: pid) :: {:stop, :normal, :ok, ClientState.t}
   def stop!(client) do
     :gen_server.call(client, :stop)
   end
   @doc """
   Connect to a server with the provided server and port
 
   Example:
     Client.connect! pid, "localhost", 6667
   """
   @spec connect!(client :: pid, server :: binary, port :: non_neg_integer) :: :ok
   def connect!(client, server, port) do
     :gen_server.call(client, {:connect, server, port}, :infinity)
   end
   @doc """
   Determine if the provided client process has an open connection to a server
   """
   @spec is_connected?(client :: pid) :: true | false
   def is_connected?(client) do
     :gen_server.call(client, :is_connected?)
   end
   @doc """
   Logon to a server
 
   Example:
     Client.logon pid, "password", "mynick", "username", "My Name"
   """
   @spec logon(client :: pid, pass :: binary, nick :: binary, user :: binary, name :: binary) :: :ok | {:error, :not_connected}
   def logon(client, pass, nick, user, name) do
     :gen_server.call(client, {:logon, pass, nick, user, name}, :infinity)
   end
   @doc """
   Determine if the provided client is logged on to a server
   """
   @spec is_logged_on?(client :: pid) :: true | false
   def is_logged_on?(client) do
     :gen_server.call(client, :is_logged_on?)
   end
   @doc """
   Send a message to a nick or channel
   Message types are:
     :privmsg
     :notice
     :ctcp
   """
   @spec msg(client :: pid, type :: atom, nick :: binary, msg :: binary) :: :ok | {:error, atom}
   def msg(client, type, nick, msg) do
     :gen_server.call(client, {:msg, type, nick, msg}, :infinity)
   end
   @doc """
   Change the client's nick
   """
   @spec nick(client :: pid, new_nick :: binary) :: :ok | {:error, atom}
   def nick(client, new_nick) do
     :gen_server.call(client, {:nick, new_nick}, :infinity)
   end
   @doc """
   Send a raw IRC command
   """
   @spec cmd(client :: pid, raw_cmd :: binary) :: :ok | {:error, atom}
   def cmd(client, raw_cmd) do
     :gen_server.call(client, {:cmd, raw_cmd})
   end
   @doc """
   Join a channel, with an optional password
   """
   @spec join(client :: pid, channel :: binary, key :: binary | nil) :: :ok | {:error, atom}
   def join(client, channel, key \\ "") do
     :gen_server.call(client, {:join, channel, key}, :infinity)
   end
   @doc """
   Leave a channel
   """
   @spec part(client :: pid, channel :: binary) :: :ok | {:error, atom}
   def part(client, channel) do
     :gen_server.call(client, {:part, channel}, :infinity)
   end
   @doc """
   Kick a user from a channel
   """
   @spec kick(client :: pid, channel :: binary, nick :: binary, message :: binary | nil) :: :ok | {:error, atom}
   def kick(client, channel, nick, message \\ "") do
     :gen_server.call(client, {:kick, channel, nick, message}, :infinity)
   end
   @doc """
   Change mode for a user or channel
   """
   @spec mode(client :: pid, channel_or_nick :: binary, flags :: binary, args :: binary | nil) :: :ok | {:error, atom}
   def mode(client, channel_or_nick, flags, args \\ "") do
     :gen_server.call(client, {:mode, channel_or_nick, flags, args}, :infinity)
   end
   @doc """
   Invite a user to a channel
   """
   @spec invite(client :: pid, nick :: binary, channel :: binary) :: :ok | {:error, atom}
   def invite(client, nick, channel) do
     :gen_server.call(client, {:invite, nick, channel}, :infinity)
   end
   @doc """
   Quit the server, with an optional part message
   """
   @spec quit(client :: pid, msg :: binary | nil) :: :ok | {:error, atom}
   def quit(client, msg \\ "Leaving..") do
     :gen_server.call(client, {:quit, msg}, :infinity)
   end
   @doc """
   Get details about each of the client's currently joined channels
   """
   @spec channels(client :: pid) :: list(binary) | [] | {:error, atom}
   def channels(client) do
     :gen_server.call(client, :channels)
   end
   @doc """
   Get a list of users in the provided channel
   """
   @spec channel_users(client :: pid, channel :: binary) :: list(binary) | [] | {:error, atom}
   def channel_users(client, channel) do
     :gen_server.call(client, {:channel_users, channel})
   end
   @doc """
   Get the topic of the provided channel
   """
   @spec channel_topic(client :: pid, channel :: binary) :: binary | {:error, atom}
   def channel_topic(client, channel) do
     :gen_server.call(client, {:channel_topic, channel})
   end
   @doc """
   Get the channel type of the provided channel
   """
   @spec channel_type(client :: pid, channel :: binary) :: atom | {:error, atom}
   def channel_type(client, channel) do
     :gen_server.call(client, {:channel_type, channel})
   end
   @doc """
   Determine if a nick is present in the provided channel
   """
   @spec channel_has_user?(client :: pid, channel :: binary, nick :: binary) :: true | false | {:error, atom}
   def channel_has_user?(client, channel, nick) do
     :gen_server.call(client, {:channel_has_user?, channel, nick})
   end
   @doc """
   Add a new event handler process
   """
   @spec add_handler(client :: pid, pid) :: :ok
   def add_handler(client, pid) do
     :gen_server.call(client, {:add_handler, pid})
   end
   @doc """
   Add a new event handler process, asynchronously
   """
   @spec add_handler_async(client :: pid, pid) :: :ok
   def add_handler_async(client, pid) do
     :gen_server.cast(client, {:add_handler, pid})
   end
   @doc """
   Remove an event handler process
   """
   @spec remove_handler(client :: pid, pid) :: :ok
   def remove_handler(client, pid) do
     :gen_server.call(client, {:remove_handler, pid})
   end
   @doc """
   Remove an event handler process, asynchronously
   """
   @spec remove_handler_async(client :: pid, pid) :: :ok
   def remove_handler_async(client, pid) do
     :gen_server.cast(client, {:remove_handler, pid})
   end
   @doc """
   Get the current state of the provided client
   """
   @spec state(client :: pid) :: [{atom, any}]
   def state(client) do
     state = :gen_server.call(client, :state)
     [server:            state.server,
      port:              state.port,
      nick:              state.nick,
      pass:              state.pass,
      user:              state.user,
      name:              state.name,
      autoping:          state.autoping,
      connected?:        state.connected?,
      logged_on?:        state.logged_on?,
      channel_prefixes:  state.channel_prefixes,
      user_prefixes:     state.user_prefixes,
      channels:          Channels.to_proplist(state.channels),
      network:           state.network,
      login_time:        state.login_time,
      debug?:            state.debug?,
      event_handlers:    state.event_handlers]
   end
 
   ###############
   # GenServer API
   ###############
 
   @doc """
   Called when :gen_server initializes the client
   """
   @spec init(list(any) | []) :: {:ok, ClientState.t}
   def init(options \\ []) do
     autoping = Keyword.get(options, :autoping, true)
     debug    = Keyword.get(options, :debug, false)
     # Add event handlers
     handlers = 
       Keyword.get(options, :event_handlers, []) 
       |> List.foldl([], &do_add_handler/2)
     # Return initial state
     {:ok, ClientState[
       event_handlers: handlers,
       autoping:       autoping,
       logged_on?:     false,
       debug?:         debug,
       channels:       ExIrc.Channels.init()]}
   end
   @doc """
   Handle calls from the external API. It is not recommended to call these directly.
   """
   # Handle call to get the current state of the client process
   def handle_call(:state, _from, state), do: {:reply, state, state}
   # Handle call to stop the current client process
   def handle_call(:stop, _from, state) do
     # Ensure the socket connection is closed if stop is called while still connected to the server
     if state.connected?, do: :gen_tcp.close(state.socket)
-    {:stop, :normal, :ok, state.connected?(false).logged_on?(false).socket(nil)}
+    {:stop, :normal, :ok, state.update [connected?: false, logged_on?: false, socket: nil]}
   end
   # Handles call to add a new event handler process
   def handle_call({:add_handler, pid}, _from, state) do
     handlers = do_add_handler(pid, state.event_handlers)
-    {:reply, :ok, state.event_handlers(handlers)}
+    {:reply, :ok, state.update [event_handlers: handlers]}
   end
   # Handles call to remove an event handler process
   def handle_call({:remove_handler, pid}, _from, state) do
     handlers = do_remove_handler(pid, state.event_handlers)
-    {:reply, :ok, state.event_handlers(handlers)}
+    {:reply, :ok, state.update [event_handlers: handlers]}
   end
   # Handle call to connect to an IRC server
   def handle_call({:connect, server, port}, _from, state) do
     # If there is an open connection already, close it.
     if state.socket != nil, do: :gen_tcp.close(state.socket)
     # Open a new connection
     case :gen_tcp.connect(to_char_list!(server), port, [:list, {:packet, :line}, {:keepalive, true}]) do
       {:ok, socket} ->
         send_event {:connected, server, port}, state
         {:reply, :ok, state.connected?(true).server(server).port(port).socket(socket)}
       error ->
         {:reply, error, state}
     end
   end
   # Handle call to determine if the client is connected
   def handle_call(:is_connected?, _from, state), do: {:reply, state.connected?, state}
   # Prevents any of the following messages from being handled if the client is not connected to a server.
   # Instead, it returns {:error, :not_connected}.
   def handle_call(_, _from, ClientState[connected?: false] = state), do: {:reply, {:error, :not_connected}, state}
   # Handle call to login to the connected IRC server
   def handle_call({:logon, pass, nick, user, name}, _from, ClientState[logged_on?: false] = state) do
     send! state.socket, pass!(pass)
     send! state.socket, nick!(nick)
     send! state.socket, user!(user, name)
-    {:reply, :ok, state.pass(pass).nick(nick).user(user).name(name)}
+    {:reply, :ok, state.update [pass: pass, nick: nick, user: user, name: name] }
   end
   # Handle call to determine if client is logged on to a server
   def handle_call(:is_logged_on?, _from, state), do: {:reply, state.logged_on?, state}
   # Prevents any of the following messages from being handled if the client is not logged on to a server.
   # Instead, it returns {:error, :not_logged_in}.
   def handle_call(_, _from, ClientState[logged_on?: false] = state), do: {:reply, {:error, :not_logged_in}, state}
   # Handles call to send a message
   def handle_call({:msg, type, nick, msg}, _from, state) do
     data = case type do
       :privmsg -> privmsg!(nick, msg)
       :notice  -> notice!(nick, msg)
       :ctcp    -> notice!(nick, ctcp!(msg))
     end
     send! state.socket, data
     {:reply, :ok, state}
   end
   # Handles call to join a channel
   def handle_call({:join, channel, key}, _from, state)      do send!(state.socket, join!(channel, key)); {:reply, :ok, state} end
   # Handles a call to leave a channel
   def handle_call({:part, channel}, _from, state)           do send!(state.socket, part!(channel)); {:reply, :ok, state} end
   # Handles a call to kick a client
   def handle_call({:kick, channel, nick, message}, _from, state) do
     send!(state.socket, kick!(channel, nick, message))
     {:reply, :ok, state}
   end
   # Handles a call to change mode for a user or channel
   def handle_call({:mode, channel_or_nick, flags, args}, _from, state) do
     send!(state.socket, mode!(channel_or_nick, flags, args))
     {:reply, :ok, state}
   end
   # Handle call to invite a user to a channel
   def handle_call({:invite, nick, channel}, _from, state) do
     send!(state.socket, invite!(nick, channel))
     {:reply, :ok, state}
   end
   # Handle call to quit the server and close the socket connection
   def handle_call({:quit, msg}, _from, state) do
     if state.connected? do
       send! state.socket, quit!(msg)
       send_event :disconnected, state
       :gen_tcp.close state.socket
     end
-    {:reply, :ok, state.connected?(false).logged_on?(false).socket(nil)}
+    {:reply, :ok, state.update [connected?: false, logged_on?: false, socket: nil]}
   end
   # Handles call to change the client's nick
   def handle_call({:nick, new_nick}, _from, state) do send!(state.socket, nick!(new_nick)); {:reply, :ok, state} end
   # Handles call to send a raw command to the IRC server
   def handle_call({:cmd, raw_cmd}, _from, state) do send!(state.socket, command!(raw_cmd)); {:reply, :ok, state} end
   # Handles call to return the client's channel data
   def handle_call(:channels, _from, state), do: {:reply, Channels.channels(state.channels), state}
   # Handles call to return a list of users for a given channel
   def handle_call({:channel_users, channel}, _from, state), do: {:reply, Channels.channel_users(state.channels, channel), state}
   # Handles call to return the given channel's topic
   def handle_call({:channel_topic, channel}, _from, state), do: {:reply, Channels.channel_topic(state.channels, channel), state}
   # Handles call to return the type of the given channel
   def handle_call({:channel_type, channel}, _from, state), do: {:reply, Channels.channel_type(state.channels, channel), state}
   # Handles call to determine if a nick is present in the given channel
   def handle_call({:channel_has_user?, channel, nick}, _from, state) do
     {:reply, Channels.channel_has_user?(state.channels, channel, nick), state}
   end
   # Handles message to add a new event handler process asynchronously
   def handle_cast({:add_handler, pid}, state) do
     handlers = do_add_handler(pid, state.event_handlers)
-    {:noreply, state.event_handlers(handlers)}
+    {:noreply, state.update [event_handlers: handlers]}
   end
   @doc """
   Handles asynchronous messages from the external API. Not recommended to call these directly.
   """
   # Handles message to remove an event handler process asynchronously
   def handle_cast({:remove_handler, pid}, state) do
     handlers = do_remove_handler(pid, state.event_handlers)
-    {:noreply, state.event_handlers(handlers)}
+    {:noreply, state.update [event_handlers: handlers]}
   end
   @doc """
   Handle messages from the TCP socket connection.
   """
   # Handles the client's socket connection 'closed' event
   def handle_info({:tcp_closed, _socket}, ClientState[server: server, port: port] = state) do
     info "Connection to #{server}:#{port} closed!"
     send_event :disconnected, state
-    {:noreply, state.socket(nil).connected?(false).logged_on?(false).channels(Channels.init())}
+    new_state = state.update [
+      socket:     nil,
+      connected?: false,
+      logged_on?: false,
+      channels:   Channels.init()
+    ]
+    {:noreply, new_state}
   end
   # Handles any TCP errors in the client's socket connection
   def handle_info({:tcp_error, socket, reason}, ClientState[server: server, port: port] = state) do
     error "TCP error in connection to #{server}:#{port}:\r\n#{reason}\r\nClient connection closed."
-    {:stop, {:tcp_error, socket}, state.socket(nil).connected?(false).logged_on?(false).channels(Channels.init())}
+    new_state = state.update [
+      socket: nil,
+      connected?: false,
+      logged_on?: false,
+      channels: Channels.init()
+    ]
+    {:stop, {:tcp_error, socket}, new_state}
   end
   # General handler for messages from the IRC server
   def handle_info({:tcp, _, data}, state) do
     debug? = state.debug?
     case Utils.parse(data) do
       IrcMessage[ctcp: true] = msg ->
         send_event msg, state
         {:noreply, state}
       IrcMessage[ctcp: false] = msg ->
         send_event msg, state
         handle_data msg, state
       IrcMessage[ctcp: :invalid] = msg when debug? ->
         send_event msg, state
         {:noreply, state}
       _ ->
         {:noreply, state}
     end
   end
   # If an event handler process dies, remove it from the list of event handlers
   def handle_info({'DOWN', _, _, pid, _}, state) do
     handlers = do_remove_handler(pid, state.event_handlers)
-    {:noreply, state.event_handlers(handlers)}
+    {:noreply, state.update [event_handlers: handlers]}
   end
   # Catch-all for unrecognized messages (do nothing)
   def handle_info(_, state) do
     {:noreply, state}
   end
   @doc """
   Handle termination
   """
   def terminate(_reason, state) do
     if state.socket != nil do
       :gen_tcp.close state.socket
-      state.socket(nil)
+      state.update [socket: nil]
     end
     :ok
   end
   @doc """
   Transform state for hot upgrades/downgrades
   """
   def code_change(_old, state, _extra), do: {:ok, state}
 
   ################
   # Data handling
   ################
 
   @doc """
   Handle IrcMessages received from the server.
   """
   # Called upon successful login
   def handle_data(IrcMessage[cmd: @rpl_welcome] = _msg, ClientState[logged_on?: false] = state) do
     if state.debug?, do: debug "SUCCESFULLY LOGGED ON"
-    new_state = state.logged_on?(true).login_time(:erlang.now())
+    new_state = state.update [logged_on?: true, login_time: :erlang.now()]
     send_event :logged_in, new_state
     {:noreply, new_state}
   end
   # Called when the server sends it's current capabilities
   def handle_data(IrcMessage[cmd: @rpl_isupport] = msg, state) do
     if state.debug?, do: debug "RECEIVING SERVER CAPABILITIES"
     {:noreply, Utils.isup(msg.args, state)}
   end
   # Called when the client enters a channel
   def handle_data(IrcMessage[nick: nick, cmd: "JOIN"] = msg, ClientState[nick: nick] = state) do
     channel = msg.args |> List.first
     if state.debug?, do: debug "JOINED A CHANNEL #{channel}"
     channels  = Channels.join(state.channels, channel)
-    new_state = state.channels(channels)
+    new_state = state.update [channels: channels]
     send_event {:joined, channel}, new_state
     {:noreply, state.channels(channels)}
   end
   # Called when another user joins a channel the client is in
   def handle_data(IrcMessage[nick: user_nick, cmd: "JOIN"] = msg, state) do
     channel = msg.args |> List.first
     if state.debug?, do: debug "ANOTHER USER JOINED A CHANNEL: #{channel} - #{user_nick}"
     channels  = Channels.user_join(state.channels, channel, user_nick)
-    new_state = state.channels(channels)
+    new_state = state.update [channels: channels]
     send_event {:joined, channel, user_nick}, new_state
     {:noreply, state.channels(channels)}
   end
   # Called on joining a channel, to tell us the channel topic
   # Message with three arguments is not RFC compliant but very common
   # Message with two arguments is RFC compliant
   def handle_data(IrcMessage[cmd: @rpl_topic] = msg, state) do
     if state.debug?, do: debug "INITIAL TOPIC MSG"
     {channel, topic} = case msg.args do
       [_nick, channel, topic] -> debug("1. TOPIC SET FOR #{channel} TO #{topic}"); {channel, topic}
       [channel, topic]        -> debug("2. TOPIC SET FOR #{channel} TO #{topic}"); {channel, topic}
     end
     channels  = Channels.set_topic(state.channels, channel, topic)
-    new_state = state.channels(channels)
+    new_state = state.update [channels: channels]
     send_event {:topic_changed, channel, topic}, new_state
     {:noreply, new_state}
   end
   # Called when the topic changes while we're in the channel
   def handle_data(IrcMessage[cmd: "TOPIC", args: [channel, topic]], state) do
     if state.debug?, do: debug "TOPIC CHANGED FOR #{channel} TO #{topic}"
     channels  = Channels.set_topic(state.channels, channel, topic)
-    new_state = state.channels(channels)
+    new_state = state.update [channels: channels]
     send_event {:topic_changed, channel, topic}, new_state
     {:noreply, state.channels(channels)}
   end
   # Called when joining a channel with the list of current users in that channel, or when the NAMES command is sent
   def handle_data(IrcMessage[cmd: @rpl_namereply] = msg, state) do
     if state.debug?, do: debug "NAMES LIST RECEIVED"
     {_nick, channel_type, channel, names} = case msg.args do
       [nick, channel_type, channel, names]  -> {nick, channel_type, channel, names}
       [channel_type, channel, names]        -> {nil, channel_type, channel, names}
     end
     channels = Channels.set_type(
       Channels.users_join(state.channels, channel, String.split(names, " ", trim: true)),
       channel,
       channel_type)
-    {:noreply, state.channels(channels)}
+    {:noreply, state.update [channels: channels]}
   end
   # Called when our nick has succesfully changed
   def handle_data(IrcMessage[cmd: "NICK", nick: nick, args: [new_nick]], ClientState[nick: nick] = state) do
     if state.debug?, do: debug "NICK CHANGED FROM #{nick} TO #{new_nick}"
-    new_state = state.nick(new_nick)
+    new_state = state.update [nick: new_nick]
     send_event {:nick_changed, new_nick}, new_state
     {:noreply, new_state}
   end
   # Called when someone visible to us changes their nick
   def handle_data(IrcMessage[cmd: "NICK", nick: nick, args: [new_nick]], state) do
     if state.debug?, do: debug "#{nick} CHANGED THEIR NICK TO #{new_nick}"
     channels  = Channels.user_rename(state.channels, nick, new_nick)
-    new_state = state.channels(channels)
+    new_state = state.update [channels: channels]
     send_event {:nick_changed, nick, new_nick}, new_state
     {:noreply, new_state}
   end
   # Called when we leave a channel
   def handle_data(IrcMessage[cmd: "PART", nick: nick] = msg, ClientState[nick: nick] = state) do
     channel = msg.args |> List.first
     if state.debug?, do: debug "WE LEFT A CHANNEL: #{channel}"
     channels  = Channels.part(state.channels, channel)
-    new_state = state.channels(channels)
+    new_state = state.update [channels: channels]
     send_event {:parted, channel}, new_state
     {:noreply, new_state}
   end
   # Called when someone else in our channel leaves
   def handle_data(IrcMessage[cmd: "PART", nick: user_nick] = msg, state) do
     channel = msg.args |> List.first
     if state.debug?, do: debug "#{user_nick} LEFT A CHANNEL: #{channel}"
     channels  = Channels.user_part(state.channels, channel, user_nick)
-    new_state = state.channels(channels)
+    new_state = state.update [channels: channels]
     send_event {:parted, channel, user_nick}, new_state
     {:noreply, new_state}
   end
   # Called when we receive a PING
   def handle_data(IrcMessage[cmd: "PING"] = msg, ClientState[autoping: true] = state) do
     if state.debug?, do: debug "RECEIVED A PING!"
     case msg do
       IrcMessage[args: [from]] -> debug("SENT PONG2"); send!(state.socket, pong2!(state.nick, from))
                              _ -> debug("SENT PONG1"); send!(state.socket, pong1!(state.nick))
     end
     {:noreply, state};
   end
   # Called when we are invited to a channel
   def handle_data(IrcMessage[cmd: "INVITE", args: [nick, channel], nick: by] = msg, ClientState[nick: nick] = state) do
     if state.debug?, do: debug "RECEIVED AN INVITE: #{msg.args |> Enum.join(" ")}"
     send_event {:invited, by, channel}, state
     {:noreply, state}
   end
   # Called when we are kicked from a channel
   def handle_data(IrcMessage[cmd: "KICK", args: [channel, nick], nick: by] = _msg, ClientState[nick: nick] = state) do
     if state.debug?, do: debug "WE WERE KICKED FROM #{channel} BY #{by}"
     send_event {:kicked, by, channel}, state
     {:noreply, state}
   end
   # Called when someone else was kicked from a channel
   def handle_data(IrcMessage[cmd: "KICK", args: [channel, nick], nick: by] = _msg, state) do
     if state.debug?, do: debug "#{nick} WAS KICKED FROM #{channel} BY #{by}"
     send_event {:kicked, nick, by, channel}, state
     {:noreply, state}
   end
   # Called when someone sends us a message
   def handle_data(IrcMessage[nick: from, cmd: "PRIVMSG", args: [nick, message]] = _msg, ClientState[nick: nick] = state) do
     if state.debug?, do: debug "#{from} SENT US #{message}"
     send_event {:received, message, from}, state
     {:noreply, state}
   end
   # Called when someone sends a message to a channel we're in, or a list of users
   def handle_data(IrcMessage[nick: from, cmd: "PRIVMSG", args: [to, message]] = _msg, ClientState[nick: nick] = state) do
     if state.debug?, do: debug "#{from} SENT #{message} TO #{to}"
     case String.contains?(to, nick) do
       # Treat it like a private message if message was sent to a list of users that includes us
       true -> send_event {:received, message, from}, state
       # Otherwise it was just a channel message
       _ ->
         send_event {:received, message, from, to}, state
         # If we were mentioned, fire that event as well
         if String.contains?(message, nick), do: send_event({:mentioned, message, from, to}, state)
     end
     {:noreply, state}
   end
   # Called any time we receive an unrecognized message
   def handle_data(msg, state) do
     if state.debug? do debug "UNRECOGNIZED MSG: #{msg.cmd}"; IO.inspect(msg) end
     {:noreply, state}
   end
 
   ###############
   # Internal API
   ###############
   defp send_event(msg, ClientState[event_handlers: handlers]) when is_list(handlers) do
     Enum.each(handlers, fn({pid, _}) -> Kernel.send(pid, msg) end)
   end
 
   defp do_add_handler(pid, handlers) do
     case Process.alive?(pid) and not Enum.member?(handlers, pid) do
       true ->
         ref = Process.monitor(pid)
         [{pid, ref} | handlers]
       false ->
         handlers
     end
   end
 
   defp do_remove_handler(pid, handlers) do
     case List.keyfind(handlers, pid, 0) do
       {pid, ref} ->
         Process.demonitor(ref)
         List.keydelete(handlers, pid, 0)
       nil ->
           handlers
     end
   end
 
   defp debug(msg) do
     IO.puts(IO.ANSI.green() <> msg <> IO.ANSI.reset())
   end
 
 end
\ No newline at end of file
diff --git a/lib/exirc/utils.ex b/lib/exirc/utils.ex
index fbed98f..01d8b68 100644
--- a/lib/exirc/utils.ex
+++ b/lib/exirc/utils.ex
@@ -1,171 +1,171 @@
 defmodule ExIrc.Utils do
 
   import String, only: [from_char_list!: 1]
 
   ######################
   # IRC Message Parsing
   ######################
 
   @doc """
   Parse an IRC message
 
   Example:
 
       data    = ':irc.example.org 005 nick NETWORK=Freenode PREFIX=(ov)@+ CHANTYPES=#&'
       message = ExIrc.Utils.parse data
       assert "irc.example.org" = message.server
   """
   @spec parse(raw_data :: char_list) :: IrcMessage.t
   def parse(raw_data) do
     data = :string.substr(raw_data, 1, length(raw_data))
     case data do
       [?:|_] ->
           [[?:|from]|rest] = :string.tokens(data, ' ')
           get_cmd(rest, parse_from(from, IrcMessage[ctcp: false]))
       data ->
           get_cmd(:string.tokens(data, ' '), IrcMessage[ctcp: false])
     end
   end
 
   defp parse_from(from, msg) do
     case Regex.split(~r/(!|@|\.)/, iolist_to_binary(from)) do
       [nick, "!", user, "@", host | host_rest] ->
-        msg.nick(nick).user(user).host(host <> host_rest)
+        msg.update [nick: nick, user: user, host: host <> host_rest]
       [nick, "@", host | host_rest] ->
-        msg.nick(nick).host(host <> host_rest)
+        msg.update [nick: nick, host: host <> host_rest]
       [_, "." | _] ->
         # from is probably a server name
-        msg.server(from_char_list!(from))
+        msg.update [server: from_char_list!(from)]
       [nick] ->
-        msg.nick(nick)
+        msg.update [nick: nick]
     end
   end
 
   # Parse command from message
   defp get_cmd([cmd, arg1, [?:, 1 | ctcp_trail] | restargs], msg) when cmd == 'PRIVMSG' or cmd == 'NOTICE' do
     get_cmd([cmd, arg1, [1 | ctcp_trail] | restargs], msg)
   end
 
   defp get_cmd([cmd, _arg1, [1 | ctcp_trail] | restargs], msg) when cmd == 'PRIVMSG' or cmd == 'NOTICE' do
     args = ctcp_trail ++ lc arg inlist restargs, do: ' ' ++ arg
       |> Enum.flatten
       |> Enum.reverse
     case args do
       [1 | ctcp_rev] ->
         [ctcp_cmd | args] = ctcp_rev |> Enum.reverse |> :string.tokens(' ')
-        msg.cmd(from_char_list!(ctcp_cmd)).args(args).ctcp(true)
+        msg.update [cmd: from_char_list!(ctcp_cmd), args: args, ctcp: true]
       _ ->
-        msg.cmd(from_char_list!(cmd)).ctcp(:invalid)
+        msg.update [cmd: from_char_list!(cmd), ctcp: :invalid]
     end
   end
 
   defp get_cmd([cmd | rest], msg) do
     get_args(rest, msg.cmd(from_char_list!(cmd)))
   end
 
 
   # Parse command args from message
   defp get_args([], msg) do
     msg.args
     |> Enum.reverse 
     |> Enum.filter(fn(arg) -> arg != [] end)
     |> Enum.map(&String.from_char_list!/1)
     |> msg.args
   end
 
   defp get_args([[?: | first_arg] | rest], msg) do
     args = (lc arg inlist [first_arg | rest], do: ' ' ++ trim_crlf(arg)) |> List.flatten
     case args do
       [_ | []] ->
-          get_args([], msg.args([msg.args]))
+          get_args [], msg.update([args: [msg.args]])
       [_ | full_trail] ->
-          get_args([], msg.args([full_trail | msg.args]))
+          get_args [], msg.update([args: [full_trail | msg.args]])
     end
   end
 
   defp get_args([arg | []], msg) do
-    get_args([], msg.args([arg | msg.args]))
+    get_args [], msg.update([args: [arg | msg.args]])
   end
 
   defp get_args([arg | rest], msg) do
-    get_args(rest, msg.args([arg | msg.args]))
+    get_args rest, msg.update([args: [arg | msg.args]])
   end
 
   ############################
   # Parse RPL_ISUPPORT (005)
   ############################
 
   @doc """
   Parse RPL_ISUPPORT message.
 
   If an empty list is provided, do nothing, otherwise parse CHANTYPES,
   NETWORK, and PREFIX parameters for relevant data.
   """
   @spec isup(parameters :: list(binary), state :: ExIrc.Client.ClientState.t) :: ExIrc.Client.ClientState.t
   def isup([], state), do: state
   def isup([param | rest], state) do
     try do
       isup(rest, isup_param(param, state))
     rescue
       _ -> isup(rest, state)
     end
   end
 
   defp isup_param("CHANTYPES=" <> channel_prefixes, state) do
     prefixes = channel_prefixes |> String.split("", trim: true)
-    state.channel_prefixes(prefixes)
+    state.update [channel_prefixes: prefixes]
   end
   defp isup_param("NETWORK=" <> network, state) do
-    state.network(network)
+    state.update [network: network]
   end
   defp isup_param("PREFIX=" <> user_prefixes, state) do
     prefixes = Regex.run(~r/\((.*)\)(.*)/, user_prefixes, capture: :all_but_first)
                |> Enum.map(&String.to_char_list!/1)
                |> List.zip
-    state.user_prefixes(prefixes)
+    state.update [user_prefixes: prefixes]
   end
   defp isup_param(_, state) do
     state
   end
 
   ###################
   # Helper Functions
   ###################
 
   @days_of_week   ['Mon','Tue','Wed','Thu','Fri','Sat','Sun']
   @months_of_year ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']
   @doc """
   Get CTCP formatted time from a tuple representing the current calendar time:
 
   Example:
 
       iex> local_time = {{2013,12,6},{14,5,00}}
       {{2013,12,6},{14,5,00}}
       iex> ExIrc.Utils.ctcp_time local_time
       "Fri Dec 06 14:05:00 2013"
   """
   @spec ctcp_time(datetime :: {{integer, integer, integer}, {integer, integer, integer}}) :: binary
   def ctcp_time({{y, m, d}, {h, n, s}} = _datetime) do
     [:lists.nth(:calendar.day_of_the_week(y,m,d), @days_of_week),
      ' ',
      :lists.nth(m, @months_of_year),
      ' ',
      :io_lib.format("~2..0s", [integer_to_list(d)]),
      ' ',
      :io_lib.format("~2..0s", [integer_to_list(h)]),
      ':',
      :io_lib.format("~2..0s", [integer_to_list(n)]),
      ':',
      :io_lib.format("~2..0s", [integer_to_list(s)]),
      ' ',
      integer_to_list(y)] |> List.flatten |> String.from_char_list!
   end
 
   defp trim_crlf(charlist) do
     case Enum.reverse(charlist) do
       [?\n, ?\r | text] -> Enum.reverse(text)
       _ -> charlist
     end
   end
 
 end
\ No newline at end of file