Add type class?

[paf31]

This library looks useful, thanks!

Would you be interested in adding something like

class Multivariate a where
  toMulti :: forall r. (a -> r) -> Fn a r
  fromMulti :: forall r. Fn a r -> a -> r

instance multiUnit :: Multivariate Unit where
  toMulti = fnConst
  fromMulti fn _ = getConst fn

instance multiCurry :: (Multivariate args) => Multivariate (Tuple a args) where
  toMulti f = fnUncurry \a -> toMulti \args -> f (Tuple a args)
  fromMulti fn (Tuple a args) = fromMulti (fnCurry fn a) args

It needs some type annotations in some cases, but seems like it would be handy for building these functions.

[DavidHarrison]

Thanks! Having a type class to convert between the two would be really useful. I had been playing around with the idea of using an Isomorphic type class based on Iso, but that runs into issues since I was unable to define instances for symmetry or composition, it seems like this type class would clear those issues up.

[DavidHarrison]

With your suggestions, I've been able to get the the Isomorphic type class to work, which gives us the ability to fully curry and uncurry functions in a single step, though does come at the cost of making it a multi-parameter type class.

What are your thoughts on the following?

class Isomorphic a b where
  to   :: a -> b
  from :: b -> a

-- reify :: Isomorphic a b => Iso a b
-- reify = Iso to from

instance isoRefl :: Isomorphic a a where
  to   = id
  from = id

instance isoConstFnZ :: Isomorphic ret (Fn Unit ret) where
  to   = pure
  from = getConst

instance isoArrFnZ :: Isomorphic (Unit -> ret) (Fn Unit ret) where
  to   = pure <<< ($ unit)
  from = const <<< getConst

instance isoCurriedFnS :: (Isomorphic (b -> c) (Fn args ret)) => Isomorphic (Tuple a b -> c) (Fn (Tuple a args) ret) where
  to f                   = fnUncurry \a -> to \args -> f (Tuple a args)
  from fn (Tuple a args) = from (fnCurry fn a) args

instance isoArrFnS :: (Isomorphic f (Fn args ret)) => Isomorphic (a -> f) (Fn (Tuple a args) ret) where
  to   = fnUncurry <<< map to
  from = map from  <<< fnCurry

test1 :: forall a b c d. (a -> b -> c -> d) -> Fn (Tuple a (Tuple b (Tuple c Unit))) d
test1 = to

test2 :: forall a b c d. Fn (Tuple a (Tuple b (Tuple c Unit))) d -> a -> b -> c -> d
test2 = from

test3 :: forall a b c d. (Tuple a (Tuple b c) -> d) -> Fn (Tuple a (Tuple b (Tuple c Unit))) d
test3 = to

test4 :: forall a b c d. Fn (Tuple a (Tuple b (Tuple c Unit))) d -> (Tuple a (Tuple b c) -> d)
test4 = from

[paf31]

It looks good, but you might find you run into type ambiguity errors. Only way is to try both and see, I suppose.

[DavidHarrison]

Sounds good, I've added both for now and will see how that goes. Thanks again.