main.ts

type Dict<T> = { [key: string]: T }

interface component {
  bacon: Stream<string>
    lettuce?: Stream<number>
}

type baconArgs = {
  firstBastard: Stream<string>,
  secondBastard: Stream<string>
}

function bacon(args: baconArgs): Stream<string> {
  return xs.merge(args.firstBastard, args.secondBastard)
}

type lettuceArgs = {
  secondBastard: Stream<number>
}
function lettuce(args: lettuceArgs): Stream<number> {
  return xs.merge(args.secondBastard)
}

function mix <
  T extends Dict<component>,
  V extends component,
  U extends { [K in keyof component]: (a: {[key in keyof T]: T[key][K]}) => component[K] }
>(components: T, combinators: U): void {
}

mix({
  firstBastard: {
    bacon: xs.of('abc')
  },
  secondBastard: {
    bacon: xs.of('abcde'),
    lettuce: xs.of(123)
  }
}, {
  bacon: bacon,
  lettuce: lettuce
})