How to do pointfree style with long parameter list

I've got a function that creates an Async workflow, and the function that takes 10 arguments in curry style. e.g.

let createSequenceCore a b c d e f g h i j = 
  async { 
    ... 
  }

I want to create another function to start that workflow, so I've got

let startSequenceCore a b c d e f g h i j =
  Async.StartImmediate (createSequenceCore a b c d e f g h i j)

Is there any way I can get rid of those redundant parameters? I tried the << operator, but that only lets me remove one.

let startSequenceCore a b c d e f g h i =
  Async.StartImmediate << (createSequenceCore a b c d e f g h i)

(I added Haskell and Scala to this question even though the code itself is F#, as really what I want is just how to do this kind of currying, which would apply to any; I'd think a Haskell or Scala answer would be easily portable to F# and could well be marked as the correct answer).

NOTE Reasonably well showing that there is not an easy solution to this could also get the bounty.

UPDATE geesh I'm not going to give 100 points to an answer that argues with the question rather than answering it, even if it's the highest voted, so here:

I've got a function that creates an Async workflow, and the function that takes 4 arguments in curry style. e.g.

let createSequenceCore a b c d = 
  async { 
    ... 
  }

I want to create another function to start that workflow, so I've got

let startSequenceCore a b c d =
  Async.StartImmediate (createSequenceCore a b c d)

Is there any way I can get rid of those redundant parameters? I tried the << operator, but that only lets me remove one.

let startSequenceCore a b c =
  Async.StartImmediate << (createSequenceCore a b c)

Solution

10 arguments sounds like too many... How about you'd create a record with 10 properties instead, or maybe a DU where you don't need all 10 in every case? Either way, you'd end up with a single argument that way and normal function composition works as expected again.

EDIT: When you actually need it, you can create a more powerful version of the << and >> operators thusly:

let (<.<) f = (<<) (<<) (<<) f
let (<..<) f = (<<) (<<) (<.<) f
let (<...<) f = (<<) (<<) (<..<) f

let flip f a b = f b a
let (>.>) f = flip (<.<) f
let (>..>) f = flip (<..<) f
let (>...>) f = flip (<...<) f

and then you can just write:

let startSequenceCore =
    Async.StartImmediate <...< createSequenceCore

let startSequenceCore =
    createSequenceCore >...> Async.StartImmediate

P.S.: The argument f is there, so that the type inference infers generic args as opposed to obj.