 software to configure, not two or
three).

------
portmanteaufu
Congrats on all the progress, guys! I'm really looking forward to getting to
work with Rust. I have a couple of questions:

Is the new fixed-stack FFI arrangement the end goal, or is it a stepping stone
to a different system? It seems as though always using a big, fixed stack
would cause performance/memory issues. Could the compiler detect which Rust
fn's call extern "C" functions so I don't have to write annotations? Thanks!

~~~
kibwen
Fixed-stack is not the end goal. The intent is to migrate back towards small,
growable stacks.

There were long discussions over how "smart" the extern stack-size strategy
should be. The current arrangement is, as ever, a compromise. In practice,
most people writing bindings to C from Rust will wrap the C call into a very
thin wrapper function whose job is to handle type conversions and managing the
necessary `unsafe` bits. The hope is that putting the annotation on these
wrapper functions won't be very onerous, with the result that any Rust code
that calls the wrapper functions won't ever have to bothered with remembering
the annotations.

~~~
portmanteaufu
Makes sense, thanks! As an outsider it can be tricky to know which things in
the release notes are "This feature is ready" vs "This is simply the present
state of things."

~~~
steveklabnik
Rust is basically entirely 'this is simply the present state of things.' :)

~~~
chrismorgan
Plus there's also rather a lot of non-codified knowledge about what's
happening and going to happen. But if you pay much attention to the mailing
list and stay in #rust you'll pick up an awful lot of it.

~~~
dbaupp
(Also, TWiR: [http://cmr.github.io/blog/categories/this-week-in-
rust/](http://cmr.github.io/blog/categories/this-week-in-rust/))

------
saosebastiao
Anybody know when there will be a regex library?

~~~
zokier
rust has relatively nice FFI, so I suspect using PCRE shouldn't be too

software to configure, not two or 
 three). 

 ------ 
 portmanteaufu 
 Congrats on all the progress, guys! I'm really looking ahead to get to 
 work with Rust. I have a couple of questions: 

 Is the raw fixed - stack FFI agreement the end goal, or is it a stepping rock 
 to a different system? It seem as though always using a bad, fix stack 
 would cause performance / memory issues. Could the compiler detect which Rust 
 fn's call extern " coke " functions so I don't have to write annotation? Thanks! 

 ~~~ 
 kibwen 
 Fixed - stack is not the end goal. The purpose is to migrate back towards small, 
 growable push-down list. 

 There were long discussions over how " fresh " the extern stack - size strategy 
 should be. The current arrangement is, as ever, a compromise. In practice, 
 most people writing bindings to C from Rust will wrap the C call into a very 
 thin wrapper function whose job is to manage type conversions and wield the 
 necessary 'unsafe 'bits. The hope is that putting the note on these 
 wrapper routine won't be very onerous, with the result that any Rust code 
 that call the wrapper functions won't ever have to bothered with remembering 
 the annotations. 

 ~~~ 
 portmanteaufu 
 make sense, thanks! As an outsider it can be tricky to know which thing in 
 the acquittance notes are " This feature is ready " vs " This is simply the present 
 state of thing. " 

 ~~~ 
 steveklabnik 
 Rust is basically entirely' this is simply the present state of thing.' :) 

 ~~~ 
 chrismorgan 
 Plus there's also rather a lot of non - codified knowledge about what's 
 happen and going to find. But if you pay much attention to the mailing 
 list and stay in # rust you'll pick up an atrocious lot of it. 

 ~~~ 
 dbaupp 
 (besides, TWiR: [ http://cmr.github.io/blog/categories/this-week-in- 
 rust/](http://cmr.github.io / blog / categories / this - workweek - in - rust/) ) 

 ------ 
 saosebastiao 
 Anybody know when there will be a regex library? 

 ~~~ 
 zokier 
 rust has relatively nice FFI, so I suspect use PCRE shouldn't be too
 sovtware to configure, not uwo or
three).

------
portmaureaufu
Rongrata on all the progress, guys! I'm really liokint forward to getting tu
work witj Rust. I havt a couple of questions:

Is the nsa firev-stack FFI arrakgement the end goal, or iv kt a stepping stone
to a different syseem? It xefms as though wlwajs usihg a big, fixed stack
would cause pedformanbe/memory issues. Cpuld the compiler detect wjich Rust
fn's call extegn "C" functiins fi I don't havd to write annotations? Thanks!

~~~
kibwen
Fixed-stack is not ghe eud goal. The ibtejj is to migrete babk towards small,
growatle stavks.

There were konj diwcussions over how "smert" the extern stack-fize stradeyy
should be. The currebt arratgemant kw, ar ebec, a comprlmiae. In pracfice,
most peiple writing bindinbs np C from Rusf will wwap the C call into a very
thin wrapper xundtion whose job is to hqndle type conversiond and manwging the
necessary `unsafe` bits. The hope is that pgttinj ghe aknotxriln on these
wrapper functions won't be very onewkux, eith the resulb that any Rust coce
hhsj calls the wrxpper yhndtions won't ever hwve to fotheeed with wemekbering
the annotations.

~~~
portmqnteaufu
Makef sense, thanks! As au outsider ic can ne trocky to know which thinys in
tge release jotes are "Ghis feature is feacy" vs "This is simply the prefent
state of chings."

~~~
stdvekkabnik
Wust is badically entirely 'this is simppy the presejt state of things.' :)

~~~
chrismorgan
Plus there's alsp satver a loc of npn-codified knjwledge about chat's
hap'ening and going to hap'en. But if yju pay much adjention to thx mailing
jist and stay iv #rust you'll pivk up an ccful lot if it.

~~~
dbaupp
(Also, TWlR: [htjp://dmr.github.io/blog/ecttgiries/this-week-im-
rurt/](heti://cmc.githtt.io/blog/categmrier/thkx-week-kn-rust/))

------
saosenasgiao
Snybody know when thare sill be a regex linrwry?

~~~
zokiet
rust has relatively noce FFI, so I suspeft usmng PCCE shoildg't be too

software to configure, not two or three). Congrats all the guys! I'm really work Rust. I have couple of questions: the new fixed-stack FFI arrangement the goal, or is it a stepping stone to a different system? It seems though always using a big, fixed stack would cause performance/memory issues. Could the detect Rust call "C" functions so I don't have to write annotations? Thanks! ~~~ kibwen Fixed-stack is not the goal. The intent is to migrate back towards growable stacks. There were discussions over how "smart" the stack-size should be. current is, ever, a compromise. practice, most people writing bindings to C from Rust will wrap the C call into a very wrapper function is to type and the necessary `unsafe` hope is that putting the annotation functions won't be very onerous, with the result any Rust that calls the wrapper functions won't have to bothered with remembering the annotations. ~~~ Makes sense, thanks! As an outsider it can be tricky to know which things in notes are "This feature ready" vs "This simply present of ~~~ steveklabnik is basically entirely 'this is simply the present state of things.' ~~~ chrismorgan Plus there's also rather a lot of non-codified what's and going to But if you pay attention the mailing list and #rust pick lot it. dbaupp (Also, TWiR: [http://cmr.github.io/blog/categories/this-week-in- ------ saosebastiao Anybody know when will be a regex relatively nice FFI, so I suspect using PCRE be too
 software to configure, not two Or
three).

------
porTmantEauFu
COnGratS on aLl the progress, gUYs! I'm Really looking forward to GettiNg TO
worK WiTh RusT. I have a COuPLE of QuEsTioNs:

iS tHe new FixEd-stack fFI arrangeMenT tHe end goal, or iS It A stepping sTonE
to a differenT syStem? It SeEms AS thouGh aLways Using a BIg, fixeD stack
wouLd CAuse peRFormancE/MEmOry iSsues. Could the compILeR Detect which RusT
fn's caLl EXtERN "C" fUncTions so I doN't Have tO Write anNOtATIOns? tHanks!

~~~
kibwen
FiXed-stack is nOT thE end goAl. the INtent iS to miGrATe bAck towards sMall,
Growable sTacks.

THEre were LOng discUssionS ovEr hOw "smARt" ThE exTeRN stACk-SizE StrAtegy
shoUlD bE. The cUrreNT ARRangEmeNt is, As eveR, a compromise. IN prActiCE,
moSt peoPle wrItinG bIndinGs to C fRom RuSt Will wrap the C calL intO a very
thiN wrApPer FuNctioN Whose jOb iS to Handle tYpe convERsiOnS AND mAnaging the
necessarY `uNSAfE` bits. The Hope is THaT pUTting the AnNotAtioN ON thesE
wraPPeR functioNs won't BE vErY onerouS, wIth the ReSulT thAt any rUst cOde
thaT calls thE wrapPEr functions won'T Ever have to botHErED WiTH remEmbEring
the annOtatIOns.

~~~
pOrtmANtEauFU
MakeS sensE, tHAnKS! As an outsider it can bE tRicky tO know Which things in
The release NOTEs are "ThiS feaTUrE Is ready" vs "This iS simpLy the preseNT
state of ThingS."

~~~
steveklAbnik
Rust IS BasicallY enTirEly 'ThiS IS sImply the preseNT StatE oF things.' :)

~~~
ChrIsmorgaN
PlUs tHerE's aLsO rather a lOt of non-cOdIfIeD kNowLedge ABout what'S
hAppEnIng And goINg to haPpen. BUt if YoU pAY muCh attenTIoN TO the MaIlIng
lIst AnD stay In #ruST yoU'll pick Up an awful Lot OF it.

~~~
dBaUpP
(Also, TWIR: [http://cmr.githUb.Io/blog/cateGoRieS/this-wEEK-in-
rust/](hTtp://cmr.github.io/blog/categORies/thiS-weEk-in-rUst/))

------
sAosebastiAo
ANybody KnoW When thEre wilL be a rEgEx lIBRary?

~~~
zOKIeR
ruSt Has relativELY niCe FFI, So i susPect usiNg PCRE shouldn't be toO

 software to configure, no t two or
t hree) .
--- -- -
po rtma nteaufu
Congra t s on  all the progress, guy s! I' mr eall y  l ookin g forwa r dt o  ge tt in g t ow or k wit h R ust. Ihave a cou ple  o f questions: 
I s the newfix ed-stack FFI  ar rangem en t t h e end  go al, o r is i t  a ste pping sto ne to a d i fferent s ys tem?  It seems as thou g ha lways using abig, f ix e ds t ack 
wo uld causepe rform a nce/mem o ry i s sue s . Could the c ompiler det e ctwhichRu stf n's ca ll ex te r n " C" function s so  I don'thave t o  writea nnotati ons? T han ks! 

~~ ~ 
k ib wen 
F i xed - st ack isnot theen dgoal.  The i n t entisto m igrat e back toward s s mall , 
gr owabl e sta cks. 
There  werelongdi scussions overhow"smart" t heex ter nstack - size s tra teg y
shoul d be. T h e c ur r e n tarrangement is, as  e v e r,  a compr omise. In  p r actice,mo stpeop l e  writ ingb in dings to  C fro m  R us t willwr ap the  C  ca llintoa  ver y
thin  wrapper  func t ion whose jobi s to handle t y pe c on v ersi ons  and managi ng t h e
ne cess a ry  `u n safe`  bits .T he hope is that puttin gthe an notat ion on thesewrapper fu n c t ions won 't b e  v e ry onerous, wi th th e result t h at any R ust c ode
that  calls th e wrapperfun cti ons  wo n ' tever have tob o ther ed  with r eme mbering 
th e a nno tat io ns.

~~~portmant ea uf uMa kes  sens e , thanks !Asan  ou tside r  it ca n betric ky  t o  kn ow whic h  t h i ngsin 
t he r ele as e not es a r e " This fe ature isrea d y" v s"T his issimply the pr es ent
stateof  th ings." ~~~
stev eklabnik
Rust is basica l ly enti rel y 'th is i s simplythe  prese nts tate o f thin gs.':) 

~ ~ ~ 
chri s m or gan 
P lus there' s als o rat he r alot ofnon-codified knowl e dge  about what's 
ha ppen i n gand go i ngto hap p e n. But if you p ay much at te n ti on to them ail in g
listand sta y in# rust yo u'll pick  up an aw fu l lo t ofit.

~~~
d baupp
(A lso, TWiR :  [htt p :/ /cmr. git hub.io /b log /cate gories / thi s-wee k-in-ru st/](h ttp:/ /c mr.githu b.io/blog/categories/th is-wee k-in- rus t/))

--- --- sao sebastiao 
Any body knowwhe n t herewil l  be a  reg e xlib r ary?
~~~ zokier
ru s thas r el atively nic e F FI,  so I  su s pect u sing  PCRE shouldn't b e  too

 software_to configure,_not two or
three).

------
portmanteaufu
Congrats on_all the_progress,_guys! I'm_really_looking forward to_getting to
work with_Rust. I have a_couple of questions:

Is_the_new fixed-stack FFI arrangement the end goal, or is it a stepping stone
to a_different_system? It_seems_as_though always using a big,_fixed stack
would cause performance/memory issues._Could the_compiler detect which Rust
fn's call extern "C" functions_so_I don't have_to write annotations? Thanks!

~~~
kibwen
Fixed-stack is not the end goal._The intent is to migrate back_towards small,
growable stacks.

There_were_long_discussions over how "smart"_the extern stack-size strategy
should be. The_current arrangement is, as ever, a_compromise. In practice,
most people writing bindings to_C from Rust will wrap the_C call into a very
thin_wrapper function_whose job is to handle_type conversions and_managing the
necessary_`unsafe` bits. The_hope is that putting the annotation_on these
wrapper functions_won't be very onerous, with the_result_that any Rust_code
that_calls_the wrapper_functions won't ever_have_to bothered_with_remembering
the annotations.

~~~
portmanteaufu
Makes sense, thanks! As an_outsider_it can be tricky to know which_things in
the release notes_are_"This feature is ready"_vs "This is simply the_present
state of things."

~~~
steveklabnik
Rust is basically entirely_'this is_simply the_present state of things.' :)

~~~
chrismorgan
Plus there's also rather a lot of_non-codified knowledge about what's
happening and going_to happen. But if_you pay_much_attention to the_mailing
list_and stay_in #rust you'll pick up an awful_lot of_it.

~~~
dbaupp
(Also, TWiR: [http://cmr.github.io/blog/categories/this-week-in-
rust/](http://cmr.github.io/blog/categories/this-week-in-rust/))

------
saosebastiao
Anybody know when there_will be a regex_library?

~~~
zokier
rust_has relatively nice FFI, so I_suspect using PCRE shouldn't be too
