diff --git a/src/libcore/comm.rs b/src/libcore/comm.rs
index 4775e297795..cf146ad8aa0 100644
--- a/src/libcore/comm.rs
+++ b/src/libcore/comm.rs
@@ -99,7 +99,6 @@ fn listen<T: send, U>(f: fn(Chan<T>) -> U) -> U {
 
 struct PortPtr<T:send> {
   let po: *rust_port;
-  new(po: *rust_port) { self.po = po; }
   drop unsafe {
       do task::unkillable {
         // Once the port is detached it's guaranteed not to receive further
@@ -122,6 +121,12 @@ struct PortPtr<T:send> {
   }
 }
 
+fn PortPtr<T: send>(po: *rust_port) -> PortPtr<T> {
+    PortPtr {
+        po: po
+    }
+}
+
 /**
  * Internal function for converting from a channel to a port
  *
@@ -134,7 +139,6 @@ fn as_raw_port<T: send, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U {
 
     struct PortRef {
        let p: *rust_port;
-       new(p: *rust_port) { self.p = p; }
        drop {
          if !ptr::is_null(self.p) {
            rustrt::rust_port_drop(self.p);
@@ -142,6 +146,12 @@ fn as_raw_port<T: send, U>(ch: comm::Chan<T>, f: fn(*rust_port) -> U) -> U {
        }
     }
 
+    fn PortRef(p: *rust_port) -> PortRef {
+        PortRef {
+            p: p
+        }
+    }
+
     let p = PortRef(rustrt::rust_port_take(*ch));
 
     if ptr::is_null(p.p) {
diff --git a/src/libcore/io.rs b/src/libcore/io.rs
index 21047660e7d..483c96206b5 100644
--- a/src/libcore/io.rs
+++ b/src/libcore/io.rs
@@ -247,10 +247,15 @@ impl<T: Reader, C> {base: T, cleanup: C}: Reader {
 
 struct FILERes {
     let f: *libc::FILE;
-    new(f: *libc::FILE) { self.f = f; }
     drop { libc::fclose(self.f); }
 }
 
+fn FILERes(f: *libc::FILE) -> FILERes {
+    FILERes {
+        f: f
+    }
+}
+
 fn FILE_reader(f: *libc::FILE, cleanup: bool) -> Reader {
     if cleanup {
         {base: f, cleanup: FILERes(f)} as Reader
@@ -417,10 +422,15 @@ impl fd_t: Writer {
 
 struct FdRes {
     let fd: fd_t;
-    new(fd: fd_t) { self.fd = fd; }
     drop { libc::close(self.fd); }
 }
 
+fn FdRes(fd: fd_t) -> FdRes {
+    FdRes {
+        fd: fd
+    }
+}
+
 fn fd_writer(fd: fd_t, cleanup: bool) -> Writer {
     if cleanup {
         {base: fd, cleanup: FdRes(fd)} as Writer
@@ -768,7 +778,6 @@ mod fsync {
     // Artifacts that need to fsync on destruction
     struct Res<t> {
         let arg: Arg<t>;
-        new(-arg: Arg<t>) { self.arg <- arg; }
         drop {
           match self.arg.opt_level {
             option::None => (),
@@ -780,6 +789,12 @@ mod fsync {
         }
     }
 
+    fn Res<t>(-arg: Arg<t>) -> Res<t>{
+        Res {
+            arg: move arg
+        }
+    }
+
     type Arg<t> = {
         val: t,
         opt_level: Option<Level>,
diff --git a/src/libcore/option.rs b/src/libcore/option.rs
index c9620e4df84..dfa02303751 100644
--- a/src/libcore/option.rs
+++ b/src/libcore/option.rs
@@ -292,9 +292,15 @@ fn test_unwrap_str() {
 fn test_unwrap_resource() {
     struct R {
        let i: @mut int;
-       new(i: @mut int) { self.i = i; }
        drop { *(self.i) += 1; }
     }
+
+    fn R(i: @mut int) -> R {
+        R {
+            i: i
+        }
+    }
+
     let i = @mut 0;
     {
         let x = R(i);
diff --git a/src/libcore/pipes.rs b/src/libcore/pipes.rs
index ae78c8108eb..f0b656ea649 100644
--- a/src/libcore/pipes.rs
+++ b/src/libcore/pipes.rs
@@ -135,12 +135,16 @@ struct BufferHeader {
     // get away with restricting it to 0 or 1, if we're careful.
     let mut ref_count: int;
 
-    new() { self.ref_count = 0; }
-
     // We may want a drop, and to be careful about stringing this
     // thing along.
 }
 
+fn BufferHeader() -> BufferHeader{
+    BufferHeader {
+        ref_count: 0
+    }
+}
+
 // XXX remove me
 #[cfg(stage0)]
 fn buffer_header() -> BufferHeader { BufferHeader() }
@@ -160,12 +164,6 @@ struct PacketHeader {
     // to a buffer_header if need be.
     let mut buffer: *libc::c_void;
 
-    new() {
-        self.state = Empty;
-        self.blocked_task = ptr::null();
-        self.buffer = ptr::null();
-    }
-
     // Returns the old state.
     unsafe fn mark_blocked(this: *rust_task) -> State {
         rustrt::rust_task_ref(this);
@@ -197,6 +195,14 @@ struct PacketHeader {
     }
 }
 
+fn PacketHeader() -> PacketHeader {
+    PacketHeader {
+        state: Empty,
+        blocked_task: ptr::null(),
+        buffer: ptr::null()
+    }
+}
+
 #[doc(hidden)]
 type Packet<T: send> = {
     header: PacketHeader,
@@ -368,12 +374,6 @@ unsafe fn get_buffer<T: send>(p: *PacketHeader) -> ~Buffer<T> {
 // This could probably be done with SharedMutableState to avoid move_it!().
 struct BufferResource<T: send> {
     let buffer: ~Buffer<T>;
-    new(+b: ~Buffer<T>) {
-        //let p = ptr::addr_of(*b);
-        //error!("take %?", p);
-        atomic_add_acq(&mut b.header.ref_count, 1);
-        self.buffer = b;
-    }
 
     drop unsafe {
         let b = move_it!(self.buffer);
@@ -392,6 +392,16 @@ struct BufferResource<T: send> {
     }
 }
 
+fn BufferResource<T: send>(+b: ~Buffer<T>) -> BufferResource<T> {
+    //let p = ptr::addr_of(*b);
+    //error!("take %?", p);
+    atomic_add_acq(&mut b.header.ref_count, 1);
+
+    BufferResource {
+        buffer: b
+    }
+}
+
 #[doc(hidden)]
 fn send<T: send, Tbuffer: send>(+p: SendPacketBuffered<T, Tbuffer>,
                                 +payload: T) -> bool {
@@ -770,15 +780,6 @@ fn send_packet<T: send>(p: *packet<T>) -> SendPacket<T> {
 struct SendPacketBuffered<T: send, Tbuffer: send> {
     let mut p: Option<*Packet<T>>;
     let mut buffer: Option<BufferResource<Tbuffer>>;
-    new(p: *Packet<T>) {
-        //debug!("take send %?", p);
-        self.p = Some(p);
-        unsafe {
-            self.buffer = Some(
-                BufferResource(
-                    get_buffer(ptr::addr_of((*p).header))));
-        };
-    }
     drop {
         //if self.p != none {
         //    debug!("drop send %?", option::get(self.p));
@@ -819,6 +820,18 @@ struct SendPacketBuffered<T: send, Tbuffer: send> {
     }
 }
 
+fn SendPacketBuffered<T: send, Tbuffer: send>(p: *Packet<T>)
+    -> SendPacketBuffered<T, Tbuffer> {
+        //debug!("take send %?", p);
+    SendPacketBuffered {
+        p: Some(p),
+        buffer: unsafe {
+            Some(BufferResource(
+                get_buffer(ptr::addr_of((*p).header))))
+        }
+    }
+}
+
 // XXX remove me
 #[cfg(stage0)]
 #[allow(non_camel_case_types)]
@@ -848,15 +861,6 @@ fn recv_packet<T: send>(p: *packet<T>) -> RecvPacket<T> {
 struct RecvPacketBuffered<T: send, Tbuffer: send> : Selectable {
     let mut p: Option<*Packet<T>>;
     let mut buffer: Option<BufferResource<Tbuffer>>;
-    new(p: *Packet<T>) {
-        //debug!("take recv %?", p);
-        self.p = Some(p);
-        unsafe {
-            self.buffer = Some(
-                BufferResource(
-                    get_buffer(ptr::addr_of((*p).header))));
-        };
-    }
     drop {
         //if self.p != none {
         //    debug!("drop recv %?", option::get(self.p));
@@ -897,6 +901,18 @@ struct RecvPacketBuffered<T: send, Tbuffer: send> : Selectable {
     }
 }
 
+fn RecvPacketBuffered<T: send, Tbuffer: send>(p: *Packet<T>)
+    -> RecvPacketBuffered<T, Tbuffer> {
+    //debug!("take recv %?", p);
+    RecvPacketBuffered {
+        p: Some(p),
+        buffer: unsafe {
+            Some(BufferResource(
+                get_buffer(ptr::addr_of((*p).header))))
+        }
+    }
+}
+
 // XXX remove me
 #[cfg(stage0)]
 #[allow(non_camel_case_types)]
@@ -1083,8 +1099,6 @@ impl<T: send> Port<T>: Recv<T> {
 struct PortSet<T: send> : Recv<T> {
     let mut ports: ~[pipes::Port<T>];
 
-    new() { self.ports = ~[]; }
-
     fn add(+port: pipes::Port<T>) {
         vec::push(self.ports, port)
     }
@@ -1131,6 +1145,12 @@ struct PortSet<T: send> : Recv<T> {
     }
 }
 
+fn PortSet<T: send>() -> PortSet<T>{
+    PortSet {
+        ports: ~[]
+    }
+}
+
 impl<T: send> Port<T>: Selectable {
     pure fn header() -> *PacketHeader unchecked {
         match self.endp {
diff --git a/src/libcore/priv.rs b/src/libcore/priv.rs
index 5db54650a6c..ae82e59efad 100644
--- a/src/libcore/priv.rs
+++ b/src/libcore/priv.rs
@@ -196,11 +196,16 @@ unsafe fn weaken_task(f: fn(comm::Port<()>)) {
 
     struct Unweaken {
       let ch: comm::Chan<()>;
-      new(ch: comm::Chan<()>) { self.ch = ch; }
       drop unsafe {
         rustrt::rust_task_unweaken(unsafe::reinterpret_cast(&self.ch));
       }
     }
+
+    fn Unweaken(ch: comm::Chan<()>) -> Unweaken {
+        Unweaken {
+            ch: ch
+        }
+    }
 }
 
 #[test]
diff --git a/src/libcore/rand.rs b/src/libcore/rand.rs
index 1a4592954e3..cdead813899 100644
--- a/src/libcore/rand.rs
+++ b/src/libcore/rand.rs
@@ -245,10 +245,15 @@ impl Rng {
 
 struct RandRes {
     let c: *rctx;
-    new(c: *rctx) { self.c = c; }
     drop { rustrt::rand_free(self.c); }
 }
 
+fn RandRes(c: *rctx) -> RandRes {
+    RandRes {
+        c: c
+    }
+}
+
 impl @RandRes: Rng {
     fn next() -> u32 { return rustrt::rand_next((*self).c); }
 }
diff --git a/src/libcore/run.rs b/src/libcore/run.rs
index 2e8d07175c9..866fcb2275a 100644
--- a/src/libcore/run.rs
+++ b/src/libcore/run.rs
@@ -228,10 +228,15 @@ fn start_program(prog: &str, args: &[~str]) -> Program {
     }
     struct ProgRes {
         let r: ProgRepr;
-        new(+r: ProgRepr) { self.r = r; }
         drop { destroy_repr(&self.r); }
     }
 
+    fn ProgRes(+r: ProgRepr) -> ProgRes {
+        ProgRes {
+            r: r
+        }
+    }
+
     impl ProgRes: Program {
         fn get_id() -> pid_t { return self.r.pid; }
         fn input() -> io::Writer { io::fd_writer(self.r.in_fd, false) }
diff --git a/src/libcore/stackwalk.rs b/src/libcore/stackwalk.rs
index 2d5518525fa..0f79a5b6f5f 100644
--- a/src/libcore/stackwalk.rs
+++ b/src/libcore/stackwalk.rs
@@ -8,9 +8,11 @@ type Word = uint;
 
 struct Frame {
     let fp: *Word;
+}
 
-    new(fp: *Word) {
-        self.fp = fp;
+fn Frame(fp: *Word) -> Frame {
+    Frame {
+        fp: fp
     }
 }
 
diff --git a/src/libcore/task.rs b/src/libcore/task.rs
index 5303c9d7bf2..8d1eb53cc79 100644
--- a/src/libcore/task.rs
+++ b/src/libcore/task.rs
@@ -610,10 +610,15 @@ fn get_task() -> Task {
 unsafe fn unkillable<U>(f: fn() -> U) -> U {
     struct AllowFailure {
         let t: *rust_task;
-        new(t: *rust_task) { self.t = t; }
         drop { rustrt::rust_task_allow_kill(self.t); }
     }
 
+    fn AllowFailure(t: *rust_task) -> AllowFailure{
+        AllowFailure {
+            t: t
+        }
+    }
+
     let t = rustrt::rust_get_task();
     let _allow_failure = AllowFailure(t);
     rustrt::rust_task_inhibit_kill(t);
@@ -624,10 +629,15 @@ unsafe fn unkillable<U>(f: fn() -> U) -> U {
 unsafe fn rekillable<U>(f: fn() -> U) -> U {
     struct DisallowFailure {
         let t: *rust_task;
-        new(t: *rust_task) { self.t = t; }
         drop { rustrt::rust_task_inhibit_kill(self.t); }
     }
 
+    fn DisallowFailure(t: *rust_task) -> DisallowFailure {
+        DisallowFailure {
+            t: t
+        }
+    }
+
     let t = rustrt::rust_get_task();
     let _allow_failure = DisallowFailure(t);
     rustrt::rust_task_allow_kill(t);
@@ -641,12 +651,18 @@ unsafe fn rekillable<U>(f: fn() -> U) -> U {
 unsafe fn atomically<U>(f: fn() -> U) -> U {
     struct DeferInterrupts {
         let t: *rust_task;
-        new(t: *rust_task) { self.t = t; }
         drop {
             rustrt::rust_task_allow_yield(self.t);
             rustrt::rust_task_allow_kill(self.t);
         }
     }
+
+    fn DeferInterrupts(t: *rust_task) -> DeferInterrupts {
+        DeferInterrupts {
+            t: t
+        }
+    }
+
     let t = rustrt::rust_get_task();
     let _interrupts = DeferInterrupts(t);
     rustrt::rust_task_inhibit_kill(t);
@@ -938,15 +954,6 @@ struct TCB {
     let mut ancestors: AncestorList;
     let is_main:       bool;
     let notifier:      Option<AutoNotify>;
-    new(me: *rust_task, -tasks: TaskGroupArc, -ancestors: AncestorList,
-        is_main: bool, -notifier: Option<AutoNotify>) {
-        self.me        = me;
-        self.tasks     = tasks;
-        self.ancestors = ancestors;
-        self.is_main   = is_main;
-        self.notifier  = notifier;
-        self.notifier.iter(|x| { x.failed = false; });
-    }
     // Runs on task exit.
     drop {
         // If we are failing, the whole taskgroup needs to die.
@@ -971,19 +978,37 @@ struct TCB {
     }
 }
 
+fn TCB(me: *rust_task, +tasks: TaskGroupArc, +ancestors: AncestorList,
+       is_main: bool, +notifier: Option<AutoNotify>) -> TCB {
+
+    let notifier = move notifier;
+    notifier.iter(|x| { x.failed = false; });
+
+    TCB {
+        me: me,
+        tasks: tasks,
+        ancestors: ancestors,
+        is_main: is_main,
+        notifier: move notifier
+    }
+}
+
 struct AutoNotify {
     let notify_chan: comm::Chan<Notification>;
     let mut failed:  bool;
-    new(chan: comm::Chan<Notification>) {
-        self.notify_chan = chan;
-        self.failed = true; // Un-set above when taskgroup successfully made.
-    }
     drop {
         let result = if self.failed { Failure } else { Success };
         comm::send(self.notify_chan, Exit(get_task(), result));
     }
 }
 
+fn AutoNotify(chan: comm::Chan<Notification>) -> AutoNotify {
+    AutoNotify {
+        notify_chan: chan,
+        failed: true // Un-set above when taskgroup successfully made.
+    }
+}
+
 fn enlist_in_taskgroup(state: TaskGroupInner, me: *rust_task,
                        is_member: bool) -> bool {
     let newstate = util::replace(state, None);
diff --git a/src/libcore/unsafe.rs b/src/libcore/unsafe.rs
index 86d78528e4d..e4a73c12921 100644
--- a/src/libcore/unsafe.rs
+++ b/src/libcore/unsafe.rs
@@ -95,7 +95,6 @@ struct ArcData<T> {
 
 struct ArcDestruct<T> {
     mut data: *libc::c_void;
-    new(data: *libc::c_void) { self.data = data; }
     drop unsafe {
         if self.data.is_null() {
             return; // Happens when destructing an unwrapper's handle.
@@ -132,6 +131,12 @@ struct ArcDestruct<T> {
     }
 }
 
+fn ArcDestruct<T>(data: *libc::c_void) -> ArcDestruct<T> {
+    ArcDestruct {
+        data: data
+    }
+}
+
 unsafe fn unwrap_shared_mutable_state<T: send>(+rc: SharedMutableState<T>)
         -> T {
     struct DeathThroes<T> {
@@ -276,21 +281,29 @@ extern mod rustrt {
 
 struct LittleLock {
     let l: rust_little_lock;
-    new() {
-        self.l = rustrt::rust_create_little_lock();
-    }
     drop { rustrt::rust_destroy_little_lock(self.l); }
 }
 
+fn LittleLock() -> LittleLock {
+    LittleLock {
+        l: rustrt::rust_create_little_lock()
+    }
+}
+
 impl LittleLock {
     #[inline(always)]
     unsafe fn lock<T>(f: fn() -> T) -> T {
         struct Unlock {
             let l: rust_little_lock;
-            new(l: rust_little_lock) { self.l = l; }
             drop { rustrt::rust_unlock_little_lock(self.l); }
         }
 
+        fn Unlock(l: rust_little_lock) -> Unlock {
+            Unlock {
+                l: l
+            }
+        }
+
         do atomically {
             rustrt::rust_lock_little_lock(self.l);
             let _r = Unlock(self.l);
diff --git a/src/libcore/util.rs b/src/libcore/util.rs
index f0b4a344307..57590dbfc3e 100644
--- a/src/libcore/util.rs
+++ b/src/libcore/util.rs
@@ -55,10 +55,11 @@ fn replace<T>(dest: &mut T, +src: T) -> T {
 /// A non-copyable dummy type.
 struct NonCopyable {
     i: ();
-    new() { self.i = (); }
     drop { }
 }
 
+fn NonCopyable() -> NonCopyable { NonCopyable { i: () } }
+
 mod tests {
     #[test]
     fn identity_crisis() {