remove rx and most from depends on typeclasses

Author: jcouyang

Makefile

@@ -8,13 +8,14 @@ test: unit integrate
 build: lib/**/*.js
 
 lib/**/*.js: src/**/*.ts
+	tsc
 
 lib/%.js: src/%.ts
 	tsc
 
-all: test browser
+all: test dist
 
-.PHONY: test build unit integrate browser docs docs/publish
+.PHONY: test build unit integrate dist docs docs/publish
 
 unit: build
 	yarn test
@@ -28,7 +29,7 @@ docs/src/main/tut/examples/example.js: docs/src/main/tut/examples/example.tsx
 watch/example: docs/src/main/tut/examples/example.tsx
 	$(watchify) -p [tsify -p tsconfig.examples.json] -t envify docs/src/main/tut/examples/example.tsx -dv -o docs/src/main/tut/examples/example.js
 
-browser: dist/xreact.min.js dist/xreact-most.min.js dist/xreact-rx.min.js
+dist: dist/xreact.min.js dist/xreact-most.min.js dist/xreact-rx.min.js
 
 dist/xreact.js: lib/index.js dist/xreact-most.js dist/xreact-rx.js
 	env NODE_ENV=production $(browserify) -t browserify-shim -t envify -x ./lib/xs $< -s xreact -o $@

package.json

@@ -21,6 +21,7 @@
   },
   "browserify-shim": {
     "react": "global:React",
+    "reflect-metadata": "global:Reflect",
     "@reactivex/rxjs": "global:Rx",
     "most": "global:most"
   },

src/fantasy/fantasyx.ts

@@ -30,15 +30,15 @@ export class FantasyX<F extends Stream, I, S, A> {
   }
 
   toStream(intent$: Subject<F, I>): $<F, Update<S>> {
-    return map<Stream, State<S, A>, Update<S>>(
+    return streamOps.map<State<S, A>, Update<S>>(
       s => (state => s.patch(a => a).runS(state)),
       this.plan.runA(intent$))
   }
 
   map<B>(f: (a: A) => B): FantasyX<F, I, S, B> {
     return new FantasyX<F, I, S, B>(
       Functor.State.map(update$ => (
-        map<Stream, State<S, A>, State<S, B>>(state => (
+        streamOps.map<State<S, A>, State<S, B>>(state => (
           Functor.State.map(f, state)
         ), update$)
       ), this.plan)
@@ -48,7 +48,7 @@ export class FantasyX<F extends Stream, I, S, A> {
   foldS<B>(f: (s: S, a: A) => S): FantasyX<F, I, S, Partial<S>> {
     return new FantasyX<F, I, S, Partial<S>>(
       Functor.State.map(update$ => (
-        map<Stream, State<S, A>, State<S, Partial<S>>>(state => (
+        streamOps.map<State<S, A>, State<S, Partial<S>>>(state => (
           state.patch((a: A, s: S) => f(s, a))
         ), update$)
       ), this.plan)

src/fantasy/index.ts

@@ -1,5 +1,6 @@
 export { Xstream } from './xstream'
 export { FantasyX } from './fantasyx'
+
 export * from './typeclasses/applicative'
 export * from './typeclasses/functor'
 export * from './typeclasses/apply'
@@ -8,130 +9,3 @@ export * from './typeclasses/flatmap'
 export * from './typeclasses/cartesian'
 export * from './typeclasses/semigroup'
 export * from './typeclasses/traversable'
-// export function fromPlan<E extends Stream, I, S>(plan: Plan<E, I, S>): FantasyX<E, I, S, void> {
-//   return new FantasyX<E, I, S, void>((intent$: Subject<E, I>) => {
-//     let { update$, actions } = plan(intent$)
-//     return {
-//       actions,
-//       update$: streamOps.map<Update<S>, State<S, void>>(
-//         f => State.modify<S>(f), update$
-//       )
-//     }
-//   })
-// }
-
-// export function fromEvent<E extends Stream, I extends Event, S>(
-//   type: string, name: string, defaultVal?: string
-// ): FantasyX<E, I, S, string> {
-//   return new FantasyX<E, I, S, string>(intent$ => {
-//     return {
-//       update$: streamOps.merge<State<S, string>>(
-//         typeof defaultVal != 'undefined' ? streamOps.just<State<S, string>>(State.pure<S, string>(defaultVal)) : streamOps.empty<State<S, string>>(),
-//         streamOps.map<Event, State<S, string>>(
-//           e => State.pure<S, string>((e.target as HTMLFormElement).value),
-//           streamOps.filter<I>(i => {
-//             let target = i.target as HTMLFormElement
-//             return target.tagName == 'INPUT' && target.name == name
-//           }, (intent$ as _<I>[E])))
-//       )
-//     }
-//   })
-// }
-
-// export function pure<E extends Stream, I, S, A>(a: A) {
-//   return new FantasyX<E, I, S, A>(intent$ => {
-//     return {
-//       update$: streamOps.just<State<S, A>>(State.pure<S, A>(a))
-//     }
-//   })
-// }
-
-// export function ap<E extends Stream, I, S, A, B>(
-//   ff: FantasyX<E, I, S, (a: A) => B>,
-//   fa: FantasyX<E, I, S, A>
-// ): FantasyX<E, I, S, B> {
-//   return ff.combine((f, a) => f(a), fa)
-// }
-
-// export function empty<E extends Stream, I, S, A>() {
-//   return new FantasyX<E, I, S, A>(intent$ => {
-//     return {
-//       update$: streamOps.empty<State<S, A>>()
-//     }
-//   })
-// }
-
-// export function map<E extends Stream, I, S, A, B>(
-//   f: (s: A) => B, fa: FantasyX<E, I, S, A>
-// ): FantasyX<E, I, S, B> {
-//   return fa.map(f)
-// }
-
-
-// export function traverse<E extends Stream, I, S, A>(
-//   f: (a: A, index?: number) => FantasyX<E, I, S, A>, xs: A[]
-// ): FantasyX<E, I, S, A[]> {
-//   return xs.reduce((acc, i, index) => acc.concat(f(i, index).map(x => [x])), pure<E, I, S, A[]>([]))
-// }
-
-// export function fold<E extends Stream, I, S, A, B>(
-//   f: (acc: B, i: A) => B, base: B, fa: FantasyX<E, I, S, A>
-// ): FantasyX<E, I, S, B> {
-//   return fa.fold(f, base)
-// }
-
-// export function lift<E extends Stream, I, S, A, B>(
-//   f: (s: A) => B
-// ): (fa: FantasyX<E, I, S, A>) => FantasyX<E, I, S, B> {
-//   return fa => fa.map(f)
-// }
-
-// export function lift2<E extends Stream, I, S, A, B, C>(
-//   f: (a: A, b: B) => C
-// ): (fa1: FantasyX<E, I, S, A>, fa2: FantasyX<E, I, S, B>) => FantasyX<E, I, S, C> {
-//   return (fa1, fa2) => fa1.combine(f, fa2)
-// }
-
-// export function lift3<E extends Stream, I, S, A, B, C, D>(
-//   f: (a: A, b: B, c: C) => D
-// ): (fa1: FantasyX<E, I, S, A>, fa2: FantasyX<E, I, S, B>, fa3: FantasyX<E, I, S, C>) => FantasyX<E, I, S, D> {
-//   return (fa1, fa2, fa3) => fa1.combine3(f, fa2, fa3)
-// }
-
-// export function lift4<E extends Stream, I, S, A, B, C, D, F>(
-//   f: (a: A, b: B, c: C, d: D) => F
-// ): (fa1: FantasyX<E, I, S, A>, fa2: FantasyX<E, I, S, B>, fa3: FantasyX<E, I, S, C>, fa4: FantasyX<E, I, S, D>) => FantasyX<E, I, S, F> {
-//   return (fa1, fa2, fa3, fa4) => fa1.combine4(f, fa2, fa3, fa4)
-// }
-
-// export function lift5<E extends Stream, I, S, A, B, C, D, F, G>(
-//   f: (
-//     s1: A,
-//     s2: B,
-//     s3: C,
-//     s4: D,
-//     s5: F
-//   ) => G
-// ): (
-//     fa1: FantasyX<E, I, S, A>,
-//     fa2: FantasyX<E, I, S, B>,
-//     fa3: FantasyX<E, I, S, C>,
-//     fa4: FantasyX<E, I, S, D>,
-//     fa5: FantasyX<E, I, S, F>
-//   ) => FantasyX<E, I, S, G> {
-//   return (fa1, fa2, fa3, fa4, fa5) => fa1.combine5(f, fa2, fa3, fa4, fa5)
-// }
-
-// export function concat<E extends Stream, I, S, A>(
-//   fa: FantasyX<E, I, S, A>,
-//   fb: FantasyX<E, I, S, A>
-// ): FantasyX<E, I, S, A> {
-//   return fa.concat(fb)
-// }
-
-// export function merge<E extends Stream, I, S, A, B>(
-//   fa: FantasyX<E, I, S, A>,
-//   fb: FantasyX<E, I, S, B>
-// ): FantasyX<E, I, S, A | B> {
-//   return fa.merge(fb)
-// }

src/fantasy/typeclasses/index.ts

@@ -14,9 +14,15 @@ export function datatype(name: string) {
 }
 
 export function kind(target: any) {
-  if (isPrimitive(target))
+  if (isPrimitive(target)) {
     return target.constructor.name
-  return Reflect.getMetadata('design:type', target.constructor);
+  }
+  else {
+    let tag = Reflect.getMetadata('design:type', target.constructor);
+    if (tag) return tag
+    throw `target ${target.constructor} is not a datatype, please decorate it with @datatype!`
+  }
+
 }
 
 datatype('Array')(Array)

src/fantasy/xstream.ts

@@ -63,7 +63,7 @@ export class Xstream<S extends Stream, I, A> {
         let state$ = this.streamS.runA(intent$)
         return {
           s: intent$,
-          a: map<S, A, State<St, A>>((a: A) => Applicative.State.pure<St, A>(a), state$)
+          a: streamOps.map<A, State<St, A>>((a: A) => Applicative.State.pure<St, A>(a), state$)
         }
       }))
   }
@@ -83,7 +83,7 @@ declare module './typeclasses/functor' {
 
 export class XstreamFunctor implements Functor<"Xstream">{
   map<A, B>(f: (a: A) => B, fa: Xstream<Stream, any, A>): Xstream<Stream, any, B> {
-    return new Xstream(Monad.State.map(sa => map<Stream, A, B>(f, sa), fa.streamS))
+    return new Xstream(Monad.State.map(sa => streamOps.map<A, B>(f, sa), fa.streamS))
   }
 }
 
@@ -94,7 +94,7 @@ export class XstreamCartesian implements Cartesian<"Xstream">{
     return new Xstream(
       FlatMap.State.flatMap(s1 => (
         Functor.State.map(s2 => (
-          product(s1, s2)
+          streamOps.combine((a, b) => [a, b], s1, s2)
         ), fb.streamS)
       ), fa.streamS))
   }
@@ -138,7 +138,7 @@ export class XstreamFlatMap extends XstreamApply {
       FlatMap.State.flatMap((a$: $<Stream, A>) => (
         map<"State", $<Stream, A>, $<Stream, B>>(i$ => {
           let sdf = (a: A) => f(a).streamS.runA(i$)
-          return flatMap<Stream, A, B>(sdf, a$)
+          return streamOps.flatMap<A, B>(sdf, a$)
         }, State.get<$<Stream, A>>())
       ), fa.streamS)
     )

src/xs/most.ts

@@ -1,16 +1,6 @@
 import { Stream as MostStream, empty, just, combineArray, combine, flatMap, fromPromise } from 'most'
 import { sync, SyncSubject, Subject } from 'most-subject'
 import { Subscription, StreamOps } from '.'
-import { Functor } from '../fantasy/typeclasses/functor'
-import { Cartesian } from '../fantasy/typeclasses/cartesian'
-import { Apply } from '../fantasy/typeclasses/apply'
-import { FlatMap } from '../fantasy/typeclasses/flatmap'
-import { Applicative } from '../fantasy/typeclasses/applicative'
-import { Monad } from '../fantasy/typeclasses/monad'
-import { datatype } from '../fantasy/typeclasses'
-
-export const kind = 'MostStream'
-export type kind = typeof kind
 
 declare module '.' {
   interface S_<A> {
@@ -25,95 +15,6 @@ declare module '../fantasy/typeclasses' {
   }
 }
 
-datatype(kind)(MostStream)
-
-export class MostFunctor implements Functor<kind>{
-  map<A, B>(f: (a: A) => B, fa: MostStream<A>): MostStream<B> {
-    return fa.map(f)
-  }
-}
-
-declare module '../fantasy/typeclasses/functor' {
-  namespace Functor {
-    let MostStream: MostFunctor
-  }
-}
-
-Functor.MostStream = new MostFunctor
-
-export class MostCartesian implements Cartesian<kind>{
-  product<A, B>(fa: MostStream<A>, fb: MostStream<B>): MostStream<[A, B]> {
-    return combine((a, b) => [a, b] as [A, B], fa, fb)
-  }
-}
-
-declare module '../fantasy/typeclasses/cartesian' {
-  export namespace Cartesian {
-    export let MostStream: MostCartesian
-  }
-}
-
-Cartesian.MostStream = new MostCartesian
-
-export class MostApply implements Apply<kind> {
-  ap<A, B>(fab: MostStream<(a: A) => B>, fa: MostStream<A>): MostStream<B> {
-    return combine((ab, a) => ab(a), fab, fa)
-  }
-  map = Functor.MostStream.map
-  product = Cartesian.MostStream.product
-}
-
-declare module '../fantasy/typeclasses/apply' {
-  namespace Apply {
-    export let MostStream: MostApply
-  }
-}
-
-
-export class MostFlatMap extends MostApply {
-  flatMap<A, B>(f: (a: A) => MostStream<B>, fa: MostStream<A>): MostStream<B> {
-    return flatMap(f, fa)
-  }
-}
-
-FlatMap.MostStream = new MostFlatMap
-
-declare module '../fantasy/typeclasses/flatmap' {
-  export namespace FlatMap {
-    export let MostStream: MostFlatMap
-  }
-}
-
-export class MostApplicative extends MostApply {
-  pure<A>(v: A): MostStream<A> {
-    return just(v)
-  }
-}
-
-Applicative.MostStream = new MostApplicative
-
-declare module '../fantasy/typeclasses/applicative' {
-  export namespace Applicative {
-    export let MostStream: MostApplicative
-  }
-}
-
-export class MostMonad implements Monad<kind> {
-  flatMap = FlatMap.MostStream.flatMap
-  map = Applicative.MostStream.map
-  ap = Applicative.MostStream.ap
-  pure = Applicative.MostStream.pure
-  product = Applicative.MostStream.product
-}
-
-Monad.MostStream = new MostMonad
-
-declare module '../fantasy/typeclasses/monad' {
-  export namespace Monad {
-    export let MostStream: MostMonad
-  }
-}
-
 StreamOps.prototype.empty = empty
 StreamOps.prototype.just = just