Skip to content

Commit 9496e82

Browse files
zrhozrho
committed
Tuple fields.
1 parent f9bb1dc commit 9496e82

38 files changed

Lines changed: 295 additions & 475 deletions

‎hugr-core/src/export.rs‎

Lines changed: 9 additions & 9 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,11 +961,11 @@ 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()),
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()),
969969
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(
@@ -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: 12 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -684,7 +684,7 @@ impl MakeExtensionOp for MakeTuple {
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();
@@ -693,11 +693,7 @@ impl MakeExtensionOp for MakeTuple {
693693

694694
fn type_args(&self) -> Vec<TypeArg> {
695695
vec![TypeArg::List {
696-
elems: self
697-
.0
698-
.iter()
699-
.map(|t| TypeArg::Type { ty: t.clone() })
700-
.collect(),
696+
elems: self.0.iter().map(|t| t.clone().into()).collect(),
701697
}]
702698
}
703699
}
@@ -745,7 +741,7 @@ impl MakeExtensionOp for UnpackTuple {
745741
let tys: Result<Vec<Type>, _> = elems
746742
.iter()
747743
.map(|a| match a {
748-
TypeArg::Type { ty } => Ok(ty.clone()),
744+
TypeArg::Type(ty) => Ok(ty.clone()),
749745
_ => Err(SignatureError::InvalidTypeArgs),
750746
})
751747
.collect();
@@ -754,11 +750,7 @@ impl MakeExtensionOp for UnpackTuple {
754750

755751
fn type_args(&self) -> Vec<TypeArg> {
756752
vec![TypeArg::List {
757-
elems: self
758-
.0
759-
.iter()
760-
.map(|t| TypeArg::Type { ty: t.clone() })
761-
.collect(),
753+
elems: self.0.iter().map(|t| t.clone().into()).collect(),
762754
}]
763755
}
764756
}
@@ -863,14 +855,14 @@ impl MakeExtensionOp for Noop {
863855
Self: Sized,
864856
{
865857
let _def = NoopDef::from_def(ext_op.def())?;
866-
let [TypeArg::Type { ty }] = ext_op.args() else {
858+
let [TypeArg::Type(ty)] = ext_op.args() else {
867859
return Err(SignatureError::InvalidTypeArgs)?;
868860
};
869861
Ok(Self(ty.clone()))
870862
}
871863

872864
fn type_args(&self) -> Vec<TypeArg> {
873-
vec![TypeArg::Type { ty: self.0.clone() }]
865+
vec![self.0.clone().into()]
874866
}
875867
}
876868

@@ -975,7 +967,7 @@ impl MakeExtensionOp for Barrier {
975967
let tys: Result<Vec<Type>, _> = elems
976968
.iter()
977969
.map(|a| match a {
978-
TypeArg::Type { ty } => Ok(ty.clone()),
970+
TypeArg::Type(ty) => Ok(ty.clone()),
979971
_ => Err(SignatureError::InvalidTypeArgs),
980972
})
981973
.collect();
@@ -986,11 +978,7 @@ impl MakeExtensionOp for Barrier {
986978

987979
fn type_args(&self) -> Vec<TypeArg> {
988980
vec![TypeArg::List {
989-
elems: self
990-
.type_row
991-
.iter()
992-
.map(|t| TypeArg::Type { ty: t.clone() })
993-
.collect(),
981+
elems: self.type_row.iter().map(|t| t.clone().into()).collect(),
994982
}]
995983
}
996984
}
@@ -1009,6 +997,7 @@ impl MakeRegisteredOp for Barrier {
1009997
mod test {
1010998
use crate::builder::inout_sig;
1011999
use crate::std_extensions::arithmetic::float_types::{ConstF64, float64_type};
1000+
use crate::types::Term;
10121001
use crate::{
10131002
Hugr, Wire,
10141003
builder::{DFGBuilder, Dataflow, DataflowHugr, endo_sig},
@@ -1132,7 +1121,7 @@ mod test {
11321121

11331122
let err = b.add_load_value(error_val);
11341123

1135-
const TYPE_ARG_NONE: TypeArg = TypeArg::List { elems: vec![] };
1124+
const TYPE_ARG_NONE: Term = Term::List { elems: vec![] };
11361125
let op = PRELUDE
11371126
.instantiate_extension_op(&EXIT_OP_ID, [TYPE_ARG_NONE, TYPE_ARG_NONE])
11381127
.unwrap();
@@ -1146,8 +1135,8 @@ mod test {
11461135
/// test the panic operation with input and output wires
11471136
fn test_panic_with_io() {
11481137
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 {
1138+
let type_arg_q: Term = qb_t().into();
1139+
let type_arg_2q: Term = Term::List {
11511140
elems: vec![type_arg_q.clone(), type_arg_q],
11521141
};
11531142
let panic_op = PRELUDE

‎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: 2 additions & 2 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),
219+
TypeArg::Type(ty) => collect_type_exts(ty, used_extensions, missing_extensions),
220220
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: 2 additions & 2 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)?,
224+
TypeArg::Type(ty) => resolve_type_exts(node, ty, extensions, used_extensions)?,
225225
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
}

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

Lines changed: 10 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -147,7 +147,7 @@ impl TypeDef {
147147
least_upper_bound(indices.iter().map(|i| {
148148
let ta = args.get(*i);
149149
match ta {
150-
Some(TypeArg::Type { ty: s }) => s.least_upper_bound(),
150+
Some(TypeArg::Type(s)) => s.least_upper_bound(),
151151
_ => panic!("TypeArg index does not refer to a type."),
152152
}
153153
}))
@@ -241,7 +241,7 @@ mod test {
241241
use crate::extension::SignatureError;
242242
use crate::extension::prelude::{qb_t, usize_t};
243243
use crate::std_extensions::arithmetic::float_types::float64_type;
244-
use crate::types::type_param::{TypeArg, TypeArgError, TypeParam};
244+
use crate::types::type_param::{TypeArgError, TypeParam};
245245
use crate::types::{Signature, Type, TypeBound};
246246

247247
use super::{TypeDef, TypeDefBound};
@@ -250,19 +250,17 @@ mod test {
250250
fn test_instantiate_typedef() {
251251
let def = TypeDef {
252252
name: "MyType".into(),
253-
params: vec![TypeParam::RuntimeType {
254-
bound: TypeBound::Copyable,
255-
}],
253+
params: vec![TypeParam::RuntimeType(TypeBound::Copyable)],
256254
extension: "MyRsrc".try_into().unwrap(),
257255
// Dummy extension. Will return `None` when trying to upgrade it into an `Arc`.
258256
extension_ref: Default::default(),
259257
description: "Some parametrised type".into(),
260258
bound: TypeDefBound::FromParams { indices: vec![0] },
261259
};
262260
let typ = Type::new_extension(
263-
def.instantiate(vec![TypeArg::Type {
264-
ty: Type::new_function(Signature::new(vec![], vec![])),
265-
}])
261+
def.instantiate(vec![
262+
Type::new_function(Signature::new(vec![], vec![])).into(),
263+
])
266264
.unwrap(),
267265
);
268266
assert_eq!(typ.least_upper_bound(), TypeBound::Copyable);
@@ -271,10 +269,10 @@ mod test {
271269

272270
// And some bad arguments...firstly, wrong kind of TypeArg:
273271
assert_eq!(
274-
def.instantiate([TypeArg::Type { ty: qb_t() }]),
272+
def.instantiate([qb_t().into()]),
275273
Err(SignatureError::TypeArgMismatch(
276274
TypeArgError::TypeMismatch {
277-
term: TypeArg::Type { ty: qb_t() },
275+
term: qb_t().into(),
278276
type_: TypeBound::Copyable.into()
279277
}
280278
))
@@ -286,11 +284,8 @@ mod test {
286284
);
287285
// Too many arguments:
288286
assert_eq!(
289-
def.instantiate([
290-
TypeArg::Type { ty: float64_type() },
291-
TypeArg::Type { ty: float64_type() },
292-
])
293-
.unwrap_err(),
287+
def.instantiate([float64_type().into(), float64_type().into(),])
288+
.unwrap_err(),
294289
SignatureError::TypeArgMismatch(TypeArgError::WrongNumberArgs(2, 1))
295290
);
296291
}

0 commit comments

Comments
 (0)