From bf9905d6637d03b8c358dfe4721c3f5a90c59047 Mon Sep 17 00:00:00 2001
From: RamIdeas <rahul@ramideas.com>
Date: Wed, 22 Feb 2017 12:12:18 +0000
Subject: [PATCH 1/2] Added spreadability to `sample`

---
 type-definitions/most.d.ts | 58 ++++++++++++++++++++++++--------------
 1 file changed, 37 insertions(+), 21 deletions(-)

diff --git a/type-definitions/most.d.ts b/type-definitions/most.d.ts
index 68fd1e67..baeee285 100644
--- a/type-definitions/most.d.ts
+++ b/type-definitions/most.d.ts
@@ -161,23 +161,30 @@ export interface Stream<A> {
   // Note: Without higher-kinded types, this type cannot be written properly
   await<B>(): Stream<B>;
 
-  sample<B, C, R>(
-    fn: (b: B, c: C) => R,
+  sample<B, C, V, R>(
+    fn: (b: B, c: C, ...values: V[]) => R,
     b: Stream<B>,
-    c: Stream<C>
+    c: Stream<C>,
+    ...streams: Stream<V>[]
   ): Stream<R>;
-  sample<B, C, D, R>(
-    fn: (b: B, c: C, d: D) => R,
+  sample<B, C, D, V, R>(
+    fn: (b: B, c: C, d: D, ...values: V[]) => R,
     b: Stream<B>,
     c: Stream<C>,
-    d: Stream<D>
+    d: Stream<D>,
+    ...streams: Stream<V>[]
   ): Stream<R>;
-  sample<B, C, D, E, R>(
-    fn: (b: B, c: C, d: D, e: E) => R,
+  sample<B, C, D, E, V, R>(
+    fn: (b: B, c: C, d: D, e: E, ...values: V[]) => R,
     b: Stream<B>,
     c: Stream<C>,
     d: Stream<D>,
-    e: Stream<E>
+    e: Stream<E>,
+    ...streams: Stream<V>[]
+  ): Stream<R>;
+  sample<V, R>(
+    fn: (...values: V[]) => R,
+    ...streams: Stream<V>[]
   ): Stream<R>;
 
   sampleWith(sampler: Stream<any>): Stream<A>;
@@ -333,35 +340,44 @@ export function delay<A>(dt: number, s: Stream<A>): Stream<A>;
 export function fromPromise<A>(p: Promise<A>): Stream<A>;
 export function await<A>(s: Stream<Promise<A>>): Stream<A>;
 
-export function sample<A, B, R>(
-  fn: (a: A, b: B) => R,
+export function sample<A, B, V, R>(
+  fn: (a: A, b: B, ...values: V[]) => R,
   sampler: Stream<any>,
   a: Stream<A>,
-  b: Stream<B>
+  b: Stream<B>,
+  ...streams: Stream<V>[]
 ): Stream<R>;
-export function sample<A, B, C, R>(
-  fn: (a: A, b: B, c: C) => R,
+export function sample<A, B, C, V, R>(
+  fn: (a: A, b: B, c: C, ...values: V[]) => R,
   sampler: Stream<any>,
   a: Stream<A>,
   b: Stream<B>,
-  c: Stream<C>
+  c: Stream<C>,
+  ...streams: Stream<V>[]
 ): Stream<R>;
-export function sample<A, B, C, D, R>(
-  fn: (a: A, b: B, c: C, d: D) => R,
+export function sample<A, B, C, D, V, R>(
+  fn: (a: A, b: B, c: C, d: D, ...values: V[]) => R,
   sampler: Stream<any>,
   a: Stream<A>,
   b: Stream<B>,
   c: Stream<C>,
-  d: Stream<D>
+  d: Stream<D>,
+  ...streams: Stream<V>[]
 ): Stream<R>;
-export function sample<A, B, C, D, E, R>(
-  fn: (a: A, b: B, c: C, d: D, e: E) => R,
+export function sample<A, B, C, D, E, V, R>(
+  fn: (a: A, b: B, c: C, d: D, e: E, ...values: V[]) => R,
   sampler: Stream<any>,
   a: Stream<A>,
   b: Stream<B>,
   c: Stream<C>,
   d: Stream<D>,
-  e: Stream<E>
+  e: Stream<E>,
+  ...streams: Stream<V>[]
+): Stream<R>;
+export function sample<V, R>(
+  fn: (...values: V[]) => R,
+  sampler: Stream<any>,
+  ...streams: Stream<V>[]
 ): Stream<R>;
 
 export function sampleWith<A>(sampler: Stream<any>, s: Stream<A>): Stream<A>;

From c976607a181841c750a4bb27d73dddac993de4de Mon Sep 17 00:00:00 2001
From: RamIdeas <rahul@ramideas.com>
Date: Wed, 22 Feb 2017 12:29:43 +0000
Subject: [PATCH 2/2] Added overloads for 1 (or more) sampled streams

---
 type-definitions/most.d.ts | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/type-definitions/most.d.ts b/type-definitions/most.d.ts
index baeee285..42895be4 100644
--- a/type-definitions/most.d.ts
+++ b/type-definitions/most.d.ts
@@ -161,6 +161,11 @@ export interface Stream<A> {
   // Note: Without higher-kinded types, this type cannot be written properly
   await<B>(): Stream<B>;
 
+  sample<B, V, R>(
+    fn: (b: B, ...values: V[]) => R,
+    b: Stream<B>,
+    ...streams: Stream<V>[]
+  ): Stream<R>;
   sample<B, C, V, R>(
     fn: (b: B, c: C, ...values: V[]) => R,
     b: Stream<B>,
@@ -340,6 +345,12 @@ export function delay<A>(dt: number, s: Stream<A>): Stream<A>;
 export function fromPromise<A>(p: Promise<A>): Stream<A>;
 export function await<A>(s: Stream<Promise<A>>): Stream<A>;
 
+export function sample<A, V, R>(
+  fn: (a: A, ...values: V[]) => R,
+  sampler: Stream<any>,
+  a: Stream<A>,
+  ...streams: Stream<V>[]
+): Stream<R>;
 export function sample<A, B, V, R>(
   fn: (a: A, b: B, ...values: V[]) => R,
   sampler: Stream<any>,