refactor to avoid explicit any type

Author: jcouyang

src/fantasy/typeclasses/applicative.ts

@@ -11,7 +11,7 @@ export namespace Applicative {
 
 export function lift2<F extends ApplicativeInstances, A, B, C>(fabc: (a: A, b: B) => C): (fa: $<F, A>, fb: $<F, B>) => $<F, C> {
   return function(fa: $<F, A>, fb: $<F, B>): $<F, C> {
-    let instance: any = Applicative[kind(fa) as F]
+    let instance = Applicative[kind<F>(fa)] as Applicative<F>
     return ap2<F, A, B, C>(instance.pure(fabc), fa, fb)
   }
 }

src/fantasy/typeclasses/apply.ts

@@ -13,17 +13,17 @@ export namespace Apply {
 }
 
 export function ap<F extends ApplyInstances, A, B>(fab: $<F, (a: A) => B>, fa: $<F, A>): $<F, B> {
-  let instance = (<any>Functor)[kind(fab)]
-  let faba: $<F, [(a: A) => B, A]> = instance.product(fab, fa)
-  return instance.map((aba: [(a: A) => B, A]) => aba[0](aba[1]), faba) as $<F, B>
+  let instance = Apply[kind<F>(fab)] as Apply<F>
+  let faba = instance.product<(a: A) => B, A>(fab, fa)
+  return instance.map((aba: [(a: A) => B, A]) => aba[0](aba[1]), faba)
 }
 
 export function ap2<F extends ApplyInstances, A, B, C>(fabc: $<F, (a: A, b: B) => C>, fa: $<F, A>, fb: $<F, B>): $<F, C> {
-  let instance: any = Apply[kind(fabc) as F]
-  return instance.ap(
+  let instance = Apply[kind<F>(fabc)] as Apply<F>
+  return ap<F, [A, B], C>(
     instance.map(
       (f: (a: A, b: B) => C) => (([a, b]: [A, B]) => f(a, b))
       , fabc)
-    , instance.product(fa, fb)
-  ) as $<F, C>
+    , instance.product<A, B>(fa, fb)
+  )
 }

src/fantasy/typeclasses/cartesian.ts

@@ -5,11 +5,11 @@ export interface Cartesian<F extends HKT> {
   product<A, B>(fa: $<F, A>, fb: $<F, B>): $<F, [A, B]>
 }
 
-export namespace Cartesian { 
+export namespace Cartesian {
   const __name = "Cartesian"
 }
 
 export function product<F extends CartesianInstances, A, B>(fa: $<F, A>, fb: $<F, B>): $<F, [A, B]> {
-  let instance = (<any>Cartesian)[kind(fa)]
-  return instance.product(fa, fb) as $<F, [A, B]>
+  let instance = Cartesian[kind<F>(fa)] as Cartesian<F>
+  return instance.product<A, B>(fa, fb)
 }

src/fantasy/typeclasses/flatmap.ts

@@ -5,10 +5,10 @@ export interface FlatMap<F extends HKT> extends Apply<F> {
   flatMap<A, B>(f: (a: A) => $<F, B>, fb: $<F, A>): $<F, B>
 }
 export type FlatMapInstances = keyof typeof FlatMap
-export namespace FlatMap { 
+export namespace FlatMap {
   const __name = "FlatMap"
 }
 
 export function flatMap<F extends FlatMapInstances, A, B>(f: (a: A) => $<F, B>, fa: $<F, A>): $<F, B> {
-  return (<any>FlatMap)[kind(fa)].flatMap(f, fa) as $<F, B>
+  return (FlatMap[kind<F>(fa)] as FlatMap<F>).flatMap<A, B>(f, fa)
 }

src/fantasy/typeclasses/functor.ts

@@ -12,6 +12,6 @@ export namespace Functor {
 }
 
 export function map<F extends FunctorInstances, A, B>(f: (a: A) => B, fa: $<F, A>): $<F, B> {
-  let instance = (<any>Functor)[kind(fa)]
-  return instance.map(f, fa) as $<F, B>
+  let instance = Functor[kind<F>(fa)] as Functor<F>
+  return instance.map(f, fa)
 }

src/fantasy/typeclasses/index.ts

@@ -5,6 +5,7 @@ export interface _<A> {
 export type HKT = keyof _<any>
 
 export type $<F extends HKT, A> = _<A>[F]
+
 import 'reflect-metadata'
 
 export function datatype(name: string) {
@@ -13,7 +14,7 @@ export function datatype(name: string) {
   }
 }
 
-export function kind(target: any) {
+export function datatypeOf(target: any): string {
   if (isPrimitive(target)) {
     return target.constructor.name
   }
@@ -22,7 +23,10 @@ export function kind(target: any) {
     if (tag) return tag
     throw new Error(`target ${target.constructor} is not a datatype, please decorate it with @datatype!`)
   }
+}
 
+export function kind<F extends HKT>(target: $<F, any>): F {
+  return datatypeOf(target) as F
 }
 
 datatype('Array')(Array)

src/fantasy/typeclasses/semigroup.ts

@@ -1,6 +1,6 @@
 export type instanceKey = keyof S
 export type S = typeof Semigroup
-import { datatype, kind } from '.'
+import { datatype, datatypeOf } from '.'
 export type SemigroupInstance = keyof typeof Semigroup
 export type SemigroupInstanceType = typeof Semigroup[SemigroupInstance]['_T']
 export interface Semigroup<A> {
@@ -38,8 +38,6 @@ 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)
   }
 }
@@ -53,6 +51,6 @@ export namespace Semigroup {
 }
 
 export function concat<A extends SemigroupInstanceType>(a: A, b: A): A {
-  let instance = (<any>Semigroup)[kind(a)]
+  let instance = (<any>Semigroup)[datatypeOf(a)]
   return instance.concat(a, b)
 }