testing synchronize code with Id Monad

Author: jcouyang

src/__tests__/fantasyx-test.ts

@@ -1,17 +1,20 @@
-import { Observable, Subject } from '@reactivex/rxjs'
-import '../xs/rx'
+import { streamOps } from '../xs'
+import '../xs/array'
 import { FantasyX } from '../fantasy/fantasyx'
+import { Id } from '../fantasy/typeclasses/id'
 import { Update } from '../interfaces'
 import { Xstream } from '../fantasy/xstream'
 import { flatMap, FlatMap } from '../fantasy/typeclasses/flatmap'
 import { concat, Semigroup } from '../fantasy/typeclasses/semigroup'
 describe('FantasyX', () => {
   let intent;
   beforeEach(() => {
-    intent = new Subject()
+    intent = streamOps.subject()
   })
-  it('map and fold', (done) => {
-    Xstream
+  it('map and fold', () => {
+    intent.next(1)
+    intent.next(2)
+    let res = Xstream
       .fromIntent()
       .toFantasyX()
       .map(a => {
@@ -23,59 +26,44 @@ describe('FantasyX', () => {
       })
       .foldS((s, a) => ({ count: a.count + s.count }))
       .toStream(intent)
-      .reduce((acc, f: any) => {
-        return f(acc)
-      }, { count: 10 })
-      .subscribe(a => {
-        expect(a.count).toBe(22)// 5 + 10 + 7
-        done()
-      });
+      .reduce((acc, f) => f(acc), { count: 10 })
+    expect(res).toEqual({ count: 10 + 5 + 7 })
+  })
+
+  it('flatMap Xstream', () => {
     intent.next(1)
     intent.next(2)
-    intent.complete()
-  })
 
-  it('flatMap Xstream', (done) => {
-    FlatMap.Xstream.flatMap(
-      (x: number) => Xstream.fromPromise<"RxStream", number, number>(Promise.resolve({ count: x + 1 }))
-      , Xstream.fromIntent<"RxStream", number>())
+    let res = FlatMap.Xstream.flatMap(
+      (x: number) => Xstream.fromPromise<"ArrayStream", number, number>(new Id({ count: x + 1 }))
+      , Xstream.fromIntent<"ArrayStream", number>())
       .toFantasyX()
       .toStream(intent)
       .reduce((acc, f: any) => f(acc), { count: 10 })
-      .toPromise().then(a => expect(a).toEqual({ count: 3 })).then(done)
-    intent.next(1)
-    intent.next(2)
-    intent.complete()
+    expect(res).toEqual({ count: 3 })
   })
 
-  it('concat object', (done) => {
-    Semigroup.Xstream.concat(
+  it('concat object', () => {
+    intent.next({ count1: 1 })
+    intent.next({ count2: 2 })
+
+    let res = Semigroup.Xstream.concat(
       Xstream.fromIntent()
       , Xstream.fromIntent())
       .toFantasyX()
       .toStream(intent)
       .reduce((acc, f: any) => f(acc), { count: 0 })
-      .toPromise()
-      .then(a => expect(a).toEqual(
-        { "count": 0, "count1": 1, "count2": 2 }
-      ))
-      .then(done)
-    intent.next({ count1: 1 })
-    intent.next({ count2: 2 })
-    intent.complete()
+    expect(res).toEqual({ "count": 0, "count1": 1, "count2": 2 })
   })
 
-  it('concat promise', (done) => {
-    Semigroup.Xstream.concat(
-      Xstream.fromPromise(Promise.resolve({ count1: 1 }))
-      , Xstream.fromPromise(Promise.resolve({ count2: 2 })))
+  it('concat promise', () => {
+
+    let res = Semigroup.Xstream.concat(
+      Xstream.fromPromise(new Id({ count1: 1 }))
+      , Xstream.fromPromise(new Id({ count2: 2 })))
       .toFantasyX()
       .toStream(intent)
       .reduce((acc, f: any) => f(acc), { count: 0 })
-      .toPromise()
-      .then(a => expect(a).toEqual(
-        { "count": 0, "count1": 1, "count2": 2 }
-      ))
-      .then(done)
+    expect(res).toEqual({ "count": 0, "count1": 1, "count2": 2 })
   })
 })

src/fantasy/typeclasses/semigroup.ts

@@ -38,6 +38,8 @@ export class StringSemigroup implements Semigroup<string> {
 export class ArraySemigroup<A> implements Semigroup<Array<A>> {
   _T: Array<A>
   concat(a: Array<A>, b: Array<A>): Array<A> {
+    console.log(a, b, '----------------------')
+
     return a.concat(b)
   }
 }

src/xs/array.ts

@@ -28,7 +28,7 @@ StreamOps.prototype.combine = function <A, C>(
   f: (...a: any[]) => C,
   ...v: any[]
 ): Array<C> {
-  return f.call(null, v)
+  return f.apply(null, v)
 }
 
 StreamOps.prototype.filter = function <A>(f: (a: A) => boolean, fa: Array<A>): Array<A> {
@@ -41,16 +41,19 @@ StreamOps.prototype.flatMap = function <A, B>(f: (a: A) => Array<B>, fa: Array<A
   return fa.reduce((acc, a) => acc.concat(f(a)), [] as B[])
 }
 
-class Subject<T> extends Array<T> {
-  next(a: T) {
-    this.push(a)
-  }
-  complete() {
-  }
+function Subject() {
+}
+Subject.prototype = Array.prototype
+
+Subject.prototype.next = function(a: any) {
+  this.push(a)
+}
+
+Subject.prototype.complete = function() {
 }
 
 StreamOps.prototype.subject = function <A>() {
-  return new Subject()
+  return new (<any>Subject)()
 }
 
 StreamOps.prototype.subscribe = function <A>(fa: Array<A>, next: (v: A) => void, complete?: () => void) {