anchor.diff:      (obj)
     (list (url-element/addr obj)))
   
  +(clim:define-presentation-to-command-translator select-user
  +    (user switch-to-private-channel-frame potato-frame)
  +    (obj)
  +  (list obj))
  +
   (defun redisplay-channel-content (channel)
     (let* ((frame (channel/frame channel))
            (pane (clim:find-pane-named frame 'channel-content)))
  
positive.code: (defun init-connection (frame)  
    (lparallel:future
      (let ((channels (loop
                        with channel-tree = (potato-client:load-channel-tree :connection (potato-frame/connection frame))
                        for domain in channel-tree
                        for domain-name = (cdr (assoc :name domain))
                        for type = (cdr (assoc :type domain))
                        unless (eq type :private)
                          append (loop
                                   for channel in (cdr (assoc :channels domain))
                                   for name = (cdr (assoc :name channel))
                                   for group-type = (cdr (assoc :group-type channel))
                                   unless (eq group-type :private)
                                     collect (make-instance 'channel
                                                            :id (cdr (assoc :id channel))
                                                            :name (format nil "~a - ~a" domain-name name)
                                                            :frame frame)))))
        (log:trace "Channels loaded: ~s" channels)
        (with-call-in-event-handler frame
          (setf (potato-frame/channels frame) channels)
  
negative.code:     (lparallel:future
        (potato-client:send-message (channel/id channel) text :connection (potato-frame/connection frame)))))
  
  (define-potato-frame-command (switch-to-private-channel-frame :name "Open private conversation")
    ((obj 'user))
    (log:error "Open private conversation not implemented. user = ~s" (user/id obj)))
  
  (define-potato-frame-command (open-url-in-browser :name "Open URL")
    ((url 'string))
    (uiop:run-program (list "xdg-open" url)))
  