Rename try_ to try_fn

Author: Nemo157

macros/src/lib.rs

@@ -15,7 +15,7 @@ pub fn throws(args: TokenStream, input: TokenStream) -> TokenStream {
 }
 
 #[proc_macro_attribute]
-pub fn try_(args: TokenStream, input: TokenStream) -> TokenStream {
-    assert!(args.to_string() == "", "try does not take arguments");
+pub fn try_fn(args: TokenStream, input: TokenStream) -> TokenStream {
+    assert!(args.to_string() == "", "try_fn does not take arguments");
     Throws::new(None).fold(input)
 }

src/lib.rs

@@ -98,7 +98,7 @@ pub use culpa_macros::throws;
 /// Annotates a function that implicitly wraps a try block.
 ///
 /// See the main crate docs for more details.
-pub use culpa_macros::try_;
+pub use culpa_macros::try_fn;
 
 /// Throw an error.
 ///

tests/try.rs

@@ -1,43 +1,43 @@
-use culpa::{throw, try_};
+use culpa::{throw, try_fn};
 
 type Error = isize;
 
-#[try_]
+#[try_fn]
 pub fn unit_fn() -> Result<(), Error> {}
 
-#[try_]
+#[try_fn]
 pub fn returns_fn() -> Result<i32, Error> {
     return 0;
 }
 
-#[try_]
+#[try_fn]
 pub fn returns_unit_fn() -> Result<(), Error> {
     if true {
         return;
     }
 }
 
-#[try_]
+#[try_fn]
 pub fn tail_returns_value() -> Result<i32, Error> {
     0
 }
 
-#[try_]
+#[try_fn]
 pub async fn async_fn() -> Result<(), Error> {}
 
-#[try_]
+#[try_fn]
 pub async fn async_fn_with_ret() -> Result<i32, Error> {
     0
 }
 
-#[try_]
+#[try_fn]
 pub fn throws_error() -> Result<(), i32> {
     if true {
         throw!(0);
     }
 }
 
-#[try_]
+#[try_fn]
 pub fn throws_and_has_return_type() -> Result<&'static str, i32> {
     if true {
         return "success";
@@ -47,16 +47,16 @@ pub fn throws_and_has_return_type() -> Result<&'static str, i32> {
     "okay"
 }
 
-#[try_]
+#[try_fn]
 pub fn throws_generics<E>() -> Result<(), E> {}
 
 pub struct Foo;
 
 impl Foo {
-    #[try_]
+    #[try_fn]
     pub fn static_method() -> Result<(), Error> {}
 
-    #[try_]
+    #[try_fn]
     pub fn bar(&self) -> Result<i32, Error> {
         if true {
             return 1;
@@ -65,88 +65,88 @@ impl Foo {
     }
 }
 
-#[try_]
+#[try_fn]
 pub fn has_inner_fn() -> Result<(), Error> {
     fn inner_fn() -> i32 {
         0
     }
     let _: i32 = inner_fn();
 }
 
-#[try_]
+#[try_fn]
 pub fn has_inner_closure() -> Result<(), Error> {
     let f = || 0;
     let _: i32 = f();
 }
 
-#[try_]
+#[try_fn]
 pub async fn has_inner_async_block() -> Result<(), Error> {
     let f = async { 0 };
     let _: i32 = f.await;
 }
 
-#[try_]
+#[try_fn]
 pub fn throws_as_result() -> Result<i32, Error> {
     0
 }
 
-#[try_]
+#[try_fn]
 pub fn throws_as_result_alias() -> std::io::Result<i32> {
     0
 }
 
-#[try_]
+#[try_fn]
 pub fn ommitted_error() -> Result<(), Error> {}
 
 pub mod foo {
-    use culpa::{throw, try_};
+    use culpa::{throw, try_fn};
 
     pub type Error = i32;
 
-    #[try_]
+    #[try_fn]
     pub fn throws_integer() -> Result<(), i32> {
         throw!(0);
     }
 }
 
 pub mod foo_trait_obj {
-    use culpa::try_;
+    use culpa::try_fn;
     pub trait FooTrait {}
 
     struct FooStruct;
 
     pub struct FooError;
     impl FooTrait for FooStruct {}
 
-    #[try_]
+    #[try_fn]
     pub fn foo() -> Result<Box<dyn FooTrait>, FooError> {
         Box::new(FooStruct)
     }
 }
 
-#[try_]
+#[try_fn]
 pub fn let_else(a: Option<u8>) -> Result<u8, Error> {
     let Some(a) = a else {
         return 0;
     };
     a
 }
 
-#[try_]
+#[try_fn]
 pub fn impl_trait() -> Result<impl std::fmt::Debug, Error> {}
 
-#[try_]
+#[try_fn]
 #[deny(unreachable_code)]
 pub fn unreachable() -> Result<(), i32> {
     todo!()
 }
 
 trait Example {
-    #[try_]
+    #[try_fn]
     fn foo() -> Result<i32, Error>;
 }
 
-#[try_]
+#[try_fn]
 fn as_option(x: bool) -> Option<i32> {
     if x {
         throw!();