Skip to content

Commit e69748d

Browse files
zrhozrho
committed
Tuple fields.
1 parent f9bb1dc commit e69748d

39 files changed

+368
-578
lines changed

‎hugr-core/src/export.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -935,7 +935,7 @@ impl<'a> Context<'a> {
935935
var: Option<(table::NodeId, table::VarIndex)>,
936936
) -> table::TermId {
937937
match t {
938-
Term::RuntimeType { bound: b } => {
938+
Term::RuntimeType(b) => {
939939
if let (Some((node, index)), TypeBound::Copyable) = (var, b) {
940940
let term = self.make_term(table::Term::Var(table::VarId(node, index)));
941941
let non_linear = self.make_term_apply(model::CORE_NON_LINEAR, &[term]);
@@ -948,11 +948,11 @@ impl<'a> Context<'a> {
948948
Term::StringType => self.make_term_apply(model::CORE_STR_TYPE, &[]),
949949
Term::BytesType => self.make_term_apply(model::CORE_BYTES_TYPE, &[]),
950950
Term::FloatType => self.make_term_apply(model::CORE_FLOAT_TYPE, &[]),
951-
Term::ListType { item_type } => {
951+
Term::ListType(item_type) => {
952952
let item_type = self.export_term(item_type, None);
953953
self.make_term_apply(model::CORE_LIST_TYPE, &[item_type])
954954
}
955-
Term::TupleType { item_types: params } => {
955+
Term::TupleType(params) => {
956956
let item_types = self.bump.alloc_slice_fill_iter(
957957
params
958958
.iter()
@@ -961,12 +961,12 @@ impl<'a> Context<'a> {
961961
let types = self.make_term(table::Term::List(item_types));
962962
self.make_term_apply(model::CORE_TUPLE_TYPE, &[types])
963963
}
964-
Term::Type { ty } => self.export_type(ty),
965-
Term::BoundedNat { value } => self.make_term(model::Literal::Nat(*value).into()),
966-
Term::String { value } => self.make_term(model::Literal::Str(value.into()).into()),
967-
Term::Float { value } => self.make_term(model::Literal::Float(*value).into()),
968-
Term::Bytes { value } => self.make_term(model::Literal::Bytes(value.clone()).into()),
969-
Term::List { elems } => {
964+
Term::Type(ty) => self.export_type(ty),
965+
Term::BoundedNat(value) => self.make_term(model::Literal::Nat(*value).into()),
966+
Term::String(value) => self.make_term(model::Literal::Str(value.into()).into()),
967+
Term::Float(value) => self.make_term(model::Literal::Float(*value).into()),
968+
Term::Bytes(value) => self.make_term(model::Literal::Bytes(value.clone()).into()),
969+
Term::List(elems) => {
970970
// For now we assume that the sequence is meant to be a list.
971971
let parts = self.bump.alloc_slice_fill_iter(
972972
elems
@@ -975,7 +975,7 @@ impl<'a> Context<'a> {
975975
);
976976
self.make_term(table::Term::List(parts))
977977
}
978-
Term::Tuple { elems } => {
978+
Term::Tuple(elems) => {
979979
let parts = self.bump.alloc_slice_fill_iter(
980980
elems
981981
.iter()

‎hugr-core/src/extension/op_def.rs‎

Lines changed: 8 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -656,9 +656,7 @@ pub(super) mod test {
656656
const OP_NAME: OpName = OpName::new_inline("Reverse");
657657

658658
let ext = Extension::try_new_test_arc(EXT_ID, |ext, extension_ref| {
659-
const TP: TypeParam = TypeParam::RuntimeType {
660-
bound: TypeBound::Any,
661-
};
659+
const TP: TypeParam = TypeParam::RuntimeType(TypeBound::Any);
662660
let list_of_var =
663661
Type::new_extension(list_def.instantiate(vec![TypeArg::new_var_use(0, TP)])?);
664662
let type_scheme = PolyFuncTypeRV::new(vec![TP], Signature::new_endo(vec![list_of_var]));
@@ -680,11 +678,10 @@ pub(super) mod test {
680678
reg.validate()?;
681679
let e = reg.get(&EXT_ID).unwrap();
682680

683-
let list_usize =
684-
Type::new_extension(list_def.instantiate(vec![TypeArg::Type { ty: usize_t() }])?);
681+
let list_usize = Type::new_extension(list_def.instantiate(vec![usize_t().into()])?);
685682
let mut dfg = DFGBuilder::new(endo_sig(vec![list_usize]))?;
686683
let rev = dfg.add_dataflow_op(
687-
e.instantiate_extension_op(&OP_NAME, vec![TypeArg::Type { ty: usize_t() }])
684+
e.instantiate_extension_op(&OP_NAME, vec![usize_t().into()])
688685
.unwrap(),
689686
dfg.input_wires(),
690687
)?;
@@ -705,10 +702,8 @@ pub(super) mod test {
705702
&self,
706703
arg_values: &[TypeArg],
707704
) -> Result<PolyFuncTypeRV, SignatureError> {
708-
const TP: TypeParam = TypeParam::RuntimeType {
709-
bound: TypeBound::Any,
710-
};
711-
let [TypeArg::BoundedNat { value: n }] = arg_values else {
705+
const TP: TypeParam = TypeParam::RuntimeType(TypeBound::Any);
706+
let [TypeArg::BoundedNat(n)] = arg_values else {
712707
return Err(SignatureError::InvalidTypeArgs);
713708
};
714709
let n = *n as usize;
@@ -731,7 +726,7 @@ pub(super) mod test {
731726
ext.add_op("MyOp".into(), String::new(), SigFun(), extension_ref)?;
732727

733728
// Base case, no type variables:
734-
let args = [TypeArg::BoundedNat { value: 3 }, usize_t().into()];
729+
let args = [TypeArg::BoundedNat(3), usize_t().into()];
735730
assert_eq!(
736731
def.compute_signature(&args),
737732
Ok(Signature::new(
@@ -744,7 +739,7 @@ pub(super) mod test {
744739
// Second arg may be a variable (substitutable)
745740
let tyvar = Type::new_var_use(0, TypeBound::Copyable);
746741
let tyvars: Vec<Type> = vec![tyvar.clone(); 3];
747-
let args = [TypeArg::BoundedNat { value: 3 }, tyvar.clone().into()];
742+
let args = [TypeArg::BoundedNat(3), tyvar.clone().into()];
748743
assert_eq!(
749744
def.compute_signature(&args),
750745
Ok(Signature::new(
@@ -802,7 +797,7 @@ pub(super) mod test {
802797
extension_ref,
803798
)?;
804799
let tv = Type::new_var_use(0, TypeBound::Copyable);
805-
let args = [TypeArg::Type { ty: tv.clone() }];
800+
let args = [tv.clone().into()];
806801
let decls = [TypeBound::Copyable.into()];
807802
def.validate_args(&args, &decls).unwrap();
808803
assert_eq!(def.compute_signature(&args), Ok(Signature::new_endo(tv)));

‎hugr-core/src/extension/prelude.rs‎

Lines changed: 20 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -18,8 +18,8 @@ use crate::ops::constant::{CustomCheckFailure, CustomConst, ValueName};
1818
use crate::ops::{NamedOp, Value};
1919
use crate::types::type_param::{TypeArg, TypeParam};
2020
use crate::types::{
21-
CustomType, FuncValueType, PolyFuncType, PolyFuncTypeRV, Signature, SumType, Type, TypeBound,
22-
TypeName, TypeRV, TypeRow, TypeRowRV,
21+
CustomType, FuncValueType, PolyFuncType, PolyFuncTypeRV, Signature, SumType, Term, Type,
22+
TypeBound, TypeName, TypeRV, TypeRow, TypeRowRV,
2323
};
2424
use crate::utils::sorted_consts;
2525
use crate::{Extension, type_row};
@@ -678,27 +678,21 @@ impl MakeExtensionOp for MakeTuple {
678678
if def != TupleOpDef::MakeTuple {
679679
return Err(OpLoadError::NotMember(ext_op.unqualified_id().to_string()))?;
680680
}
681-
let [TypeArg::List { elems }] = ext_op.args() else {
681+
let [TypeArg::List(elems)] = ext_op.args() else {
682682
return Err(SignatureError::InvalidTypeArgs)?;
683683
};
684684
let tys: Result<Vec<Type>, _> = elems
685685
.iter()
686686
.map(|a| match a {
687-
TypeArg::Type { ty } => Ok(ty.clone()),
687+
TypeArg::Type(ty) => Ok(ty.clone()),
688688
_ => Err(SignatureError::InvalidTypeArgs),
689689
})
690690
.collect();
691691
Ok(Self(tys?.into()))
692692
}
693693

694694
fn type_args(&self) -> Vec<TypeArg> {
695-
vec![TypeArg::List {
696-
elems: self
697-
.0
698-
.iter()
699-
.map(|t| TypeArg::Type { ty: t.clone() })
700-
.collect(),
701-
}]
695+
vec![Term::new_list(self.0.iter().map(|t| t.clone().into()))]
702696
}
703697
}
704698

@@ -739,27 +733,21 @@ impl MakeExtensionOp for UnpackTuple {
739733
if def != TupleOpDef::UnpackTuple {
740734
return Err(OpLoadError::NotMember(ext_op.unqualified_id().to_string()))?;
741735
}
742-
let [TypeArg::List { elems }] = ext_op.args() else {
736+
let [Term::List(elems)] = ext_op.args() else {
743737
return Err(SignatureError::InvalidTypeArgs)?;
744738
};
745739
let tys: Result<Vec<Type>, _> = elems
746740
.iter()
747741
.map(|a| match a {
748-
TypeArg::Type { ty } => Ok(ty.clone()),
742+
Term::Type(ty) => Ok(ty.clone()),
749743
_ => Err(SignatureError::InvalidTypeArgs),
750744
})
751745
.collect();
752746
Ok(Self(tys?.into()))
753747
}
754748

755-
fn type_args(&self) -> Vec<TypeArg> {
756-
vec![TypeArg::List {
757-
elems: self
758-
.0
759-
.iter()
760-
.map(|t| TypeArg::Type { ty: t.clone() })
761-
.collect(),
762-
}]
749+
fn type_args(&self) -> Vec<Term> {
750+
vec![Term::new_list(self.0.iter().map(|t| t.clone().into()))]
763751
}
764752
}
765753

@@ -863,14 +851,14 @@ impl MakeExtensionOp for Noop {
863851
Self: Sized,
864852
{
865853
let _def = NoopDef::from_def(ext_op.def())?;
866-
let [TypeArg::Type { ty }] = ext_op.args() else {
854+
let [TypeArg::Type(ty)] = ext_op.args() else {
867855
return Err(SignatureError::InvalidTypeArgs)?;
868856
};
869857
Ok(Self(ty.clone()))
870858
}
871859

872860
fn type_args(&self) -> Vec<TypeArg> {
873-
vec![TypeArg::Type { ty: self.0.clone() }]
861+
vec![self.0.clone().into()]
874862
}
875863
}
876864

@@ -969,13 +957,13 @@ impl MakeExtensionOp for Barrier {
969957
{
970958
let _def = BarrierDef::from_def(ext_op.def())?;
971959

972-
let [TypeArg::List { elems }] = ext_op.args() else {
960+
let [TypeArg::List(elems)] = ext_op.args() else {
973961
return Err(SignatureError::InvalidTypeArgs)?;
974962
};
975963
let tys: Result<Vec<Type>, _> = elems
976964
.iter()
977965
.map(|a| match a {
978-
TypeArg::Type { ty } => Ok(ty.clone()),
966+
TypeArg::Type(ty) => Ok(ty.clone()),
979967
_ => Err(SignatureError::InvalidTypeArgs),
980968
})
981969
.collect();
@@ -985,13 +973,9 @@ impl MakeExtensionOp for Barrier {
985973
}
986974

987975
fn type_args(&self) -> Vec<TypeArg> {
988-
vec![TypeArg::List {
989-
elems: self
990-
.type_row
991-
.iter()
992-
.map(|t| TypeArg::Type { ty: t.clone() })
993-
.collect(),
994-
}]
976+
vec![TypeArg::new_list(
977+
self.type_row.iter().map(|t| t.clone().into()),
978+
)]
995979
}
996980
}
997981

@@ -1009,6 +993,7 @@ impl MakeRegisteredOp for Barrier {
1009993
mod test {
1010994
use crate::builder::inout_sig;
1011995
use crate::std_extensions::arithmetic::float_types::{ConstF64, float64_type};
996+
use crate::types::Term;
1012997
use crate::{
1013998
Hugr, Wire,
1014999
builder::{DFGBuilder, Dataflow, DataflowHugr, endo_sig},
@@ -1132,9 +1117,8 @@ mod test {
11321117

11331118
let err = b.add_load_value(error_val);
11341119

1135-
const TYPE_ARG_NONE: TypeArg = TypeArg::List { elems: vec![] };
11361120
let op = PRELUDE
1137-
.instantiate_extension_op(&EXIT_OP_ID, [TYPE_ARG_NONE, TYPE_ARG_NONE])
1121+
.instantiate_extension_op(&EXIT_OP_ID, [Term::new_list([]), Term::new_list([])])
11381122
.unwrap();
11391123

11401124
b.add_dataflow_op(op, [err]).unwrap();
@@ -1146,10 +1130,8 @@ mod test {
11461130
/// test the panic operation with input and output wires
11471131
fn test_panic_with_io() {
11481132
let error_val = ConstError::new(42, "PANIC");
1149-
let type_arg_q: TypeArg = TypeArg::Type { ty: qb_t() };
1150-
let type_arg_2q: TypeArg = TypeArg::List {
1151-
elems: vec![type_arg_q.clone(), type_arg_q],
1152-
};
1133+
let type_arg_q: Term = qb_t().into();
1134+
let type_arg_2q: Term = Term::new_list([type_arg_q.clone(), type_arg_q]);
11531135
let panic_op = PRELUDE
11541136
.instantiate_extension_op(&PANIC_OP_ID, [type_arg_2q.clone(), type_arg_2q.clone()])
11551137
.unwrap();

‎hugr-core/src/extension/prelude/generic.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -175,7 +175,7 @@ mod tests {
175175
fn test_load_nat() {
176176
let mut b = DFGBuilder::new(inout_sig(type_row![], vec![usize_t()])).unwrap();
177177

178-
let arg = TypeArg::BoundedNat { value: 4 };
178+
let arg = TypeArg::BoundedNat(4);
179179
let op = LoadNat::new(arg);
180180

181181
let out = b.add_dataflow_op(op.clone(), []).unwrap();
@@ -195,7 +195,7 @@ mod tests {
195195

196196
#[test]
197197
fn test_load_nat_fold() {
198-
let arg = TypeArg::BoundedNat { value: 5 };
198+
let arg = TypeArg::BoundedNat(5);
199199
let op = LoadNat::new(arg);
200200

201201
let optype: OpType = op.into();

‎hugr-core/src/extension/resolution/test.rs‎

Lines changed: 4 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ use crate::std_extensions::arithmetic::int_types::{self, int_type};
2525
use crate::std_extensions::collections::list::ListValue;
2626
use crate::std_extensions::std_reg;
2727
use crate::types::type_param::TypeParam;
28-
use crate::types::{PolyFuncType, Signature, Type, TypeArg, TypeBound};
28+
use crate::types::{PolyFuncType, Signature, Type, TypeBound};
2929
use crate::{Extension, Hugr, HugrView, type_row};
3030

3131
#[rstest]
@@ -333,14 +333,12 @@ fn resolve_custom_const(#[case] custom_const: impl CustomConst) {
333333
#[rstest]
334334
fn resolve_call() {
335335
let dummy_fn_sig = PolyFuncType::new(
336-
vec![TypeParam::RuntimeType {
337-
bound: TypeBound::Any,
338-
}],
336+
vec![TypeParam::RuntimeType(TypeBound::Any)],
339337
Signature::new(vec![], vec![bool_t()]),
340338
);
341339

342-
let generic_type_1 = TypeArg::Type { ty: float64_type() };
343-
let generic_type_2 = TypeArg::Type { ty: int_type(6) };
340+
let generic_type_1 = float64_type().into();
341+
let generic_type_2 = int_type(6).into();
344342
let expected_exts = [
345343
float_types::EXTENSION_ID.clone(),
346344
int_types::EXTENSION_ID.clone(),

‎hugr-core/src/extension/resolution/types.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -216,13 +216,13 @@ pub(super) fn collect_typearg_exts(
216216
missing_extensions: &mut ExtensionSet,
217217
) {
218218
match arg {
219-
TypeArg::Type { ty } => collect_type_exts(ty, used_extensions, missing_extensions),
220-
TypeArg::List { elems } => {
219+
TypeArg::Type(ty) => collect_type_exts(ty, used_extensions, missing_extensions),
220+
TypeArg::List(elems) => {
221221
for elem in elems.iter() {
222222
collect_typearg_exts(elem, used_extensions, missing_extensions);
223223
}
224224
}
225-
TypeArg::Tuple { elems } => {
225+
TypeArg::Tuple(elems) => {
226226
for elem in elems.iter() {
227227
collect_typearg_exts(elem, used_extensions, missing_extensions);
228228
}

‎hugr-core/src/extension/resolution/types_mut.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -221,13 +221,13 @@ pub(super) fn resolve_typearg_exts(
221221
used_extensions: &mut WeakExtensionRegistry,
222222
) -> Result<(), ExtensionResolutionError> {
223223
match arg {
224-
TypeArg::Type { ty } => resolve_type_exts(node, ty, extensions, used_extensions)?,
225-
TypeArg::List { elems } => {
224+
TypeArg::Type(ty) => resolve_type_exts(node, ty, extensions, used_extensions)?,
225+
TypeArg::List(elems) => {
226226
for elem in elems.iter_mut() {
227227
resolve_typearg_exts(node, elem, extensions, used_extensions)?;
228228
}
229229
}
230-
TypeArg::Tuple { elems } => {
230+
TypeArg::Tuple(elems) => {
231231
for elem in elems.iter_mut() {
232232
resolve_typearg_exts(node, elem, extensions, used_extensions)?;
233233
}

‎hugr-core/src/extension/simple_op.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -393,7 +393,7 @@ mod test {
393393

394394
assert_eq!(o.instantiate(&[]), Ok(o.clone()));
395395
assert_eq!(
396-
o.instantiate(&[TypeArg::BoundedNat { value: 1 }]),
396+
o.instantiate(&[TypeArg::BoundedNat(1)]),
397397
Err(OpLoadError::InvalidArgs(SignatureError::InvalidTypeArgs))
398398
);
399399
}

0 commit comments

Comments
 (0)