justinwoo / purescript-choco-pie

A Cycle.js-like utility for working with Purescript-Event

Purescript-Choco-Pie

Docs on Pursuit

A Cycle.js-like utility for working with Purescript-Event. Aptly named for a circular Korean snack food.

Usage

program = runChocoPie main' drivers
  where
    main' ::
      { a :: Event Int
      , b :: Unit
      } ->
      { a :: Event Unit
      , b :: Event Int
      }
    main' sources =
      { a: mempty
      , b: sources.a
      }

    drivers ::
      { a :: Event Unit -> Effect (Event Int)
      , b :: Event Int -> Effect Unit
      }
    drivers =
      { a: const $ pure (pure 1)
      , b: \events -> subscribe events logShow
      }

With appropriate context and individual annotations, the type signature annotations are no longer needed.

Usage Exmples

I rewrote some code in my simple-rpc-telegram-bot repo, where I have drivers for running a child process, receiving and sending messages from Telegram, and a timer that ticks for every hour.

type Main
   = { torscraper :: Event Result
     , bot :: Event Request
     , timer :: Event Request
     }
  -> { torscraper :: Event Request
     , bot :: Event Result
     , timer :: Event Unit
     }
main' :: Main
main' sources =
  { torscraper: sources.timer <|> sources.bot
  , bot: sources.torscraper
  , timer: mempty
  }

drivers
  :: Config
  -> { torscraper :: Event Request -> Effect (Event Result)
     , bot :: Event Result -> Effect (Event Request)
     , timer :: Event Unit -> Effect (Event Request)
     }
drivers
  { token
  , torscraperPath
  , master
  } =
  { torscraper
  , bot
  , timer
  }
  where
    torscraper requests = do
      { event, push } <- create
      _ <- subscribe requests $ handleTorscraper torscraperPath master push
      pure event

    bot results = do
      connection <- connect $ unwrap token
      _ <- subscribe results $ sendMessage' connection
      messages <- getMessages connection
      pure $ { origin: FromUser, id: master } <$ messages

    timer _
      | tick <- pure unit <|> unit <$ interval (60 * 60 * 1000)
      , reqs <- { origin: FromTimer, id: master } <$ tick
      = pure reqs

-- runChocoPie main' (drivers config)

I also have a simpler example in atarime-purescript for similar usage of this library.

purescript-choco-pie's Issues

Needs upgrade to newest behaviors or any PureScript library

Essentially, needs to replace these two lines:

purescript-choco-pie/src/ChocoPie.purs

Line 77 in c976e08

bundle <- create

purescript-choco-pie/src/ChocoPie.purs

Line 169 in c976e08

subscribe sink bundle.push

The first part is where a proxy event gets made, and the second part where events are pushed into it. If you're familiar with Cycle.js, you'll know how all this works anyway, but in short:

Essentially there are two parts here, the "main" function and the "driver" function(s).

For all sink and source and known symbol key, we have something like this:

main :: { key :: source } -> { key :: Event sink }

drivers :: { key :: Event sink -> IO source }

So to start this thing up, the runChocoPie works by creating a proxy Event for every key, so that this can be passed into the driver function to obtain source. This source is then passed into our "main" function to obtain our Event of sink. But of course, this Event cannot be used to call the drivers a second time (and nor do we want to). But because we know that this is a concrete Event/"subject" (and not just some unconstrained f), we can subscribe to it and push items into it. So when we subscribe to this "real" Event and push items into our proxy Event, we have the complete cycle here. Hence, Cycle.js, or Choco-Pie.

---

Since the new behaviors doesn't give you a subject by default, you would probably have to provide your own subject implementation for this change. But if you think using coroutines or something else would be a better fit, you should make a PR with it. My only conditions are that whatever the library used should allow for both effectful and pure transformation of the streaming structure and provide some basic utilities (Functor, Applicative, Alternative instances, mapMaybe or similar operations for filtering -- note that I don't need a Bind/Monad instance) AND it must not use an npm library (because I do not have enough time on this earth to deal with them, and I already also have purescript-cycle-run).