// -*- rust -*- fn ho(fn(int) -> int f) -> int { let int n = f(3); ret n; } fn direct(int x) -> int { ret x + 1; } fn main() { let int a = direct(3); // direct //let int b = ho(direct); // indirect unbound let int c = ho(bind direct(_)); // indirect bound //check(a == b); //check(b == c); } // -*- rust -*- fn ho(fn(int) -> int f) -> int { let int n = f(3); ret n; } fn direct(int x) -> int { ret x + 1; } fn main() { let int a = direct(3); // direct //let int b = ho(direct); // indirect unbound let int c = ho(bind direct(_)); // indirect bound //assert (a == b); //assert (b == c); } // -*- rust -*- fn ho(fn(int) -> int f) -> int { let int n = f(3); ret n; } fn direct(int x) -> int { ret x + 1; } fn main() { let int a = direct(3); // direct //let int b = ho(direct); // indirect unbound let int c = ho(bind direct(_)); // indirect bound //check(a == b); //check(b == c); } // -*- rust -*- fn ho(fn(int) -> int f) -> int { let int n = f(3); ret n; } fn direct(int x) -> int { ret x + 1; } fn main() { let int a = direct(3); // direct //let int b = ho(direct); // indirect unbound let int c = ho(bind direct(_)); // indirect bound //assert (a == b); //assert (b == c); } // -*- rust -*- fn ho(fn(int) -> int f) -> int { let int n = f(3); ret n; } fn direct(int x) -> int { ret x + 1; } fn main() { let int a = direct(3); // direct //let int b = ho(direct); // indirect unbound let int c = ho(bind direct(_)); // indirect bound //assert (a == b); //assert (b == c); } // -*- rust -*- fn ho(f: fn(int) -> int ) -> int { let n: int = f(3); ret n; } fn direct(x: int) -> int { ret x + 1; } fn main() { let a: int = direct(3); // direct //let int b = ho(direct); // indirect unbound let c: int = ho(bind direct(_)); // indirect bound //assert (a == b); //assert (b == c); } // xfail-pretty // -*- rust -*- fn ho(f: fn(int) -> int ) -> int { let n: int = f(3); ret n; } fn direct(x: int) -> int { ret x + 1; } fn main() { let a: int = direct(3); // direct //let int b = ho(direct); // indirect unbound let c: int = ho(bind direct(_)); // indirect bound //assert (a == b); //assert (b == c); } // -*- rust -*- fn ho(f: fn(int) -> int ) -> int { let n: int = f(3); ret n; } fn direct(x: int) -> int { ret x + 1; } fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound let c: int = ho(bind direct(_)); // indirect bound assert (a == b); assert (b == c); } // -*- rust -*- fn ho(f: fn(int) -> int) -> int { let n: int = f(3); ret n; } fn direct(x: int) -> int { ret x + 1; } fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound let c: int = ho(bind direct(_)); // indirect bound assert (a == b); assert (b == c); } // -*- rust -*- fn ho(f: fn@(int) -> int) -> int { let n: int = f(3); ret n; } fn direct(x: int) -> int { ret x + 1; } fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound let c: int = ho(bind direct(_)); // indirect bound assert (a == b); assert (b == c); } // -*- rust -*- fn ho(f: fn@(int) -> int) -> int { let n: int = f(3); ret n; } fn direct(x: int) -> int { ret x + 1; } fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound let c: int = ho(direct(_)); // indirect bound assert (a == b); assert (b == c); } // -*- rust -*- fn ho(f: fn@(int) -> int) -> int { let n: int = f(3); ret n; } fn direct(x: int) -> int { ret x + 1; } fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert (a == b); } // -*- rust -*- fn ho(f: fn@(int) -> int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert (a == b); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho(f: fn@(int) -> int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert (a == b); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho(f: fn@(int) -> int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert (a == b); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho(f: @fn(int) -> int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert (a == b); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho(f: @fn(int) -> int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound fail_unless!((a == b)); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho(f: @fn(int) -> int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert!((a == b)); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho(f: @fn(int) -> int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert_eq!(a, b); } // -*- rust -*- // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho(f: &fn(int) -> int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert_eq!(a, b); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho(f: &fn(int) -> int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert_eq!(a, b); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho(f: |int| -> int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert_eq!(a, b); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho<F>(f: F) -> int where F: FnOnce(int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert_eq!(a, b); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // pretty-expanded FIXME #23616 fn ho<F>(f: F) -> int where F: FnOnce(int) -> int { let n: int = f(3); return n; } fn direct(x: int) -> int { return x + 1; } pub fn main() { let a: int = direct(3); // direct let b: int = ho(direct); // indirect unbound assert_eq!(a, b); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. // pretty-expanded FIXME #23616 fn ho<F>(f: F) -> isize where F: FnOnce(isize) -> isize { let n: isize = f(3); return n; } fn direct(x: isize) -> isize { return x + 1; } pub fn main() { let a: isize = direct(3); // direct let b: isize = ho(direct); // indirect unbound assert_eq!(a, b); } // Copyright 2012 The Rust Project Developers. See the COPYRIGHT // file at the top-level directory of this distribution and at // http://rust-lang.org/COPYRIGHT. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. fn ho<F>(f: F) -> isize where F: FnOnce(isize) -> isize { let n: isize = f(3); return n; } fn direct(x: isize) -> isize { return x + 1; } pub fn main() { let a: isize = direct(3); // direct let b: isize = ho(direct); // indirect unbound assert_eq!(a, b); }