Composing Custom Subscriptions

Writing a Subscription
The Basics
The most basic subscription looks like this:
1
const myCoolSubscription = (dispatch, ...yourArgsHere) => {
2
  // Do your stuff here
3
  
4
  return () => {
5
    // Clean your stuff up here
6
  };
7
};
Copied!
If this doesn't do everything you want, we can definitely add some arguments:
1
const myCoolSubscription = (dispatch, a, b) => {
2
  // Do your stuff here with a and b
3
  
4
  return () => {
5
    // Clean your stuff up here
6
  };
7
};
Copied!
This is all well and good, but there is a hitch - your parameters need to be consistent. If you are dynamically creating an object, or pass in different values, your subscription will be reset. One thing about subscriptions is they introduce one-way communication, being that you set a few defaults to initialize the subscription, but all other communication is from the subscription back into the application.
Smart Subscription Parameters
One very important detail to remember with subscriptions is a change in parameters will do a clean up of the old subscription and rebuild a new one. This means a change in value or reference. This means changing a value from 0 to 1, 'hello' to 'goodbye', or passing an inline function like () => 'foo'. Knowing when it's a good time to change these values to rebuild subscriptions can be hard, and knowing how to keep the same reference is equally hard. Here's an example of a bad subscription:
1
const { app, effects } = require('ferp');
2
​
3
const tickEffect = () => ({ type: 'tick' });
4
​
5
const tickSubscription = (dispatch, delay) => {
6
  console.log('Create tick sub every', delay, 'milliseconds');
7
  const handle = setInterval(effects.thunk, delay, tickEffect);
8
  
9
  return () => {
10
    console.log('Destroy tick sub every', delay, 'milliseconds');
11
    clearInterval(handle);
12
  };
13
}
14
​
15
app({
16
  init: [{}, effects.none()],
17
  subscribe: state => [
18
    [tickSubscription, (Math.random() * 1000) + 1000], // Hmmmm
19
  ],
20
});
Copied!
This is bad because the result of (Math.random() * 1000) + 1000 will be different every time it is calculated (which will be every update), and as a result, will forcibly clean up the previous subscription and create a new subscription every application action that is ran.
If you want a consistent calculated value, you should put it in state. To do this with the above example, it would look like:
1
const { app, effects } = require('ferp');
2
​
3
​
4
const tickSubscription = (dispatch, delay) => {
5
  console.log('Create tick sub every', delay, 'milliseconds');
6
  const handle = setInterval(effects.thunk, delay, tickEffect);
7
  
8
  return () => {
9
    console.log('Destroy tick sub every', delay, 'milliseconds');
10
    clearInterval(handle);
11
  };
12
}
13
​
14
app({
15
  init: [{ delay: (Math.random() * 1000) + 1000 }, effects.none()],
16
  subscribe: state => [
17
    [tickSubscription, state.delay], // That's better!
18
  ],
19
});
Copied!
​

Understanding Subscriptions in Ferp - Previous

What is a Ferp Subscription?

Next - Understanding Subscriptions in Ferp

Testing Your Subscriptions

Last modified 5mo ago

Copy link

Contents

Writing a Subscription

The Basics

Smart Subscription Parameters