Implement states in functional programming

I wrote some libraries that tried to address this, the result was fairly ugly, IMO.

Basically, turned Activity, Fragment, etc. into pure functions that accepted State and returned State.

This in conjunction with IO monads made the interface somewhat pure. An example of this follows (the source to PureActivity can be found at https://github.com/pfn/iota-pure), the 'state' in this case is 'Option[Process]' with Process being present when logcat is running and empty when it is not. No vars:

class LogcatActivity extends AppCompatActivity with PureActivity[Option[Process]] {
  val LOG_LINE = """^([A-Z])/(.+?)\( *(\d+)\): (.*?)$""".r
  val buffersize = 1024
  lazy val toolbar = newToolbar
  lazy val recycler = {
    val r = new RecyclerView(this)
    r.setLayoutManager(new LinearLayoutManager(this))
    r.setAdapter(Adapter)
    r
  }
  lazy val layout = l[LinearLayout](
    toolbar.!  >>= lp(MATCH_PARENT, WRAP_CONTENT),
    recycler.! >>= lp(MATCH_PARENT, 0, 1)
  ) >>= vertical

  override def initialState(b: Option[Bundle]) = None

  override def applyState[T](s: ActivityState[T]) = s match {
    case OnPreCreate(_) => s(IO(
      setTheme(if (Settings.get(Settings.DAYNIGHT_MODE)) R.style.SetupTheme_Light else R.style.SetupTheme_Dark)
    ))
    case OnCreate(_) => s(IO {
      toolbar.setTitle("Logcat")
      toolbar.setNavigationIcon(resolveAttr(R.attr.qicrCloseIcon, _.resourceId))
      toolbar.navigationOnClick0(finish())
      setContentView(layout.perform())
    })
    case OnStart(_) => s.applyState(IO {
      var buffering = true
      val logcat = "logcat" :: "-v" :: "brief" :: Nil
      val lineLogger = new ProcessLogger {
        override def out(s: => String) = addLine(s)
        override def buffer[X](f: => X) = f
        override def err(s: => String) = addLine(s)

        def addLine(line: String) = line match {
          case LOG_LINE(level, tag, pid, msg) =>
            if (tag != "ResourceType") UiBus.run {
              val c = Adapter.getItemCount // store in case at max items already
              Adapter.buffer += LogEntry(tag, level, msg)
              Adapter.notifyItemInserted(math.min(buffersize, c + 1))
              if (!buffering)
                recycler.smoothScrollToPosition(Adapter.getItemCount)
            }
          case _ =>
        }
      }
      Future {
        Thread.sleep(500)
        buffering = false
      } onSuccessMain { case _ =>
        recycler.scrollToPosition(Adapter.getItemCount - 1)
      }
      logcat.run(lineLogger).?
    })
    case OnStop(proc) => s.applyState(IO {
      proc.foreach(_.destroy())
      None
    })
    case x => defaultApplyState(x)
  }

  case class LogEntry(tag: String, level: String, msg: String)
  case class LogcatHolder(view: TextView) extends RecyclerView.ViewHolder(view) {
    def bind(e: LogEntry): Unit = view.setText(" %1 %2: %3" formatSpans (
      textColor(MessageAdapter.nickColor(e.level), e.level),
      textColor(MessageAdapter.nickColor(e.tag),   e.tag), e.msg))
  }
  object Adapter extends RecyclerView.Adapter[LogcatHolder] {
    val buffer = RingBuffer[LogEntry](buffersize)
    override def getItemCount = buffer.size
    override def onBindViewHolder(vh: LogcatHolder, i: Int) = vh.bind(buffer(i))

    override def onCreateViewHolder(viewGroup: ViewGroup, i: Int) = {
      val tv = new TextView(LogcatActivity.this)
      tv.setTypeface(Typeface.MONOSPACE)
      LogcatHolder(tv)
    }
  }
}

You are talking about the UI. It is stateful in its essence. You cannot and must not work with it without states. There is only one correct way: to divide the code without states from the code with states.

The best concept for that is the FRP - Functional reactive programming. It separates functional parts and immutable boxes with mutable stateful content and connects them by events.

Be careful, many so-named reactive programming technologies on the net are not such really and only declare being reactive. For example, java RX is absolute invalid and lacks two very important features. (hiding listeners and simultaneousity support)

There is a very good book on the subject. It can be found on the net in some actions, too. The authors give opensource base library and swift FRP support library that could be used as a pattern for creation of your own FRP classes for your need.