How to use the callbag-basics.pipe function in callbag-basics

export const toCallback = <a>(callback: Callback</a><a>) =&gt; (source: Source</a><a>) =&gt; {
  if (callback == null) callback = (_, error) =&gt; error &amp;&amp; console.log(error)
  return pipe(
    source,
    catchError((error: Error) =&gt; callback(null, error)),
    observe((value: A) =&gt; callback(value, null))
  )
}
export const toCallbackOrPromise = </a><a>(cb?: Callback</a><a>) =&gt; (source: Source</a><a>) =&gt; {</a>

function counters$(realtime, next) {
    return pipe(
        fromObs(channelToObs(realtime, 'chat:counters')),
        map(msg => msg.params),
        map(counters => ({
            ...counters,
            isOnline: new window.Map(counters.peers || []),
        })),
        subscribe({ next })
    );
}

.add('cb-basics', function (deferred) {
        runners.runCallbag(deferred,
            callbag.pipe(
                fromArray(a),
                callbag.filter(even),
                callbag.map(add1),
                callbag.scan(sum, 0)
            )
        );
    }, options)
    .add('xstream', function (deferred) {

.add('cb-basics', function (deferred) {
        runners.runCallbag(deferred,
            callbag.pipe(
                fromArray(a),
                callbag.map(add1),
                callbag.filter(odd),
                callbag.map(add1),
                callbag.map(add1),
                callbag.filter(even),
                callbag.scan(sum, 0)
            )
        );
    }, options)
    .add('xstream', function (deferred) {

.add('cb-basics', function (deferred) {
        runners.runCallbag(deferred,
            callbag.pipe(
                callbag.combine(cbag1, cbag2, cbag3),
                callbag.map(add3Arr),
                callbag.filter(even)
            )
        );
    }, options)
    .add('xstream', function (deferred) {

addFilter( 'carbon-fields.conditional-display-post-format.classic', 'carbon-fields/metaboxes', () => {
	const node = document.querySelector( 'div#post-formats-select' );

	if ( ! node ) {
		return of( INITIAL_STATE );
	}

	return pipe(
		fromDelegatedEvent( node, 'input.post-format', 'change' ),
		map( ( { target } ) => getPostFormatFromRadioInput( target ) ),
		startWith( getPostFormatFromRadioInput( node.querySelector( 'input.post-format:checked' ) ) )
	);
} );

.add('cb-basics', function (deferred) {
        var source = fromArray(a);
        var inc = callbag.pipe(
            source,
            callbag.filter(isPositive),
            callbag.map(returnPlus1)
        );
        var dec = callbag.pipe(
            source,
            callbag.filter(isNegative),
            callbag.map(returnMinus1)
        );
        var count = callbag.pipe(
            callbag.merge(inc, dec),
            callbag.scan(addXY, 0)
        );
        var label = fromArray(['initial', 'Count is ']);
        var view = callbag.pipe(
            callbag.combine(label, count),
            callbag.map(renderWithArray)
        );
        runners.runCallbag(deferred, view);
    }, options)
    .add('xstream', function (deferred) {

.add('cb-basics', function (deferred) {
        var source = fromArray(a);
        var inc = callbag.pipe(
            source,
            callbag.filter(isPositive),
            callbag.map(returnPlus1)
        );
        var dec = callbag.pipe(
            source,
            callbag.filter(isNegative),
            callbag.map(returnMinus1)
        );
        var count = callbag.pipe(
            callbag.merge(inc, dec),
            callbag.scan(addXY, 0)
        );
        var label = fromArray(['initial', 'Count is ']);
        var view = callbag.pipe(
            callbag.combine(label, count),

applicationSubject => {
          const { source, forEachSink } = makeWebSocketDuplex({ webSocketUrl });
          pipe(telnetInputSource, mapTelnetSink, mapSink, forEachSink);

          const telnetOutputSource = pipe(
            source,
            mapSource,
            makeTelnetMapSource({ telnetSubject: telnetInputSubject }),
            share
          );
          const bufOutputSource = pipe(
            telnetOutputSource,
            makeAnsiMapSource(),
            makeLegacyBufMapSource({ buf: __SINGLETON__.legacy.buf }),
            share
          );
          const onCloseSubject = makeSubject();
          bufOutputSource(0, t => {
            if (t === 2) {
              onCloseSubject(1, {
                type: WS_CLOSED,

function input( props ) {
	return pipe(
		fromSelector( select( 'core/editor' ).getBlock, props.blockId ),
		distinctUntilChanged(),
		map( ( { attributes } ) => attributes.data )
	);
}