diff --git a/crates/glue/src/glue.rs b/crates/glue/src/glue.rs new file mode 100644 index 0000000000..0f497eb9b3 --- /dev/null +++ b/crates/glue/src/glue.rs @@ -0,0 +1,4081 @@ +// ⚠️ GENERATED CODE ⚠️ - this entire file was generated by the `roc glue` CLI command + +#![allow(dead_code)] +#![allow(unused_mut)] +#![allow(non_snake_case)] +#![allow(non_camel_case_types)] +#![allow(non_upper_case_globals)] +#![allow(clippy::undocumented_unsafe_blocks)] + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct Types { + pub aligns: roc_std::RocList, + pub deps: roc_std::RocDict>, + pub sizes: roc_std::RocList, + pub types: roc_std::RocList, + pub typesByName: roc_std::RocDict, + pub target: Target, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(u8)] +pub enum discriminant_RocType { + Bool = 0, + EmptyTagUnion = 1, + Function = 2, + Num = 3, + RecursivePointer = 4, + RocBox = 5, + RocDict = 6, + RocList = 7, + RocResult = 8, + RocSet = 9, + RocStr = 10, + Struct = 11, + TagUnion = 12, + TagUnionPayload = 13, + Unit = 14, +} + +impl core::fmt::Debug for discriminant_RocType { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::Bool => f.write_str("discriminant_RocType::Bool"), + Self::EmptyTagUnion => f.write_str("discriminant_RocType::EmptyTagUnion"), + Self::Function => f.write_str("discriminant_RocType::Function"), + Self::Num => f.write_str("discriminant_RocType::Num"), + Self::RecursivePointer => f.write_str("discriminant_RocType::RecursivePointer"), + Self::RocBox => f.write_str("discriminant_RocType::RocBox"), + Self::RocDict => f.write_str("discriminant_RocType::RocDict"), + Self::RocList => f.write_str("discriminant_RocType::RocList"), + Self::RocResult => f.write_str("discriminant_RocType::RocResult"), + Self::RocSet => f.write_str("discriminant_RocType::RocSet"), + Self::RocStr => f.write_str("discriminant_RocType::RocStr"), + Self::Struct => f.write_str("discriminant_RocType::Struct"), + Self::TagUnion => f.write_str("discriminant_RocType::TagUnion"), + Self::TagUnionPayload => f.write_str("discriminant_RocType::TagUnionPayload"), + Self::Unit => f.write_str("discriminant_RocType::Unit"), + } + } +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[repr(C)] +pub union RocType { + Function: core::mem::ManuallyDrop, + Num: RocNum, + RecursivePointer: u32, + RocBox: u32, + RocDict: RocType_RocDict, + RocList: u32, + RocResult: RocType_RocResult, + RocSet: u32, + Struct: core::mem::ManuallyDrop, + TagUnion: core::mem::ManuallyDrop, + TagUnionPayload: core::mem::ManuallyDrop, + _sizer: [u8; 52], +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Copy, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R15 { + pub discriminant: u32, + pub r#type: u32, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R12 { + pub name: roc_std::RocStr, + pub payload: U4, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R10 { + pub name: roc_std::RocStr, + pub payload: U3, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R7 { + pub name: roc_std::RocStr, + pub payload: U1, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R3 { + pub name: roc_std::RocStr, + pub r#type: u32, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct Target { + pub architecture: Architecture, + pub operatingSystem: OperatingSystem, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(u8)] +pub enum OperatingSystem { + Unix = 0, + Wasi = 1, + Windows = 2, +} + +impl core::fmt::Debug for OperatingSystem { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::Unix => f.write_str("OperatingSystem::Unix"), + Self::Wasi => f.write_str("OperatingSystem::Wasi"), + Self::Windows => f.write_str("OperatingSystem::Windows"), + } + } +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(u8)] +pub enum Architecture { + Aarch32 = 0, + Aarch64 = 1, + Wasm32 = 2, + X86x32 = 3, + X86x64 = 4, +} + +impl core::fmt::Debug for Architecture { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::Aarch32 => f.write_str("Architecture::Aarch32"), + Self::Aarch64 => f.write_str("Architecture::Aarch64"), + Self::Wasm32 => f.write_str("Architecture::Wasm32"), + Self::X86x32 => f.write_str("Architecture::X86x32"), + Self::X86x64 => f.write_str("Architecture::X86x64"), + } + } +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R14 { + pub fields: roc_std::RocList, + pub name: roc_std::RocStr, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(u8)] +pub enum discriminant_RocTagUnion { + Enumeration = 0, + NonNullableUnwrapped = 1, + NonRecursive = 2, + NullableUnwrapped = 3, + NullableWrapped = 4, + Recursive = 5, + SingleTagStruct = 6, +} + +impl core::fmt::Debug for discriminant_RocTagUnion { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::Enumeration => f.write_str("discriminant_RocTagUnion::Enumeration"), + Self::NonNullableUnwrapped => f.write_str("discriminant_RocTagUnion::NonNullableUnwrapped"), + Self::NonRecursive => f.write_str("discriminant_RocTagUnion::NonRecursive"), + Self::NullableUnwrapped => f.write_str("discriminant_RocTagUnion::NullableUnwrapped"), + Self::NullableWrapped => f.write_str("discriminant_RocTagUnion::NullableWrapped"), + Self::Recursive => f.write_str("discriminant_RocTagUnion::Recursive"), + Self::SingleTagStruct => f.write_str("discriminant_RocTagUnion::SingleTagStruct"), + } + } +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[repr(C)] +pub union RocTagUnion { + Enumeration: core::mem::ManuallyDrop, + NonNullableUnwrapped: core::mem::ManuallyDrop, + NonRecursive: core::mem::ManuallyDrop, + NullableUnwrapped: core::mem::ManuallyDrop, + NullableWrapped: core::mem::ManuallyDrop, + Recursive: core::mem::ManuallyDrop, + SingleTagStruct: core::mem::ManuallyDrop, + _sizer: [u8; 48], +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R13 { + pub name: roc_std::RocStr, + pub payloadFields: roc_std::RocList, + pub tagName: roc_std::RocStr, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R11 { + pub discriminantOffset: u32, + pub discriminantSize: u32, + pub name: roc_std::RocStr, + pub tags: roc_std::RocList, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(u8)] +pub enum discriminant_U4 { + None = 0, + Some = 1, +} + +impl core::fmt::Debug for discriminant_U4 { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::None => f.write_str("discriminant_U4::None"), + Self::Some => f.write_str("discriminant_U4::Some"), + } + } +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[repr(C)] +pub union U4 { + Some: u32, + _sizer: [u8; 8], +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R9 { + pub discriminantOffset: u32, + pub discriminantSize: u32, + pub name: roc_std::RocStr, + pub tags: roc_std::RocList, + pub indexOfNullTag: u16, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(u8)] +pub enum discriminant_U3 { + None = 0, + Some = 1, +} + +impl core::fmt::Debug for discriminant_U3 { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::None => f.write_str("discriminant_U3::None"), + Self::Some => f.write_str("discriminant_U3::Some"), + } + } +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[repr(C)] +pub union U3 { + Some: u32, + _sizer: [u8; 8], +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R8 { + pub name: roc_std::RocStr, + pub nonNullPayload: u32, + pub nonNullTag: roc_std::RocStr, + pub nullTag: roc_std::RocStr, + pub whichTagIsNull: U2, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(u8)] +pub enum U2 { + FirstTagIsNull = 0, + SecondTagIsNull = 1, +} + +impl core::fmt::Debug for U2 { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::FirstTagIsNull => f.write_str("U2::FirstTagIsNull"), + Self::SecondTagIsNull => f.write_str("U2::SecondTagIsNull"), + } + } +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R6 { + pub discriminantOffset: u32, + pub discriminantSize: u32, + pub name: roc_std::RocStr, + pub tags: roc_std::RocList, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(u8)] +pub enum discriminant_U1 { + None = 0, + Some = 1, +} + +impl core::fmt::Debug for discriminant_U1 { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::None => f.write_str("discriminant_U1::None"), + Self::Some => f.write_str("discriminant_U1::Some"), + } + } +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[repr(C)] +pub union U1 { + Some: u32, + _sizer: [u8; 8], +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R5 { + pub name: roc_std::RocStr, + pub payload: u32, + pub tagName: roc_std::RocStr, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R4 { + pub name: roc_std::RocStr, + pub size: u32, + pub tags: roc_std::RocList, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R2 { + pub fields: roc_std::RocList, + pub name: roc_std::RocStr, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Copy, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +struct RocType_RocResult { + pub f0: u32, + pub f1: u32, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Copy, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +struct RocType_RocDict { + pub f0: u32, + pub f1: u32, +} + +#[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(u8)] +pub enum RocNum { + Dec = 0, + F128 = 1, + F32 = 2, + F64 = 3, + I128 = 4, + I16 = 5, + I32 = 6, + I64 = 7, + I8 = 8, + U128 = 9, + U16 = 10, + U32 = 11, + U64 = 12, + U8 = 13, +} + +impl core::fmt::Debug for RocNum { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + match self { + Self::Dec => f.write_str("RocNum::Dec"), + Self::F128 => f.write_str("RocNum::F128"), + Self::F32 => f.write_str("RocNum::F32"), + Self::F64 => f.write_str("RocNum::F64"), + Self::I128 => f.write_str("RocNum::I128"), + Self::I16 => f.write_str("RocNum::I16"), + Self::I32 => f.write_str("RocNum::I32"), + Self::I64 => f.write_str("RocNum::I64"), + Self::I8 => f.write_str("RocNum::I8"), + Self::U128 => f.write_str("RocNum::U128"), + Self::U16 => f.write_str("RocNum::U16"), + Self::U32 => f.write_str("RocNum::U32"), + Self::U64 => f.write_str("RocNum::U64"), + Self::U8 => f.write_str("RocNum::U8"), + } + } +} + +#[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R1 { + pub args: roc_std::RocList, + pub name: roc_std::RocStr, + pub ret: u32, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct Types { + pub aligns: roc_std::RocList, + pub deps: roc_std::RocDict>, + pub sizes: roc_std::RocList, + pub types: roc_std::RocList, + pub typesByName: roc_std::RocDict, + pub target: Target, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[repr(C)] +pub union RocType { + Function: core::mem::ManuallyDrop, + Num: RocNum, + RecursivePointer: u64, + RocBox: u64, + RocDict: RocType_RocDict, + RocList: u64, + RocResult: RocType_RocResult, + RocSet: u64, + Struct: core::mem::ManuallyDrop, + TagUnion: core::mem::ManuallyDrop, + TagUnionPayload: core::mem::ManuallyDrop, + _sizer: [u8; 104], +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R15 { + pub discriminant: u64, + pub r#type: u64, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R3 { + pub name: roc_std::RocStr, + pub r#type: u64, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[repr(C)] +pub union RocTagUnion { + Enumeration: core::mem::ManuallyDrop, + NonNullableUnwrapped: core::mem::ManuallyDrop, + NonRecursive: core::mem::ManuallyDrop, + NullableUnwrapped: core::mem::ManuallyDrop, + NullableWrapped: core::mem::ManuallyDrop, + Recursive: core::mem::ManuallyDrop, + SingleTagStruct: core::mem::ManuallyDrop, + _sizer: [u8; 96], +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R13 { + pub name: roc_std::RocStr, + pub payloadFields: roc_std::RocList, + pub tagName: roc_std::RocStr, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R11 { + pub name: roc_std::RocStr, + pub tags: roc_std::RocList, + pub discriminantOffset: u32, + pub discriminantSize: u32, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[repr(C)] +pub union U4 { + Some: u64, + _sizer: [u8; 16], +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R9 { + pub name: roc_std::RocStr, + pub tags: roc_std::RocList, + pub discriminantOffset: u32, + pub discriminantSize: u32, + pub indexOfNullTag: u16, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[repr(C)] +pub union U3 { + Some: u64, + _sizer: [u8; 16], +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R8 { + pub name: roc_std::RocStr, + pub nonNullPayload: u64, + pub nonNullTag: roc_std::RocStr, + pub nullTag: roc_std::RocStr, + pub whichTagIsNull: U2, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R6 { + pub name: roc_std::RocStr, + pub tags: roc_std::RocList, + pub discriminantOffset: u32, + pub discriminantSize: u32, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[repr(C)] +pub union U1 { + Some: u64, + _sizer: [u8; 16], +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R5 { + pub name: roc_std::RocStr, + pub payload: u64, + pub tagName: roc_std::RocStr, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R4 { + pub name: roc_std::RocStr, + pub tags: roc_std::RocList, + pub size: u32, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +struct RocType_RocResult { + pub f0: u64, + pub f1: u64, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Copy, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +struct RocType_RocDict { + pub f0: u64, + pub f1: u64, +} + +#[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" +))] +#[derive(Clone, Debug, Default, Eq, Ord, Hash, PartialEq, PartialOrd)] +#[repr(C)] +pub struct R1 { + pub args: roc_std::RocList, + pub name: roc_std::RocStr, + pub ret: u64, +} + +impl RocType { + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_RocType { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(48)) + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_RocType) { + let discriminant_ptr: *mut discriminant_RocType = (self as *mut RocType).cast(); + + unsafe { + *(discriminant_ptr.add(48)) = discriminant; + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// A tag named Bool, which has no payload. + pub const Bool: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[48] = discriminant_RocType::Bool as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], RocType>(bytes) + }; + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `into_` methods return a payload, but since the Bool tag + /// has no payload, this does nothing and is only here for completeness. + pub fn into_Bool(self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `as` methods return a payload, but since the Bool tag + /// has no payload, this does nothing and is only here for completeness. + pub fn as_Bool(&self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// A tag named EmptyTagUnion, which has no payload. + pub const EmptyTagUnion: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[48] = discriminant_RocType::EmptyTagUnion as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], RocType>(bytes) + }; + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `into_` methods return a payload, but since the EmptyTagUnion tag + /// has no payload, this does nothing and is only here for completeness. + pub fn into_EmptyTagUnion(self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `as` methods return a payload, but since the EmptyTagUnion tag + /// has no payload, this does nothing and is only here for completeness. + pub fn as_EmptyTagUnion(&self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `Function`, with the appropriate payload + pub fn Function(arg0: R1) -> Self { + let mut answer = Self { + Function: core::mem::ManuallyDrop::new(arg0) + }; + + answer.set_discriminant(discriminant_RocType::Function); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `Function` and convert it to `Function`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Function`. + pub unsafe fn into_Function(mut self) -> R1 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::Function); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.Function, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `Function` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Function`. + pub unsafe fn as_Function(&self) -> &R1 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::Function); + let payload = &self.Function; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `Num`, with the appropriate payload + pub fn Num(arg: RocNum) -> Self { + let mut answer = Self { + Num: arg + }; + + answer.set_discriminant(discriminant_RocType::Num); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `Num` and convert it to `Num`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Num`. + pub unsafe fn into_Num(self) -> RocNum { + debug_assert_eq!(self.discriminant(), discriminant_RocType::Num); + let payload = self.Num; + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `Num` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Num`. + pub unsafe fn as_Num(&self) -> &RocNum { + debug_assert_eq!(self.discriminant(), discriminant_RocType::Num); + let payload = &self.Num; + + &payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Construct a tag named `RecursivePointer`, with the appropriate payload + pub fn RecursivePointer(arg: u32) -> Self { + let mut answer = Self { + RecursivePointer: arg + }; + + answer.set_discriminant(discriminant_RocType::RecursivePointer); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RecursivePointer` and convert it to `RecursivePointer`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RecursivePointer`. + pub unsafe fn into_RecursivePointer(self) -> u32 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RecursivePointer); + let payload = self.RecursivePointer; + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RecursivePointer` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RecursivePointer`. + pub unsafe fn as_RecursivePointer(&self) -> &u32 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RecursivePointer); + let payload = &self.RecursivePointer; + + &payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Construct a tag named `RocBox`, with the appropriate payload + pub fn RocBox(arg: u32) -> Self { + let mut answer = Self { + RocBox: arg + }; + + answer.set_discriminant(discriminant_RocType::RocBox); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocBox` and convert it to `RocBox`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocBox`. + pub unsafe fn into_RocBox(self) -> u32 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocBox); + let payload = self.RocBox; + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocBox` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocBox`. + pub unsafe fn as_RocBox(&self) -> &u32 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocBox); + let payload = &self.RocBox; + + &payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Construct a tag named `RocDict`, with the appropriate payload + pub fn RocDict(arg0: u32, arg1: u32) -> Self { + let mut answer = Self { + RocDict: core::mem::ManuallyDrop::new(RocType_RocDict { + f0: arg0, + f1: arg1, + }) + }; + + answer.set_discriminant(discriminant_RocType::RocDict); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocDict` and convert it to `RocDict`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocDict`. + pub unsafe fn into_RocDict(self) -> (u32, u32) { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocDict); + let payload = self.RocDict; + + ( + payload.f0, + payload.f1 + ) + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocDict` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocDict`. + pub unsafe fn as_RocDict(&self) -> (&u32, &u32) { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocDict); + let payload = &self.RocDict; + + ( + &payload.f0, + &payload.f1 + ) + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Construct a tag named `RocList`, with the appropriate payload + pub fn RocList(arg: u32) -> Self { + let mut answer = Self { + RocList: arg + }; + + answer.set_discriminant(discriminant_RocType::RocList); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocList` and convert it to `RocList`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocList`. + pub unsafe fn into_RocList(self) -> u32 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocList); + let payload = self.RocList; + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocList` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocList`. + pub unsafe fn as_RocList(&self) -> &u32 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocList); + let payload = &self.RocList; + + &payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Construct a tag named `RocResult`, with the appropriate payload + pub fn RocResult(arg0: u32, arg1: u32) -> Self { + let mut answer = Self { + RocResult: core::mem::ManuallyDrop::new(RocType_RocResult { + f0: arg0, + f1: arg1, + }) + }; + + answer.set_discriminant(discriminant_RocType::RocResult); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocResult` and convert it to `RocResult`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocResult`. + pub unsafe fn into_RocResult(self) -> (u32, u32) { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocResult); + let payload = self.RocResult; + + ( + payload.f0, + payload.f1 + ) + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocResult` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocResult`. + pub unsafe fn as_RocResult(&self) -> (&u32, &u32) { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocResult); + let payload = &self.RocResult; + + ( + &payload.f0, + &payload.f1 + ) + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Construct a tag named `RocSet`, with the appropriate payload + pub fn RocSet(arg: u32) -> Self { + let mut answer = Self { + RocSet: arg + }; + + answer.set_discriminant(discriminant_RocType::RocSet); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocSet` and convert it to `RocSet`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocSet`. + pub unsafe fn into_RocSet(self) -> u32 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocSet); + let payload = self.RocSet; + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocSet` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocSet`. + pub unsafe fn as_RocSet(&self) -> &u32 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocSet); + let payload = &self.RocSet; + + &payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// A tag named RocStr, which has no payload. + pub const RocStr: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[48] = discriminant_RocType::RocStr as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], RocType>(bytes) + }; + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `into_` methods return a payload, but since the RocStr tag + /// has no payload, this does nothing and is only here for completeness. + pub fn into_RocStr(self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `as` methods return a payload, but since the RocStr tag + /// has no payload, this does nothing and is only here for completeness. + pub fn as_RocStr(&self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `Struct`, with the appropriate payload + pub fn Struct(arg0: R2) -> Self { + let mut answer = Self { + Struct: core::mem::ManuallyDrop::new(arg0) + }; + + answer.set_discriminant(discriminant_RocType::Struct); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `Struct` and convert it to `Struct`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Struct`. + pub unsafe fn into_Struct(mut self) -> R2 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::Struct); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.Struct, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `Struct` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Struct`. + pub unsafe fn as_Struct(&self) -> &R2 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::Struct); + let payload = &self.Struct; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `TagUnion`, with the appropriate payload + pub fn TagUnion(arg: RocTagUnion) -> Self { + let mut answer = Self { + TagUnion: core::mem::ManuallyDrop::new(arg) + }; + + answer.set_discriminant(discriminant_RocType::TagUnion); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `TagUnion` and convert it to `TagUnion`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `TagUnion`. + pub unsafe fn into_TagUnion(mut self) -> RocTagUnion { + debug_assert_eq!(self.discriminant(), discriminant_RocType::TagUnion); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.TagUnion, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `TagUnion` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `TagUnion`. + pub unsafe fn as_TagUnion(&self) -> &RocTagUnion { + debug_assert_eq!(self.discriminant(), discriminant_RocType::TagUnion); + let payload = &self.TagUnion; + + &payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `TagUnionPayload`, with the appropriate payload + pub fn TagUnionPayload(arg0: R14) -> Self { + let mut answer = Self { + TagUnionPayload: core::mem::ManuallyDrop::new(arg0) + }; + + answer.set_discriminant(discriminant_RocType::TagUnionPayload); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `TagUnionPayload` and convert it to `TagUnionPayload`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `TagUnionPayload`. + pub unsafe fn into_TagUnionPayload(mut self) -> R14 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::TagUnionPayload); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.TagUnionPayload, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `TagUnionPayload` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `TagUnionPayload`. + pub unsafe fn as_TagUnionPayload(&self) -> &R14 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::TagUnionPayload); + let payload = &self.TagUnionPayload; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// A tag named Unit, which has no payload. + pub const Unit: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[48] = discriminant_RocType::Unit as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], RocType>(bytes) + }; + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `into_` methods return a payload, but since the Unit tag + /// has no payload, this does nothing and is only here for completeness. + pub fn into_Unit(self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `as` methods return a payload, but since the Unit tag + /// has no payload, this does nothing and is only here for completeness. + pub fn as_Unit(&self) { + () + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_RocType { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(96)) + } + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_RocType) { + let discriminant_ptr: *mut discriminant_RocType = (self as *mut RocType).cast(); + + unsafe { + *(discriminant_ptr.add(96)) = discriminant; + } + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// A tag named Bool, which has no payload. + pub const Bool: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[96] = discriminant_RocType::Bool as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], RocType>(bytes) + }; + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// A tag named EmptyTagUnion, which has no payload. + pub const EmptyTagUnion: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[96] = discriminant_RocType::EmptyTagUnion as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], RocType>(bytes) + }; + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Construct a tag named `RecursivePointer`, with the appropriate payload + pub fn RecursivePointer(arg: u64) -> Self { + let mut answer = Self { + RecursivePointer: arg + }; + + answer.set_discriminant(discriminant_RocType::RecursivePointer); + + answer + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RecursivePointer` and convert it to `RecursivePointer`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RecursivePointer`. + pub unsafe fn into_RecursivePointer(self) -> u64 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RecursivePointer); + let payload = self.RecursivePointer; + + payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RecursivePointer` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RecursivePointer`. + pub unsafe fn as_RecursivePointer(&self) -> &u64 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RecursivePointer); + let payload = &self.RecursivePointer; + + &payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Construct a tag named `RocBox`, with the appropriate payload + pub fn RocBox(arg: u64) -> Self { + let mut answer = Self { + RocBox: arg + }; + + answer.set_discriminant(discriminant_RocType::RocBox); + + answer + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocBox` and convert it to `RocBox`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocBox`. + pub unsafe fn into_RocBox(self) -> u64 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocBox); + let payload = self.RocBox; + + payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocBox` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocBox`. + pub unsafe fn as_RocBox(&self) -> &u64 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocBox); + let payload = &self.RocBox; + + &payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Construct a tag named `RocDict`, with the appropriate payload + pub fn RocDict(arg0: u64, arg1: u64) -> Self { + let mut answer = Self { + RocDict: core::mem::ManuallyDrop::new(RocType_RocDict { + f0: arg0, + f1: arg1, + }) + }; + + answer.set_discriminant(discriminant_RocType::RocDict); + + answer + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocDict` and convert it to `RocDict`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocDict`. + pub unsafe fn into_RocDict(self) -> (u64, u64) { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocDict); + let payload = self.RocDict; + + ( + payload.f0, + payload.f1 + ) + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocDict` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocDict`. + pub unsafe fn as_RocDict(&self) -> (&u64, &u64) { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocDict); + let payload = &self.RocDict; + + ( + &payload.f0, + &payload.f1 + ) + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Construct a tag named `RocList`, with the appropriate payload + pub fn RocList(arg: u64) -> Self { + let mut answer = Self { + RocList: arg + }; + + answer.set_discriminant(discriminant_RocType::RocList); + + answer + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocList` and convert it to `RocList`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocList`. + pub unsafe fn into_RocList(self) -> u64 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocList); + let payload = self.RocList; + + payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocList` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocList`. + pub unsafe fn as_RocList(&self) -> &u64 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocList); + let payload = &self.RocList; + + &payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Construct a tag named `RocResult`, with the appropriate payload + pub fn RocResult(arg0: u64, arg1: u64) -> Self { + let mut answer = Self { + RocResult: core::mem::ManuallyDrop::new(RocType_RocResult { + f0: arg0, + f1: arg1, + }) + }; + + answer.set_discriminant(discriminant_RocType::RocResult); + + answer + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocResult` and convert it to `RocResult`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocResult`. + pub unsafe fn into_RocResult(self) -> (u64, u64) { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocResult); + let payload = self.RocResult; + + ( + payload.f0, + payload.f1 + ) + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocResult` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocResult`. + pub unsafe fn as_RocResult(&self) -> (&u64, &u64) { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocResult); + let payload = &self.RocResult; + + ( + &payload.f0, + &payload.f1 + ) + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Construct a tag named `RocSet`, with the appropriate payload + pub fn RocSet(arg: u64) -> Self { + let mut answer = Self { + RocSet: arg + }; + + answer.set_discriminant(discriminant_RocType::RocSet); + + answer + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocSet` and convert it to `RocSet`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocSet`. + pub unsafe fn into_RocSet(self) -> u64 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocSet); + let payload = self.RocSet; + + payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocType` has a `.discriminant()` of `RocSet` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `RocSet`. + pub unsafe fn as_RocSet(&self) -> &u64 { + debug_assert_eq!(self.discriminant(), discriminant_RocType::RocSet); + let payload = &self.RocSet; + + &payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// A tag named RocStr, which has no payload. + pub const RocStr: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[96] = discriminant_RocType::RocStr as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], RocType>(bytes) + }; + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// A tag named Unit, which has no payload. + pub const Unit: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[96] = discriminant_RocType::Unit as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], RocType>(bytes) + }; +} + +impl Drop for RocType { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn drop(&mut self) { + // Drop the payloads + match self.discriminant() { + discriminant_RocType::Bool => {} + discriminant_RocType::EmptyTagUnion => {} + discriminant_RocType::Function => unsafe { core::mem::ManuallyDrop::drop(&mut self.Function) }, + discriminant_RocType::Num => {} + discriminant_RocType::RecursivePointer => {} + discriminant_RocType::RocBox => {} + discriminant_RocType::RocDict => {} + discriminant_RocType::RocList => {} + discriminant_RocType::RocResult => {} + discriminant_RocType::RocSet => {} + discriminant_RocType::RocStr => {} + discriminant_RocType::Struct => unsafe { core::mem::ManuallyDrop::drop(&mut self.Struct) }, + discriminant_RocType::TagUnion => unsafe { core::mem::ManuallyDrop::drop(&mut self.TagUnion) }, + discriminant_RocType::TagUnionPayload => unsafe { core::mem::ManuallyDrop::drop(&mut self.TagUnionPayload) }, + discriminant_RocType::Unit => {} + } + + } +} + +impl Eq for RocType {} + +impl PartialEq for RocType { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn eq(&self, other: &Self) -> bool { + if self.discriminant() != other.discriminant() { + return false; + } + + unsafe { + match self.discriminant() { + discriminant_RocType::Bool => true, + discriminant_RocType::EmptyTagUnion => true, + discriminant_RocType::Function => self.Function == other.Function, + discriminant_RocType::Num => self.Num == other.Num, + discriminant_RocType::RecursivePointer => self.RecursivePointer == other.RecursivePointer, + discriminant_RocType::RocBox => self.RocBox == other.RocBox, + discriminant_RocType::RocDict => self.RocDict == other.RocDict, + discriminant_RocType::RocList => self.RocList == other.RocList, + discriminant_RocType::RocResult => self.RocResult == other.RocResult, + discriminant_RocType::RocSet => self.RocSet == other.RocSet, + discriminant_RocType::RocStr => true, + discriminant_RocType::Struct => self.Struct == other.Struct, + discriminant_RocType::TagUnion => self.TagUnion == other.TagUnion, + discriminant_RocType::TagUnionPayload => self.TagUnionPayload == other.TagUnionPayload, + discriminant_RocType::Unit => true, + } + } + } +} + +impl PartialOrd for RocType { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn partial_cmp(&self, other: &Self) -> Option { + match self.discriminant().partial_cmp(&other.discriminant()) { + Some(core::cmp::Ordering::Equal) => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_RocType::Bool => Some(core::cmp::Ordering::Equal), + discriminant_RocType::EmptyTagUnion => Some(core::cmp::Ordering::Equal), + discriminant_RocType::Function => self.Function.partial_cmp(&other.Function), + discriminant_RocType::Num => self.Num.partial_cmp(&other.Num), + discriminant_RocType::RecursivePointer => self.RecursivePointer.partial_cmp(&other.RecursivePointer), + discriminant_RocType::RocBox => self.RocBox.partial_cmp(&other.RocBox), + discriminant_RocType::RocDict => self.RocDict.partial_cmp(&other.RocDict), + discriminant_RocType::RocList => self.RocList.partial_cmp(&other.RocList), + discriminant_RocType::RocResult => self.RocResult.partial_cmp(&other.RocResult), + discriminant_RocType::RocSet => self.RocSet.partial_cmp(&other.RocSet), + discriminant_RocType::RocStr => Some(core::cmp::Ordering::Equal), + discriminant_RocType::Struct => self.Struct.partial_cmp(&other.Struct), + discriminant_RocType::TagUnion => self.TagUnion.partial_cmp(&other.TagUnion), + discriminant_RocType::TagUnionPayload => self.TagUnionPayload.partial_cmp(&other.TagUnionPayload), + discriminant_RocType::Unit => Some(core::cmp::Ordering::Equal), + } + } + } +} + +impl Ord for RocType { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn cmp(&self, other: &Self) -> core::cmp::Ordering { + match self.discriminant().cmp(&other.discriminant()) { + core::cmp::Ordering::Equal => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_RocType::Bool => core::cmp::Ordering::Equal, + discriminant_RocType::EmptyTagUnion => core::cmp::Ordering::Equal, + discriminant_RocType::Function => self.Function.cmp(&other.Function), + discriminant_RocType::Num => self.Num.cmp(&other.Num), + discriminant_RocType::RecursivePointer => self.RecursivePointer.cmp(&other.RecursivePointer), + discriminant_RocType::RocBox => self.RocBox.cmp(&other.RocBox), + discriminant_RocType::RocDict => self.RocDict.cmp(&other.RocDict), + discriminant_RocType::RocList => self.RocList.cmp(&other.RocList), + discriminant_RocType::RocResult => self.RocResult.cmp(&other.RocResult), + discriminant_RocType::RocSet => self.RocSet.cmp(&other.RocSet), + discriminant_RocType::RocStr => core::cmp::Ordering::Equal, + discriminant_RocType::Struct => self.Struct.cmp(&other.Struct), + discriminant_RocType::TagUnion => self.TagUnion.cmp(&other.TagUnion), + discriminant_RocType::TagUnionPayload => self.TagUnionPayload.cmp(&other.TagUnionPayload), + discriminant_RocType::Unit => core::cmp::Ordering::Equal, + } + } + } +} + +impl Clone for RocType { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn clone(&self) -> Self { + let mut answer = unsafe { + match self.discriminant() { + discriminant_RocType::Bool => core::mem::transmute::< + core::mem::MaybeUninit, + RocType, + >(core::mem::MaybeUninit::uninit()), + discriminant_RocType::EmptyTagUnion => core::mem::transmute::< + core::mem::MaybeUninit, + RocType, + >(core::mem::MaybeUninit::uninit()), + discriminant_RocType::Function => Self { + Function: self.Function.clone(), + }, + discriminant_RocType::Num => Self { + Num: self.Num.clone(), + }, + discriminant_RocType::RecursivePointer => Self { + RecursivePointer: self.RecursivePointer.clone(), + }, + discriminant_RocType::RocBox => Self { + RocBox: self.RocBox.clone(), + }, + discriminant_RocType::RocDict => Self { + RocDict: self.RocDict.clone(), + }, + discriminant_RocType::RocList => Self { + RocList: self.RocList.clone(), + }, + discriminant_RocType::RocResult => Self { + RocResult: self.RocResult.clone(), + }, + discriminant_RocType::RocSet => Self { + RocSet: self.RocSet.clone(), + }, + discriminant_RocType::RocStr => core::mem::transmute::< + core::mem::MaybeUninit, + RocType, + >(core::mem::MaybeUninit::uninit()), + discriminant_RocType::Struct => Self { + Struct: self.Struct.clone(), + }, + discriminant_RocType::TagUnion => Self { + TagUnion: self.TagUnion.clone(), + }, + discriminant_RocType::TagUnionPayload => Self { + TagUnionPayload: self.TagUnionPayload.clone(), + }, + discriminant_RocType::Unit => core::mem::transmute::< + core::mem::MaybeUninit, + RocType, + >(core::mem::MaybeUninit::uninit()), + } + + }; + + answer.set_discriminant(self.discriminant()); + + answer + } +} + +impl core::hash::Hash for RocType { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn hash(&self, state: &mut H) { match self.discriminant() { + discriminant_RocType::Bool => discriminant_RocType::Bool.hash(state), + discriminant_RocType::EmptyTagUnion => discriminant_RocType::EmptyTagUnion.hash(state), + discriminant_RocType::Function => unsafe { + discriminant_RocType::Function.hash(state); + self.Function.hash(state); + }, + discriminant_RocType::Num => unsafe { + discriminant_RocType::Num.hash(state); + self.Num.hash(state); + }, + discriminant_RocType::RecursivePointer => unsafe { + discriminant_RocType::RecursivePointer.hash(state); + self.RecursivePointer.hash(state); + }, + discriminant_RocType::RocBox => unsafe { + discriminant_RocType::RocBox.hash(state); + self.RocBox.hash(state); + }, + discriminant_RocType::RocDict => unsafe { + discriminant_RocType::RocDict.hash(state); + self.RocDict.hash(state); + }, + discriminant_RocType::RocList => unsafe { + discriminant_RocType::RocList.hash(state); + self.RocList.hash(state); + }, + discriminant_RocType::RocResult => unsafe { + discriminant_RocType::RocResult.hash(state); + self.RocResult.hash(state); + }, + discriminant_RocType::RocSet => unsafe { + discriminant_RocType::RocSet.hash(state); + self.RocSet.hash(state); + }, + discriminant_RocType::RocStr => discriminant_RocType::RocStr.hash(state), + discriminant_RocType::Struct => unsafe { + discriminant_RocType::Struct.hash(state); + self.Struct.hash(state); + }, + discriminant_RocType::TagUnion => unsafe { + discriminant_RocType::TagUnion.hash(state); + self.TagUnion.hash(state); + }, + discriminant_RocType::TagUnionPayload => unsafe { + discriminant_RocType::TagUnionPayload.hash(state); + self.TagUnionPayload.hash(state); + }, + discriminant_RocType::Unit => discriminant_RocType::Unit.hash(state), + } + } +} + +impl core::fmt::Debug for RocType { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str("RocType::")?; + + unsafe { + match self.discriminant() { + discriminant_RocType::Bool => f.write_str("Bool"), + discriminant_RocType::EmptyTagUnion => f.write_str("EmptyTagUnion"), + discriminant_RocType::Function => f.debug_tuple("Function") + .field(&*self.Function) + .finish(), + discriminant_RocType::Num => f.debug_tuple("Num") + .field(&self.Num) + .finish(), + discriminant_RocType::RecursivePointer => f.debug_tuple("RecursivePointer") + .field(&self.RecursivePointer) + .finish(), + discriminant_RocType::RocBox => f.debug_tuple("RocBox") + .field(&self.RocBox) + .finish(), + discriminant_RocType::RocDict => f.debug_tuple("RocDict") + .field(&(&self.RocDict).f0) +.field(&(&self.RocDict).f1) + .finish(), + discriminant_RocType::RocList => f.debug_tuple("RocList") + .field(&self.RocList) + .finish(), + discriminant_RocType::RocResult => f.debug_tuple("RocResult") + .field(&(&self.RocResult).f0) +.field(&(&self.RocResult).f1) + .finish(), + discriminant_RocType::RocSet => f.debug_tuple("RocSet") + .field(&self.RocSet) + .finish(), + discriminant_RocType::RocStr => f.write_str("RocStr"), + discriminant_RocType::Struct => f.debug_tuple("Struct") + .field(&*self.Struct) + .finish(), + discriminant_RocType::TagUnion => f.debug_tuple("TagUnion") + .field(&*self.TagUnion) + .finish(), + discriminant_RocType::TagUnionPayload => f.debug_tuple("TagUnionPayload") + .field(&*self.TagUnionPayload) + .finish(), + discriminant_RocType::Unit => f.write_str("Unit"), + } + } + } +} + +impl RocTagUnion { + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_RocTagUnion { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(44)) + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_RocTagUnion) { + let discriminant_ptr: *mut discriminant_RocTagUnion = (self as *mut RocTagUnion).cast(); + + unsafe { + *(discriminant_ptr.add(44)) = discriminant; + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `Enumeration`, with the appropriate payload + pub fn Enumeration(arg0: R4) -> Self { + let mut answer = Self { + Enumeration: core::mem::ManuallyDrop::new(arg0) + }; + + answer.set_discriminant(discriminant_RocTagUnion::Enumeration); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `Enumeration` and convert it to `Enumeration`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Enumeration`. + pub unsafe fn into_Enumeration(mut self) -> R4 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::Enumeration); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.Enumeration, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `Enumeration` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Enumeration`. + pub unsafe fn as_Enumeration(&self) -> &R4 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::Enumeration); + let payload = &self.Enumeration; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `NonNullableUnwrapped`, with the appropriate payload + pub fn NonNullableUnwrapped(arg0: R5) -> Self { + let mut answer = Self { + NonNullableUnwrapped: core::mem::ManuallyDrop::new(arg0) + }; + + answer.set_discriminant(discriminant_RocTagUnion::NonNullableUnwrapped); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `NonNullableUnwrapped` and convert it to `NonNullableUnwrapped`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `NonNullableUnwrapped`. + pub unsafe fn into_NonNullableUnwrapped(mut self) -> R5 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::NonNullableUnwrapped); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.NonNullableUnwrapped, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `NonNullableUnwrapped` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `NonNullableUnwrapped`. + pub unsafe fn as_NonNullableUnwrapped(&self) -> &R5 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::NonNullableUnwrapped); + let payload = &self.NonNullableUnwrapped; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `NonRecursive`, with the appropriate payload + pub fn NonRecursive(arg0: R6) -> Self { + let mut answer = Self { + NonRecursive: core::mem::ManuallyDrop::new(arg0) + }; + + answer.set_discriminant(discriminant_RocTagUnion::NonRecursive); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `NonRecursive` and convert it to `NonRecursive`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `NonRecursive`. + pub unsafe fn into_NonRecursive(mut self) -> R6 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::NonRecursive); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.NonRecursive, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `NonRecursive` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `NonRecursive`. + pub unsafe fn as_NonRecursive(&self) -> &R6 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::NonRecursive); + let payload = &self.NonRecursive; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `NullableUnwrapped`, with the appropriate payload + pub fn NullableUnwrapped(arg0: R8) -> Self { + let mut answer = Self { + NullableUnwrapped: core::mem::ManuallyDrop::new(arg0) + }; + + answer.set_discriminant(discriminant_RocTagUnion::NullableUnwrapped); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `NullableUnwrapped` and convert it to `NullableUnwrapped`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `NullableUnwrapped`. + pub unsafe fn into_NullableUnwrapped(mut self) -> R8 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::NullableUnwrapped); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.NullableUnwrapped, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `NullableUnwrapped` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `NullableUnwrapped`. + pub unsafe fn as_NullableUnwrapped(&self) -> &R8 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::NullableUnwrapped); + let payload = &self.NullableUnwrapped; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `NullableWrapped`, with the appropriate payload + pub fn NullableWrapped(arg0: R9) -> Self { + let mut answer = Self { + NullableWrapped: core::mem::ManuallyDrop::new(arg0) + }; + + answer.set_discriminant(discriminant_RocTagUnion::NullableWrapped); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `NullableWrapped` and convert it to `NullableWrapped`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `NullableWrapped`. + pub unsafe fn into_NullableWrapped(mut self) -> R9 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::NullableWrapped); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.NullableWrapped, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `NullableWrapped` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `NullableWrapped`. + pub unsafe fn as_NullableWrapped(&self) -> &R9 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::NullableWrapped); + let payload = &self.NullableWrapped; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `Recursive`, with the appropriate payload + pub fn Recursive(arg0: R11) -> Self { + let mut answer = Self { + Recursive: core::mem::ManuallyDrop::new(arg0) + }; + + answer.set_discriminant(discriminant_RocTagUnion::Recursive); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `Recursive` and convert it to `Recursive`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Recursive`. + pub unsafe fn into_Recursive(mut self) -> R11 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::Recursive); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.Recursive, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `Recursive` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Recursive`. + pub unsafe fn as_Recursive(&self) -> &R11 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::Recursive); + let payload = &self.Recursive; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Construct a tag named `SingleTagStruct`, with the appropriate payload + pub fn SingleTagStruct(arg0: R13) -> Self { + let mut answer = Self { + SingleTagStruct: core::mem::ManuallyDrop::new(arg0) + }; + + answer.set_discriminant(discriminant_RocTagUnion::SingleTagStruct); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `SingleTagStruct` and convert it to `SingleTagStruct`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `SingleTagStruct`. + pub unsafe fn into_SingleTagStruct(mut self) -> R13 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::SingleTagStruct); + let payload = { + let mut uninitialized = core::mem::MaybeUninit::uninit(); + let swapped = unsafe { + core::mem::replace( + &mut self.SingleTagStruct, + core::mem::ManuallyDrop::new(uninitialized.assume_init()), + ) + }; + + core::mem::forget(self); + + core::mem::ManuallyDrop::into_inner(swapped) + }; + + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `RocTagUnion` has a `.discriminant()` of `SingleTagStruct` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `SingleTagStruct`. + pub unsafe fn as_SingleTagStruct(&self) -> &R13 { + debug_assert_eq!(self.discriminant(), discriminant_RocTagUnion::SingleTagStruct); + let payload = &self.SingleTagStruct; + + + payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_RocTagUnion { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(88)) + } + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_RocTagUnion) { + let discriminant_ptr: *mut discriminant_RocTagUnion = (self as *mut RocTagUnion).cast(); + + unsafe { + *(discriminant_ptr.add(88)) = discriminant; + } + } +} + +impl Drop for RocTagUnion { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn drop(&mut self) { + // Drop the payloads + match self.discriminant() { + discriminant_RocTagUnion::Enumeration => unsafe { core::mem::ManuallyDrop::drop(&mut self.Enumeration) }, + discriminant_RocTagUnion::NonNullableUnwrapped => unsafe { core::mem::ManuallyDrop::drop(&mut self.NonNullableUnwrapped) }, + discriminant_RocTagUnion::NonRecursive => unsafe { core::mem::ManuallyDrop::drop(&mut self.NonRecursive) }, + discriminant_RocTagUnion::NullableUnwrapped => unsafe { core::mem::ManuallyDrop::drop(&mut self.NullableUnwrapped) }, + discriminant_RocTagUnion::NullableWrapped => unsafe { core::mem::ManuallyDrop::drop(&mut self.NullableWrapped) }, + discriminant_RocTagUnion::Recursive => unsafe { core::mem::ManuallyDrop::drop(&mut self.Recursive) }, + discriminant_RocTagUnion::SingleTagStruct => unsafe { core::mem::ManuallyDrop::drop(&mut self.SingleTagStruct) }, + } + + } +} + +impl Eq for RocTagUnion {} + +impl PartialEq for RocTagUnion { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn eq(&self, other: &Self) -> bool { + if self.discriminant() != other.discriminant() { + return false; + } + + unsafe { + match self.discriminant() { + discriminant_RocTagUnion::Enumeration => self.Enumeration == other.Enumeration, + discriminant_RocTagUnion::NonNullableUnwrapped => self.NonNullableUnwrapped == other.NonNullableUnwrapped, + discriminant_RocTagUnion::NonRecursive => self.NonRecursive == other.NonRecursive, + discriminant_RocTagUnion::NullableUnwrapped => self.NullableUnwrapped == other.NullableUnwrapped, + discriminant_RocTagUnion::NullableWrapped => self.NullableWrapped == other.NullableWrapped, + discriminant_RocTagUnion::Recursive => self.Recursive == other.Recursive, + discriminant_RocTagUnion::SingleTagStruct => self.SingleTagStruct == other.SingleTagStruct, + } + } + } +} + +impl PartialOrd for RocTagUnion { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn partial_cmp(&self, other: &Self) -> Option { + match self.discriminant().partial_cmp(&other.discriminant()) { + Some(core::cmp::Ordering::Equal) => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_RocTagUnion::Enumeration => self.Enumeration.partial_cmp(&other.Enumeration), + discriminant_RocTagUnion::NonNullableUnwrapped => self.NonNullableUnwrapped.partial_cmp(&other.NonNullableUnwrapped), + discriminant_RocTagUnion::NonRecursive => self.NonRecursive.partial_cmp(&other.NonRecursive), + discriminant_RocTagUnion::NullableUnwrapped => self.NullableUnwrapped.partial_cmp(&other.NullableUnwrapped), + discriminant_RocTagUnion::NullableWrapped => self.NullableWrapped.partial_cmp(&other.NullableWrapped), + discriminant_RocTagUnion::Recursive => self.Recursive.partial_cmp(&other.Recursive), + discriminant_RocTagUnion::SingleTagStruct => self.SingleTagStruct.partial_cmp(&other.SingleTagStruct), + } + } + } +} + +impl Ord for RocTagUnion { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn cmp(&self, other: &Self) -> core::cmp::Ordering { + match self.discriminant().cmp(&other.discriminant()) { + core::cmp::Ordering::Equal => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_RocTagUnion::Enumeration => self.Enumeration.cmp(&other.Enumeration), + discriminant_RocTagUnion::NonNullableUnwrapped => self.NonNullableUnwrapped.cmp(&other.NonNullableUnwrapped), + discriminant_RocTagUnion::NonRecursive => self.NonRecursive.cmp(&other.NonRecursive), + discriminant_RocTagUnion::NullableUnwrapped => self.NullableUnwrapped.cmp(&other.NullableUnwrapped), + discriminant_RocTagUnion::NullableWrapped => self.NullableWrapped.cmp(&other.NullableWrapped), + discriminant_RocTagUnion::Recursive => self.Recursive.cmp(&other.Recursive), + discriminant_RocTagUnion::SingleTagStruct => self.SingleTagStruct.cmp(&other.SingleTagStruct), + } + } + } +} + +impl Clone for RocTagUnion { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn clone(&self) -> Self { + let mut answer = unsafe { + match self.discriminant() { + discriminant_RocTagUnion::Enumeration => Self { + Enumeration: self.Enumeration.clone(), + }, + discriminant_RocTagUnion::NonNullableUnwrapped => Self { + NonNullableUnwrapped: self.NonNullableUnwrapped.clone(), + }, + discriminant_RocTagUnion::NonRecursive => Self { + NonRecursive: self.NonRecursive.clone(), + }, + discriminant_RocTagUnion::NullableUnwrapped => Self { + NullableUnwrapped: self.NullableUnwrapped.clone(), + }, + discriminant_RocTagUnion::NullableWrapped => Self { + NullableWrapped: self.NullableWrapped.clone(), + }, + discriminant_RocTagUnion::Recursive => Self { + Recursive: self.Recursive.clone(), + }, + discriminant_RocTagUnion::SingleTagStruct => Self { + SingleTagStruct: self.SingleTagStruct.clone(), + }, + } + + }; + + answer.set_discriminant(self.discriminant()); + + answer + } +} + +impl core::hash::Hash for RocTagUnion { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn hash(&self, state: &mut H) { match self.discriminant() { + discriminant_RocTagUnion::Enumeration => unsafe { + discriminant_RocTagUnion::Enumeration.hash(state); + self.Enumeration.hash(state); + }, + discriminant_RocTagUnion::NonNullableUnwrapped => unsafe { + discriminant_RocTagUnion::NonNullableUnwrapped.hash(state); + self.NonNullableUnwrapped.hash(state); + }, + discriminant_RocTagUnion::NonRecursive => unsafe { + discriminant_RocTagUnion::NonRecursive.hash(state); + self.NonRecursive.hash(state); + }, + discriminant_RocTagUnion::NullableUnwrapped => unsafe { + discriminant_RocTagUnion::NullableUnwrapped.hash(state); + self.NullableUnwrapped.hash(state); + }, + discriminant_RocTagUnion::NullableWrapped => unsafe { + discriminant_RocTagUnion::NullableWrapped.hash(state); + self.NullableWrapped.hash(state); + }, + discriminant_RocTagUnion::Recursive => unsafe { + discriminant_RocTagUnion::Recursive.hash(state); + self.Recursive.hash(state); + }, + discriminant_RocTagUnion::SingleTagStruct => unsafe { + discriminant_RocTagUnion::SingleTagStruct.hash(state); + self.SingleTagStruct.hash(state); + }, + } + } +} + +impl core::fmt::Debug for RocTagUnion { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str("RocTagUnion::")?; + + unsafe { + match self.discriminant() { + discriminant_RocTagUnion::Enumeration => f.debug_tuple("Enumeration") + .field(&*self.Enumeration) + .finish(), + discriminant_RocTagUnion::NonNullableUnwrapped => f.debug_tuple("NonNullableUnwrapped") + .field(&*self.NonNullableUnwrapped) + .finish(), + discriminant_RocTagUnion::NonRecursive => f.debug_tuple("NonRecursive") + .field(&*self.NonRecursive) + .finish(), + discriminant_RocTagUnion::NullableUnwrapped => f.debug_tuple("NullableUnwrapped") + .field(&*self.NullableUnwrapped) + .finish(), + discriminant_RocTagUnion::NullableWrapped => f.debug_tuple("NullableWrapped") + .field(&*self.NullableWrapped) + .finish(), + discriminant_RocTagUnion::Recursive => f.debug_tuple("Recursive") + .field(&*self.Recursive) + .finish(), + discriminant_RocTagUnion::SingleTagStruct => f.debug_tuple("SingleTagStruct") + .field(&*self.SingleTagStruct) + .finish(), + } + } + } +} + +impl U4 { + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_U4 { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(4)) + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_U4) { + let discriminant_ptr: *mut discriminant_U4 = (self as *mut U4).cast(); + + unsafe { + *(discriminant_ptr.add(4)) = discriminant; + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// A tag named None, which has no payload. + pub const None: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[4] = discriminant_U4::None as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], U4>(bytes) + }; + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `into_` methods return a payload, but since the None tag + /// has no payload, this does nothing and is only here for completeness. + pub fn into_None(self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `as` methods return a payload, but since the None tag + /// has no payload, this does nothing and is only here for completeness. + pub fn as_None(&self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Construct a tag named `Some`, with the appropriate payload + pub fn Some(arg: u32) -> Self { + let mut answer = Self { + Some: arg + }; + + answer.set_discriminant(discriminant_U4::Some); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `U4` has a `.discriminant()` of `Some` and convert it to `Some`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn into_Some(self) -> u32 { + debug_assert_eq!(self.discriminant(), discriminant_U4::Some); + let payload = self.Some; + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `U4` has a `.discriminant()` of `Some` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn as_Some(&self) -> &u32 { + debug_assert_eq!(self.discriminant(), discriminant_U4::Some); + let payload = &self.Some; + + &payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_U4 { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(8)) + } + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_U4) { + let discriminant_ptr: *mut discriminant_U4 = (self as *mut U4).cast(); + + unsafe { + *(discriminant_ptr.add(8)) = discriminant; + } + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// A tag named None, which has no payload. + pub const None: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[8] = discriminant_U4::None as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], U4>(bytes) + }; + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Construct a tag named `Some`, with the appropriate payload + pub fn Some(arg: u64) -> Self { + let mut answer = Self { + Some: arg + }; + + answer.set_discriminant(discriminant_U4::Some); + + answer + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `U4` has a `.discriminant()` of `Some` and convert it to `Some`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn into_Some(self) -> u64 { + debug_assert_eq!(self.discriminant(), discriminant_U4::Some); + let payload = self.Some; + + payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `U4` has a `.discriminant()` of `Some` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn as_Some(&self) -> &u64 { + debug_assert_eq!(self.discriminant(), discriminant_U4::Some); + let payload = &self.Some; + + &payload + } +} + +impl Eq for U4 {} + +impl PartialEq for U4 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn eq(&self, other: &Self) -> bool { + if self.discriminant() != other.discriminant() { + return false; + } + + unsafe { + match self.discriminant() { + discriminant_U4::None => true, + discriminant_U4::Some => self.Some == other.Some, + } + } + } +} + +impl PartialOrd for U4 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn partial_cmp(&self, other: &Self) -> Option { + match self.discriminant().partial_cmp(&other.discriminant()) { + Some(core::cmp::Ordering::Equal) => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_U4::None => Some(core::cmp::Ordering::Equal), + discriminant_U4::Some => self.Some.partial_cmp(&other.Some), + } + } + } +} + +impl Ord for U4 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn cmp(&self, other: &Self) -> core::cmp::Ordering { + match self.discriminant().cmp(&other.discriminant()) { + core::cmp::Ordering::Equal => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_U4::None => core::cmp::Ordering::Equal, + discriminant_U4::Some => self.Some.cmp(&other.Some), + } + } + } +} + +impl Copy for U4 {} + +impl Clone for U4 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn clone(&self) -> Self { + let mut answer = unsafe { + match self.discriminant() { + discriminant_U4::None => core::mem::transmute::< + core::mem::MaybeUninit, + U4, + >(core::mem::MaybeUninit::uninit()), + discriminant_U4::Some => Self { + Some: self.Some.clone(), + }, + } + + }; + + answer.set_discriminant(self.discriminant()); + + answer + } +} + +impl core::hash::Hash for U4 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn hash(&self, state: &mut H) { match self.discriminant() { + discriminant_U4::None => discriminant_U4::None.hash(state), + discriminant_U4::Some => unsafe { + discriminant_U4::Some.hash(state); + self.Some.hash(state); + }, + } + } +} + +impl core::fmt::Debug for U4 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str("U4::")?; + + unsafe { + match self.discriminant() { + discriminant_U4::None => f.write_str("None"), + discriminant_U4::Some => f.debug_tuple("Some") + .field(&self.Some) + .finish(), + } + } + } +} + +impl U3 { + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_U3 { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(4)) + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_U3) { + let discriminant_ptr: *mut discriminant_U3 = (self as *mut U3).cast(); + + unsafe { + *(discriminant_ptr.add(4)) = discriminant; + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// A tag named None, which has no payload. + pub const None: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[4] = discriminant_U3::None as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], U3>(bytes) + }; + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `into_` methods return a payload, but since the None tag + /// has no payload, this does nothing and is only here for completeness. + pub fn into_None(self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `as` methods return a payload, but since the None tag + /// has no payload, this does nothing and is only here for completeness. + pub fn as_None(&self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Construct a tag named `Some`, with the appropriate payload + pub fn Some(arg: u32) -> Self { + let mut answer = Self { + Some: arg + }; + + answer.set_discriminant(discriminant_U3::Some); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `U3` has a `.discriminant()` of `Some` and convert it to `Some`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn into_Some(self) -> u32 { + debug_assert_eq!(self.discriminant(), discriminant_U3::Some); + let payload = self.Some; + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `U3` has a `.discriminant()` of `Some` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn as_Some(&self) -> &u32 { + debug_assert_eq!(self.discriminant(), discriminant_U3::Some); + let payload = &self.Some; + + &payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_U3 { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(8)) + } + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_U3) { + let discriminant_ptr: *mut discriminant_U3 = (self as *mut U3).cast(); + + unsafe { + *(discriminant_ptr.add(8)) = discriminant; + } + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// A tag named None, which has no payload. + pub const None: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[8] = discriminant_U3::None as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], U3>(bytes) + }; + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Construct a tag named `Some`, with the appropriate payload + pub fn Some(arg: u64) -> Self { + let mut answer = Self { + Some: arg + }; + + answer.set_discriminant(discriminant_U3::Some); + + answer + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `U3` has a `.discriminant()` of `Some` and convert it to `Some`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn into_Some(self) -> u64 { + debug_assert_eq!(self.discriminant(), discriminant_U3::Some); + let payload = self.Some; + + payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `U3` has a `.discriminant()` of `Some` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn as_Some(&self) -> &u64 { + debug_assert_eq!(self.discriminant(), discriminant_U3::Some); + let payload = &self.Some; + + &payload + } +} + +impl Eq for U3 {} + +impl PartialEq for U3 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn eq(&self, other: &Self) -> bool { + if self.discriminant() != other.discriminant() { + return false; + } + + unsafe { + match self.discriminant() { + discriminant_U3::None => true, + discriminant_U3::Some => self.Some == other.Some, + } + } + } +} + +impl PartialOrd for U3 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn partial_cmp(&self, other: &Self) -> Option { + match self.discriminant().partial_cmp(&other.discriminant()) { + Some(core::cmp::Ordering::Equal) => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_U3::None => Some(core::cmp::Ordering::Equal), + discriminant_U3::Some => self.Some.partial_cmp(&other.Some), + } + } + } +} + +impl Ord for U3 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn cmp(&self, other: &Self) -> core::cmp::Ordering { + match self.discriminant().cmp(&other.discriminant()) { + core::cmp::Ordering::Equal => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_U3::None => core::cmp::Ordering::Equal, + discriminant_U3::Some => self.Some.cmp(&other.Some), + } + } + } +} + +impl Copy for U3 {} + +impl Clone for U3 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn clone(&self) -> Self { + let mut answer = unsafe { + match self.discriminant() { + discriminant_U3::None => core::mem::transmute::< + core::mem::MaybeUninit, + U3, + >(core::mem::MaybeUninit::uninit()), + discriminant_U3::Some => Self { + Some: self.Some.clone(), + }, + } + + }; + + answer.set_discriminant(self.discriminant()); + + answer + } +} + +impl core::hash::Hash for U3 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn hash(&self, state: &mut H) { match self.discriminant() { + discriminant_U3::None => discriminant_U3::None.hash(state), + discriminant_U3::Some => unsafe { + discriminant_U3::Some.hash(state); + self.Some.hash(state); + }, + } + } +} + +impl core::fmt::Debug for U3 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str("U3::")?; + + unsafe { + match self.discriminant() { + discriminant_U3::None => f.write_str("None"), + discriminant_U3::Some => f.debug_tuple("Some") + .field(&self.Some) + .finish(), + } + } + } +} + +impl U1 { + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_U1 { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(4)) + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_U1) { + let discriminant_ptr: *mut discriminant_U1 = (self as *mut U1).cast(); + + unsafe { + *(discriminant_ptr.add(4)) = discriminant; + } + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// A tag named None, which has no payload. + pub const None: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[4] = discriminant_U1::None as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], U1>(bytes) + }; + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `into_` methods return a payload, but since the None tag + /// has no payload, this does nothing and is only here for completeness. + pub fn into_None(self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + /// Other `as` methods return a payload, but since the None tag + /// has no payload, this does nothing and is only here for completeness. + pub fn as_None(&self) { + () + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Construct a tag named `Some`, with the appropriate payload + pub fn Some(arg: u32) -> Self { + let mut answer = Self { + Some: arg + }; + + answer.set_discriminant(discriminant_U1::Some); + + answer + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `U1` has a `.discriminant()` of `Some` and convert it to `Some`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn into_Some(self) -> u32 { + debug_assert_eq!(self.discriminant(), discriminant_U1::Some); + let payload = self.Some; + + payload + } + + #[cfg(any( + target_arch = "arm", + target_arch = "wasm32", + target_arch = "x86" + ))] + /// Unsafely assume the given `U1` has a `.discriminant()` of `Some` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn as_Some(&self) -> &u32 { + debug_assert_eq!(self.discriminant(), discriminant_U1::Some); + let payload = &self.Some; + + &payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Returns which variant this tag union holds. Note that this never includes a payload! + pub fn discriminant(&self) -> discriminant_U1 { + unsafe { + let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::()]>(self); + + core::mem::transmute::(*bytes.as_ptr().add(8)) + } + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Internal helper + fn set_discriminant(&mut self, discriminant: discriminant_U1) { + let discriminant_ptr: *mut discriminant_U1 = (self as *mut U1).cast(); + + unsafe { + *(discriminant_ptr.add(8)) = discriminant; + } + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// A tag named None, which has no payload. + pub const None: Self = unsafe { + let mut bytes = [0; core::mem::size_of::()]; + + bytes[8] = discriminant_U1::None as u8; + + core::mem::transmute::<[u8; core::mem::size_of::()], U1>(bytes) + }; + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Construct a tag named `Some`, with the appropriate payload + pub fn Some(arg: u64) -> Self { + let mut answer = Self { + Some: arg + }; + + answer.set_discriminant(discriminant_U1::Some); + + answer + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `U1` has a `.discriminant()` of `Some` and convert it to `Some`'s payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn into_Some(self) -> u64 { + debug_assert_eq!(self.discriminant(), discriminant_U1::Some); + let payload = self.Some; + + payload + } + + #[cfg(any( + target_arch = "aarch64", + target_arch = "x86_64" + ))] + /// Unsafely assume the given `U1` has a `.discriminant()` of `Some` and return its payload. + /// (Always examine `.discriminant()` first to make sure this is the correct variant!) + /// Panics in debug builds if the `.discriminant()` doesn't return `Some`. + pub unsafe fn as_Some(&self) -> &u64 { + debug_assert_eq!(self.discriminant(), discriminant_U1::Some); + let payload = &self.Some; + + &payload + } +} + +impl Eq for U1 {} + +impl PartialEq for U1 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn eq(&self, other: &Self) -> bool { + if self.discriminant() != other.discriminant() { + return false; + } + + unsafe { + match self.discriminant() { + discriminant_U1::None => true, + discriminant_U1::Some => self.Some == other.Some, + } + } + } +} + +impl PartialOrd for U1 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn partial_cmp(&self, other: &Self) -> Option { + match self.discriminant().partial_cmp(&other.discriminant()) { + Some(core::cmp::Ordering::Equal) => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_U1::None => Some(core::cmp::Ordering::Equal), + discriminant_U1::Some => self.Some.partial_cmp(&other.Some), + } + } + } +} + +impl Ord for U1 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn cmp(&self, other: &Self) -> core::cmp::Ordering { + match self.discriminant().cmp(&other.discriminant()) { + core::cmp::Ordering::Equal => {} + not_eq => return not_eq, + } + + unsafe { + match self.discriminant() { + discriminant_U1::None => core::cmp::Ordering::Equal, + discriminant_U1::Some => self.Some.cmp(&other.Some), + } + } + } +} + +impl Copy for U1 {} + +impl Clone for U1 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn clone(&self) -> Self { + let mut answer = unsafe { + match self.discriminant() { + discriminant_U1::None => core::mem::transmute::< + core::mem::MaybeUninit, + U1, + >(core::mem::MaybeUninit::uninit()), + discriminant_U1::Some => Self { + Some: self.Some.clone(), + }, + } + + }; + + answer.set_discriminant(self.discriminant()); + + answer + } +} + +impl core::hash::Hash for U1 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn hash(&self, state: &mut H) { match self.discriminant() { + discriminant_U1::None => discriminant_U1::None.hash(state), + discriminant_U1::Some => unsafe { + discriminant_U1::Some.hash(state); + self.Some.hash(state); + }, + } + } +} + +impl core::fmt::Debug for U1 { + #[cfg(any( + target_arch = "arm", + target_arch = "aarch64", + target_arch = "wasm32", + target_arch = "x86", + target_arch = "x86_64" + ))] + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + f.write_str("U1::")?; + + unsafe { + match self.discriminant() { + discriminant_U1::None => f.write_str("None"), + discriminant_U1::Some => f.debug_tuple("Some") + .field(&self.Some) + .finish(), + } + } + } +} diff --git a/crates/glue/src/lib.rs b/crates/glue/src/lib.rs index 4c78e97495..0e0aec45f9 100644 --- a/crates/glue/src/lib.rs +++ b/crates/glue/src/lib.rs @@ -1,4 +1,5 @@ pub mod enums; +pub mod glue; pub mod load; pub mod rust_glue; pub mod structs;