Type that contains all functions of N elements in Coq

I am learning Coq and as an exercise I want to define a type FnArity (N:nat) to encode all functions of N arguments. That is:

Check FnArity 3 : (forall A B C : Set, A -> B -> C).

Should work but

Check FnArity 2 : (forall A B C D : Set, A -> B -> C -> D).

Should not work.

This is for pedagogic purposes so any relevant resources are welcome.

EDIT: From the answers so far I realize I am probably approaching this wrong so here is the proposition I am trying to prove: Composing N composition operators is equivalent to a composition operator that composes f and g where g expects N arguments. In haskell-ish terms:

(.).(.) ... N times ... (.).(.) f g = \a1, .. aN -> f (g (a1, .. , aN))

EDIT2: In coq terms:

Definition compose { A B C : Type } (F : C -> B) (G : A -> C ) : A -> B :=
  fun x => F ( G (x) ).

Definition compose2 {A1 A2 B C : Type} (F : C -> B) (G : A1 -> A2 -> C)
: A1 -> A2 -> B := fun x y => F ( G x y ).

Definition compose3 {A1 A2 A3 B C : Type} (F : C -> B) (G : A1 -> A2 -> A3 -> C)
: A1 -> A2 -> A3 -> B := fun x y z => F ( G x y z ).

(* The simplest case *)
Theorem dual_compose : forall {A B C D : Type} (f: D -> C) (g : A -> B -> D) ,
                         (compose compose compose) f g = compose2 f g.
Proof. reflexivity. Qed.

Theorem triple_compose : forall {A1 A2 A3 B C : Type} (f: C -> B) (g : A1 -> A2 -> A3 -> C) ,
                         (compose (compose (compose) compose) compose) f g =
                         compose3 f g.

What I want is to define the generalized theorem for composeN.

Solution

The types that you wrote down do not quite represent what you stated in your problem: forall A B C, A -> B -> C is not the type of all functions of three arguments, but the type of certain polymorphic functions of two arguments. You probably meant to write something like { A & { B & { C & A -> B -> C }}} instead, where A, B and C are existentially quantified. You probably also meant to say Compute (FnArity 3) instead of using the Check command, since the latter is the one that evaluates a term (and, as jbapple pointed out, no term can have the type that you had originally written).

Here's a piece of code that does what you want, I think. We start by writing a function FnArityAux1 : list Type -> Type -> Type, that computes a function type with arguments given on a list:

Fixpoint FnArityAux1 (args : list Type) (res : Type) : Type :=
  match args with
  | [] => res
  | T :: args' => T -> FnArityAux1 args' res
  end.

For instance, FnArityAux1 [nat; bool] bool evaluates to nat -> bool -> bool. We can then use this function to define FnArity as follows:

Fixpoint FnArityAux2 (args : list Type) (n : nat) : Type :=
  match n with
  | 0 => { T : Type & FnArityAux1 args T }
  | S n' => { T : Type & FnArityAux2 (args ++ [T]) n' }
  end.

Definition FnArity n := FnArityAux2 [] n.

In this definition, we use another auxiliary function FnArityAux2 that has an argument args whose purpose is to carry around all the existentially quantified types produced so far. For each "iteration step", it quantifies over another type T, adds that type to the list of arguments, and recurses. When the recursion is over, we use FnArityAux1 to combine all accumulated types into a single function type. Then, we can define FnArity simply by starting the process with an empty list -- that is, no quantified types at all.