diff --git a/src/lib.rs b/src/lib.rs
index 57aeb2e3e3295f3dedaecc06dac0be24b6ac250e..4e11b3121972292ffc354f9b46c9887dbaeb2730 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -115,10 +115,11 @@ pub enum IpTo {
 }
 
 /// `$($Ident: Ident ($Ty) -> $Ty )*`
-pub type Ips = HashMap<Ident, (Option<Ty>, Ty)>;
+pub type Ips = HashMap<Ident, (Option<Ty>, Ty, Option<Resources>)>;
 
 /// `$($Ident: $Ty = $Expr < $Path,)*`
-pub type Ops = HashMap<Ident, (Ty, Expr, Path)>;
+//pub type Ops = HashMap<Ident, (Ty, Expr, Path)>;
+pub type Ops = HashMap<Ident, (Option<Ty>, Ty)>;
 
 /// `cro! { .. }`
 #[derive(Debug)]
diff --git a/src/parse.rs b/src/parse.rs
index 5ca477f3d36ee433a2c95cde5968dcf1793f1343..924a3ca1664c34daab76a6bd845d9768b4e0c473 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -498,6 +498,7 @@ fn ips(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ips> {
 
             let mut ty_arg = None;
             let mut ty_ret = syn::parse_type(&"()")?;
+            let mut op_sync = None;
             let _ = ::parse::delimited(&mut tts, DelimToken::Brace, |tts| {
                 fields(&tts, |key, mut tts| {
                     match key.as_ref() {
@@ -524,7 +525,22 @@ fn ips(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ips> {
                             };
 
                         }
-                        "sync" => (),
+                        "sync" => {
+                            op_sync = Some(::parse::resources(&mut tts)?);
+
+                            //                            let sync =
+                            //                                Some(::parse::delimited(&mut tts, DelimToken::Bracket, |tts| {
+                            //                                    let mut tts = tts.iter().peekable();
+                            //                                    let mut idents = Vec::new();
+                            //                                    while let Some(tt) = tts.next() {
+                            //                                        if tts.peek().is_none() {
+                            //                                            break;
+                            //                                        }
+                            //                                    }
+                            //                                    Ok(())
+                            //                                }));
+                        }
+
                         "async" => (),
                         _ => bail!("unknown field: `{}`", key),
                     };
@@ -539,7 +555,7 @@ fn ips(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ips> {
                 _ => bail!("expected Comma, found {:?}", tt),
             }
 
-            ips.insert(ident.clone(), (ty_arg, ty_ret));
+            ips.insert(ident.clone(), (ty_arg, ty_ret, op_sync));
         }
         Ok(ips)
 
@@ -570,20 +586,41 @@ fn ops(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ops> {
                 bail!("expected Colon, found {:?}", tt);
             }
 
-            let ty = ::parse::ty(&TokenTree::Token(Token::Eq), &mut tts)
-                .chain_err(|| format!("parsing `type` for {:?}", ident))?;
-
-
-            let expr = ::parse::expr(&TokenTree::Token(Token::Lt), &mut tts)
-                .chain_err(|| format!("parsing `type` for {:?}", ident))?;
-
-
+            let tt = tts.next();
+            if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt {
+                ensure!(id.as_ref() == "fn", "expected `fn` Ident, found {:?}", tt);
+            } else {
+                bail!("expected `fn` Ident, found {:?}", tt);
+            }
 
+            let ty_arg = Some(::parse::delimited(
+                &mut tts,
+                DelimToken::Paren,
+                |tts| if tts.is_empty() {
+                    Ok(Ty::Tup(vec![]))
+                } else {
+                    Ok(syn::parse_type(&format!("{}", quote!(#(#tts)*)))?)
+                },
+            )?);
+
+            let tt = tts.peek().cloned();
+            let ty_ret: Result<Ty> = match tt {
+                Some(&TokenTree::Token(Token::Comma)) => Ok(syn::parse_type(&"()")?),
+                Some(&TokenTree::Token(Token::RArrow)) => {
+                    tts.next();
+                    ::parse::ty(&TokenTree::Token(Token::Comma), &mut tts)
+                }
+                _ => bail!("expected `-> Type,' or `,` found {:?}", tt),
+            };
 
-            let path = ::parse::path(&mut tts).chain_err(|| "parsing `path`")?;
-            tts.next();
+            let tt = tts.next();
+            match tt {
+                None |
+                Some(&TokenTree::Token(Token::Comma)) => {}
+                _ => bail!("expected Comma, found {:?}", tt),
+            }
 
-            ops.insert(ident.clone(), (ty, expr, path));
+            ops.insert(ident.clone(), (ty_arg, ty_ret?));
         }
         Ok(ops)
     })