From 5dc775d96f401bcb2b2ff6d83fb6508618f79c5a Mon Sep 17 00:00:00 2001
From: Per Lindgren <per.lindgren@ltu.se>
Date: Sun, 13 Aug 2017 01:27:38 +0200
Subject: [PATCH] opional arguments

---
 src/lib.rs   |  2 +-
 src/parse.rs | 52 +++++-----------------------------------------------
 2 files changed, 6 insertions(+), 48 deletions(-)

diff --git a/src/lib.rs b/src/lib.rs
index 266450d..57aeb2e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -115,7 +115,7 @@ pub enum IpTo {
 }
 
 /// `$($Ident: Ident ($Ty) -> $Ty )*`
-pub type Ips = HashMap<Ident, (Ident, Ty, Ty)>;
+pub type Ips = HashMap<Ident, (Option<Ty>, Ty)>;
 
 /// `$($Ident: $Ty = $Expr < $Path,)*`
 pub type Ops = HashMap<Ident, (Ty, Expr, Path)>;
diff --git a/src/parse.rs b/src/parse.rs
index deac900..5ca477f 100644
--- a/src/parse.rs
+++ b/src/parse.rs
@@ -496,7 +496,7 @@ fn ips(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ips> {
                 bail!("expected Colon, found {:?}", tt);
             }
 
-            let mut ty_arg = syn::parse_type(&"()")?;
+            let mut ty_arg = None;
             let mut ty_ret = syn::parse_type(&"()")?;
             let _ = ::parse::delimited(&mut tts, DelimToken::Brace, |tts| {
                 fields(&tts, |key, mut tts| {
@@ -508,9 +508,9 @@ fn ips(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ips> {
                             } else {
                                 bail!("expected `fn` Ident, found {:?}", tt);
                             }
-                            ty_arg = ::parse::delimited(&mut tts, DelimToken::Paren, |tts| {
+                            ty_arg = Some(::parse::delimited(&mut tts, DelimToken::Paren, |tts| {
                                 Ok(syn::parse_type(&format!("{}", quote!(#(#tts)*)))?)
-                            })?;
+                            })?);
 
                             let tt = tts.peek().cloned();
                             let ty_ret: Result<Ty> = match tt {
@@ -538,50 +538,8 @@ fn ips(tts: &mut Peekable<Iter<TokenTree>>) -> Result<Ips> {
                 Some(&TokenTree::Token(Token::Comma)) => {}
                 _ => bail!("expected Comma, found {:?}", tt),
             }
-            //            	Ok(()))?;
-            //
-            //
-            //            let tt = tts.next();
-            //            if let Some(&TokenTree::Token(Token::Colon)) = tt {
-            //            } else {
-            //                bail!("expected Colon, found {:?}", tt);
-            //            }
-            //
-            //            let tt = tts.next();
-            //            let meth =
-            //                if let Some(&TokenTree::Token(Token::Ident(ref id))) = tt {
-            //                    id
-            //                } else {
-            //                    bail!("expected Ident, found {:?}", tt);
-            //                };
-            //
-            //            //let ty_param: Result<Ty> =
-            //            let ty_param =
-            //                ::parse::delimited(&mut tts, DelimToken::Paren, |tts| {
-            //                    Ok(syn::parse_type(&format!("{}", quote!(#(#tts)*)))?)
-            //                })?;
-            //
-            //
-            //            let tt = tts.next();
-            //            //            let ty_return: Result<Ty> = Ok(syn::parse_type(&"()")?);
-            //            let ty_return: Result<Ty> = match tt {
-            //                Some(&TokenTree::Token(Token::Comma)) => {
-            //                    tts.next();
-            //                    Ok(syn::parse_type(&"()")?)
-            //                }
-            //                Some(&TokenTree::Token(Token::RArrow)) => {
-            //                    ::parse::ty(&TokenTree::Token(Token::Comma), &mut tts)
-            //                }
-            //                _ => bail!("expected `-> Type,' or `,` found {:?}", tt),
-            //            };
-            //
-            //            //let tt = tts.next();
-            //            //            if let Some(&TokenTree::Token(Token::Comma)) = tt {
-            //            //            } else {
-            //            //                bail!("expected Comma, found {:?}", tt);
-            //            //            };
-            //
-            //            ips.insert(ident.clone(), (meth.clone(), ty_param, ty_return?));
+
+            ips.insert(ident.clone(), (ty_arg, ty_ret));
         }
         Ok(ips)
 
-- 
GitLab