П>Должен же быть смысл, какую-нибудь проблему это решает

The Unit type is a filler type. This is useful, for example, when an existing generic type is used, but one of its type arguments is not required for the particular application.

  // The single-valued type.
  [Serializable]
  public enum Unit { Unit };

  [Serializable]
  public struct Unit : IEquatable<Unit>
  {
    #region Fields

    private const int HashCodeMagicNumber = 67981;

    #endregion Fields

    #region Properties

    public static Unit Value {
      [DebuggerStepThrough]
      get { return default(Unit); }
    }

    #endregion Properties

    #region Overrides

    public override bool Equals(object obj) {
      return obj is Unit;
    }

    public override int GetHashCode() {
      return HashCodeMagicNumber;
    }

    #endregion Overrides

    #region IEquatable<Unit> Members

    public bool Equals(Unit other) {
      return true;
    }

    #endregion IEquatable<Unit> Members

    #region Operators

    [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "left", Justification = "We are can not change the operator signature.")]
    [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "right", Justification = "We are can not change the operator signature.")]
    public static bool operator ==(Unit left, Unit right) {
      return true;
    }

    [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "left", Justification = "We are can not change the operator signature.")]
    [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "right", Justification = "We are can not change the operator signature.")]
    public static bool operator !=(Unit left, Unit right) {
      return false;
    }

    #endregion Operators
  }

П>Причём это не просто синоним void, а обычный класс Microsoft.FSharp.Core.Unit, да ещё и с int _dummy внутри

П>Должен же быть смысл, какую-нибудь проблему это решает

| 1 -> ()

case 1: return;

> ignore;;
val it : ('a -> unit) = <fun:clo@0>

public static void ignore<T>(T value)

> let f1 () = ()
- let f2 () = ()
- let f3 = f1 >> f2;;

val f1 : unit -> unit
val f2 : unit -> unit
val f3 : (unit -> unit)

> let f4 = f1 >> ignore;;  

val f4 : (unit -> unit)

> let f5 = ignore >> f1;; 

  let f5 = ignore >> f1;;
  ----^^

stdin(15,5): error FS0030: Value restriction. The value 'f5' has been inferred to have generic type
        val f5 : ('_a -> unit)
Either make the arguments to 'f5' explicit or, if you do not intend for it to be generic, add a type annotation.
>

>> let f1 () = ()
S>- let f2 () = ()
S>- let f3 = f1 >> f2;;

S>val f1 : unit -> unit
S>val f2 : unit -> unit
S>val f3 : (unit -> unit)
S>

>> let f4 = f1 >> ignore;;  

S>val f4 : (unit -> unit)
S>

>> let f5 = ignore >> f1;; 

S>  let f5 = ignore >> f1;;
S>  ----^^

S>stdin(15,5): error FS0030: Value restriction. The value 'f5' has been inferred to have generic type
S>        val f5 : ('_a -> unit)
S>Either make the arguments to 'f5' explicit or, if you do not intend for it to be generic, add a type annotation.
>>
S>

> let a x = 5;;

val a : 'a -> int

> let b x = x + 1;;

val b : int -> int

> let c = a >> b;;

  let c = a >> b;;
  ----^

stdin(22,5): error FS0030: Value restriction. The value 'c' has been inferred to have generic type
    val c : ('_a -> int)
Either make the arguments to 'c' explicit or, if you do not intend for it to be generic, add a type annotation.

> let c x = (a >> b) x;;

val c : 'a -> int

| 1 -> ()

case 1: return;