use already in place tuple impl

Author: chfanghr

src/generators/correct/v1.rs

@@ -17,7 +17,6 @@ use crate::v1::transaction::{
     DCert, POSIXTime, ScriptContext, ScriptPurpose, TransactionHash, TransactionInfo,
     TransactionInput, TransactionOutput, TxInInfo,
 };
-use crate::v1::tuple::Tuple;
 use crate::v2::value::{AssetClass, CurrencySymbol, TokenName, Value};
 use num_bigint::BigInt;
 use proptest::collection::btree_map;
@@ -305,14 +304,6 @@ pub fn arb_assoc_map<K: std::fmt::Debug, V: std::fmt::Debug>(
     vec((arb_k, arb_v), 10).prop_map(AssocMap)
 }
 
-/// Strategy to generate a Tuple, given the strategies to generate its two elements
-pub fn arb_tuple<T: std::fmt::Debug, U: std::fmt::Debug>(
-    arb_k: impl Strategy<Value = T>,
-    arb_v: impl Strategy<Value = U>,
-) -> impl Strategy<Value = Tuple<T, U>> {
-    (arb_k, arb_v).prop_map(|(l, r)| Tuple(l, r))
-}
-
 /// Strategy to generate a PaymentPubKeyHash
 pub fn arb_payment_pub_key_hash() -> impl Strategy<Value = PaymentPubKeyHash> {
     arb_ed25519_pub_key_hash().prop_map(PaymentPubKeyHash)
@@ -352,10 +343,10 @@ pub fn arb_transaction_info() -> impl Strategy<Value = TransactionInfo> {
         arb_value(),
         arb_value(),
         vec(arb_d_cert(), 5),
-        vec(arb_tuple(arb_staking_credential(), arb_integer()), 5),
+        vec((arb_staking_credential(), arb_integer()), 5),
         arb_plutus_interval_posix_time(),
         vec(arb_payment_pub_key_hash(), 5),
-        vec(arb_tuple(arb_datum_hash(), arb_datum()), 5),
+        vec((arb_datum_hash(), arb_datum()), 5),
         arb_transaction_hash(),
     )
         .prop_map(

src/v1/assoc_map.rs

@@ -8,8 +8,6 @@ use serde::{Deserialize, Serialize};
 
 use crate::plutus_data::{IsPlutusData, PlutusData, PlutusDataError, PlutusType};
 
-use super::tuple::Tuple;
-
 #[derive(Debug, PartialEq, Eq, Clone)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct AssocMap<K, V>(pub Vec<(K, V)>);
@@ -39,15 +37,15 @@ impl<K: IsPlutusData, V: IsPlutusData> IsPlutusData for AssocMap<K, V> {
     }
 }
 
-impl<K, V> From<Vec<Tuple<K, V>>> for AssocMap<K, V> {
-    fn from(vec: Vec<Tuple<K, V>>) -> Self {
-        AssocMap(vec.into_iter().map(|Tuple(l, r)| (l, r)).collect())
+impl<K, V> From<Vec<(K, V)>> for AssocMap<K, V> {
+    fn from(vec: Vec<(K, V)>) -> Self {
+        AssocMap(vec)
     }
 }
 
-impl<K, V> From<AssocMap<K, V>> for Vec<Tuple<K, V>> {
+impl<K, V> From<AssocMap<K, V>> for Vec<(K, V)> {
     fn from(m: AssocMap<K, V>) -> Self {
-        m.0.into_iter().map(|(l, r)| Tuple(l, r)).collect()
+        m.0
     }
 }
 

src/v1/mod.rs

@@ -7,5 +7,4 @@ pub mod interval;
 pub mod redeemer;
 pub mod script;
 pub mod transaction;
-pub mod tuple;
 pub mod value;

src/v1/transaction.rs

@@ -4,7 +4,6 @@ use super::{
     crypto::{LedgerBytes, PaymentPubKeyHash},
     datum::{Datum, DatumHash},
     interval::PlutusInterval,
-    tuple::Tuple,
     value::{CurrencySymbol, Value},
 };
 use crate::plutus_data::{
@@ -357,10 +356,10 @@ pub struct TransactionInfo {
     pub fee: Value,
     pub mint: Value,
     pub d_cert: Vec<DCert>,
-    pub wdrl: Vec<Tuple<StakingCredential, BigInt>>,
+    pub wdrl: Vec<(StakingCredential, BigInt)>,
     pub valid_range: POSIXTimeRange,
     pub signatories: Vec<PaymentPubKeyHash>,
-    pub datums: Vec<Tuple<DatumHash, Datum>>,
+    pub datums: Vec<(DatumHash, Datum)>,
     pub id: TransactionHash,
 }
 

src/v1/tuple.rs

@@ -11,5 +11,4 @@ pub use crate::v1::crypto;
 pub use crate::v1::interval;
 pub use crate::v1::redeemer;
 pub use crate::v1::script;
-pub use crate::v1::tuple;
 pub use crate::v1::value;

src/v2/mod.rs

@@ -91,13 +91,6 @@ mod json_roundtrip_tests {
             }
         }
 
-        proptest! {
-            #[test]
-            fn test_bigint_tuple(val in arb_tuple(arb_integer(), arb_integer())) {
-                assert_eq!(val, from_to_json(&val)?);
-            }
-        }
-
         proptest! {
             #[test]
             fn test_d_cert(val in arb_d_cert()) {

tests/json.rs

@@ -175,13 +175,6 @@ mod plutusdata_roundtrip_tests {
             }
         }
 
-        proptest! {
-            #[test]
-            fn test_bigint_tuple(val in arb_tuple(arb_integer(), arb_integer())) {
-                assert_eq!(val, from_to_plutus_data(&val)?);
-            }
-        }
-
         proptest! {
             #[test]
             fn test_arb_payment_pub_key_hash(val in arb_payment_pub_key_hash()) {