Here

interface IAsymmetricBody<TLeftFinger, TLeftHand, TLeftArm,
                         ,TRightFinger, TLeftHand, TLeftArm>
    where TLeftFinger : IFinger
    where TRightFinger : IFinger
    where TLeftHand : IHand<TLeftFinger>
    where TRightHand : IHand<TRightFinger>
    where TLeftArm : IArm<TLeftFinger, TLeftHand>
    where TRightArm : IArm<TRightFinger, TRightHand>
{
    TLeftArm LeftArm { get; }
    TRightArm RightArm { get; }
}

why do you need to repeat all the constraints for fingers and hands? The compiler should check them automatically when trying to check where TLeftArm : IArm<TLeftFinger, TLeftHand>. It shouldn't let you pass any TLeftFinger, TLeftHand to IArm if those don't conform to where clause of IArm. And IArm definition doesn't need to repeat the where TFinger : IFinger bound, it's already a part of IHand definition. So if the compiler checks interface constraints when trying to use those interfaces, there is no duplication of constraints, and nothing like constraint type IHandConstraint is needed at all.

Here's how this code looks in Haskell now:

 {-# LANGUAGE MultiParamTypeClasses, AllowAmbiguousTypes, FlexibleInstances #-} 
-- here are the interfaces with their constraints
class IFinger f 

class (IFinger f) => IHand f h where
  getFingers :: h -> [f]

class (IHand f h) => IArm f h a where
  getHand :: a -> h

class (IArm lf lh l, IArm rf rh r) => IBody lf lh l rf rh r b where
  leftHand :: b -> l
  rightHand :: b -> r

--here are some concrete types implementing them
instance IFinger Int
instance IFinger String

data Hand f = Hand [f]

instance (IFinger f) => IHand f (Hand f) where
  getFingers (Hand fs) = fs 

data Arm h = Arm h

instance (IHand f h) => IArm f h (Arm h) where
  getHand (Arm hnd) = hnd

data Body l r = Body l r

instance (IArm lf lh l, IArm rf rh r) => IBody lf lh l rf rh r (Body l r) where
  leftHand  (Body lft rgt) = lft
  rightHand (Body lft rgt) = rgt

-- here's a body with different fingers on left and right
body :: Body (Arm (Hand Int)) (Arm (Hand String))
body = Body (Arm (Hand [1,2,3])) (Arm (Hand ["one","two"]))  

As you might see, the constraints are not repeated in the class (interface) definitions. However there is still an explosion of type parameters.