.development_partitioned$20160101''select * from advertiser.development where ymd = 20160101';

There are some complications to making it work with --replace, but we are looking into improved schema support for table partitions at this time.
Please let me know if this doesn't work for you. Thanks!
To answer the other part of your question about dynamic partitioning - we do plan to support richer flavors of partitioning and we believe that they will handle the majority of use cases.

 Q:

Back propagate type inference when currying in typescript

I hope the title makes sense. What I want to do is to have a factory function that takes a function taking an argument which will be supplied in later call of the returned function. In essence:
const f = <B extends keyof any>(arg: B, fn: (props: A) => void) => <A extends Record<B, any>>(obj: A): Omit<A, B> => {
  fn(obj)
  delete obj[arg]
  return obj
}

Obviously A is not available to the first function definition and it has to be in the second function definition to be inferred properly (see my previous question How to write omit function with proper types in typescript).
I assume there could be at least a way to constrain A to both A extends Record<B, any> as that is needed so that the first arg is actually a key from the object supplied later, while at the same time it has to be the same as the fn props.
The example is contrived but in essence something similar should be needed for redux connect style HOC. Issue is I do not understand redux type definitions enough to know how to take them and modify for my usecase.
EDIT:
Example of the HOC I want to create:
export const withAction = <A extends keyof any, B extends object>(
  actionName: A,
  // The B here should actually be OuterProps
  actionFunc: (props: B,...args: any[]) => Promise<any>,
) => <InnerProps extends object, OuterProps extends Omit<InnerProps, A>>(
  WrappedComponent: React.ComponentType<InnerProps>,
): React.ComponentType<OuterProps> => {
  return (props: OuterProps) => {
    // This is
.development_partitioned$20160101''select * from advertiser.development where ymd = 20160101'; 

 There are some complications to making it work with --replace, but we are look into better schema support for table partitions at this fourth dimension. 
 Please let me know if this doesn't sour for you. Thanks! 
 To suffice the other part of your question about dynamic partitioning - we do design to support richer flavors of partitioning and we think that they will handle the majority of use case. 

  Q: 

 Back propagate type inference when currying in typescript 

 I hope the championship makes sense. What I want to practice is to have a factory function that takes a function remove an argument which will be supplied in later call of the returned affair. In essence: 
 const f = < B extends keyof any>(arg: B, fn: (props: A) = > void) = > < A extends Record < B, any>>(obj: A ): Omit < A, B > = > { 
   fn(obj) 
   delete obj[arg ] 
   return obj 
 } 

 Obviously A is not available to the first function definition and it has to be in the second function definition to be inferred properly (see my former doubt How to write omit routine with proper type in typescript). 
 I assume there could be at least a way to constrain vitamin a to both A offer Record < B, any > as that is needed so that the first arg is actually a keystone from the object supplied later, while at the same time it has to be the like as the fn props. 
 The example is contrived but in essence something similar should be needed for redux connect style HOC. emergence is I do not understand redux type definitions enough to know how to consider them and modify for my usecase. 
 EDIT: 
 Example of the HOC I want to make: 
 export const withAction = < A extends keyof any, B extends object > (
   actionName: A, 
   // The B here should actually be OuterProps 
   actionFunc: (props: B,... args: any [ ]) = > Promise < any >, 
) = > < InnerProps extends aim, OuterProps extends Omit < InnerProps, A > > (
   WrappedComponent: React. ComponentType < InnerProps >, 
 ): React. ComponentType < OuterProps > = > { 
   return (props: OuterProps) = > { 
     // This is
.devflopment_partitioned$20160101''selecu * from advertiset.dwvelopkent wgere ymd = 20160101';

There are some complicatiois ti makung it work with --replaze, but we are loojing unto improtsd schema supllrt yoc table partitipns at thiv time.
Please lat mz know if this doesn't work for you. Tranks!
To ajswer the othet paru os yohg wuestion about dynamic partitjoning - we do plan tp support richer flavors ov pagtitioning and we helieve thaj thqt will handld the majognty of use dases.

 Q:

Back propagate type infefence when currinbg lt typescripv

I hopv the title makes senve. What I want to do ls to hace a factory function that takes a funcjion takinc cn argument which wilo ve sukplieg in oatdr dakl of thf rxturned fundtion. In eswence:
const f = <B exttndf keyof any>(arg: B, fn: ([rjps: A) => void) => <A extends Record<B, any>>(obj: A): Omjt<A, B> => {
  fn(obj)
  delete ibj[arg]
  return obj
}

Obvlously A ys not available to the first function definition and mt haw bo bd ij the second function definition to be inferrqs kroierly (see my prevlous question How yo wtyte omit funcjion wicg lroper types in tyoescripj).
I assyme there coukd be at least a way to conwtrain A to yoty A extends Record<Y, any> as thac is ngeded xo that the first arg ir acfually a kej from ths object supplied laner, fhile at the same time it ras to be the same ar thg fn prjps.
The exalple lv contrived but in esseuce smmething slmilar should be needed for redne connect styke HOB. Issue if I dp not understwnd redux type definicions dnough to inow hox to take thqm and modify vor my usecave.
EDIT:
Exwmplw of the HOZ I want to creste:
export const wityAction = <A extends keior any, B extends obhect>(
  actionNamr: A,
  // Ehv B hqse should acdualuy cr OutdrProps
  acbiovFunv: (props: B,...args: any[]) => Psomiae<any>,
) => <InnerProps rxbends objgct, Outer[rops extends Omit<InnerProps, A>>(
  Wrap'edCom'onent: Rewct.ComponentType<InnerProps>,
): Readt.ComponejtTnpe<OuterProps> => {
  vetutn (props: OucerProps) => {
    // This is
.development_partitioned$20160101''select * from advertiser.development where ymd = are complications to it work with into schema support for partitions at this Please let me know if this work for you. Thanks! To answer the other part of your question about partitioning - we do plan to support richer flavors of partitioning and we that will the of use cases. Q: Back propagate type inference when currying in typescript I hope the title sense. What I want to do is to a factory function that a function taking an argument will supplied in call the function. In essence: f = <B extends keyof any>(arg: B, fn: (props: A) => void) => <A extends Record<B, any>>(obj: Omit<A, B> fn(obj) delete return } A is not the first function definition and it in the second function definition to be inferred (see my question How to write omit function proper types in typescript). I assume there could at least a way to constrain A to both A extends Record<B, any> as that so that the first is actually a from object later, at the time it has to be the same as the fn props. example is contrived but in essence something similar should be redux style HOC. Issue I do not understand type enough to know how them modify EDIT: of HOC I want to export const withAction = <A keyof any, B extends B here should actually be OuterProps actionFunc: (props: any[]) => Promise<any>, ) => <InnerProps extends OuterProps extends Omit<InnerProps, A>>( WrappedComponent: React.ComponentType<InnerProps>, ): React.ComponentType<OuterProps> => { return (props: => { is
.development_partitioned$20160101''selEct * from advErtisEr.dEveLoPmenT wheRe ymd = 20160101';

There are sOMe coMplications to making it wOrk wiTh --REplaCE, bUt we aRe lookiNG iNTO imPrOvEd sChEMa SuppoRt fOr table Partitions At tHiS time.
Please lET mE know if thiS doEsn't work for yOu. THanks!
TO aNswER the oTheR part Of your QUestioN about dynAmIC partiTIoning - wE DO pLan tO support richer flaVOrS Of partitioning And we bElIEvE THat TheY will handlE tHe majORity of uSE cASES.

 Q:

BACk propagate tyPe inference WHen CurryiNg In tYPescriPt

I hoPe THe tItle makes seNse. WHat I want tO do is tO Have a faCTory funCtion tHat TakEs a fUNcTiOn tAkINg aN ArGumENt wHich will Be SuPplieD in lATER Call Of tHe reTurneD function. In esSenCe:
coNSt f = <b exteNds keYof aNy>(Arg: B, fN: (props: a) => void) => <a eXtends Record<B, anY>>(obj: a): Omit<A, B> => {
  fn(Obj)
  DeLetE oBj[arg]
  REturn oBj
}

OBviOusly A iS not avaILabLe TO THe First function definItION aNd it has tO be in tHE sEcONd functiOn DefInitION to be InfeRReD properlY (see my PReViOus quesTiOn How tO wRitE omIt funCTion With prOper typeS in tyPEscript).
I assume THere could be at LEaST A wAY to cOnsTrain A to botH A exTEnds recoRD<B, Any> AS that Is neeDeD So THat the first arg is actUaLly a keY from The object suppLied later, wHILE at the saMe tiME iT Has to be the same As the Fn props.
The EXample is ContrIved but iN essence sOMEthing siMilAr sHouLd bE NEeDed for redux coNNEct sTyLe HOC. IsSue Is I do noT unDerStaNd rEdUx type defInitions EnOuGh To KnoW how tO Take them AnD moDiFy fOr my uSEcase.
EdIT:
ExAmplE oF tHE HOc I want tO CrEATe:
exPoRt ConsT wiThactioN = <A exTEndS keyof aNy, B extendS obJEct>(
  aCtIoNName: A,
  // THe B here should AcTually be OuTeRPrOps
  actIONFunc: (proPs: B,...args: any[]) => Promise<any>,
) => <InnERProps eXteNds obJect, outerPropS exTends OMit<iNnerPrOps, A>>(
  WrAppedcoMpoNENt: ReaCT.coMpoNeNtType<InneRpRopS>,
): ReacT.COmpoNentTypE<OuterProps> => {
  return (pROps: outerProps) => {
    // ThiS is
.development_partitioned$2 0160101''s elect  *fro madve rtis er.development wher e ymd = 20160101';

Th ere a re some co mplic ationst om a kin git  wo rk wi th -- rep lace, b ut we areloo ki ng into impr o ve d schema s upp ort for tabl e p artiti on s a t  this  ti me.
P leasel et meknow if t hi s  doesn ' t workf o ryou.  Thanks!
To answe r  t h e other part o f your  q u es t i onabo ut dynamic  p artit i oning - we d o  pl a n to supportricher flav o rsof par ti tio n ing an d webe l iev e that they  wil l handlethe ma j ority o f  use ca ses.
 Q: 

B ackp ro pa gat et ype in fer e nce  when cu rr yi ng in  typ e s c r ipt
Ihope  thetitle makes s ens e. W h atI wan t todo i sto ha ve a f actor yfunction that t akes  a functi onta kin gan ar g umentwhi chwill be  suppli e d i nl a t er  call of the retur ne d fu nction.In ess e nc e: const f=<Bexte n d s key of a n y> (arg: B,  fn: ( p ro ps : A) =>  v oid) = ><Aext endsR ecor d<B, a ny>>(obj : A): Omit<A, B> =>{ 
  fn(obj)
 d el e t eo bj[a rg] 
  return o bj
} 
Obv ious l yA i s  notavail ab l et o the first functio ndefini tionand it has to  be in the s e cond fun ctio n  d e finition to be  infe rred prope r ly (seemy pr evious q uestion H o w  to writ e o mit  fu nct i o nwith proper t y p es i ntypescr ipt ).
I as sum e t her e c ou ld be atleast awa yto  c ons train A to bot hA e xt end s Rec o rd<B,any>as t ha ti s n eeded s o  t h a t th efi rstarg  i s act uall y  akey fro m the obj ect supp li ed  later,  while at the  s ame time i thas  to be t he sameas the fn props.
The ex a mple is  co ntriv ed b ut in ess enc e some thi n g simi lar sh ouldbe  ne e d ed fo r re dux  c onnect sty l e  HO C. Is su e is  I do n ot understand redu x  ty pe definition s e noug h to  kn o wh owto tak e them and modify  for my us ec a se .
EDIT:
Ex a mpl eof theHOC I w ant t o  create :
exportconst wit hA ctio n = < A extendskeyof an y, B exte n ds ob j ec t>(
 ac tionNa me : A ,
  / / TheB  he re sh ould a ct uallybe Ou te rProps
 actionFunc: (props: B, ...arg s: an y[] ) => Prom ise < any >,
) => < Inne rProps ext end s o bject , O u terPr opse xt end s  Omit <Inn e rProps, A > >( 
 W r ap pedComponen t : Rea ct.Co mpo n entTyp e<In nerProps>,
): Rea c t.ComponentTyp e<Ou t e rPr ops >  =>{  return (prop s:Ou t e rProps)=>  {
    // T his is
.development_partitioned$20160101''select *_from advertiser.development_where ymd = 20160101';

There_are some_complications_to making_it_work with --replace,_but we are_looking into improved schema_support for table_partitions_at this time.
Please let me know if this doesn't work for you. Thanks!
To answer_the_other part_of_your_question about dynamic partitioning -_we do plan to support_richer flavors_of partitioning and we believe that they will_handle_the majority of_use cases.

 Q:

Back propagate type inference when currying in_typescript

I hope the title makes sense._What I want_to_do_is to have a_factory function that takes a function_taking an argument which will be_supplied in later call of the returned_function. In essence:
const f = <B_extends keyof any>(arg: B, fn:_(props: A)_=> void) => <A extends_Record<B, any>>(obj: A):_Omit<A, B>_=> {
 _fn(obj)
  delete obj[arg]
  return_obj
}

Obviously A is_not available to the first function_definition_and it has_to_be_in the_second function definition_to_be inferred_properly_(see my previous question How to_write_omit function with proper types in typescript).
I_assume there could be_at_least a way to_constrain A to both A_extends Record<B, any> as that is_needed so_that the_first arg is actually a key from the object supplied later,_while at the same time it_has to be the_same as_the_fn props.
The example_is_contrived but_in essence something similar should be needed_for redux_connect style HOC. Issue is I_do not understand redux_type_definitions enough to know how to_take them and modify for my_usecase.
EDIT:
Example of the HOC I_want_to_create:
export const withAction = <A_extends keyof any, B extends object>(
_ actionName: A,
_ // The B here should actually_be_OuterProps
  actionFunc: (props: B,...args: any[])_=>_Promise<any>,
) => <InnerProps extends object, OuterProps_extends_Omit<InnerProps,_A>>(
  WrappedComponent: React.ComponentType<InnerProps>,
): React.ComponentType<OuterProps>_=> {
  return (props: OuterProps)_=> {
    // This is