Implement TryFrom instead of ugly From for Result

Author: Seulgi Kim

rpc/src/v1/impls/account.rs

@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+use std::convert::TryInto;
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -98,7 +99,7 @@ where
             static ref LOCK: Mutex<()> = Mutex::new(());
         }
         let _guard = LOCK.lock();
-        let (tx, seq): (IncompleteTransaction, Option<u64>) = ::std::result::Result::from(tx)?;
+        let (tx, seq): (IncompleteTransaction, Option<u64>) = tx.try_into()?;
 
         let (hash, seq) = self
             .miner

rpc/src/v1/impls/chain.rs

@@ -14,6 +14,7 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+use std::convert::{TryFrom, TryInto};
 use std::sync::Arc;
 
 use ccore::{
@@ -273,7 +274,7 @@ where
 
     fn execute_transaction(&self, tx: UnsignedTransaction, sender: PlatformAddress) -> Result<Option<String>> {
         let sender_address = sender.try_address().map_err(errors::core)?;
-        let action = ::std::result::Result::from(tx.action).map_err(errors::conversion)?;
+        let action = Action::try_from(tx.action).map_err(errors::conversion)?;
         if let Some(transaction) = action.asset_transaction() {
             let result = self.client.execute_transaction(&transaction, sender_address);
             match result {
@@ -291,7 +292,7 @@ where
         params: Vec<Vec<BytesArray>>,
         indices: Vec<usize>,
     ) -> Result<Vec<String>> {
-        let action = ::std::result::Result::from(tx.action).map_err(errors::conversion)?;
+        let action = tx.action.try_into().map_err(errors::conversion)?;
         if let Action::TransferAsset {
             inputs,
             ..

rpc/src/v1/types/action.rs

@@ -14,14 +14,14 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-use std::iter::FromIterator;
+use std::convert::TryFrom;
 
 use cjson::uint::Uint;
 use ckey::{NetworkId, PlatformAddress, Public, Signature};
 use ctypes::transaction::{Action as ActionType, AssetMintOutput as AssetMintOutputType};
 use ctypes::ShardId;
 use primitives::{Bytes, H160, H256};
-use rustc_serialize::hex::{FromHex, FromHexError, ToHex};
+use rustc_serialize::hex::{FromHex, ToHex};
 
 use super::super::errors::ConversionError;
 use super::{AssetMintOutput, AssetTransferInput, AssetTransferOutput, OrderOnTransfer};
@@ -489,9 +489,9 @@ impl ActionWithTracker {
     }
 }
 
-// FIXME: Use TryFrom.
-impl From<Action> for Result<ActionType, ConversionError> {
-    fn from(from: Action) -> Self {
+impl TryFrom<Action> for ActionType {
+    type Error = ConversionError;
+    fn try_from(from: Action) -> Result<Self, Self::Error> {
         Ok(match from {
             Action::MintAsset {
                 network_id,
@@ -511,7 +511,7 @@ impl From<Action> for Result<ActionType, ConversionError> {
                     Some(registrar) => Some(registrar.try_into_address()?),
                     None => None,
                 };
-                let output_content = Result::<AssetMintOutputType, FromHexError>::from(*output)?;
+                let output_content = AssetMintOutputType::try_from(*output)?;
                 ActionType::MintAsset {
                     network_id,
                     shard_id,
@@ -534,13 +534,13 @@ impl From<Action> for Result<ActionType, ConversionError> {
                 approvals,
                 expiration,
             } => {
-                let iter_outputs = outputs.into_iter().map(From::from);
-                let orders = orders.into_iter().map(From::from).collect::<Result<_, _>>()?;
+                let outputs = outputs.into_iter().map(TryFrom::try_from).collect::<Result<_, _>>()?;
+                let orders = orders.into_iter().map(TryFrom::try_from).collect::<Result<_, _>>()?;
                 ActionType::TransferAsset {
                     network_id,
                     burns: burns.into_iter().map(From::from).collect(),
                     inputs: inputs.into_iter().map(From::from).collect(),
-                    outputs: Result::from_iter(iter_outputs)?,
+                    outputs,
                     orders,
                     metadata,
                     approvals,
@@ -587,7 +587,7 @@ impl From<Action> for Result<ActionType, ConversionError> {
                 output,
                 approvals,
             } => {
-                let output_content = Result::<AssetMintOutputType, FromHexError>::from(*output)?;
+                let output_content = AssetMintOutputType::try_from(*output)?;
                 ActionType::IncreaseAssetSupply {
                     network_id,
                     shard_id,
@@ -617,7 +617,7 @@ impl From<Action> for Result<ActionType, ConversionError> {
                     Some(registrar) => Some(registrar.try_into_address()?),
                     None => None,
                 };
-                let output_content = Result::<AssetMintOutputType, FromHexError>::from(*output)?;
+                let output_content = AssetMintOutputType::try_from(*output)?;
                 ActionType::ComposeAsset {
                     network_id,
                     shard_id,
@@ -637,11 +637,11 @@ impl From<Action> for Result<ActionType, ConversionError> {
 
                 approvals,
             } => {
-                let iter_outputs = outputs.into_iter().map(From::from);
+                let outputs = outputs.into_iter().map(TryFrom::try_from).collect::<Result<_, _>>()?;
                 ActionType::DecomposeAsset {
                     network_id,
                     input: (*input).into(),
-                    outputs: Result::from_iter(iter_outputs)?,
+                    outputs,
                     approvals,
                 }
             }

rpc/src/v1/types/asset_output.rs

@@ -15,6 +15,7 @@
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 extern crate rustc_serialize;
 
+use std::convert::TryFrom;
 use std::iter::FromIterator;
 use std::ops::Deref;
 
@@ -46,8 +47,9 @@ impl From<AssetTransferOutputType> for AssetTransferOutput {
     }
 }
 
-impl From<AssetTransferOutput> for Result<AssetTransferOutputType, FromHexError> {
-    fn from(from: AssetTransferOutput) -> Self {
+impl TryFrom<AssetTransferOutput> for AssetTransferOutputType {
+    type Error = FromHexError;
+    fn try_from(from: AssetTransferOutput) -> Result<Self, Self::Error> {
         Ok(AssetTransferOutputType {
             lock_script_hash: from.lock_script_hash,
             parameters: Result::from_iter(from.parameters.iter().map(Deref::deref).map(FromHex::from_hex))?,
@@ -76,8 +78,9 @@ impl From<AssetMintOutputType> for AssetMintOutput {
     }
 }
 
-impl From<AssetMintOutput> for Result<AssetMintOutputType, FromHexError> {
-    fn from(from: AssetMintOutput) -> Self {
+impl TryFrom<AssetMintOutput> for AssetMintOutputType {
+    type Error = FromHexError;
+    fn try_from(from: AssetMintOutput) -> Result<Self, Self::Error> {
         Ok(AssetMintOutputType {
             lock_script_hash: from.lock_script_hash,
             parameters: Result::from_iter(from.parameters.iter().map(Deref::deref).map(FromHex::from_hex))?,

rpc/src/v1/types/order.rs

@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+use std::convert::{TryFrom, TryInto};
+
 use cjson::uint::Uint;
 use ctypes::transaction::{Order as OrderType, OrderOnTransfer as OrderOnTransferType};
 use ctypes::ShardId;
@@ -64,8 +66,9 @@ impl From<OrderType> for Order {
     }
 }
 
-impl From<Order> for Result<OrderType, FromHexError> {
-    fn from(from: Order) -> Self {
+impl TryFrom<Order> for OrderType {
+    type Error = FromHexError;
+    fn try_from(from: Order) -> Result<Self, Self::Error> {
         let parameters_from =
             from.parameters_from.into_iter().map(|param| param.from_hex()).collect::<Result<_, _>>()?;
         let parameters_fee = from.parameters_fee.into_iter().map(|param| param.from_hex()).collect::<Result<_, _>>()?;
@@ -109,10 +112,11 @@ impl From<OrderOnTransferType> for OrderOnTransfer {
     }
 }
 
-impl From<OrderOnTransfer> for Result<OrderOnTransferType, FromHexError> {
-    fn from(from: OrderOnTransfer) -> Self {
+impl TryFrom<OrderOnTransfer> for OrderOnTransferType {
+    type Error = FromHexError;
+    fn try_from(from: OrderOnTransfer) -> Result<Self, Self::Error> {
         Ok(OrderOnTransferType {
-            order: Result::from(from.order)?,
+            order: from.order.try_into()?,
             spent_quantity: from.spent_quantity.into(),
             input_indices: from.input_indices,
             output_indices: from.output_indices,

rpc/src/v1/types/unsigned_transaction.rs

@@ -14,6 +14,8 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+use std::convert::{TryFrom, TryInto};
+
 use cjson::uint::Uint;
 use ckey::NetworkId;
 use ctypes::transaction::IncompleteTransaction;
@@ -31,14 +33,14 @@ pub struct UnsignedTransaction {
     pub action: Action,
 }
 
-// FIXME: Use TryFrom.
-impl From<UnsignedTransaction> for Result<(IncompleteTransaction, Option<u64>), Error> {
-    fn from(tx: UnsignedTransaction) -> Self {
+impl TryFrom<UnsignedTransaction> for (IncompleteTransaction, Option<u64>) {
+    type Error = Error;
+    fn try_from(tx: UnsignedTransaction) -> Result<Self, Self::Error> {
         Ok((
             IncompleteTransaction {
                 fee: tx.fee.into(),
                 network_id: tx.network_id,
-                action: Result::from(tx.action).map_err(errors::conversion)?,
+                action: tx.action.try_into().map_err(errors::conversion)?,
             },
             tx.seq,
         ))