https://github.com/athanclark/elm-every

It's like something that does stuff
https://github.com/athanclark/elm-every

elm poller

Last synced: about 1 month ago
JSON representation

It's like something that does stuff

• Host: GitHub
• URL: https://github.com/athanclark/elm-every
• Owner: athanclark
• Created: 2016-05-13T22:22:59.000Z (over 8 years ago)
• Default Branch: master
• Last Pushed: 2016-12-25T06:12:40.000Z (about 8 years ago)
• Last Synced: 2024-10-12T20:20:56.410Z (2 months ago)
• Topics: elm, poller
• Language: Elm
• Size: 12.7 KB
• Stars: 1
• Watchers: 3
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# Elm-Every

Repeatidly issue an action, with some time frame in-between.

It's pretty simple to integrate, all you need is:

- a function to determine how much time to wait until the next issue, based on

  the total time waited so far: `Time -> Time`

- an action to issue, with some data it would expect to apply with

Then, to start the poller, you issue `Start` with some data you would want the

action to use. To update this data, just make another call to `Start`. Then,

to stop the poller, just issue `Stop`.

```elm

import Every

type alias EveryState =

  { kickoffCount : Int

  }

type alias MyModel =

  { mySession : SessionModel

  , poller    : Every.Model EveryState

  }

initMyModel : MyModel

initMyModel =

  { mySession = initSession

  , poller    = Every.init

  }

type MyAction

  = SessionMsg SessionMsg

  | EveryMsg (Every.Msg EveryState)

  | KickStart

-- we're calculating the time to add to the total, based on the current total.

fibbDelay : Maybe EveryState -> Time -> Time

fibbDelay _ total = total

issueMsg : Maybe EveryState -> Msg

issueMsg ms =

  -- ...

updateModel : MyAction

           -> MyModel

           -> (MyModel, Cmd MyAction)

updateModel action model =

  case action of

    SessionMsg a ->

      let (newSession, eff) = updateSession a model.mySession

      in  ( { model | mySession = newSession }

          , Cmd.map SessionMsg eff

          )

    EveryMsg a ->

      let (newEvery, eff) = updateEvery

                              fibbDelay

                              issueMsg

                              a

                              model.poller

      in  ( { model | poller = newEvery }

          , Cmd.map (\r -> case r of

                             Err x -> x -- resolve issued data

                             Ok  x -> EveryMsg x) eff

          )

    KickStart ->

      ( model

      , Task.perform (Debug.crash << toString) EveryMsg

        <| Every.Start { resetSoFar = True

                       , modifyData = Just <| Every.Update <| \ms ->

                           case ms of

                             Nothing ->

                               { kickoffCount = 1

                               }

                             Just ks ->

                               { kickoffCount = ks.kickoffCount + 1

                               }

                       }

      )

```