diff --git a/crates/roc_app/src/aarch64.rs b/crates/roc_app/src/aarch64.rs
index 7af0ae50..9d600354 100644
--- a/crates/roc_app/src/aarch64.rs
+++ b/crates/roc_app/src/aarch64.rs
@@ -14,7 +14,7 @@
 #![allow(clippy::missing_safety_doc)]
 #![allow(clippy::needless_borrow)]
 #![allow(clippy::clone_on_copy)]
-#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 
 #[derive(Clone, Default, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, )]
@@ -323,7 +323,7 @@ pub union union_ReadErr {
     Unsupported: (),
 }
 
-// const _SIZE_CHECK_union_ReadErr: () = assert!(core::mem::size_of::<union_ReadErr>() == 40);
+const _SIZE_CHECK_union_ReadErr: () = assert!(core::mem::size_of::<union_ReadErr>() == 40);
 const _ALIGN_CHECK_union_ReadErr: () = assert!(core::mem::align_of::<union_ReadErr>() == 8);
 
 const _SIZE_CHECK_ReadErr: () = assert!(core::mem::size_of::<ReadErr>() == 40);
@@ -794,7 +794,7 @@ pub union union_WriteErr {
     WriteZero: (),
 }
 
-// const _SIZE_CHECK_union_WriteErr: () = assert!(core::mem::size_of::<union_WriteErr>() == 40);
+const _SIZE_CHECK_union_WriteErr: () = assert!(core::mem::size_of::<union_WriteErr>() == 40);
 const _ALIGN_CHECK_union_WriteErr: () = assert!(core::mem::align_of::<union_WriteErr>() == 8);
 
 const _SIZE_CHECK_WriteErr: () = assert!(core::mem::size_of::<WriteErr>() == 40);
@@ -1762,7 +1762,7 @@ pub union union_InternalResponse {
     Timeout: u64,
 }
 
-// const _SIZE_CHECK_union_InternalResponse: () = assert!(core::mem::size_of::<union_InternalResponse>() == 112);
+const _SIZE_CHECK_union_InternalResponse: () = assert!(core::mem::size_of::<union_InternalResponse>() == 112);
 const _ALIGN_CHECK_union_InternalResponse: () = assert!(core::mem::align_of::<union_InternalResponse>() == 8);
 
 const _SIZE_CHECK_InternalResponse: () = assert!(core::mem::size_of::<InternalResponse>() == 112);
@@ -2028,6 +2028,13 @@ impl Drop for InternalResponse {
     }
 }
 
+#[derive(Clone, Default, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, )]
+#[repr(C)]
+pub struct R1 {
+    pub body: roc_std::RocList<u8>,
+    pub code: u16,
+}
+
 #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, )]
 #[repr(u8)]
 pub enum discriminant_Error {
@@ -2054,15 +2061,15 @@ impl core::fmt::Debug for discriminant_Error {
 pub union union_Error {
     BadBody: core::mem::ManuallyDrop<roc_std::RocStr>,
     BadRequest: core::mem::ManuallyDrop<roc_std::RocStr>,
-    BadStatus: u16,
+    BadStatus: core::mem::ManuallyDrop<R1>,
     NetworkError: (),
     Timeout: u64,
 }
 
-const _SIZE_CHECK_union_Error: () = assert!(core::mem::size_of::<union_Error>() == 24);
+const _SIZE_CHECK_union_Error: () = assert!(core::mem::size_of::<union_Error>() == 32);
 const _ALIGN_CHECK_union_Error: () = assert!(core::mem::align_of::<union_Error>() == 8);
 
-const _SIZE_CHECK_Error: () = assert!(core::mem::size_of::<Error>() == 32);
+const _SIZE_CHECK_Error: () = assert!(core::mem::size_of::<Error>() == 40);
 const _ALIGN_CHECK_Error: () = assert!(core::mem::align_of::<Error>() == 8);
 
 impl Error {
@@ -2071,7 +2078,7 @@ impl Error {
         unsafe {
             let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::<Self>()]>(self);
 
-            core::mem::transmute::<u8, discriminant_Error>(*bytes.as_ptr().add(24))
+            core::mem::transmute::<u8, discriminant_Error>(*bytes.as_ptr().add(32))
         }
     }
 
@@ -2080,7 +2087,7 @@ impl Error {
         let discriminant_ptr: *mut discriminant_Error = (self as *mut Error).cast();
 
         unsafe {
-            *(discriminant_ptr.add(24)) = discriminant;
+            *(discriminant_ptr.add(32)) = discriminant;
         }
     }
 }
@@ -2137,7 +2144,7 @@ impl core::fmt::Debug for Error {
                     f.debug_tuple("Error::BadRequest").field(field).finish()
                 },
                 BadStatus => {
-                    let field: &u16 = &self.payload.BadStatus;
+                    let field: &R1 = &self.payload.BadStatus;
                     f.debug_tuple("Error::BadStatus").field(field).finish()
                 },
                 NetworkError => {
@@ -2239,9 +2246,9 @@ impl Error {
         matches!(self.discriminant, discriminant_Error::BadRequest)
     }
 
-    pub fn unwrap_BadStatus(mut self) -> u16 {
+    pub fn unwrap_BadStatus(mut self) -> R1 {
         debug_assert_eq!(self.discriminant, discriminant_Error::BadStatus);
-        unsafe { self.payload.BadStatus }
+        unsafe { core::mem::ManuallyDrop::take(&mut self.payload.BadStatus) }
     }
 
     pub fn is_BadStatus(&self) -> bool {
@@ -2284,11 +2291,11 @@ impl Error {
         }
     }
 
-    pub fn BadStatus(payload: u16) -> Self {
+    pub fn BadStatus(payload: R1) -> Self {
         Self {
             discriminant: discriminant_Error::BadStatus,
             payload: union_Error {
-                BadStatus: payload,
+                BadStatus: core::mem::ManuallyDrop::new(payload),
             }
         }
     }
@@ -2318,7 +2325,7 @@ impl Drop for Error {
         match self.discriminant() {
             discriminant_Error::BadBody => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.BadBody) },
             discriminant_Error::BadRequest => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.BadRequest) },
-            discriminant_Error::BadStatus => {}
+            discriminant_Error::BadStatus => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.BadStatus) },
             discriminant_Error::NetworkError => {}
             discriminant_Error::Timeout => {}
         }
@@ -2588,7 +2595,7 @@ pub union union_GetMetadataErr {
     Unrecognized: core::mem::ManuallyDrop<ReadErr_Unrecognized>,
 }
 
-// const _SIZE_CHECK_union_GetMetadataErr: () = assert!(core::mem::size_of::<union_GetMetadataErr>() == 40);
+const _SIZE_CHECK_union_GetMetadataErr: () = assert!(core::mem::size_of::<union_GetMetadataErr>() == 40);
 const _ALIGN_CHECK_union_GetMetadataErr: () = assert!(core::mem::align_of::<union_GetMetadataErr>() == 8);
 
 const _SIZE_CHECK_GetMetadataErr: () = assert!(core::mem::size_of::<GetMetadataErr>() == 40);
@@ -2831,7 +2838,7 @@ pub union union_ConnectErr {
     Unsupported: (),
 }
 
-// const _SIZE_CHECK_union_ConnectErr: () = assert!(core::mem::size_of::<union_ConnectErr>() == 40);
+const _SIZE_CHECK_union_ConnectErr: () = assert!(core::mem::size_of::<union_ConnectErr>() == 40);
 const _ALIGN_CHECK_union_ConnectErr: () = assert!(core::mem::align_of::<union_ConnectErr>() == 8);
 
 const _SIZE_CHECK_ConnectErr: () = assert!(core::mem::size_of::<ConnectErr>() == 40);
@@ -3191,7 +3198,7 @@ pub union union_StreamErr {
     Unrecognized: core::mem::ManuallyDrop<ReadErr_Unrecognized>,
 }
 
-// const _SIZE_CHECK_union_StreamErr: () = assert!(core::mem::size_of::<union_StreamErr>() == 40);
+const _SIZE_CHECK_union_StreamErr: () = assert!(core::mem::size_of::<union_StreamErr>() == 40);
 const _ALIGN_CHECK_union_StreamErr: () = assert!(core::mem::align_of::<union_StreamErr>() == 8);
 
 const _SIZE_CHECK_StreamErr: () = assert!(core::mem::size_of::<StreamErr>() == 40);
@@ -4336,299 +4343,98 @@ impl Drop for ReadExactlyResult {
     }
 }
 
+#[derive(Clone, Copy, Default, PartialEq, PartialOrd, Eq, Ord, Hash, )]
+#[repr(transparent)]
+pub struct BindErr ();
+
+impl BindErr {
+    /// A tag named Nope, which has no payload.
+    pub const Nope: Self = Self();
+
+    /// Other `into_` methods return a payload, but since Nope tag
+    /// has no payload, this does nothing and is only here for completeness.
+    pub fn into_Nope(self) {
+        ()
+    }
+
+    /// Other `as_` methods return a payload, but since Nope tag
+    /// has no payload, this does nothing and is only here for completeness.
+    pub fn as_Nope(&self) {
+        ()
+    }
+}
+
+impl core::fmt::Debug for BindErr {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str("BindErr::Nope")
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, )]
 #[repr(u8)]
-pub enum discriminant_IOError {
-    AddrInUse = 0,
-    AddrNotAvailable = 1,
-    AlreadyExists = 2,
-    ArgumentListTooLong = 3,
-    BrokenPipe = 4,
-    ConnectionAborted = 5,
-    ConnectionRefused = 6,
-    ConnectionReset = 7,
-    CrossesDevices = 8,
-    Deadlock = 9,
-    DirectoryNotEmpty = 10,
-    ExecutableFileBusy = 11,
-    FileTooLarge = 12,
-    FilesystemLoop = 13,
-    FilesystemQuotaExceeded = 14,
-    HostUnreachable = 15,
-    Interrupted = 16,
-    InvalidData = 17,
-    InvalidFilename = 18,
-    InvalidInput = 19,
-    IsADirectory = 20,
-    NetworkDown = 21,
-    NetworkUnreachable = 22,
-    NotADirectory = 23,
-    NotConnected = 24,
-    NotFound = 25,
-    NotSeekable = 26,
-    Other = 27,
-    OutOfMemory = 28,
-    PermissionDenied = 29,
-    ReadOnlyFilesystem = 30,
-    ResourceBusy = 31,
-    StaleNetworkFileHandle = 32,
-    StorageFull = 33,
-    TimedOut = 34,
-    TooManyLinks = 35,
-    UnexpectedEof = 36,
-    Unsupported = 37,
-    WouldBlock = 38,
-    WriteZero = 39,
-}
-
-impl core::fmt::Debug for discriminant_IOError {
+pub enum discriminant_BindResult {
+    Bound = 0,
+    Error = 1,
+}
+
+impl core::fmt::Debug for discriminant_BindResult {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
-            Self::AddrInUse => f.write_str("discriminant_IOError::AddrInUse"),
-            Self::AddrNotAvailable => f.write_str("discriminant_IOError::AddrNotAvailable"),
-            Self::AlreadyExists => f.write_str("discriminant_IOError::AlreadyExists"),
-            Self::ArgumentListTooLong => f.write_str("discriminant_IOError::ArgumentListTooLong"),
-            Self::BrokenPipe => f.write_str("discriminant_IOError::BrokenPipe"),
-            Self::ConnectionAborted => f.write_str("discriminant_IOError::ConnectionAborted"),
-            Self::ConnectionRefused => f.write_str("discriminant_IOError::ConnectionRefused"),
-            Self::ConnectionReset => f.write_str("discriminant_IOError::ConnectionReset"),
-            Self::CrossesDevices => f.write_str("discriminant_IOError::CrossesDevices"),
-            Self::Deadlock => f.write_str("discriminant_IOError::Deadlock"),
-            Self::DirectoryNotEmpty => f.write_str("discriminant_IOError::DirectoryNotEmpty"),
-            Self::ExecutableFileBusy => f.write_str("discriminant_IOError::ExecutableFileBusy"),
-            Self::FileTooLarge => f.write_str("discriminant_IOError::FileTooLarge"),
-            Self::FilesystemLoop => f.write_str("discriminant_IOError::FilesystemLoop"),
-            Self::FilesystemQuotaExceeded => f.write_str("discriminant_IOError::FilesystemQuotaExceeded"),
-            Self::HostUnreachable => f.write_str("discriminant_IOError::HostUnreachable"),
-            Self::Interrupted => f.write_str("discriminant_IOError::Interrupted"),
-            Self::InvalidData => f.write_str("discriminant_IOError::InvalidData"),
-            Self::InvalidFilename => f.write_str("discriminant_IOError::InvalidFilename"),
-            Self::InvalidInput => f.write_str("discriminant_IOError::InvalidInput"),
-            Self::IsADirectory => f.write_str("discriminant_IOError::IsADirectory"),
-            Self::NetworkDown => f.write_str("discriminant_IOError::NetworkDown"),
-            Self::NetworkUnreachable => f.write_str("discriminant_IOError::NetworkUnreachable"),
-            Self::NotADirectory => f.write_str("discriminant_IOError::NotADirectory"),
-            Self::NotConnected => f.write_str("discriminant_IOError::NotConnected"),
-            Self::NotFound => f.write_str("discriminant_IOError::NotFound"),
-            Self::NotSeekable => f.write_str("discriminant_IOError::NotSeekable"),
-            Self::Other => f.write_str("discriminant_IOError::Other"),
-            Self::OutOfMemory => f.write_str("discriminant_IOError::OutOfMemory"),
-            Self::PermissionDenied => f.write_str("discriminant_IOError::PermissionDenied"),
-            Self::ReadOnlyFilesystem => f.write_str("discriminant_IOError::ReadOnlyFilesystem"),
-            Self::ResourceBusy => f.write_str("discriminant_IOError::ResourceBusy"),
-            Self::StaleNetworkFileHandle => f.write_str("discriminant_IOError::StaleNetworkFileHandle"),
-            Self::StorageFull => f.write_str("discriminant_IOError::StorageFull"),
-            Self::TimedOut => f.write_str("discriminant_IOError::TimedOut"),
-            Self::TooManyLinks => f.write_str("discriminant_IOError::TooManyLinks"),
-            Self::UnexpectedEof => f.write_str("discriminant_IOError::UnexpectedEof"),
-            Self::Unsupported => f.write_str("discriminant_IOError::Unsupported"),
-            Self::WouldBlock => f.write_str("discriminant_IOError::WouldBlock"),
-            Self::WriteZero => f.write_str("discriminant_IOError::WriteZero"),
-        }
-    }
-}
-
-#[repr(C, align(1))]
-pub union union_IOError {
-    AddrInUse: (),
-    AddrNotAvailable: (),
-    AlreadyExists: (),
-    ArgumentListTooLong: (),
-    BrokenPipe: (),
-    ConnectionAborted: (),
-    ConnectionRefused: (),
-    ConnectionReset: (),
-    CrossesDevices: (),
-    Deadlock: (),
-    DirectoryNotEmpty: (),
-    ExecutableFileBusy: (),
-    FileTooLarge: (),
-    FilesystemLoop: (),
-    FilesystemQuotaExceeded: (),
-    HostUnreachable: (),
-    Interrupted: (),
-    InvalidData: (),
-    InvalidFilename: (),
-    InvalidInput: (),
-    IsADirectory: (),
-    NetworkDown: (),
-    NetworkUnreachable: (),
-    NotADirectory: (),
-    NotConnected: (),
-    NotFound: (),
-    NotSeekable: (),
-    Other: (),
-    OutOfMemory: (),
-    PermissionDenied: (),
-    ReadOnlyFilesystem: (),
-    ResourceBusy: (),
-    StaleNetworkFileHandle: (),
-    StorageFull: (),
-    TimedOut: (),
-    TooManyLinks: (),
-    UnexpectedEof: (),
-    Unsupported: (),
-    WouldBlock: (),
-    WriteZero: (),
+            Self::Bound => f.write_str("discriminant_BindResult::Bound"),
+            Self::Error => f.write_str("discriminant_BindResult::Error"),
+        }
+    }
 }
 
-// const _SIZE_CHECK_union_IOError: () = assert!(core::mem::size_of::<union_IOError>() == 1);
-const _ALIGN_CHECK_union_IOError: () = assert!(core::mem::align_of::<union_IOError>() == 1);
+#[repr(C, align(8))]
+pub union union_BindResult {
+    Bound: u64,
+    Error: BindErr,
+}
 
-const _SIZE_CHECK_IOError: () = assert!(core::mem::size_of::<IOError>() == 1);
-const _ALIGN_CHECK_IOError: () = assert!(core::mem::align_of::<IOError>() == 1);
+const _SIZE_CHECK_union_BindResult: () = assert!(core::mem::size_of::<union_BindResult>() == 8);
+const _ALIGN_CHECK_union_BindResult: () = assert!(core::mem::align_of::<union_BindResult>() == 8);
 
-impl IOError {
+const _SIZE_CHECK_BindResult: () = assert!(core::mem::size_of::<BindResult>() == 16);
+const _ALIGN_CHECK_BindResult: () = assert!(core::mem::align_of::<BindResult>() == 8);
+
+impl BindResult {
     /// Returns which variant this tag union holds. Note that this never includes a payload!
-    pub fn discriminant(&self) -> discriminant_IOError {
+    pub fn discriminant(&self) -> discriminant_BindResult {
         unsafe {
             let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::<Self>()]>(self);
 
-            core::mem::transmute::<u8, discriminant_IOError>(*bytes.as_ptr().add(0))
+            core::mem::transmute::<u8, discriminant_BindResult>(*bytes.as_ptr().add(8))
         }
     }
 
     /// Internal helper
-    fn set_discriminant(&mut self, discriminant: discriminant_IOError) {
-        let discriminant_ptr: *mut discriminant_IOError = (self as *mut IOError).cast();
+    fn set_discriminant(&mut self, discriminant: discriminant_BindResult) {
+        let discriminant_ptr: *mut discriminant_BindResult = (self as *mut BindResult).cast();
 
         unsafe {
-            *(discriminant_ptr.add(0)) = discriminant;
+            *(discriminant_ptr.add(8)) = discriminant;
         }
     }
 }
 
 #[repr(C)]
-pub struct IOError {
-    payload: union_IOError,
-    discriminant: discriminant_IOError,
+pub struct BindResult {
+    payload: union_BindResult,
+    discriminant: discriminant_BindResult,
 }
 
-impl Clone for IOError {
+impl Clone for BindResult {
     fn clone(&self) -> Self {
-        use discriminant_IOError::*;
+        use discriminant_BindResult::*;
 
         let payload = unsafe {
             match self.discriminant {
-                AddrInUse => union_IOError {
-                    AddrInUse: self.payload.AddrInUse.clone(),
-                },
-                AddrNotAvailable => union_IOError {
-                    AddrNotAvailable: self.payload.AddrNotAvailable.clone(),
-                },
-                AlreadyExists => union_IOError {
-                    AlreadyExists: self.payload.AlreadyExists.clone(),
-                },
-                ArgumentListTooLong => union_IOError {
-                    ArgumentListTooLong: self.payload.ArgumentListTooLong.clone(),
-                },
-                BrokenPipe => union_IOError {
-                    BrokenPipe: self.payload.BrokenPipe.clone(),
-                },
-                ConnectionAborted => union_IOError {
-                    ConnectionAborted: self.payload.ConnectionAborted.clone(),
-                },
-                ConnectionRefused => union_IOError {
-                    ConnectionRefused: self.payload.ConnectionRefused.clone(),
-                },
-                ConnectionReset => union_IOError {
-                    ConnectionReset: self.payload.ConnectionReset.clone(),
-                },
-                CrossesDevices => union_IOError {
-                    CrossesDevices: self.payload.CrossesDevices.clone(),
-                },
-                Deadlock => union_IOError {
-                    Deadlock: self.payload.Deadlock.clone(),
-                },
-                DirectoryNotEmpty => union_IOError {
-                    DirectoryNotEmpty: self.payload.DirectoryNotEmpty.clone(),
-                },
-                ExecutableFileBusy => union_IOError {
-                    ExecutableFileBusy: self.payload.ExecutableFileBusy.clone(),
-                },
-                FileTooLarge => union_IOError {
-                    FileTooLarge: self.payload.FileTooLarge.clone(),
-                },
-                FilesystemLoop => union_IOError {
-                    FilesystemLoop: self.payload.FilesystemLoop.clone(),
-                },
-                FilesystemQuotaExceeded => union_IOError {
-                    FilesystemQuotaExceeded: self.payload.FilesystemQuotaExceeded.clone(),
-                },
-                HostUnreachable => union_IOError {
-                    HostUnreachable: self.payload.HostUnreachable.clone(),
-                },
-                Interrupted => union_IOError {
-                    Interrupted: self.payload.Interrupted.clone(),
-                },
-                InvalidData => union_IOError {
-                    InvalidData: self.payload.InvalidData.clone(),
-                },
-                InvalidFilename => union_IOError {
-                    InvalidFilename: self.payload.InvalidFilename.clone(),
-                },
-                InvalidInput => union_IOError {
-                    InvalidInput: self.payload.InvalidInput.clone(),
-                },
-                IsADirectory => union_IOError {
-                    IsADirectory: self.payload.IsADirectory.clone(),
-                },
-                NetworkDown => union_IOError {
-                    NetworkDown: self.payload.NetworkDown.clone(),
-                },
-                NetworkUnreachable => union_IOError {
-                    NetworkUnreachable: self.payload.NetworkUnreachable.clone(),
-                },
-                NotADirectory => union_IOError {
-                    NotADirectory: self.payload.NotADirectory.clone(),
-                },
-                NotConnected => union_IOError {
-                    NotConnected: self.payload.NotConnected.clone(),
-                },
-                NotFound => union_IOError {
-                    NotFound: self.payload.NotFound.clone(),
-                },
-                NotSeekable => union_IOError {
-                    NotSeekable: self.payload.NotSeekable.clone(),
-                },
-                Other => union_IOError {
-                    Other: self.payload.Other.clone(),
-                },
-                OutOfMemory => union_IOError {
-                    OutOfMemory: self.payload.OutOfMemory.clone(),
-                },
-                PermissionDenied => union_IOError {
-                    PermissionDenied: self.payload.PermissionDenied.clone(),
-                },
-                ReadOnlyFilesystem => union_IOError {
-                    ReadOnlyFilesystem: self.payload.ReadOnlyFilesystem.clone(),
-                },
-                ResourceBusy => union_IOError {
-                    ResourceBusy: self.payload.ResourceBusy.clone(),
-                },
-                StaleNetworkFileHandle => union_IOError {
-                    StaleNetworkFileHandle: self.payload.StaleNetworkFileHandle.clone(),
-                },
-                StorageFull => union_IOError {
-                    StorageFull: self.payload.StorageFull.clone(),
-                },
-                TimedOut => union_IOError {
-                    TimedOut: self.payload.TimedOut.clone(),
-                },
-                TooManyLinks => union_IOError {
-                    TooManyLinks: self.payload.TooManyLinks.clone(),
-                },
-                UnexpectedEof => union_IOError {
-                    UnexpectedEof: self.payload.UnexpectedEof.clone(),
-                },
-                Unsupported => union_IOError {
-                    Unsupported: self.payload.Unsupported.clone(),
-                },
-                WouldBlock => union_IOError {
-                    WouldBlock: self.payload.WouldBlock.clone(),
+                Bound => union_BindResult {
+                    Bound: self.payload.Bound.clone(),
                 },
-                WriteZero => union_IOError {
-                    WriteZero: self.payload.WriteZero.clone(),
+                Error => union_BindResult {
+                    Error: self.payload.Error.clone(),
                 },
             }
         };
@@ -4640,182 +4446,30 @@ impl Clone for IOError {
     }
 }
 
-impl core::fmt::Debug for IOError {
+impl core::fmt::Debug for BindResult {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        use discriminant_IOError::*;
+        use discriminant_BindResult::*;
 
         unsafe {
             match self.discriminant {
-                AddrInUse => {
-                    let field: &() = &self.payload.AddrInUse;
-                    f.debug_tuple("IOError::AddrInUse").field(field).finish()
-                },
-                AddrNotAvailable => {
-                    let field: &() = &self.payload.AddrNotAvailable;
-                    f.debug_tuple("IOError::AddrNotAvailable").field(field).finish()
-                },
-                AlreadyExists => {
-                    let field: &() = &self.payload.AlreadyExists;
-                    f.debug_tuple("IOError::AlreadyExists").field(field).finish()
-                },
-                ArgumentListTooLong => {
-                    let field: &() = &self.payload.ArgumentListTooLong;
-                    f.debug_tuple("IOError::ArgumentListTooLong").field(field).finish()
-                },
-                BrokenPipe => {
-                    let field: &() = &self.payload.BrokenPipe;
-                    f.debug_tuple("IOError::BrokenPipe").field(field).finish()
-                },
-                ConnectionAborted => {
-                    let field: &() = &self.payload.ConnectionAborted;
-                    f.debug_tuple("IOError::ConnectionAborted").field(field).finish()
-                },
-                ConnectionRefused => {
-                    let field: &() = &self.payload.ConnectionRefused;
-                    f.debug_tuple("IOError::ConnectionRefused").field(field).finish()
+                Bound => {
+                    let field: &u64 = &self.payload.Bound;
+                    f.debug_tuple("BindResult::Bound").field(field).finish()
                 },
-                ConnectionReset => {
-                    let field: &() = &self.payload.ConnectionReset;
-                    f.debug_tuple("IOError::ConnectionReset").field(field).finish()
-                },
-                CrossesDevices => {
-                    let field: &() = &self.payload.CrossesDevices;
-                    f.debug_tuple("IOError::CrossesDevices").field(field).finish()
-                },
-                Deadlock => {
-                    let field: &() = &self.payload.Deadlock;
-                    f.debug_tuple("IOError::Deadlock").field(field).finish()
-                },
-                DirectoryNotEmpty => {
-                    let field: &() = &self.payload.DirectoryNotEmpty;
-                    f.debug_tuple("IOError::DirectoryNotEmpty").field(field).finish()
-                },
-                ExecutableFileBusy => {
-                    let field: &() = &self.payload.ExecutableFileBusy;
-                    f.debug_tuple("IOError::ExecutableFileBusy").field(field).finish()
-                },
-                FileTooLarge => {
-                    let field: &() = &self.payload.FileTooLarge;
-                    f.debug_tuple("IOError::FileTooLarge").field(field).finish()
-                },
-                FilesystemLoop => {
-                    let field: &() = &self.payload.FilesystemLoop;
-                    f.debug_tuple("IOError::FilesystemLoop").field(field).finish()
-                },
-                FilesystemQuotaExceeded => {
-                    let field: &() = &self.payload.FilesystemQuotaExceeded;
-                    f.debug_tuple("IOError::FilesystemQuotaExceeded").field(field).finish()
-                },
-                HostUnreachable => {
-                    let field: &() = &self.payload.HostUnreachable;
-                    f.debug_tuple("IOError::HostUnreachable").field(field).finish()
-                },
-                Interrupted => {
-                    let field: &() = &self.payload.Interrupted;
-                    f.debug_tuple("IOError::Interrupted").field(field).finish()
-                },
-                InvalidData => {
-                    let field: &() = &self.payload.InvalidData;
-                    f.debug_tuple("IOError::InvalidData").field(field).finish()
-                },
-                InvalidFilename => {
-                    let field: &() = &self.payload.InvalidFilename;
-                    f.debug_tuple("IOError::InvalidFilename").field(field).finish()
-                },
-                InvalidInput => {
-                    let field: &() = &self.payload.InvalidInput;
-                    f.debug_tuple("IOError::InvalidInput").field(field).finish()
-                },
-                IsADirectory => {
-                    let field: &() = &self.payload.IsADirectory;
-                    f.debug_tuple("IOError::IsADirectory").field(field).finish()
-                },
-                NetworkDown => {
-                    let field: &() = &self.payload.NetworkDown;
-                    f.debug_tuple("IOError::NetworkDown").field(field).finish()
-                },
-                NetworkUnreachable => {
-                    let field: &() = &self.payload.NetworkUnreachable;
-                    f.debug_tuple("IOError::NetworkUnreachable").field(field).finish()
-                },
-                NotADirectory => {
-                    let field: &() = &self.payload.NotADirectory;
-                    f.debug_tuple("IOError::NotADirectory").field(field).finish()
-                },
-                NotConnected => {
-                    let field: &() = &self.payload.NotConnected;
-                    f.debug_tuple("IOError::NotConnected").field(field).finish()
-                },
-                NotFound => {
-                    let field: &() = &self.payload.NotFound;
-                    f.debug_tuple("IOError::NotFound").field(field).finish()
-                },
-                NotSeekable => {
-                    let field: &() = &self.payload.NotSeekable;
-                    f.debug_tuple("IOError::NotSeekable").field(field).finish()
-                },
-                Other => {
-                    let field: &() = &self.payload.Other;
-                    f.debug_tuple("IOError::Other").field(field).finish()
-                },
-                OutOfMemory => {
-                    let field: &() = &self.payload.OutOfMemory;
-                    f.debug_tuple("IOError::OutOfMemory").field(field).finish()
-                },
-                PermissionDenied => {
-                    let field: &() = &self.payload.PermissionDenied;
-                    f.debug_tuple("IOError::PermissionDenied").field(field).finish()
-                },
-                ReadOnlyFilesystem => {
-                    let field: &() = &self.payload.ReadOnlyFilesystem;
-                    f.debug_tuple("IOError::ReadOnlyFilesystem").field(field).finish()
-                },
-                ResourceBusy => {
-                    let field: &() = &self.payload.ResourceBusy;
-                    f.debug_tuple("IOError::ResourceBusy").field(field).finish()
-                },
-                StaleNetworkFileHandle => {
-                    let field: &() = &self.payload.StaleNetworkFileHandle;
-                    f.debug_tuple("IOError::StaleNetworkFileHandle").field(field).finish()
-                },
-                StorageFull => {
-                    let field: &() = &self.payload.StorageFull;
-                    f.debug_tuple("IOError::StorageFull").field(field).finish()
-                },
-                TimedOut => {
-                    let field: &() = &self.payload.TimedOut;
-                    f.debug_tuple("IOError::TimedOut").field(field).finish()
-                },
-                TooManyLinks => {
-                    let field: &() = &self.payload.TooManyLinks;
-                    f.debug_tuple("IOError::TooManyLinks").field(field).finish()
-                },
-                UnexpectedEof => {
-                    let field: &() = &self.payload.UnexpectedEof;
-                    f.debug_tuple("IOError::UnexpectedEof").field(field).finish()
-                },
-                Unsupported => {
-                    let field: &() = &self.payload.Unsupported;
-                    f.debug_tuple("IOError::Unsupported").field(field).finish()
-                },
-                WouldBlock => {
-                    let field: &() = &self.payload.WouldBlock;
-                    f.debug_tuple("IOError::WouldBlock").field(field).finish()
-                },
-                WriteZero => {
-                    let field: &() = &self.payload.WriteZero;
-                    f.debug_tuple("IOError::WriteZero").field(field).finish()
+                Error => {
+                    let field: &BindErr = &self.payload.Error;
+                    f.debug_tuple("BindResult::Error").field(field).finish()
                 },
             }
         }
     }
 }
 
-impl Eq for IOError {}
+impl Eq for BindResult {}
 
-impl PartialEq for IOError {
+impl PartialEq for BindResult {
     fn eq(&self, other: &Self) -> bool {
-        use discriminant_IOError::*;
+        use discriminant_BindResult::*;
 
         if self.discriminant != other.discriminant {
             return false;
@@ -4823,60 +4477,22 @@ impl PartialEq for IOError {
 
         unsafe {
             match self.discriminant {
-                AddrInUse => self.payload.AddrInUse == other.payload.AddrInUse,
-                AddrNotAvailable => self.payload.AddrNotAvailable == other.payload.AddrNotAvailable,
-                AlreadyExists => self.payload.AlreadyExists == other.payload.AlreadyExists,
-                ArgumentListTooLong => self.payload.ArgumentListTooLong == other.payload.ArgumentListTooLong,
-                BrokenPipe => self.payload.BrokenPipe == other.payload.BrokenPipe,
-                ConnectionAborted => self.payload.ConnectionAborted == other.payload.ConnectionAborted,
-                ConnectionRefused => self.payload.ConnectionRefused == other.payload.ConnectionRefused,
-                ConnectionReset => self.payload.ConnectionReset == other.payload.ConnectionReset,
-                CrossesDevices => self.payload.CrossesDevices == other.payload.CrossesDevices,
-                Deadlock => self.payload.Deadlock == other.payload.Deadlock,
-                DirectoryNotEmpty => self.payload.DirectoryNotEmpty == other.payload.DirectoryNotEmpty,
-                ExecutableFileBusy => self.payload.ExecutableFileBusy == other.payload.ExecutableFileBusy,
-                FileTooLarge => self.payload.FileTooLarge == other.payload.FileTooLarge,
-                FilesystemLoop => self.payload.FilesystemLoop == other.payload.FilesystemLoop,
-                FilesystemQuotaExceeded => self.payload.FilesystemQuotaExceeded == other.payload.FilesystemQuotaExceeded,
-                HostUnreachable => self.payload.HostUnreachable == other.payload.HostUnreachable,
-                Interrupted => self.payload.Interrupted == other.payload.Interrupted,
-                InvalidData => self.payload.InvalidData == other.payload.InvalidData,
-                InvalidFilename => self.payload.InvalidFilename == other.payload.InvalidFilename,
-                InvalidInput => self.payload.InvalidInput == other.payload.InvalidInput,
-                IsADirectory => self.payload.IsADirectory == other.payload.IsADirectory,
-                NetworkDown => self.payload.NetworkDown == other.payload.NetworkDown,
-                NetworkUnreachable => self.payload.NetworkUnreachable == other.payload.NetworkUnreachable,
-                NotADirectory => self.payload.NotADirectory == other.payload.NotADirectory,
-                NotConnected => self.payload.NotConnected == other.payload.NotConnected,
-                NotFound => self.payload.NotFound == other.payload.NotFound,
-                NotSeekable => self.payload.NotSeekable == other.payload.NotSeekable,
-                Other => self.payload.Other == other.payload.Other,
-                OutOfMemory => self.payload.OutOfMemory == other.payload.OutOfMemory,
-                PermissionDenied => self.payload.PermissionDenied == other.payload.PermissionDenied,
-                ReadOnlyFilesystem => self.payload.ReadOnlyFilesystem == other.payload.ReadOnlyFilesystem,
-                ResourceBusy => self.payload.ResourceBusy == other.payload.ResourceBusy,
-                StaleNetworkFileHandle => self.payload.StaleNetworkFileHandle == other.payload.StaleNetworkFileHandle,
-                StorageFull => self.payload.StorageFull == other.payload.StorageFull,
-                TimedOut => self.payload.TimedOut == other.payload.TimedOut,
-                TooManyLinks => self.payload.TooManyLinks == other.payload.TooManyLinks,
-                UnexpectedEof => self.payload.UnexpectedEof == other.payload.UnexpectedEof,
-                Unsupported => self.payload.Unsupported == other.payload.Unsupported,
-                WouldBlock => self.payload.WouldBlock == other.payload.WouldBlock,
-                WriteZero => self.payload.WriteZero == other.payload.WriteZero,
+                Bound => self.payload.Bound == other.payload.Bound,
+                Error => self.payload.Error == other.payload.Error,
             }
         }
     }
 }
 
-impl Ord for IOError {
+impl Ord for BindResult {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         self.partial_cmp(other).unwrap()
     }
 }
 
-impl PartialOrd for IOError {
+impl PartialOrd for BindResult {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        use discriminant_IOError::*;
+        use discriminant_BindResult::*;
 
         use std::cmp::Ordering::*;
 
@@ -4885,627 +4501,273 @@ impl PartialOrd for IOError {
             Greater => Option::Some(Greater),
             Equal => unsafe {
                 match self.discriminant {
-                    AddrInUse => self.payload.AddrInUse.partial_cmp(&other.payload.AddrInUse),
-                    AddrNotAvailable => self.payload.AddrNotAvailable.partial_cmp(&other.payload.AddrNotAvailable),
-                    AlreadyExists => self.payload.AlreadyExists.partial_cmp(&other.payload.AlreadyExists),
-                    ArgumentListTooLong => self.payload.ArgumentListTooLong.partial_cmp(&other.payload.ArgumentListTooLong),
-                    BrokenPipe => self.payload.BrokenPipe.partial_cmp(&other.payload.BrokenPipe),
-                    ConnectionAborted => self.payload.ConnectionAborted.partial_cmp(&other.payload.ConnectionAborted),
-                    ConnectionRefused => self.payload.ConnectionRefused.partial_cmp(&other.payload.ConnectionRefused),
-                    ConnectionReset => self.payload.ConnectionReset.partial_cmp(&other.payload.ConnectionReset),
-                    CrossesDevices => self.payload.CrossesDevices.partial_cmp(&other.payload.CrossesDevices),
-                    Deadlock => self.payload.Deadlock.partial_cmp(&other.payload.Deadlock),
-                    DirectoryNotEmpty => self.payload.DirectoryNotEmpty.partial_cmp(&other.payload.DirectoryNotEmpty),
-                    ExecutableFileBusy => self.payload.ExecutableFileBusy.partial_cmp(&other.payload.ExecutableFileBusy),
-                    FileTooLarge => self.payload.FileTooLarge.partial_cmp(&other.payload.FileTooLarge),
-                    FilesystemLoop => self.payload.FilesystemLoop.partial_cmp(&other.payload.FilesystemLoop),
-                    FilesystemQuotaExceeded => self.payload.FilesystemQuotaExceeded.partial_cmp(&other.payload.FilesystemQuotaExceeded),
-                    HostUnreachable => self.payload.HostUnreachable.partial_cmp(&other.payload.HostUnreachable),
-                    Interrupted => self.payload.Interrupted.partial_cmp(&other.payload.Interrupted),
-                    InvalidData => self.payload.InvalidData.partial_cmp(&other.payload.InvalidData),
-                    InvalidFilename => self.payload.InvalidFilename.partial_cmp(&other.payload.InvalidFilename),
-                    InvalidInput => self.payload.InvalidInput.partial_cmp(&other.payload.InvalidInput),
-                    IsADirectory => self.payload.IsADirectory.partial_cmp(&other.payload.IsADirectory),
-                    NetworkDown => self.payload.NetworkDown.partial_cmp(&other.payload.NetworkDown),
-                    NetworkUnreachable => self.payload.NetworkUnreachable.partial_cmp(&other.payload.NetworkUnreachable),
-                    NotADirectory => self.payload.NotADirectory.partial_cmp(&other.payload.NotADirectory),
-                    NotConnected => self.payload.NotConnected.partial_cmp(&other.payload.NotConnected),
-                    NotFound => self.payload.NotFound.partial_cmp(&other.payload.NotFound),
-                    NotSeekable => self.payload.NotSeekable.partial_cmp(&other.payload.NotSeekable),
-                    Other => self.payload.Other.partial_cmp(&other.payload.Other),
-                    OutOfMemory => self.payload.OutOfMemory.partial_cmp(&other.payload.OutOfMemory),
-                    PermissionDenied => self.payload.PermissionDenied.partial_cmp(&other.payload.PermissionDenied),
-                    ReadOnlyFilesystem => self.payload.ReadOnlyFilesystem.partial_cmp(&other.payload.ReadOnlyFilesystem),
-                    ResourceBusy => self.payload.ResourceBusy.partial_cmp(&other.payload.ResourceBusy),
-                    StaleNetworkFileHandle => self.payload.StaleNetworkFileHandle.partial_cmp(&other.payload.StaleNetworkFileHandle),
-                    StorageFull => self.payload.StorageFull.partial_cmp(&other.payload.StorageFull),
-                    TimedOut => self.payload.TimedOut.partial_cmp(&other.payload.TimedOut),
-                    TooManyLinks => self.payload.TooManyLinks.partial_cmp(&other.payload.TooManyLinks),
-                    UnexpectedEof => self.payload.UnexpectedEof.partial_cmp(&other.payload.UnexpectedEof),
-                    Unsupported => self.payload.Unsupported.partial_cmp(&other.payload.Unsupported),
-                    WouldBlock => self.payload.WouldBlock.partial_cmp(&other.payload.WouldBlock),
-                    WriteZero => self.payload.WriteZero.partial_cmp(&other.payload.WriteZero),
+                    Bound => self.payload.Bound.partial_cmp(&other.payload.Bound),
+                    Error => self.payload.Error.partial_cmp(&other.payload.Error),
                 }
             },
         }
     }
 }
 
-impl core::hash::Hash for IOError {
+impl core::hash::Hash for BindResult {
     fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-        use discriminant_IOError::*;
+        use discriminant_BindResult::*;
 
         unsafe {
             match self.discriminant {
-                AddrInUse => self.payload.AddrInUse.hash(state),
-                AddrNotAvailable => self.payload.AddrNotAvailable.hash(state),
-                AlreadyExists => self.payload.AlreadyExists.hash(state),
-                ArgumentListTooLong => self.payload.ArgumentListTooLong.hash(state),
-                BrokenPipe => self.payload.BrokenPipe.hash(state),
-                ConnectionAborted => self.payload.ConnectionAborted.hash(state),
-                ConnectionRefused => self.payload.ConnectionRefused.hash(state),
-                ConnectionReset => self.payload.ConnectionReset.hash(state),
-                CrossesDevices => self.payload.CrossesDevices.hash(state),
-                Deadlock => self.payload.Deadlock.hash(state),
-                DirectoryNotEmpty => self.payload.DirectoryNotEmpty.hash(state),
-                ExecutableFileBusy => self.payload.ExecutableFileBusy.hash(state),
-                FileTooLarge => self.payload.FileTooLarge.hash(state),
-                FilesystemLoop => self.payload.FilesystemLoop.hash(state),
-                FilesystemQuotaExceeded => self.payload.FilesystemQuotaExceeded.hash(state),
-                HostUnreachable => self.payload.HostUnreachable.hash(state),
-                Interrupted => self.payload.Interrupted.hash(state),
-                InvalidData => self.payload.InvalidData.hash(state),
-                InvalidFilename => self.payload.InvalidFilename.hash(state),
-                InvalidInput => self.payload.InvalidInput.hash(state),
-                IsADirectory => self.payload.IsADirectory.hash(state),
-                NetworkDown => self.payload.NetworkDown.hash(state),
-                NetworkUnreachable => self.payload.NetworkUnreachable.hash(state),
-                NotADirectory => self.payload.NotADirectory.hash(state),
-                NotConnected => self.payload.NotConnected.hash(state),
-                NotFound => self.payload.NotFound.hash(state),
-                NotSeekable => self.payload.NotSeekable.hash(state),
-                Other => self.payload.Other.hash(state),
-                OutOfMemory => self.payload.OutOfMemory.hash(state),
-                PermissionDenied => self.payload.PermissionDenied.hash(state),
-                ReadOnlyFilesystem => self.payload.ReadOnlyFilesystem.hash(state),
-                ResourceBusy => self.payload.ResourceBusy.hash(state),
-                StaleNetworkFileHandle => self.payload.StaleNetworkFileHandle.hash(state),
-                StorageFull => self.payload.StorageFull.hash(state),
-                TimedOut => self.payload.TimedOut.hash(state),
-                TooManyLinks => self.payload.TooManyLinks.hash(state),
-                UnexpectedEof => self.payload.UnexpectedEof.hash(state),
-                Unsupported => self.payload.Unsupported.hash(state),
-                WouldBlock => self.payload.WouldBlock.hash(state),
-                WriteZero => self.payload.WriteZero.hash(state),
+                Bound => self.payload.Bound.hash(state),
+                Error => self.payload.Error.hash(state),
             }
         }
     }
 }
 
-impl IOError {
-
-    pub fn is_AddrInUse(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::AddrInUse)
-    }
-
-    pub fn is_AddrNotAvailable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::AddrNotAvailable)
-    }
-
-    pub fn is_AlreadyExists(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::AlreadyExists)
-    }
-
-    pub fn is_ArgumentListTooLong(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ArgumentListTooLong)
-    }
-
-    pub fn is_BrokenPipe(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::BrokenPipe)
-    }
-
-    pub fn is_ConnectionAborted(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ConnectionAborted)
-    }
-
-    pub fn is_ConnectionRefused(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ConnectionRefused)
-    }
-
-    pub fn is_ConnectionReset(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ConnectionReset)
-    }
-
-    pub fn is_CrossesDevices(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::CrossesDevices)
-    }
-
-    pub fn is_Deadlock(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Deadlock)
-    }
-
-    pub fn is_DirectoryNotEmpty(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::DirectoryNotEmpty)
-    }
-
-    pub fn is_ExecutableFileBusy(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ExecutableFileBusy)
-    }
-
-    pub fn is_FileTooLarge(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::FileTooLarge)
-    }
-
-    pub fn is_FilesystemLoop(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::FilesystemLoop)
-    }
-
-    pub fn is_FilesystemQuotaExceeded(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::FilesystemQuotaExceeded)
-    }
-
-    pub fn is_HostUnreachable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::HostUnreachable)
-    }
-
-    pub fn is_Interrupted(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Interrupted)
-    }
-
-    pub fn is_InvalidData(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::InvalidData)
-    }
-
-    pub fn is_InvalidFilename(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::InvalidFilename)
-    }
-
-    pub fn is_InvalidInput(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::InvalidInput)
-    }
-
-    pub fn is_IsADirectory(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::IsADirectory)
-    }
-
-    pub fn is_NetworkDown(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NetworkDown)
-    }
-
-    pub fn is_NetworkUnreachable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NetworkUnreachable)
-    }
-
-    pub fn is_NotADirectory(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotADirectory)
-    }
-
-    pub fn is_NotConnected(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotConnected)
-    }
-
-    pub fn is_NotFound(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotFound)
-    }
-
-    pub fn is_NotSeekable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotSeekable)
-    }
-
-    pub fn is_Other(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Other)
-    }
-
-    pub fn is_OutOfMemory(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::OutOfMemory)
-    }
-
-    pub fn is_PermissionDenied(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::PermissionDenied)
-    }
-
-    pub fn is_ReadOnlyFilesystem(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ReadOnlyFilesystem)
-    }
-
-    pub fn is_ResourceBusy(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ResourceBusy)
-    }
+impl BindResult {
 
-    pub fn is_StaleNetworkFileHandle(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::StaleNetworkFileHandle)
+    pub fn unwrap_Bound(mut self) -> u64 {
+        debug_assert_eq!(self.discriminant, discriminant_BindResult::Bound);
+        unsafe { self.payload.Bound }
     }
 
-    pub fn is_StorageFull(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::StorageFull)
+    pub fn is_Bound(&self) -> bool {
+        matches!(self.discriminant, discriminant_BindResult::Bound)
     }
 
-    pub fn is_TimedOut(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::TimedOut)
+    pub fn unwrap_Error(mut self) -> BindErr {
+        debug_assert_eq!(self.discriminant, discriminant_BindResult::Error);
+        unsafe { self.payload.Error }
     }
 
-    pub fn is_TooManyLinks(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::TooManyLinks)
-    }
-
-    pub fn is_UnexpectedEof(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::UnexpectedEof)
-    }
-
-    pub fn is_Unsupported(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Unsupported)
-    }
-
-    pub fn is_WouldBlock(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::WouldBlock)
-    }
-
-    pub fn is_WriteZero(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::WriteZero)
+    pub fn is_Error(&self) -> bool {
+        matches!(self.discriminant, discriminant_BindResult::Error)
     }
 }
 
 
 
-impl IOError {
+impl BindResult {
 
-    pub fn AddrInUse() -> Self {
+    pub fn Bound(payload: u64) -> Self {
         Self {
-            discriminant: discriminant_IOError::AddrInUse,
-            payload: union_IOError {
-                AddrInUse: (),
+            discriminant: discriminant_BindResult::Bound,
+            payload: union_BindResult {
+                Bound: payload,
             }
         }
     }
 
-    pub fn AddrNotAvailable() -> Self {
+    pub fn Error(payload: BindErr) -> Self {
         Self {
-            discriminant: discriminant_IOError::AddrNotAvailable,
-            payload: union_IOError {
-                AddrNotAvailable: (),
-            }
-        }
-    }
-
-    pub fn AlreadyExists() -> Self {
-        Self {
-            discriminant: discriminant_IOError::AlreadyExists,
-            payload: union_IOError {
-                AlreadyExists: (),
-            }
-        }
-    }
-
-    pub fn ArgumentListTooLong() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ArgumentListTooLong,
-            payload: union_IOError {
-                ArgumentListTooLong: (),
+            discriminant: discriminant_BindResult::Error,
+            payload: union_BindResult {
+                Error: payload,
             }
         }
     }
+}
 
-    pub fn BrokenPipe() -> Self {
-        Self {
-            discriminant: discriminant_IOError::BrokenPipe,
-            payload: union_IOError {
-                BrokenPipe: (),
-            }
-        }
-    }
+#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, )]
+#[repr(u8)]
+pub enum discriminant_ReceiveResult {
+    Error = 0,
+    Received = 1,
+}
 
-    pub fn ConnectionAborted() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ConnectionAborted,
-            payload: union_IOError {
-                ConnectionAborted: (),
-            }
+impl core::fmt::Debug for discriminant_ReceiveResult {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Error => f.write_str("discriminant_ReceiveResult::Error"),
+            Self::Received => f.write_str("discriminant_ReceiveResult::Received"),
         }
     }
+}
 
-    pub fn ConnectionRefused() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ConnectionRefused,
-            payload: union_IOError {
-                ConnectionRefused: (),
-            }
-        }
-    }
+#[repr(C, align(8))]
+pub union union_ReceiveResult {
+    Error: BindErr,
+    Received: core::mem::ManuallyDrop<roc_std::RocList<u8>>,
+}
 
-    pub fn ConnectionReset() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ConnectionReset,
-            payload: union_IOError {
-                ConnectionReset: (),
-            }
-        }
-    }
+const _SIZE_CHECK_union_ReceiveResult: () = assert!(core::mem::size_of::<union_ReceiveResult>() == 24);
+const _ALIGN_CHECK_union_ReceiveResult: () = assert!(core::mem::align_of::<union_ReceiveResult>() == 8);
 
-    pub fn CrossesDevices() -> Self {
-        Self {
-            discriminant: discriminant_IOError::CrossesDevices,
-            payload: union_IOError {
-                CrossesDevices: (),
-            }
-        }
-    }
+const _SIZE_CHECK_ReceiveResult: () = assert!(core::mem::size_of::<ReceiveResult>() == 32);
+const _ALIGN_CHECK_ReceiveResult: () = assert!(core::mem::align_of::<ReceiveResult>() == 8);
 
-    pub fn Deadlock() -> Self {
-        Self {
-            discriminant: discriminant_IOError::Deadlock,
-            payload: union_IOError {
-                Deadlock: (),
-            }
-        }
-    }
+impl ReceiveResult {
+    /// Returns which variant this tag union holds. Note that this never includes a payload!
+    pub fn discriminant(&self) -> discriminant_ReceiveResult {
+        unsafe {
+            let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::<Self>()]>(self);
 
-    pub fn DirectoryNotEmpty() -> Self {
-        Self {
-            discriminant: discriminant_IOError::DirectoryNotEmpty,
-            payload: union_IOError {
-                DirectoryNotEmpty: (),
-            }
+            core::mem::transmute::<u8, discriminant_ReceiveResult>(*bytes.as_ptr().add(24))
         }
     }
 
-    pub fn ExecutableFileBusy() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ExecutableFileBusy,
-            payload: union_IOError {
-                ExecutableFileBusy: (),
-            }
-        }
-    }
+    /// Internal helper
+    fn set_discriminant(&mut self, discriminant: discriminant_ReceiveResult) {
+        let discriminant_ptr: *mut discriminant_ReceiveResult = (self as *mut ReceiveResult).cast();
 
-    pub fn FileTooLarge() -> Self {
-        Self {
-            discriminant: discriminant_IOError::FileTooLarge,
-            payload: union_IOError {
-                FileTooLarge: (),
-            }
+        unsafe {
+            *(discriminant_ptr.add(24)) = discriminant;
         }
     }
+}
 
-    pub fn FilesystemLoop() -> Self {
-        Self {
-            discriminant: discriminant_IOError::FilesystemLoop,
-            payload: union_IOError {
-                FilesystemLoop: (),
-            }
-        }
-    }
+#[repr(C)]
+pub struct ReceiveResult {
+    payload: union_ReceiveResult,
+    discriminant: discriminant_ReceiveResult,
+}
 
-    pub fn FilesystemQuotaExceeded() -> Self {
-        Self {
-            discriminant: discriminant_IOError::FilesystemQuotaExceeded,
-            payload: union_IOError {
-                FilesystemQuotaExceeded: (),
-            }
-        }
-    }
+impl Clone for ReceiveResult {
+    fn clone(&self) -> Self {
+        use discriminant_ReceiveResult::*;
 
-    pub fn HostUnreachable() -> Self {
-        Self {
-            discriminant: discriminant_IOError::HostUnreachable,
-            payload: union_IOError {
-                HostUnreachable: (),
+        let payload = unsafe {
+            match self.discriminant {
+                Error => union_ReceiveResult {
+                    Error: self.payload.Error.clone(),
+                },
+                Received => union_ReceiveResult {
+                    Received: self.payload.Received.clone(),
+                },
             }
-        }
-    }
+        };
 
-    pub fn Interrupted() -> Self {
         Self {
-            discriminant: discriminant_IOError::Interrupted,
-            payload: union_IOError {
-                Interrupted: (),
-            }
+            discriminant: self.discriminant,
+            payload,
         }
     }
+}
 
-    pub fn InvalidData() -> Self {
-        Self {
-            discriminant: discriminant_IOError::InvalidData,
-            payload: union_IOError {
-                InvalidData: (),
-            }
-        }
-    }
+impl core::fmt::Debug for ReceiveResult {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        use discriminant_ReceiveResult::*;
 
-    pub fn InvalidFilename() -> Self {
-        Self {
-            discriminant: discriminant_IOError::InvalidFilename,
-            payload: union_IOError {
-                InvalidFilename: (),
+        unsafe {
+            match self.discriminant {
+                Error => {
+                    let field: &BindErr = &self.payload.Error;
+                    f.debug_tuple("ReceiveResult::Error").field(field).finish()
+                },
+                Received => {
+                    let field: &roc_std::RocList<u8> = &self.payload.Received;
+                    f.debug_tuple("ReceiveResult::Received").field(field).finish()
+                },
             }
         }
     }
+}
 
-    pub fn InvalidInput() -> Self {
-        Self {
-            discriminant: discriminant_IOError::InvalidInput,
-            payload: union_IOError {
-                InvalidInput: (),
-            }
-        }
-    }
+impl Eq for ReceiveResult {}
 
-    pub fn IsADirectory() -> Self {
-        Self {
-            discriminant: discriminant_IOError::IsADirectory,
-            payload: union_IOError {
-                IsADirectory: (),
-            }
-        }
-    }
+impl PartialEq for ReceiveResult {
+    fn eq(&self, other: &Self) -> bool {
+        use discriminant_ReceiveResult::*;
 
-    pub fn NetworkDown() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NetworkDown,
-            payload: union_IOError {
-                NetworkDown: (),
-            }
+        if self.discriminant != other.discriminant {
+            return false;
         }
-    }
 
-    pub fn NetworkUnreachable() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NetworkUnreachable,
-            payload: union_IOError {
-                NetworkUnreachable: (),
+        unsafe {
+            match self.discriminant {
+                Error => self.payload.Error == other.payload.Error,
+                Received => self.payload.Received == other.payload.Received,
             }
         }
     }
+}
 
-    pub fn NotADirectory() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotADirectory,
-            payload: union_IOError {
-                NotADirectory: (),
-            }
-        }
+impl Ord for ReceiveResult {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.partial_cmp(other).unwrap()
     }
+}
 
-    pub fn NotConnected() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotConnected,
-            payload: union_IOError {
-                NotConnected: (),
-            }
-        }
-    }
+impl PartialOrd for ReceiveResult {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        use discriminant_ReceiveResult::*;
 
-    pub fn NotFound() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotFound,
-            payload: union_IOError {
-                NotFound: (),
-            }
-        }
-    }
+        use std::cmp::Ordering::*;
 
-    pub fn NotSeekable() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotSeekable,
-            payload: union_IOError {
-                NotSeekable: (),
-            }
+        match self.discriminant.cmp(&other.discriminant) {
+            Less => Option::Some(Less),
+            Greater => Option::Some(Greater),
+            Equal => unsafe {
+                match self.discriminant {
+                    Error => self.payload.Error.partial_cmp(&other.payload.Error),
+                    Received => self.payload.Received.partial_cmp(&other.payload.Received),
+                }
+            },
         }
     }
+}
 
-    pub fn Other() -> Self {
-        Self {
-            discriminant: discriminant_IOError::Other,
-            payload: union_IOError {
-                Other: (),
-            }
-        }
-    }
+impl core::hash::Hash for ReceiveResult {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        use discriminant_ReceiveResult::*;
 
-    pub fn OutOfMemory() -> Self {
-        Self {
-            discriminant: discriminant_IOError::OutOfMemory,
-            payload: union_IOError {
-                OutOfMemory: (),
+        unsafe {
+            match self.discriminant {
+                Error => self.payload.Error.hash(state),
+                Received => self.payload.Received.hash(state),
             }
         }
     }
+}
 
-    pub fn PermissionDenied() -> Self {
-        Self {
-            discriminant: discriminant_IOError::PermissionDenied,
-            payload: union_IOError {
-                PermissionDenied: (),
-            }
-        }
-    }
+impl ReceiveResult {
 
-    pub fn ReadOnlyFilesystem() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ReadOnlyFilesystem,
-            payload: union_IOError {
-                ReadOnlyFilesystem: (),
-            }
-        }
+    pub fn unwrap_Error(mut self) -> BindErr {
+        debug_assert_eq!(self.discriminant, discriminant_ReceiveResult::Error);
+        unsafe { self.payload.Error }
     }
 
-    pub fn ResourceBusy() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ResourceBusy,
-            payload: union_IOError {
-                ResourceBusy: (),
-            }
-        }
+    pub fn is_Error(&self) -> bool {
+        matches!(self.discriminant, discriminant_ReceiveResult::Error)
     }
 
-    pub fn StaleNetworkFileHandle() -> Self {
-        Self {
-            discriminant: discriminant_IOError::StaleNetworkFileHandle,
-            payload: union_IOError {
-                StaleNetworkFileHandle: (),
-            }
-        }
+    pub fn unwrap_Received(mut self) -> roc_std::RocList<u8> {
+        debug_assert_eq!(self.discriminant, discriminant_ReceiveResult::Received);
+        unsafe { core::mem::ManuallyDrop::take(&mut self.payload.Received) }
     }
 
-    pub fn StorageFull() -> Self {
-        Self {
-            discriminant: discriminant_IOError::StorageFull,
-            payload: union_IOError {
-                StorageFull: (),
-            }
-        }
+    pub fn is_Received(&self) -> bool {
+        matches!(self.discriminant, discriminant_ReceiveResult::Received)
     }
+}
 
-    pub fn TimedOut() -> Self {
-        Self {
-            discriminant: discriminant_IOError::TimedOut,
-            payload: union_IOError {
-                TimedOut: (),
-            }
-        }
-    }
 
-    pub fn TooManyLinks() -> Self {
-        Self {
-            discriminant: discriminant_IOError::TooManyLinks,
-            payload: union_IOError {
-                TooManyLinks: (),
-            }
-        }
-    }
 
-    pub fn UnexpectedEof() -> Self {
-        Self {
-            discriminant: discriminant_IOError::UnexpectedEof,
-            payload: union_IOError {
-                UnexpectedEof: (),
-            }
-        }
-    }
+impl ReceiveResult {
 
-    pub fn Unsupported() -> Self {
+    pub fn Error(payload: BindErr) -> Self {
         Self {
-            discriminant: discriminant_IOError::Unsupported,
-            payload: union_IOError {
-                Unsupported: (),
+            discriminant: discriminant_ReceiveResult::Error,
+            payload: union_ReceiveResult {
+                Error: payload,
             }
         }
     }
 
-    pub fn WouldBlock() -> Self {
+    pub fn Received(payload: roc_std::RocList<u8>) -> Self {
         Self {
-            discriminant: discriminant_IOError::WouldBlock,
-            payload: union_IOError {
-                WouldBlock: (),
+            discriminant: discriminant_ReceiveResult::Received,
+            payload: union_ReceiveResult {
+                Received: core::mem::ManuallyDrop::new(payload),
             }
         }
     }
+}
 
-    pub fn WriteZero() -> Self {
-        Self {
-            discriminant: discriminant_IOError::WriteZero,
-            payload: union_IOError {
-                WriteZero: (),
-            }
+impl Drop for ReceiveResult {
+    fn drop(&mut self) {
+        // Drop the payloads
+        match self.discriminant() {
+            discriminant_ReceiveResult::Error => {}
+            discriminant_ReceiveResult::Received => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.Received) },
         }
     }
 }
@@ -5542,9 +4804,13 @@ pub struct GlueTypes {
     pub tcpe: WriteResult,
     pub tcpf: ReadResult,
     pub tcpg: ReadExactlyResult,
-    pub dir: IOError,
+    pub udpa: u64,
+    pub udpd: BindResult,
+    pub udpe: ReceiveResult,
     pub hb: Method,
     pub pd: InternalPathType,
+    pub udpb: BindErr,
+    pub udpc: BindErr,
 }
 
 
diff --git a/crates/roc_app/src/lib.rs b/crates/roc_app/src/lib.rs
index 9b035dab..2be6a892 100644
--- a/crates/roc_app/src/lib.rs
+++ b/crates/roc_app/src/lib.rs
@@ -14,7 +14,7 @@
 #![allow(clippy::missing_safety_doc)]
 #![allow(clippy::needless_borrow)]
 #![allow(clippy::clone_on_copy)]
-#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 
 #[cfg(target_arch = "aarch64")]
diff --git a/crates/roc_app/src/wasm32.rs b/crates/roc_app/src/wasm32.rs
index 935fb63d..a604c082 100644
--- a/crates/roc_app/src/wasm32.rs
+++ b/crates/roc_app/src/wasm32.rs
@@ -14,7 +14,7 @@
 #![allow(clippy::missing_safety_doc)]
 #![allow(clippy::needless_borrow)]
 #![allow(clippy::clone_on_copy)]
-#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 
 #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, )]
@@ -335,7 +335,7 @@ pub union union_InternalResponse {
     Timeout: u64,
 }
 
-// const _SIZE_CHECK_union_InternalResponse: () = assert!(core::mem::size_of::<union_InternalResponse>() == 64);
+const _SIZE_CHECK_union_InternalResponse: () = assert!(core::mem::size_of::<union_InternalResponse>() == 64);
 const _ALIGN_CHECK_union_InternalResponse: () = assert!(core::mem::align_of::<union_InternalResponse>() == 8);
 
 const _SIZE_CHECK_InternalResponse: () = assert!(core::mem::size_of::<InternalResponse>() == 64);
@@ -601,6 +601,13 @@ impl Drop for InternalResponse {
     }
 }
 
+#[derive(Clone, Default, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, )]
+#[repr(C)]
+pub struct R1 {
+    pub body: roc_std::RocList<u8>,
+    pub code: u16,
+}
+
 #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, )]
 #[repr(u8)]
 pub enum discriminant_Error {
@@ -627,7 +634,7 @@ impl core::fmt::Debug for discriminant_Error {
 pub union union_Error {
     BadBody: core::mem::ManuallyDrop<roc_std::RocStr>,
     BadRequest: core::mem::ManuallyDrop<roc_std::RocStr>,
-    BadStatus: u16,
+    BadStatus: core::mem::ManuallyDrop<R1>,
     NetworkError: (),
     Timeout: u64,
 }
@@ -710,7 +717,7 @@ impl core::fmt::Debug for Error {
                     f.debug_tuple("Error::BadRequest").field(field).finish()
                 },
                 BadStatus => {
-                    let field: &u16 = &self.payload.BadStatus;
+                    let field: &R1 = &self.payload.BadStatus;
                     f.debug_tuple("Error::BadStatus").field(field).finish()
                 },
                 NetworkError => {
@@ -812,9 +819,9 @@ impl Error {
         matches!(self.discriminant, discriminant_Error::BadRequest)
     }
 
-    pub fn unwrap_BadStatus(mut self) -> u16 {
+    pub fn unwrap_BadStatus(mut self) -> R1 {
         debug_assert_eq!(self.discriminant, discriminant_Error::BadStatus);
-        unsafe { self.payload.BadStatus }
+        unsafe { core::mem::ManuallyDrop::take(&mut self.payload.BadStatus) }
     }
 
     pub fn is_BadStatus(&self) -> bool {
@@ -857,11 +864,11 @@ impl Error {
         }
     }
 
-    pub fn BadStatus(payload: u16) -> Self {
+    pub fn BadStatus(payload: R1) -> Self {
         Self {
             discriminant: discriminant_Error::BadStatus,
             payload: union_Error {
-                BadStatus: payload,
+                BadStatus: core::mem::ManuallyDrop::new(payload),
             }
         }
     }
@@ -891,7 +898,7 @@ impl Drop for Error {
         match self.discriminant() {
             discriminant_Error::BadBody => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.BadBody) },
             discriminant_Error::BadRequest => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.BadRequest) },
-            discriminant_Error::BadStatus => {}
+            discriminant_Error::BadStatus => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.BadStatus) },
             discriminant_Error::NetworkError => {}
             discriminant_Error::Timeout => {}
         }
@@ -945,7 +952,7 @@ pub union union_ConnectErr {
     Unsupported: (),
 }
 
-// const _SIZE_CHECK_union_ConnectErr: () = assert!(core::mem::size_of::<union_ConnectErr>() == 20);
+const _SIZE_CHECK_union_ConnectErr: () = assert!(core::mem::size_of::<union_ConnectErr>() == 20);
 const _ALIGN_CHECK_union_ConnectErr: () = assert!(core::mem::align_of::<union_ConnectErr>() == 4);
 
 const _SIZE_CHECK_ConnectErr: () = assert!(core::mem::size_of::<ConnectErr>() == 20);
@@ -1474,6 +1481,229 @@ impl Drop for ConnectResult {
     }
 }
 
+#[derive(Clone, Copy, Default, PartialEq, PartialOrd, Eq, Ord, Hash, )]
+#[repr(transparent)]
+pub struct BindErr ();
+
+impl BindErr {
+    /// A tag named Nope, which has no payload.
+    pub const Nope: Self = Self();
+
+    /// Other `into_` methods return a payload, but since Nope tag
+    /// has no payload, this does nothing and is only here for completeness.
+    pub fn into_Nope(self) {
+        ()
+    }
+
+    /// Other `as_` methods return a payload, but since Nope tag
+    /// has no payload, this does nothing and is only here for completeness.
+    pub fn as_Nope(&self) {
+        ()
+    }
+}
+
+impl core::fmt::Debug for BindErr {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str("BindErr::Nope")
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, )]
+#[repr(u8)]
+pub enum discriminant_BindResult {
+    Bound = 0,
+    Error = 1,
+}
+
+impl core::fmt::Debug for discriminant_BindResult {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Bound => f.write_str("discriminant_BindResult::Bound"),
+            Self::Error => f.write_str("discriminant_BindResult::Error"),
+        }
+    }
+}
+
+#[repr(C, align(8))]
+pub union union_BindResult {
+    Bound: u64,
+    Error: BindErr,
+}
+
+const _SIZE_CHECK_union_BindResult: () = assert!(core::mem::size_of::<union_BindResult>() == 8);
+const _ALIGN_CHECK_union_BindResult: () = assert!(core::mem::align_of::<union_BindResult>() == 8);
+
+const _SIZE_CHECK_BindResult: () = assert!(core::mem::size_of::<BindResult>() == 16);
+const _ALIGN_CHECK_BindResult: () = assert!(core::mem::align_of::<BindResult>() == 8);
+
+impl BindResult {
+    /// Returns which variant this tag union holds. Note that this never includes a payload!
+    pub fn discriminant(&self) -> discriminant_BindResult {
+        unsafe {
+            let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::<Self>()]>(self);
+
+            core::mem::transmute::<u8, discriminant_BindResult>(*bytes.as_ptr().add(8))
+        }
+    }
+
+    /// Internal helper
+    fn set_discriminant(&mut self, discriminant: discriminant_BindResult) {
+        let discriminant_ptr: *mut discriminant_BindResult = (self as *mut BindResult).cast();
+
+        unsafe {
+            *(discriminant_ptr.add(8)) = discriminant;
+        }
+    }
+}
+
+#[repr(C)]
+pub struct BindResult {
+    payload: union_BindResult,
+    discriminant: discriminant_BindResult,
+}
+
+impl Clone for BindResult {
+    fn clone(&self) -> Self {
+        use discriminant_BindResult::*;
+
+        let payload = unsafe {
+            match self.discriminant {
+                Bound => union_BindResult {
+                    Bound: self.payload.Bound.clone(),
+                },
+                Error => union_BindResult {
+                    Error: self.payload.Error.clone(),
+                },
+            }
+        };
+
+        Self {
+            discriminant: self.discriminant,
+            payload,
+        }
+    }
+}
+
+impl core::fmt::Debug for BindResult {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        use discriminant_BindResult::*;
+
+        unsafe {
+            match self.discriminant {
+                Bound => {
+                    let field: &u64 = &self.payload.Bound;
+                    f.debug_tuple("BindResult::Bound").field(field).finish()
+                },
+                Error => {
+                    let field: &BindErr = &self.payload.Error;
+                    f.debug_tuple("BindResult::Error").field(field).finish()
+                },
+            }
+        }
+    }
+}
+
+impl Eq for BindResult {}
+
+impl PartialEq for BindResult {
+    fn eq(&self, other: &Self) -> bool {
+        use discriminant_BindResult::*;
+
+        if self.discriminant != other.discriminant {
+            return false;
+        }
+
+        unsafe {
+            match self.discriminant {
+                Bound => self.payload.Bound == other.payload.Bound,
+                Error => self.payload.Error == other.payload.Error,
+            }
+        }
+    }
+}
+
+impl Ord for BindResult {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.partial_cmp(other).unwrap()
+    }
+}
+
+impl PartialOrd for BindResult {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        use discriminant_BindResult::*;
+
+        use std::cmp::Ordering::*;
+
+        match self.discriminant.cmp(&other.discriminant) {
+            Less => Option::Some(Less),
+            Greater => Option::Some(Greater),
+            Equal => unsafe {
+                match self.discriminant {
+                    Bound => self.payload.Bound.partial_cmp(&other.payload.Bound),
+                    Error => self.payload.Error.partial_cmp(&other.payload.Error),
+                }
+            },
+        }
+    }
+}
+
+impl core::hash::Hash for BindResult {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        use discriminant_BindResult::*;
+
+        unsafe {
+            match self.discriminant {
+                Bound => self.payload.Bound.hash(state),
+                Error => self.payload.Error.hash(state),
+            }
+        }
+    }
+}
+
+impl BindResult {
+
+    pub fn unwrap_Bound(mut self) -> u64 {
+        debug_assert_eq!(self.discriminant, discriminant_BindResult::Bound);
+        unsafe { self.payload.Bound }
+    }
+
+    pub fn is_Bound(&self) -> bool {
+        matches!(self.discriminant, discriminant_BindResult::Bound)
+    }
+
+    pub fn unwrap_Error(mut self) -> BindErr {
+        debug_assert_eq!(self.discriminant, discriminant_BindResult::Error);
+        unsafe { self.payload.Error }
+    }
+
+    pub fn is_Error(&self) -> bool {
+        matches!(self.discriminant, discriminant_BindResult::Error)
+    }
+}
+
+
+
+impl BindResult {
+
+    pub fn Bound(payload: u64) -> Self {
+        Self {
+            discriminant: discriminant_BindResult::Bound,
+            payload: union_BindResult {
+                Bound: payload,
+            }
+        }
+    }
+
+    pub fn Error(payload: BindErr) -> Self {
+        Self {
+            discriminant: discriminant_BindResult::Error,
+            payload: union_BindResult {
+                Error: payload,
+            }
+        }
+    }
+}
+
 #[derive(Clone, Default, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, )]
 #[repr(C)]
 pub struct Command {
@@ -2244,7 +2474,7 @@ pub union union_WriteErr {
     WriteZero: (),
 }
 
-// const _SIZE_CHECK_union_WriteErr: () = assert!(core::mem::size_of::<union_WriteErr>() == 20);
+const _SIZE_CHECK_union_WriteErr: () = assert!(core::mem::size_of::<union_WriteErr>() == 20);
 const _ALIGN_CHECK_union_WriteErr: () = assert!(core::mem::align_of::<union_WriteErr>() == 4);
 
 const _SIZE_CHECK_WriteErr: () = assert!(core::mem::size_of::<WriteErr>() == 20);
@@ -3157,7 +3387,7 @@ pub union union_GetMetadataErr {
     Unrecognized: core::mem::ManuallyDrop<ConnectErr_Unrecognized>,
 }
 
-// const _SIZE_CHECK_union_GetMetadataErr: () = assert!(core::mem::size_of::<union_GetMetadataErr>() == 20);
+const _SIZE_CHECK_union_GetMetadataErr: () = assert!(core::mem::size_of::<union_GetMetadataErr>() == 20);
 const _ALIGN_CHECK_union_GetMetadataErr: () = assert!(core::mem::align_of::<union_GetMetadataErr>() == 4);
 
 const _SIZE_CHECK_GetMetadataErr: () = assert!(core::mem::size_of::<GetMetadataErr>() == 20);
@@ -3397,7 +3627,7 @@ pub union union_StreamErr {
     Unrecognized: core::mem::ManuallyDrop<ConnectErr_Unrecognized>,
 }
 
-// const _SIZE_CHECK_union_StreamErr: () = assert!(core::mem::size_of::<union_StreamErr>() == 20);
+const _SIZE_CHECK_union_StreamErr: () = assert!(core::mem::size_of::<union_StreamErr>() == 20);
 const _ALIGN_CHECK_union_StreamErr: () = assert!(core::mem::align_of::<union_StreamErr>() == 4);
 
 const _SIZE_CHECK_StreamErr: () = assert!(core::mem::size_of::<StreamErr>() == 20);
@@ -4338,297 +4568,69 @@ impl Drop for ReadExactlyResult {
 
 #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, )]
 #[repr(u8)]
-pub enum discriminant_IOError {
-    AddrInUse = 0,
-    AddrNotAvailable = 1,
-    AlreadyExists = 2,
-    ArgumentListTooLong = 3,
-    BrokenPipe = 4,
-    ConnectionAborted = 5,
-    ConnectionRefused = 6,
-    ConnectionReset = 7,
-    CrossesDevices = 8,
-    Deadlock = 9,
-    DirectoryNotEmpty = 10,
-    ExecutableFileBusy = 11,
-    FileTooLarge = 12,
-    FilesystemLoop = 13,
-    FilesystemQuotaExceeded = 14,
-    HostUnreachable = 15,
-    Interrupted = 16,
-    InvalidData = 17,
-    InvalidFilename = 18,
-    InvalidInput = 19,
-    IsADirectory = 20,
-    NetworkDown = 21,
-    NetworkUnreachable = 22,
-    NotADirectory = 23,
-    NotConnected = 24,
-    NotFound = 25,
-    NotSeekable = 26,
-    Other = 27,
-    OutOfMemory = 28,
-    PermissionDenied = 29,
-    ReadOnlyFilesystem = 30,
-    ResourceBusy = 31,
-    StaleNetworkFileHandle = 32,
-    StorageFull = 33,
-    TimedOut = 34,
-    TooManyLinks = 35,
-    UnexpectedEof = 36,
-    Unsupported = 37,
-    WouldBlock = 38,
-    WriteZero = 39,
-}
-
-impl core::fmt::Debug for discriminant_IOError {
+pub enum discriminant_ReceiveResult {
+    Error = 0,
+    Received = 1,
+}
+
+impl core::fmt::Debug for discriminant_ReceiveResult {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
-            Self::AddrInUse => f.write_str("discriminant_IOError::AddrInUse"),
-            Self::AddrNotAvailable => f.write_str("discriminant_IOError::AddrNotAvailable"),
-            Self::AlreadyExists => f.write_str("discriminant_IOError::AlreadyExists"),
-            Self::ArgumentListTooLong => f.write_str("discriminant_IOError::ArgumentListTooLong"),
-            Self::BrokenPipe => f.write_str("discriminant_IOError::BrokenPipe"),
-            Self::ConnectionAborted => f.write_str("discriminant_IOError::ConnectionAborted"),
-            Self::ConnectionRefused => f.write_str("discriminant_IOError::ConnectionRefused"),
-            Self::ConnectionReset => f.write_str("discriminant_IOError::ConnectionReset"),
-            Self::CrossesDevices => f.write_str("discriminant_IOError::CrossesDevices"),
-            Self::Deadlock => f.write_str("discriminant_IOError::Deadlock"),
-            Self::DirectoryNotEmpty => f.write_str("discriminant_IOError::DirectoryNotEmpty"),
-            Self::ExecutableFileBusy => f.write_str("discriminant_IOError::ExecutableFileBusy"),
-            Self::FileTooLarge => f.write_str("discriminant_IOError::FileTooLarge"),
-            Self::FilesystemLoop => f.write_str("discriminant_IOError::FilesystemLoop"),
-            Self::FilesystemQuotaExceeded => f.write_str("discriminant_IOError::FilesystemQuotaExceeded"),
-            Self::HostUnreachable => f.write_str("discriminant_IOError::HostUnreachable"),
-            Self::Interrupted => f.write_str("discriminant_IOError::Interrupted"),
-            Self::InvalidData => f.write_str("discriminant_IOError::InvalidData"),
-            Self::InvalidFilename => f.write_str("discriminant_IOError::InvalidFilename"),
-            Self::InvalidInput => f.write_str("discriminant_IOError::InvalidInput"),
-            Self::IsADirectory => f.write_str("discriminant_IOError::IsADirectory"),
-            Self::NetworkDown => f.write_str("discriminant_IOError::NetworkDown"),
-            Self::NetworkUnreachable => f.write_str("discriminant_IOError::NetworkUnreachable"),
-            Self::NotADirectory => f.write_str("discriminant_IOError::NotADirectory"),
-            Self::NotConnected => f.write_str("discriminant_IOError::NotConnected"),
-            Self::NotFound => f.write_str("discriminant_IOError::NotFound"),
-            Self::NotSeekable => f.write_str("discriminant_IOError::NotSeekable"),
-            Self::Other => f.write_str("discriminant_IOError::Other"),
-            Self::OutOfMemory => f.write_str("discriminant_IOError::OutOfMemory"),
-            Self::PermissionDenied => f.write_str("discriminant_IOError::PermissionDenied"),
-            Self::ReadOnlyFilesystem => f.write_str("discriminant_IOError::ReadOnlyFilesystem"),
-            Self::ResourceBusy => f.write_str("discriminant_IOError::ResourceBusy"),
-            Self::StaleNetworkFileHandle => f.write_str("discriminant_IOError::StaleNetworkFileHandle"),
-            Self::StorageFull => f.write_str("discriminant_IOError::StorageFull"),
-            Self::TimedOut => f.write_str("discriminant_IOError::TimedOut"),
-            Self::TooManyLinks => f.write_str("discriminant_IOError::TooManyLinks"),
-            Self::UnexpectedEof => f.write_str("discriminant_IOError::UnexpectedEof"),
-            Self::Unsupported => f.write_str("discriminant_IOError::Unsupported"),
-            Self::WouldBlock => f.write_str("discriminant_IOError::WouldBlock"),
-            Self::WriteZero => f.write_str("discriminant_IOError::WriteZero"),
-        }
-    }
-}
-
-#[repr(C, align(1))]
-pub union union_IOError {
-    AddrInUse: (),
-    AddrNotAvailable: (),
-    AlreadyExists: (),
-    ArgumentListTooLong: (),
-    BrokenPipe: (),
-    ConnectionAborted: (),
-    ConnectionRefused: (),
-    ConnectionReset: (),
-    CrossesDevices: (),
-    Deadlock: (),
-    DirectoryNotEmpty: (),
-    ExecutableFileBusy: (),
-    FileTooLarge: (),
-    FilesystemLoop: (),
-    FilesystemQuotaExceeded: (),
-    HostUnreachable: (),
-    Interrupted: (),
-    InvalidData: (),
-    InvalidFilename: (),
-    InvalidInput: (),
-    IsADirectory: (),
-    NetworkDown: (),
-    NetworkUnreachable: (),
-    NotADirectory: (),
-    NotConnected: (),
-    NotFound: (),
-    NotSeekable: (),
-    Other: (),
-    OutOfMemory: (),
-    PermissionDenied: (),
-    ReadOnlyFilesystem: (),
-    ResourceBusy: (),
-    StaleNetworkFileHandle: (),
-    StorageFull: (),
-    TimedOut: (),
-    TooManyLinks: (),
-    UnexpectedEof: (),
-    Unsupported: (),
-    WouldBlock: (),
-    WriteZero: (),
+            Self::Error => f.write_str("discriminant_ReceiveResult::Error"),
+            Self::Received => f.write_str("discriminant_ReceiveResult::Received"),
+        }
+    }
 }
 
-// const _SIZE_CHECK_union_IOError: () = assert!(core::mem::size_of::<union_IOError>() == 1);
-const _ALIGN_CHECK_union_IOError: () = assert!(core::mem::align_of::<union_IOError>() == 1);
+#[repr(C, align(4))]
+pub union union_ReceiveResult {
+    Error: BindErr,
+    Received: core::mem::ManuallyDrop<roc_std::RocList<u8>>,
+}
 
-const _SIZE_CHECK_IOError: () = assert!(core::mem::size_of::<IOError>() == 1);
-const _ALIGN_CHECK_IOError: () = assert!(core::mem::align_of::<IOError>() == 1);
+const _SIZE_CHECK_union_ReceiveResult: () = assert!(core::mem::size_of::<union_ReceiveResult>() == 12);
+const _ALIGN_CHECK_union_ReceiveResult: () = assert!(core::mem::align_of::<union_ReceiveResult>() == 4);
 
-impl IOError {
+const _SIZE_CHECK_ReceiveResult: () = assert!(core::mem::size_of::<ReceiveResult>() == 16);
+const _ALIGN_CHECK_ReceiveResult: () = assert!(core::mem::align_of::<ReceiveResult>() == 4);
+
+impl ReceiveResult {
     /// Returns which variant this tag union holds. Note that this never includes a payload!
-    pub fn discriminant(&self) -> discriminant_IOError {
+    pub fn discriminant(&self) -> discriminant_ReceiveResult {
         unsafe {
             let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::<Self>()]>(self);
 
-            core::mem::transmute::<u8, discriminant_IOError>(*bytes.as_ptr().add(0))
+            core::mem::transmute::<u8, discriminant_ReceiveResult>(*bytes.as_ptr().add(12))
         }
     }
 
     /// Internal helper
-    fn set_discriminant(&mut self, discriminant: discriminant_IOError) {
-        let discriminant_ptr: *mut discriminant_IOError = (self as *mut IOError).cast();
+    fn set_discriminant(&mut self, discriminant: discriminant_ReceiveResult) {
+        let discriminant_ptr: *mut discriminant_ReceiveResult = (self as *mut ReceiveResult).cast();
 
         unsafe {
-            *(discriminant_ptr.add(0)) = discriminant;
+            *(discriminant_ptr.add(12)) = discriminant;
         }
     }
 }
 
 #[repr(C)]
-pub struct IOError {
-    payload: union_IOError,
-    discriminant: discriminant_IOError,
+pub struct ReceiveResult {
+    payload: union_ReceiveResult,
+    discriminant: discriminant_ReceiveResult,
 }
 
-impl Clone for IOError {
+impl Clone for ReceiveResult {
     fn clone(&self) -> Self {
-        use discriminant_IOError::*;
+        use discriminant_ReceiveResult::*;
 
         let payload = unsafe {
             match self.discriminant {
-                AddrInUse => union_IOError {
-                    AddrInUse: self.payload.AddrInUse.clone(),
-                },
-                AddrNotAvailable => union_IOError {
-                    AddrNotAvailable: self.payload.AddrNotAvailable.clone(),
-                },
-                AlreadyExists => union_IOError {
-                    AlreadyExists: self.payload.AlreadyExists.clone(),
-                },
-                ArgumentListTooLong => union_IOError {
-                    ArgumentListTooLong: self.payload.ArgumentListTooLong.clone(),
-                },
-                BrokenPipe => union_IOError {
-                    BrokenPipe: self.payload.BrokenPipe.clone(),
-                },
-                ConnectionAborted => union_IOError {
-                    ConnectionAborted: self.payload.ConnectionAborted.clone(),
-                },
-                ConnectionRefused => union_IOError {
-                    ConnectionRefused: self.payload.ConnectionRefused.clone(),
-                },
-                ConnectionReset => union_IOError {
-                    ConnectionReset: self.payload.ConnectionReset.clone(),
-                },
-                CrossesDevices => union_IOError {
-                    CrossesDevices: self.payload.CrossesDevices.clone(),
-                },
-                Deadlock => union_IOError {
-                    Deadlock: self.payload.Deadlock.clone(),
-                },
-                DirectoryNotEmpty => union_IOError {
-                    DirectoryNotEmpty: self.payload.DirectoryNotEmpty.clone(),
-                },
-                ExecutableFileBusy => union_IOError {
-                    ExecutableFileBusy: self.payload.ExecutableFileBusy.clone(),
-                },
-                FileTooLarge => union_IOError {
-                    FileTooLarge: self.payload.FileTooLarge.clone(),
-                },
-                FilesystemLoop => union_IOError {
-                    FilesystemLoop: self.payload.FilesystemLoop.clone(),
-                },
-                FilesystemQuotaExceeded => union_IOError {
-                    FilesystemQuotaExceeded: self.payload.FilesystemQuotaExceeded.clone(),
-                },
-                HostUnreachable => union_IOError {
-                    HostUnreachable: self.payload.HostUnreachable.clone(),
-                },
-                Interrupted => union_IOError {
-                    Interrupted: self.payload.Interrupted.clone(),
-                },
-                InvalidData => union_IOError {
-                    InvalidData: self.payload.InvalidData.clone(),
-                },
-                InvalidFilename => union_IOError {
-                    InvalidFilename: self.payload.InvalidFilename.clone(),
-                },
-                InvalidInput => union_IOError {
-                    InvalidInput: self.payload.InvalidInput.clone(),
-                },
-                IsADirectory => union_IOError {
-                    IsADirectory: self.payload.IsADirectory.clone(),
-                },
-                NetworkDown => union_IOError {
-                    NetworkDown: self.payload.NetworkDown.clone(),
-                },
-                NetworkUnreachable => union_IOError {
-                    NetworkUnreachable: self.payload.NetworkUnreachable.clone(),
-                },
-                NotADirectory => union_IOError {
-                    NotADirectory: self.payload.NotADirectory.clone(),
-                },
-                NotConnected => union_IOError {
-                    NotConnected: self.payload.NotConnected.clone(),
-                },
-                NotFound => union_IOError {
-                    NotFound: self.payload.NotFound.clone(),
-                },
-                NotSeekable => union_IOError {
-                    NotSeekable: self.payload.NotSeekable.clone(),
-                },
-                Other => union_IOError {
-                    Other: self.payload.Other.clone(),
-                },
-                OutOfMemory => union_IOError {
-                    OutOfMemory: self.payload.OutOfMemory.clone(),
-                },
-                PermissionDenied => union_IOError {
-                    PermissionDenied: self.payload.PermissionDenied.clone(),
-                },
-                ReadOnlyFilesystem => union_IOError {
-                    ReadOnlyFilesystem: self.payload.ReadOnlyFilesystem.clone(),
-                },
-                ResourceBusy => union_IOError {
-                    ResourceBusy: self.payload.ResourceBusy.clone(),
-                },
-                StaleNetworkFileHandle => union_IOError {
-                    StaleNetworkFileHandle: self.payload.StaleNetworkFileHandle.clone(),
-                },
-                StorageFull => union_IOError {
-                    StorageFull: self.payload.StorageFull.clone(),
-                },
-                TimedOut => union_IOError {
-                    TimedOut: self.payload.TimedOut.clone(),
-                },
-                TooManyLinks => union_IOError {
-                    TooManyLinks: self.payload.TooManyLinks.clone(),
-                },
-                UnexpectedEof => union_IOError {
-                    UnexpectedEof: self.payload.UnexpectedEof.clone(),
-                },
-                Unsupported => union_IOError {
-                    Unsupported: self.payload.Unsupported.clone(),
-                },
-                WouldBlock => union_IOError {
-                    WouldBlock: self.payload.WouldBlock.clone(),
+                Error => union_ReceiveResult {
+                    Error: self.payload.Error.clone(),
                 },
-                WriteZero => union_IOError {
-                    WriteZero: self.payload.WriteZero.clone(),
+                Received => union_ReceiveResult {
+                    Received: self.payload.Received.clone(),
                 },
             }
         };
@@ -4640,182 +4642,30 @@ impl Clone for IOError {
     }
 }
 
-impl core::fmt::Debug for IOError {
+impl core::fmt::Debug for ReceiveResult {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        use discriminant_IOError::*;
+        use discriminant_ReceiveResult::*;
 
         unsafe {
             match self.discriminant {
-                AddrInUse => {
-                    let field: &() = &self.payload.AddrInUse;
-                    f.debug_tuple("IOError::AddrInUse").field(field).finish()
-                },
-                AddrNotAvailable => {
-                    let field: &() = &self.payload.AddrNotAvailable;
-                    f.debug_tuple("IOError::AddrNotAvailable").field(field).finish()
-                },
-                AlreadyExists => {
-                    let field: &() = &self.payload.AlreadyExists;
-                    f.debug_tuple("IOError::AlreadyExists").field(field).finish()
-                },
-                ArgumentListTooLong => {
-                    let field: &() = &self.payload.ArgumentListTooLong;
-                    f.debug_tuple("IOError::ArgumentListTooLong").field(field).finish()
+                Error => {
+                    let field: &BindErr = &self.payload.Error;
+                    f.debug_tuple("ReceiveResult::Error").field(field).finish()
                 },
-                BrokenPipe => {
-                    let field: &() = &self.payload.BrokenPipe;
-                    f.debug_tuple("IOError::BrokenPipe").field(field).finish()
-                },
-                ConnectionAborted => {
-                    let field: &() = &self.payload.ConnectionAborted;
-                    f.debug_tuple("IOError::ConnectionAborted").field(field).finish()
-                },
-                ConnectionRefused => {
-                    let field: &() = &self.payload.ConnectionRefused;
-                    f.debug_tuple("IOError::ConnectionRefused").field(field).finish()
-                },
-                ConnectionReset => {
-                    let field: &() = &self.payload.ConnectionReset;
-                    f.debug_tuple("IOError::ConnectionReset").field(field).finish()
-                },
-                CrossesDevices => {
-                    let field: &() = &self.payload.CrossesDevices;
-                    f.debug_tuple("IOError::CrossesDevices").field(field).finish()
-                },
-                Deadlock => {
-                    let field: &() = &self.payload.Deadlock;
-                    f.debug_tuple("IOError::Deadlock").field(field).finish()
-                },
-                DirectoryNotEmpty => {
-                    let field: &() = &self.payload.DirectoryNotEmpty;
-                    f.debug_tuple("IOError::DirectoryNotEmpty").field(field).finish()
-                },
-                ExecutableFileBusy => {
-                    let field: &() = &self.payload.ExecutableFileBusy;
-                    f.debug_tuple("IOError::ExecutableFileBusy").field(field).finish()
-                },
-                FileTooLarge => {
-                    let field: &() = &self.payload.FileTooLarge;
-                    f.debug_tuple("IOError::FileTooLarge").field(field).finish()
-                },
-                FilesystemLoop => {
-                    let field: &() = &self.payload.FilesystemLoop;
-                    f.debug_tuple("IOError::FilesystemLoop").field(field).finish()
-                },
-                FilesystemQuotaExceeded => {
-                    let field: &() = &self.payload.FilesystemQuotaExceeded;
-                    f.debug_tuple("IOError::FilesystemQuotaExceeded").field(field).finish()
-                },
-                HostUnreachable => {
-                    let field: &() = &self.payload.HostUnreachable;
-                    f.debug_tuple("IOError::HostUnreachable").field(field).finish()
-                },
-                Interrupted => {
-                    let field: &() = &self.payload.Interrupted;
-                    f.debug_tuple("IOError::Interrupted").field(field).finish()
-                },
-                InvalidData => {
-                    let field: &() = &self.payload.InvalidData;
-                    f.debug_tuple("IOError::InvalidData").field(field).finish()
-                },
-                InvalidFilename => {
-                    let field: &() = &self.payload.InvalidFilename;
-                    f.debug_tuple("IOError::InvalidFilename").field(field).finish()
-                },
-                InvalidInput => {
-                    let field: &() = &self.payload.InvalidInput;
-                    f.debug_tuple("IOError::InvalidInput").field(field).finish()
-                },
-                IsADirectory => {
-                    let field: &() = &self.payload.IsADirectory;
-                    f.debug_tuple("IOError::IsADirectory").field(field).finish()
-                },
-                NetworkDown => {
-                    let field: &() = &self.payload.NetworkDown;
-                    f.debug_tuple("IOError::NetworkDown").field(field).finish()
-                },
-                NetworkUnreachable => {
-                    let field: &() = &self.payload.NetworkUnreachable;
-                    f.debug_tuple("IOError::NetworkUnreachable").field(field).finish()
-                },
-                NotADirectory => {
-                    let field: &() = &self.payload.NotADirectory;
-                    f.debug_tuple("IOError::NotADirectory").field(field).finish()
-                },
-                NotConnected => {
-                    let field: &() = &self.payload.NotConnected;
-                    f.debug_tuple("IOError::NotConnected").field(field).finish()
-                },
-                NotFound => {
-                    let field: &() = &self.payload.NotFound;
-                    f.debug_tuple("IOError::NotFound").field(field).finish()
-                },
-                NotSeekable => {
-                    let field: &() = &self.payload.NotSeekable;
-                    f.debug_tuple("IOError::NotSeekable").field(field).finish()
-                },
-                Other => {
-                    let field: &() = &self.payload.Other;
-                    f.debug_tuple("IOError::Other").field(field).finish()
-                },
-                OutOfMemory => {
-                    let field: &() = &self.payload.OutOfMemory;
-                    f.debug_tuple("IOError::OutOfMemory").field(field).finish()
-                },
-                PermissionDenied => {
-                    let field: &() = &self.payload.PermissionDenied;
-                    f.debug_tuple("IOError::PermissionDenied").field(field).finish()
-                },
-                ReadOnlyFilesystem => {
-                    let field: &() = &self.payload.ReadOnlyFilesystem;
-                    f.debug_tuple("IOError::ReadOnlyFilesystem").field(field).finish()
-                },
-                ResourceBusy => {
-                    let field: &() = &self.payload.ResourceBusy;
-                    f.debug_tuple("IOError::ResourceBusy").field(field).finish()
-                },
-                StaleNetworkFileHandle => {
-                    let field: &() = &self.payload.StaleNetworkFileHandle;
-                    f.debug_tuple("IOError::StaleNetworkFileHandle").field(field).finish()
-                },
-                StorageFull => {
-                    let field: &() = &self.payload.StorageFull;
-                    f.debug_tuple("IOError::StorageFull").field(field).finish()
-                },
-                TimedOut => {
-                    let field: &() = &self.payload.TimedOut;
-                    f.debug_tuple("IOError::TimedOut").field(field).finish()
-                },
-                TooManyLinks => {
-                    let field: &() = &self.payload.TooManyLinks;
-                    f.debug_tuple("IOError::TooManyLinks").field(field).finish()
-                },
-                UnexpectedEof => {
-                    let field: &() = &self.payload.UnexpectedEof;
-                    f.debug_tuple("IOError::UnexpectedEof").field(field).finish()
-                },
-                Unsupported => {
-                    let field: &() = &self.payload.Unsupported;
-                    f.debug_tuple("IOError::Unsupported").field(field).finish()
-                },
-                WouldBlock => {
-                    let field: &() = &self.payload.WouldBlock;
-                    f.debug_tuple("IOError::WouldBlock").field(field).finish()
-                },
-                WriteZero => {
-                    let field: &() = &self.payload.WriteZero;
-                    f.debug_tuple("IOError::WriteZero").field(field).finish()
+                Received => {
+                    let field: &roc_std::RocList<u8> = &self.payload.Received;
+                    f.debug_tuple("ReceiveResult::Received").field(field).finish()
                 },
             }
         }
     }
 }
 
-impl Eq for IOError {}
+impl Eq for ReceiveResult {}
 
-impl PartialEq for IOError {
+impl PartialEq for ReceiveResult {
     fn eq(&self, other: &Self) -> bool {
-        use discriminant_IOError::*;
+        use discriminant_ReceiveResult::*;
 
         if self.discriminant != other.discriminant {
             return false;
@@ -4823,60 +4673,22 @@ impl PartialEq for IOError {
 
         unsafe {
             match self.discriminant {
-                AddrInUse => self.payload.AddrInUse == other.payload.AddrInUse,
-                AddrNotAvailable => self.payload.AddrNotAvailable == other.payload.AddrNotAvailable,
-                AlreadyExists => self.payload.AlreadyExists == other.payload.AlreadyExists,
-                ArgumentListTooLong => self.payload.ArgumentListTooLong == other.payload.ArgumentListTooLong,
-                BrokenPipe => self.payload.BrokenPipe == other.payload.BrokenPipe,
-                ConnectionAborted => self.payload.ConnectionAborted == other.payload.ConnectionAborted,
-                ConnectionRefused => self.payload.ConnectionRefused == other.payload.ConnectionRefused,
-                ConnectionReset => self.payload.ConnectionReset == other.payload.ConnectionReset,
-                CrossesDevices => self.payload.CrossesDevices == other.payload.CrossesDevices,
-                Deadlock => self.payload.Deadlock == other.payload.Deadlock,
-                DirectoryNotEmpty => self.payload.DirectoryNotEmpty == other.payload.DirectoryNotEmpty,
-                ExecutableFileBusy => self.payload.ExecutableFileBusy == other.payload.ExecutableFileBusy,
-                FileTooLarge => self.payload.FileTooLarge == other.payload.FileTooLarge,
-                FilesystemLoop => self.payload.FilesystemLoop == other.payload.FilesystemLoop,
-                FilesystemQuotaExceeded => self.payload.FilesystemQuotaExceeded == other.payload.FilesystemQuotaExceeded,
-                HostUnreachable => self.payload.HostUnreachable == other.payload.HostUnreachable,
-                Interrupted => self.payload.Interrupted == other.payload.Interrupted,
-                InvalidData => self.payload.InvalidData == other.payload.InvalidData,
-                InvalidFilename => self.payload.InvalidFilename == other.payload.InvalidFilename,
-                InvalidInput => self.payload.InvalidInput == other.payload.InvalidInput,
-                IsADirectory => self.payload.IsADirectory == other.payload.IsADirectory,
-                NetworkDown => self.payload.NetworkDown == other.payload.NetworkDown,
-                NetworkUnreachable => self.payload.NetworkUnreachable == other.payload.NetworkUnreachable,
-                NotADirectory => self.payload.NotADirectory == other.payload.NotADirectory,
-                NotConnected => self.payload.NotConnected == other.payload.NotConnected,
-                NotFound => self.payload.NotFound == other.payload.NotFound,
-                NotSeekable => self.payload.NotSeekable == other.payload.NotSeekable,
-                Other => self.payload.Other == other.payload.Other,
-                OutOfMemory => self.payload.OutOfMemory == other.payload.OutOfMemory,
-                PermissionDenied => self.payload.PermissionDenied == other.payload.PermissionDenied,
-                ReadOnlyFilesystem => self.payload.ReadOnlyFilesystem == other.payload.ReadOnlyFilesystem,
-                ResourceBusy => self.payload.ResourceBusy == other.payload.ResourceBusy,
-                StaleNetworkFileHandle => self.payload.StaleNetworkFileHandle == other.payload.StaleNetworkFileHandle,
-                StorageFull => self.payload.StorageFull == other.payload.StorageFull,
-                TimedOut => self.payload.TimedOut == other.payload.TimedOut,
-                TooManyLinks => self.payload.TooManyLinks == other.payload.TooManyLinks,
-                UnexpectedEof => self.payload.UnexpectedEof == other.payload.UnexpectedEof,
-                Unsupported => self.payload.Unsupported == other.payload.Unsupported,
-                WouldBlock => self.payload.WouldBlock == other.payload.WouldBlock,
-                WriteZero => self.payload.WriteZero == other.payload.WriteZero,
+                Error => self.payload.Error == other.payload.Error,
+                Received => self.payload.Received == other.payload.Received,
             }
         }
     }
 }
 
-impl Ord for IOError {
+impl Ord for ReceiveResult {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         self.partial_cmp(other).unwrap()
     }
 }
 
-impl PartialOrd for IOError {
+impl PartialOrd for ReceiveResult {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        use discriminant_IOError::*;
+        use discriminant_ReceiveResult::*;
 
         use std::cmp::Ordering::*;
 
@@ -4885,627 +4697,77 @@ impl PartialOrd for IOError {
             Greater => Option::Some(Greater),
             Equal => unsafe {
                 match self.discriminant {
-                    AddrInUse => self.payload.AddrInUse.partial_cmp(&other.payload.AddrInUse),
-                    AddrNotAvailable => self.payload.AddrNotAvailable.partial_cmp(&other.payload.AddrNotAvailable),
-                    AlreadyExists => self.payload.AlreadyExists.partial_cmp(&other.payload.AlreadyExists),
-                    ArgumentListTooLong => self.payload.ArgumentListTooLong.partial_cmp(&other.payload.ArgumentListTooLong),
-                    BrokenPipe => self.payload.BrokenPipe.partial_cmp(&other.payload.BrokenPipe),
-                    ConnectionAborted => self.payload.ConnectionAborted.partial_cmp(&other.payload.ConnectionAborted),
-                    ConnectionRefused => self.payload.ConnectionRefused.partial_cmp(&other.payload.ConnectionRefused),
-                    ConnectionReset => self.payload.ConnectionReset.partial_cmp(&other.payload.ConnectionReset),
-                    CrossesDevices => self.payload.CrossesDevices.partial_cmp(&other.payload.CrossesDevices),
-                    Deadlock => self.payload.Deadlock.partial_cmp(&other.payload.Deadlock),
-                    DirectoryNotEmpty => self.payload.DirectoryNotEmpty.partial_cmp(&other.payload.DirectoryNotEmpty),
-                    ExecutableFileBusy => self.payload.ExecutableFileBusy.partial_cmp(&other.payload.ExecutableFileBusy),
-                    FileTooLarge => self.payload.FileTooLarge.partial_cmp(&other.payload.FileTooLarge),
-                    FilesystemLoop => self.payload.FilesystemLoop.partial_cmp(&other.payload.FilesystemLoop),
-                    FilesystemQuotaExceeded => self.payload.FilesystemQuotaExceeded.partial_cmp(&other.payload.FilesystemQuotaExceeded),
-                    HostUnreachable => self.payload.HostUnreachable.partial_cmp(&other.payload.HostUnreachable),
-                    Interrupted => self.payload.Interrupted.partial_cmp(&other.payload.Interrupted),
-                    InvalidData => self.payload.InvalidData.partial_cmp(&other.payload.InvalidData),
-                    InvalidFilename => self.payload.InvalidFilename.partial_cmp(&other.payload.InvalidFilename),
-                    InvalidInput => self.payload.InvalidInput.partial_cmp(&other.payload.InvalidInput),
-                    IsADirectory => self.payload.IsADirectory.partial_cmp(&other.payload.IsADirectory),
-                    NetworkDown => self.payload.NetworkDown.partial_cmp(&other.payload.NetworkDown),
-                    NetworkUnreachable => self.payload.NetworkUnreachable.partial_cmp(&other.payload.NetworkUnreachable),
-                    NotADirectory => self.payload.NotADirectory.partial_cmp(&other.payload.NotADirectory),
-                    NotConnected => self.payload.NotConnected.partial_cmp(&other.payload.NotConnected),
-                    NotFound => self.payload.NotFound.partial_cmp(&other.payload.NotFound),
-                    NotSeekable => self.payload.NotSeekable.partial_cmp(&other.payload.NotSeekable),
-                    Other => self.payload.Other.partial_cmp(&other.payload.Other),
-                    OutOfMemory => self.payload.OutOfMemory.partial_cmp(&other.payload.OutOfMemory),
-                    PermissionDenied => self.payload.PermissionDenied.partial_cmp(&other.payload.PermissionDenied),
-                    ReadOnlyFilesystem => self.payload.ReadOnlyFilesystem.partial_cmp(&other.payload.ReadOnlyFilesystem),
-                    ResourceBusy => self.payload.ResourceBusy.partial_cmp(&other.payload.ResourceBusy),
-                    StaleNetworkFileHandle => self.payload.StaleNetworkFileHandle.partial_cmp(&other.payload.StaleNetworkFileHandle),
-                    StorageFull => self.payload.StorageFull.partial_cmp(&other.payload.StorageFull),
-                    TimedOut => self.payload.TimedOut.partial_cmp(&other.payload.TimedOut),
-                    TooManyLinks => self.payload.TooManyLinks.partial_cmp(&other.payload.TooManyLinks),
-                    UnexpectedEof => self.payload.UnexpectedEof.partial_cmp(&other.payload.UnexpectedEof),
-                    Unsupported => self.payload.Unsupported.partial_cmp(&other.payload.Unsupported),
-                    WouldBlock => self.payload.WouldBlock.partial_cmp(&other.payload.WouldBlock),
-                    WriteZero => self.payload.WriteZero.partial_cmp(&other.payload.WriteZero),
+                    Error => self.payload.Error.partial_cmp(&other.payload.Error),
+                    Received => self.payload.Received.partial_cmp(&other.payload.Received),
                 }
             },
         }
     }
 }
 
-impl core::hash::Hash for IOError {
+impl core::hash::Hash for ReceiveResult {
     fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-        use discriminant_IOError::*;
+        use discriminant_ReceiveResult::*;
 
         unsafe {
             match self.discriminant {
-                AddrInUse => self.payload.AddrInUse.hash(state),
-                AddrNotAvailable => self.payload.AddrNotAvailable.hash(state),
-                AlreadyExists => self.payload.AlreadyExists.hash(state),
-                ArgumentListTooLong => self.payload.ArgumentListTooLong.hash(state),
-                BrokenPipe => self.payload.BrokenPipe.hash(state),
-                ConnectionAborted => self.payload.ConnectionAborted.hash(state),
-                ConnectionRefused => self.payload.ConnectionRefused.hash(state),
-                ConnectionReset => self.payload.ConnectionReset.hash(state),
-                CrossesDevices => self.payload.CrossesDevices.hash(state),
-                Deadlock => self.payload.Deadlock.hash(state),
-                DirectoryNotEmpty => self.payload.DirectoryNotEmpty.hash(state),
-                ExecutableFileBusy => self.payload.ExecutableFileBusy.hash(state),
-                FileTooLarge => self.payload.FileTooLarge.hash(state),
-                FilesystemLoop => self.payload.FilesystemLoop.hash(state),
-                FilesystemQuotaExceeded => self.payload.FilesystemQuotaExceeded.hash(state),
-                HostUnreachable => self.payload.HostUnreachable.hash(state),
-                Interrupted => self.payload.Interrupted.hash(state),
-                InvalidData => self.payload.InvalidData.hash(state),
-                InvalidFilename => self.payload.InvalidFilename.hash(state),
-                InvalidInput => self.payload.InvalidInput.hash(state),
-                IsADirectory => self.payload.IsADirectory.hash(state),
-                NetworkDown => self.payload.NetworkDown.hash(state),
-                NetworkUnreachable => self.payload.NetworkUnreachable.hash(state),
-                NotADirectory => self.payload.NotADirectory.hash(state),
-                NotConnected => self.payload.NotConnected.hash(state),
-                NotFound => self.payload.NotFound.hash(state),
-                NotSeekable => self.payload.NotSeekable.hash(state),
-                Other => self.payload.Other.hash(state),
-                OutOfMemory => self.payload.OutOfMemory.hash(state),
-                PermissionDenied => self.payload.PermissionDenied.hash(state),
-                ReadOnlyFilesystem => self.payload.ReadOnlyFilesystem.hash(state),
-                ResourceBusy => self.payload.ResourceBusy.hash(state),
-                StaleNetworkFileHandle => self.payload.StaleNetworkFileHandle.hash(state),
-                StorageFull => self.payload.StorageFull.hash(state),
-                TimedOut => self.payload.TimedOut.hash(state),
-                TooManyLinks => self.payload.TooManyLinks.hash(state),
-                UnexpectedEof => self.payload.UnexpectedEof.hash(state),
-                Unsupported => self.payload.Unsupported.hash(state),
-                WouldBlock => self.payload.WouldBlock.hash(state),
-                WriteZero => self.payload.WriteZero.hash(state),
+                Error => self.payload.Error.hash(state),
+                Received => self.payload.Received.hash(state),
             }
         }
     }
 }
 
-impl IOError {
-
-    pub fn is_AddrInUse(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::AddrInUse)
-    }
-
-    pub fn is_AddrNotAvailable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::AddrNotAvailable)
-    }
-
-    pub fn is_AlreadyExists(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::AlreadyExists)
-    }
-
-    pub fn is_ArgumentListTooLong(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ArgumentListTooLong)
-    }
-
-    pub fn is_BrokenPipe(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::BrokenPipe)
-    }
-
-    pub fn is_ConnectionAborted(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ConnectionAborted)
-    }
-
-    pub fn is_ConnectionRefused(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ConnectionRefused)
-    }
-
-    pub fn is_ConnectionReset(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ConnectionReset)
-    }
-
-    pub fn is_CrossesDevices(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::CrossesDevices)
-    }
-
-    pub fn is_Deadlock(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Deadlock)
-    }
-
-    pub fn is_DirectoryNotEmpty(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::DirectoryNotEmpty)
-    }
-
-    pub fn is_ExecutableFileBusy(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ExecutableFileBusy)
-    }
-
-    pub fn is_FileTooLarge(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::FileTooLarge)
-    }
-
-    pub fn is_FilesystemLoop(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::FilesystemLoop)
-    }
-
-    pub fn is_FilesystemQuotaExceeded(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::FilesystemQuotaExceeded)
-    }
+impl ReceiveResult {
 
-    pub fn is_HostUnreachable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::HostUnreachable)
+    pub fn unwrap_Error(mut self) -> BindErr {
+        debug_assert_eq!(self.discriminant, discriminant_ReceiveResult::Error);
+        unsafe { self.payload.Error }
     }
 
-    pub fn is_Interrupted(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Interrupted)
-    }
-
-    pub fn is_InvalidData(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::InvalidData)
-    }
-
-    pub fn is_InvalidFilename(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::InvalidFilename)
-    }
-
-    pub fn is_InvalidInput(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::InvalidInput)
-    }
-
-    pub fn is_IsADirectory(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::IsADirectory)
-    }
-
-    pub fn is_NetworkDown(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NetworkDown)
-    }
-
-    pub fn is_NetworkUnreachable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NetworkUnreachable)
-    }
-
-    pub fn is_NotADirectory(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotADirectory)
-    }
-
-    pub fn is_NotConnected(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotConnected)
-    }
-
-    pub fn is_NotFound(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotFound)
-    }
-
-    pub fn is_NotSeekable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotSeekable)
-    }
-
-    pub fn is_Other(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Other)
-    }
-
-    pub fn is_OutOfMemory(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::OutOfMemory)
-    }
-
-    pub fn is_PermissionDenied(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::PermissionDenied)
-    }
-
-    pub fn is_ReadOnlyFilesystem(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ReadOnlyFilesystem)
-    }
-
-    pub fn is_ResourceBusy(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ResourceBusy)
-    }
-
-    pub fn is_StaleNetworkFileHandle(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::StaleNetworkFileHandle)
-    }
-
-    pub fn is_StorageFull(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::StorageFull)
-    }
-
-    pub fn is_TimedOut(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::TimedOut)
-    }
-
-    pub fn is_TooManyLinks(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::TooManyLinks)
-    }
-
-    pub fn is_UnexpectedEof(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::UnexpectedEof)
+    pub fn is_Error(&self) -> bool {
+        matches!(self.discriminant, discriminant_ReceiveResult::Error)
     }
 
-    pub fn is_Unsupported(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Unsupported)
+    pub fn unwrap_Received(mut self) -> roc_std::RocList<u8> {
+        debug_assert_eq!(self.discriminant, discriminant_ReceiveResult::Received);
+        unsafe { core::mem::ManuallyDrop::take(&mut self.payload.Received) }
     }
 
-    pub fn is_WouldBlock(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::WouldBlock)
-    }
-
-    pub fn is_WriteZero(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::WriteZero)
+    pub fn is_Received(&self) -> bool {
+        matches!(self.discriminant, discriminant_ReceiveResult::Received)
     }
 }
 
 
 
-impl IOError {
-
-    pub fn AddrInUse() -> Self {
-        Self {
-            discriminant: discriminant_IOError::AddrInUse,
-            payload: union_IOError {
-                AddrInUse: (),
-            }
-        }
-    }
-
-    pub fn AddrNotAvailable() -> Self {
-        Self {
-            discriminant: discriminant_IOError::AddrNotAvailable,
-            payload: union_IOError {
-                AddrNotAvailable: (),
-            }
-        }
-    }
-
-    pub fn AlreadyExists() -> Self {
-        Self {
-            discriminant: discriminant_IOError::AlreadyExists,
-            payload: union_IOError {
-                AlreadyExists: (),
-            }
-        }
-    }
-
-    pub fn ArgumentListTooLong() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ArgumentListTooLong,
-            payload: union_IOError {
-                ArgumentListTooLong: (),
-            }
-        }
-    }
-
-    pub fn BrokenPipe() -> Self {
-        Self {
-            discriminant: discriminant_IOError::BrokenPipe,
-            payload: union_IOError {
-                BrokenPipe: (),
-            }
-        }
-    }
-
-    pub fn ConnectionAborted() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ConnectionAborted,
-            payload: union_IOError {
-                ConnectionAborted: (),
-            }
-        }
-    }
-
-    pub fn ConnectionRefused() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ConnectionRefused,
-            payload: union_IOError {
-                ConnectionRefused: (),
-            }
-        }
-    }
-
-    pub fn ConnectionReset() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ConnectionReset,
-            payload: union_IOError {
-                ConnectionReset: (),
-            }
-        }
-    }
-
-    pub fn CrossesDevices() -> Self {
-        Self {
-            discriminant: discriminant_IOError::CrossesDevices,
-            payload: union_IOError {
-                CrossesDevices: (),
-            }
-        }
-    }
-
-    pub fn Deadlock() -> Self {
-        Self {
-            discriminant: discriminant_IOError::Deadlock,
-            payload: union_IOError {
-                Deadlock: (),
-            }
-        }
-    }
-
-    pub fn DirectoryNotEmpty() -> Self {
-        Self {
-            discriminant: discriminant_IOError::DirectoryNotEmpty,
-            payload: union_IOError {
-                DirectoryNotEmpty: (),
-            }
-        }
-    }
-
-    pub fn ExecutableFileBusy() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ExecutableFileBusy,
-            payload: union_IOError {
-                ExecutableFileBusy: (),
-            }
-        }
-    }
-
-    pub fn FileTooLarge() -> Self {
-        Self {
-            discriminant: discriminant_IOError::FileTooLarge,
-            payload: union_IOError {
-                FileTooLarge: (),
-            }
-        }
-    }
-
-    pub fn FilesystemLoop() -> Self {
-        Self {
-            discriminant: discriminant_IOError::FilesystemLoop,
-            payload: union_IOError {
-                FilesystemLoop: (),
-            }
-        }
-    }
-
-    pub fn FilesystemQuotaExceeded() -> Self {
-        Self {
-            discriminant: discriminant_IOError::FilesystemQuotaExceeded,
-            payload: union_IOError {
-                FilesystemQuotaExceeded: (),
-            }
-        }
-    }
-
-    pub fn HostUnreachable() -> Self {
-        Self {
-            discriminant: discriminant_IOError::HostUnreachable,
-            payload: union_IOError {
-                HostUnreachable: (),
-            }
-        }
-    }
+impl ReceiveResult {
 
-    pub fn Interrupted() -> Self {
+    pub fn Error(payload: BindErr) -> Self {
         Self {
-            discriminant: discriminant_IOError::Interrupted,
-            payload: union_IOError {
-                Interrupted: (),
+            discriminant: discriminant_ReceiveResult::Error,
+            payload: union_ReceiveResult {
+                Error: payload,
             }
         }
     }
 
-    pub fn InvalidData() -> Self {
+    pub fn Received(payload: roc_std::RocList<u8>) -> Self {
         Self {
-            discriminant: discriminant_IOError::InvalidData,
-            payload: union_IOError {
-                InvalidData: (),
-            }
-        }
-    }
-
-    pub fn InvalidFilename() -> Self {
-        Self {
-            discriminant: discriminant_IOError::InvalidFilename,
-            payload: union_IOError {
-                InvalidFilename: (),
-            }
-        }
-    }
-
-    pub fn InvalidInput() -> Self {
-        Self {
-            discriminant: discriminant_IOError::InvalidInput,
-            payload: union_IOError {
-                InvalidInput: (),
-            }
-        }
-    }
-
-    pub fn IsADirectory() -> Self {
-        Self {
-            discriminant: discriminant_IOError::IsADirectory,
-            payload: union_IOError {
-                IsADirectory: (),
-            }
-        }
-    }
-
-    pub fn NetworkDown() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NetworkDown,
-            payload: union_IOError {
-                NetworkDown: (),
-            }
-        }
-    }
-
-    pub fn NetworkUnreachable() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NetworkUnreachable,
-            payload: union_IOError {
-                NetworkUnreachable: (),
-            }
-        }
-    }
-
-    pub fn NotADirectory() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotADirectory,
-            payload: union_IOError {
-                NotADirectory: (),
-            }
-        }
-    }
-
-    pub fn NotConnected() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotConnected,
-            payload: union_IOError {
-                NotConnected: (),
-            }
-        }
-    }
-
-    pub fn NotFound() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotFound,
-            payload: union_IOError {
-                NotFound: (),
-            }
-        }
-    }
-
-    pub fn NotSeekable() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotSeekable,
-            payload: union_IOError {
-                NotSeekable: (),
-            }
-        }
-    }
-
-    pub fn Other() -> Self {
-        Self {
-            discriminant: discriminant_IOError::Other,
-            payload: union_IOError {
-                Other: (),
-            }
-        }
-    }
-
-    pub fn OutOfMemory() -> Self {
-        Self {
-            discriminant: discriminant_IOError::OutOfMemory,
-            payload: union_IOError {
-                OutOfMemory: (),
-            }
-        }
-    }
-
-    pub fn PermissionDenied() -> Self {
-        Self {
-            discriminant: discriminant_IOError::PermissionDenied,
-            payload: union_IOError {
-                PermissionDenied: (),
-            }
-        }
-    }
-
-    pub fn ReadOnlyFilesystem() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ReadOnlyFilesystem,
-            payload: union_IOError {
-                ReadOnlyFilesystem: (),
-            }
-        }
-    }
-
-    pub fn ResourceBusy() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ResourceBusy,
-            payload: union_IOError {
-                ResourceBusy: (),
-            }
-        }
-    }
-
-    pub fn StaleNetworkFileHandle() -> Self {
-        Self {
-            discriminant: discriminant_IOError::StaleNetworkFileHandle,
-            payload: union_IOError {
-                StaleNetworkFileHandle: (),
-            }
-        }
-    }
-
-    pub fn StorageFull() -> Self {
-        Self {
-            discriminant: discriminant_IOError::StorageFull,
-            payload: union_IOError {
-                StorageFull: (),
-            }
-        }
-    }
-
-    pub fn TimedOut() -> Self {
-        Self {
-            discriminant: discriminant_IOError::TimedOut,
-            payload: union_IOError {
-                TimedOut: (),
-            }
-        }
-    }
-
-    pub fn TooManyLinks() -> Self {
-        Self {
-            discriminant: discriminant_IOError::TooManyLinks,
-            payload: union_IOError {
-                TooManyLinks: (),
-            }
-        }
-    }
-
-    pub fn UnexpectedEof() -> Self {
-        Self {
-            discriminant: discriminant_IOError::UnexpectedEof,
-            payload: union_IOError {
-                UnexpectedEof: (),
-            }
-        }
-    }
-
-    pub fn Unsupported() -> Self {
-        Self {
-            discriminant: discriminant_IOError::Unsupported,
-            payload: union_IOError {
-                Unsupported: (),
-            }
-        }
-    }
-
-    pub fn WouldBlock() -> Self {
-        Self {
-            discriminant: discriminant_IOError::WouldBlock,
-            payload: union_IOError {
-                WouldBlock: (),
+            discriminant: discriminant_ReceiveResult::Received,
+            payload: union_ReceiveResult {
+                Received: core::mem::ManuallyDrop::new(payload),
             }
         }
     }
+}
 
-    pub fn WriteZero() -> Self {
-        Self {
-            discriminant: discriminant_IOError::WriteZero,
-            payload: union_IOError {
-                WriteZero: (),
-            }
+impl Drop for ReceiveResult {
+    fn drop(&mut self) {
+        // Drop the payloads
+        match self.discriminant() {
+            discriminant_ReceiveResult::Error => {}
+            discriminant_ReceiveResult::Received => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.Received) },
         }
     }
 }
@@ -5527,6 +4789,8 @@ pub struct GlueTypes {
     pub hi: Error,
     pub tcpa: u64,
     pub tcpd: ConnectResult,
+    pub udpa: u64,
+    pub udpd: BindResult,
     pub ca: Command,
     pub cb: Output,
     pub cc: CommandErr,
@@ -5542,9 +4806,11 @@ pub struct GlueTypes {
     pub tcpe: WriteResult,
     pub tcpf: ReadResult,
     pub tcpg: ReadExactlyResult,
-    pub dir: IOError,
+    pub udpe: ReceiveResult,
     pub hb: Method,
     pub pd: InternalPathType,
+    pub udpb: BindErr,
+    pub udpc: BindErr,
 }
 
 
diff --git a/crates/roc_app/src/x86_64.rs b/crates/roc_app/src/x86_64.rs
index 7af0ae50..9d600354 100644
--- a/crates/roc_app/src/x86_64.rs
+++ b/crates/roc_app/src/x86_64.rs
@@ -14,7 +14,7 @@
 #![allow(clippy::missing_safety_doc)]
 #![allow(clippy::needless_borrow)]
 #![allow(clippy::clone_on_copy)]
-#![allow(clippy::incorrect_partial_ord_impl_on_ord_type)]
+#![allow(clippy::non_canonical_partial_ord_impl)]
 
 
 #[derive(Clone, Default, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, )]
@@ -323,7 +323,7 @@ pub union union_ReadErr {
     Unsupported: (),
 }
 
-// const _SIZE_CHECK_union_ReadErr: () = assert!(core::mem::size_of::<union_ReadErr>() == 40);
+const _SIZE_CHECK_union_ReadErr: () = assert!(core::mem::size_of::<union_ReadErr>() == 40);
 const _ALIGN_CHECK_union_ReadErr: () = assert!(core::mem::align_of::<union_ReadErr>() == 8);
 
 const _SIZE_CHECK_ReadErr: () = assert!(core::mem::size_of::<ReadErr>() == 40);
@@ -794,7 +794,7 @@ pub union union_WriteErr {
     WriteZero: (),
 }
 
-// const _SIZE_CHECK_union_WriteErr: () = assert!(core::mem::size_of::<union_WriteErr>() == 40);
+const _SIZE_CHECK_union_WriteErr: () = assert!(core::mem::size_of::<union_WriteErr>() == 40);
 const _ALIGN_CHECK_union_WriteErr: () = assert!(core::mem::align_of::<union_WriteErr>() == 8);
 
 const _SIZE_CHECK_WriteErr: () = assert!(core::mem::size_of::<WriteErr>() == 40);
@@ -1762,7 +1762,7 @@ pub union union_InternalResponse {
     Timeout: u64,
 }
 
-// const _SIZE_CHECK_union_InternalResponse: () = assert!(core::mem::size_of::<union_InternalResponse>() == 112);
+const _SIZE_CHECK_union_InternalResponse: () = assert!(core::mem::size_of::<union_InternalResponse>() == 112);
 const _ALIGN_CHECK_union_InternalResponse: () = assert!(core::mem::align_of::<union_InternalResponse>() == 8);
 
 const _SIZE_CHECK_InternalResponse: () = assert!(core::mem::size_of::<InternalResponse>() == 112);
@@ -2028,6 +2028,13 @@ impl Drop for InternalResponse {
     }
 }
 
+#[derive(Clone, Default, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, )]
+#[repr(C)]
+pub struct R1 {
+    pub body: roc_std::RocList<u8>,
+    pub code: u16,
+}
+
 #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, )]
 #[repr(u8)]
 pub enum discriminant_Error {
@@ -2054,15 +2061,15 @@ impl core::fmt::Debug for discriminant_Error {
 pub union union_Error {
     BadBody: core::mem::ManuallyDrop<roc_std::RocStr>,
     BadRequest: core::mem::ManuallyDrop<roc_std::RocStr>,
-    BadStatus: u16,
+    BadStatus: core::mem::ManuallyDrop<R1>,
     NetworkError: (),
     Timeout: u64,
 }
 
-const _SIZE_CHECK_union_Error: () = assert!(core::mem::size_of::<union_Error>() == 24);
+const _SIZE_CHECK_union_Error: () = assert!(core::mem::size_of::<union_Error>() == 32);
 const _ALIGN_CHECK_union_Error: () = assert!(core::mem::align_of::<union_Error>() == 8);
 
-const _SIZE_CHECK_Error: () = assert!(core::mem::size_of::<Error>() == 32);
+const _SIZE_CHECK_Error: () = assert!(core::mem::size_of::<Error>() == 40);
 const _ALIGN_CHECK_Error: () = assert!(core::mem::align_of::<Error>() == 8);
 
 impl Error {
@@ -2071,7 +2078,7 @@ impl Error {
         unsafe {
             let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::<Self>()]>(self);
 
-            core::mem::transmute::<u8, discriminant_Error>(*bytes.as_ptr().add(24))
+            core::mem::transmute::<u8, discriminant_Error>(*bytes.as_ptr().add(32))
         }
     }
 
@@ -2080,7 +2087,7 @@ impl Error {
         let discriminant_ptr: *mut discriminant_Error = (self as *mut Error).cast();
 
         unsafe {
-            *(discriminant_ptr.add(24)) = discriminant;
+            *(discriminant_ptr.add(32)) = discriminant;
         }
     }
 }
@@ -2137,7 +2144,7 @@ impl core::fmt::Debug for Error {
                     f.debug_tuple("Error::BadRequest").field(field).finish()
                 },
                 BadStatus => {
-                    let field: &u16 = &self.payload.BadStatus;
+                    let field: &R1 = &self.payload.BadStatus;
                     f.debug_tuple("Error::BadStatus").field(field).finish()
                 },
                 NetworkError => {
@@ -2239,9 +2246,9 @@ impl Error {
         matches!(self.discriminant, discriminant_Error::BadRequest)
     }
 
-    pub fn unwrap_BadStatus(mut self) -> u16 {
+    pub fn unwrap_BadStatus(mut self) -> R1 {
         debug_assert_eq!(self.discriminant, discriminant_Error::BadStatus);
-        unsafe { self.payload.BadStatus }
+        unsafe { core::mem::ManuallyDrop::take(&mut self.payload.BadStatus) }
     }
 
     pub fn is_BadStatus(&self) -> bool {
@@ -2284,11 +2291,11 @@ impl Error {
         }
     }
 
-    pub fn BadStatus(payload: u16) -> Self {
+    pub fn BadStatus(payload: R1) -> Self {
         Self {
             discriminant: discriminant_Error::BadStatus,
             payload: union_Error {
-                BadStatus: payload,
+                BadStatus: core::mem::ManuallyDrop::new(payload),
             }
         }
     }
@@ -2318,7 +2325,7 @@ impl Drop for Error {
         match self.discriminant() {
             discriminant_Error::BadBody => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.BadBody) },
             discriminant_Error::BadRequest => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.BadRequest) },
-            discriminant_Error::BadStatus => {}
+            discriminant_Error::BadStatus => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.BadStatus) },
             discriminant_Error::NetworkError => {}
             discriminant_Error::Timeout => {}
         }
@@ -2588,7 +2595,7 @@ pub union union_GetMetadataErr {
     Unrecognized: core::mem::ManuallyDrop<ReadErr_Unrecognized>,
 }
 
-// const _SIZE_CHECK_union_GetMetadataErr: () = assert!(core::mem::size_of::<union_GetMetadataErr>() == 40);
+const _SIZE_CHECK_union_GetMetadataErr: () = assert!(core::mem::size_of::<union_GetMetadataErr>() == 40);
 const _ALIGN_CHECK_union_GetMetadataErr: () = assert!(core::mem::align_of::<union_GetMetadataErr>() == 8);
 
 const _SIZE_CHECK_GetMetadataErr: () = assert!(core::mem::size_of::<GetMetadataErr>() == 40);
@@ -2831,7 +2838,7 @@ pub union union_ConnectErr {
     Unsupported: (),
 }
 
-// const _SIZE_CHECK_union_ConnectErr: () = assert!(core::mem::size_of::<union_ConnectErr>() == 40);
+const _SIZE_CHECK_union_ConnectErr: () = assert!(core::mem::size_of::<union_ConnectErr>() == 40);
 const _ALIGN_CHECK_union_ConnectErr: () = assert!(core::mem::align_of::<union_ConnectErr>() == 8);
 
 const _SIZE_CHECK_ConnectErr: () = assert!(core::mem::size_of::<ConnectErr>() == 40);
@@ -3191,7 +3198,7 @@ pub union union_StreamErr {
     Unrecognized: core::mem::ManuallyDrop<ReadErr_Unrecognized>,
 }
 
-// const _SIZE_CHECK_union_StreamErr: () = assert!(core::mem::size_of::<union_StreamErr>() == 40);
+const _SIZE_CHECK_union_StreamErr: () = assert!(core::mem::size_of::<union_StreamErr>() == 40);
 const _ALIGN_CHECK_union_StreamErr: () = assert!(core::mem::align_of::<union_StreamErr>() == 8);
 
 const _SIZE_CHECK_StreamErr: () = assert!(core::mem::size_of::<StreamErr>() == 40);
@@ -4336,299 +4343,98 @@ impl Drop for ReadExactlyResult {
     }
 }
 
+#[derive(Clone, Copy, Default, PartialEq, PartialOrd, Eq, Ord, Hash, )]
+#[repr(transparent)]
+pub struct BindErr ();
+
+impl BindErr {
+    /// A tag named Nope, which has no payload.
+    pub const Nope: Self = Self();
+
+    /// Other `into_` methods return a payload, but since Nope tag
+    /// has no payload, this does nothing and is only here for completeness.
+    pub fn into_Nope(self) {
+        ()
+    }
+
+    /// Other `as_` methods return a payload, but since Nope tag
+    /// has no payload, this does nothing and is only here for completeness.
+    pub fn as_Nope(&self) {
+        ()
+    }
+}
+
+impl core::fmt::Debug for BindErr {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.write_str("BindErr::Nope")
+    }
+}
+
 #[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, )]
 #[repr(u8)]
-pub enum discriminant_IOError {
-    AddrInUse = 0,
-    AddrNotAvailable = 1,
-    AlreadyExists = 2,
-    ArgumentListTooLong = 3,
-    BrokenPipe = 4,
-    ConnectionAborted = 5,
-    ConnectionRefused = 6,
-    ConnectionReset = 7,
-    CrossesDevices = 8,
-    Deadlock = 9,
-    DirectoryNotEmpty = 10,
-    ExecutableFileBusy = 11,
-    FileTooLarge = 12,
-    FilesystemLoop = 13,
-    FilesystemQuotaExceeded = 14,
-    HostUnreachable = 15,
-    Interrupted = 16,
-    InvalidData = 17,
-    InvalidFilename = 18,
-    InvalidInput = 19,
-    IsADirectory = 20,
-    NetworkDown = 21,
-    NetworkUnreachable = 22,
-    NotADirectory = 23,
-    NotConnected = 24,
-    NotFound = 25,
-    NotSeekable = 26,
-    Other = 27,
-    OutOfMemory = 28,
-    PermissionDenied = 29,
-    ReadOnlyFilesystem = 30,
-    ResourceBusy = 31,
-    StaleNetworkFileHandle = 32,
-    StorageFull = 33,
-    TimedOut = 34,
-    TooManyLinks = 35,
-    UnexpectedEof = 36,
-    Unsupported = 37,
-    WouldBlock = 38,
-    WriteZero = 39,
-}
-
-impl core::fmt::Debug for discriminant_IOError {
+pub enum discriminant_BindResult {
+    Bound = 0,
+    Error = 1,
+}
+
+impl core::fmt::Debug for discriminant_BindResult {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
-            Self::AddrInUse => f.write_str("discriminant_IOError::AddrInUse"),
-            Self::AddrNotAvailable => f.write_str("discriminant_IOError::AddrNotAvailable"),
-            Self::AlreadyExists => f.write_str("discriminant_IOError::AlreadyExists"),
-            Self::ArgumentListTooLong => f.write_str("discriminant_IOError::ArgumentListTooLong"),
-            Self::BrokenPipe => f.write_str("discriminant_IOError::BrokenPipe"),
-            Self::ConnectionAborted => f.write_str("discriminant_IOError::ConnectionAborted"),
-            Self::ConnectionRefused => f.write_str("discriminant_IOError::ConnectionRefused"),
-            Self::ConnectionReset => f.write_str("discriminant_IOError::ConnectionReset"),
-            Self::CrossesDevices => f.write_str("discriminant_IOError::CrossesDevices"),
-            Self::Deadlock => f.write_str("discriminant_IOError::Deadlock"),
-            Self::DirectoryNotEmpty => f.write_str("discriminant_IOError::DirectoryNotEmpty"),
-            Self::ExecutableFileBusy => f.write_str("discriminant_IOError::ExecutableFileBusy"),
-            Self::FileTooLarge => f.write_str("discriminant_IOError::FileTooLarge"),
-            Self::FilesystemLoop => f.write_str("discriminant_IOError::FilesystemLoop"),
-            Self::FilesystemQuotaExceeded => f.write_str("discriminant_IOError::FilesystemQuotaExceeded"),
-            Self::HostUnreachable => f.write_str("discriminant_IOError::HostUnreachable"),
-            Self::Interrupted => f.write_str("discriminant_IOError::Interrupted"),
-            Self::InvalidData => f.write_str("discriminant_IOError::InvalidData"),
-            Self::InvalidFilename => f.write_str("discriminant_IOError::InvalidFilename"),
-            Self::InvalidInput => f.write_str("discriminant_IOError::InvalidInput"),
-            Self::IsADirectory => f.write_str("discriminant_IOError::IsADirectory"),
-            Self::NetworkDown => f.write_str("discriminant_IOError::NetworkDown"),
-            Self::NetworkUnreachable => f.write_str("discriminant_IOError::NetworkUnreachable"),
-            Self::NotADirectory => f.write_str("discriminant_IOError::NotADirectory"),
-            Self::NotConnected => f.write_str("discriminant_IOError::NotConnected"),
-            Self::NotFound => f.write_str("discriminant_IOError::NotFound"),
-            Self::NotSeekable => f.write_str("discriminant_IOError::NotSeekable"),
-            Self::Other => f.write_str("discriminant_IOError::Other"),
-            Self::OutOfMemory => f.write_str("discriminant_IOError::OutOfMemory"),
-            Self::PermissionDenied => f.write_str("discriminant_IOError::PermissionDenied"),
-            Self::ReadOnlyFilesystem => f.write_str("discriminant_IOError::ReadOnlyFilesystem"),
-            Self::ResourceBusy => f.write_str("discriminant_IOError::ResourceBusy"),
-            Self::StaleNetworkFileHandle => f.write_str("discriminant_IOError::StaleNetworkFileHandle"),
-            Self::StorageFull => f.write_str("discriminant_IOError::StorageFull"),
-            Self::TimedOut => f.write_str("discriminant_IOError::TimedOut"),
-            Self::TooManyLinks => f.write_str("discriminant_IOError::TooManyLinks"),
-            Self::UnexpectedEof => f.write_str("discriminant_IOError::UnexpectedEof"),
-            Self::Unsupported => f.write_str("discriminant_IOError::Unsupported"),
-            Self::WouldBlock => f.write_str("discriminant_IOError::WouldBlock"),
-            Self::WriteZero => f.write_str("discriminant_IOError::WriteZero"),
-        }
-    }
-}
-
-#[repr(C, align(1))]
-pub union union_IOError {
-    AddrInUse: (),
-    AddrNotAvailable: (),
-    AlreadyExists: (),
-    ArgumentListTooLong: (),
-    BrokenPipe: (),
-    ConnectionAborted: (),
-    ConnectionRefused: (),
-    ConnectionReset: (),
-    CrossesDevices: (),
-    Deadlock: (),
-    DirectoryNotEmpty: (),
-    ExecutableFileBusy: (),
-    FileTooLarge: (),
-    FilesystemLoop: (),
-    FilesystemQuotaExceeded: (),
-    HostUnreachable: (),
-    Interrupted: (),
-    InvalidData: (),
-    InvalidFilename: (),
-    InvalidInput: (),
-    IsADirectory: (),
-    NetworkDown: (),
-    NetworkUnreachable: (),
-    NotADirectory: (),
-    NotConnected: (),
-    NotFound: (),
-    NotSeekable: (),
-    Other: (),
-    OutOfMemory: (),
-    PermissionDenied: (),
-    ReadOnlyFilesystem: (),
-    ResourceBusy: (),
-    StaleNetworkFileHandle: (),
-    StorageFull: (),
-    TimedOut: (),
-    TooManyLinks: (),
-    UnexpectedEof: (),
-    Unsupported: (),
-    WouldBlock: (),
-    WriteZero: (),
+            Self::Bound => f.write_str("discriminant_BindResult::Bound"),
+            Self::Error => f.write_str("discriminant_BindResult::Error"),
+        }
+    }
 }
 
-// const _SIZE_CHECK_union_IOError: () = assert!(core::mem::size_of::<union_IOError>() == 1);
-const _ALIGN_CHECK_union_IOError: () = assert!(core::mem::align_of::<union_IOError>() == 1);
+#[repr(C, align(8))]
+pub union union_BindResult {
+    Bound: u64,
+    Error: BindErr,
+}
 
-const _SIZE_CHECK_IOError: () = assert!(core::mem::size_of::<IOError>() == 1);
-const _ALIGN_CHECK_IOError: () = assert!(core::mem::align_of::<IOError>() == 1);
+const _SIZE_CHECK_union_BindResult: () = assert!(core::mem::size_of::<union_BindResult>() == 8);
+const _ALIGN_CHECK_union_BindResult: () = assert!(core::mem::align_of::<union_BindResult>() == 8);
 
-impl IOError {
+const _SIZE_CHECK_BindResult: () = assert!(core::mem::size_of::<BindResult>() == 16);
+const _ALIGN_CHECK_BindResult: () = assert!(core::mem::align_of::<BindResult>() == 8);
+
+impl BindResult {
     /// Returns which variant this tag union holds. Note that this never includes a payload!
-    pub fn discriminant(&self) -> discriminant_IOError {
+    pub fn discriminant(&self) -> discriminant_BindResult {
         unsafe {
             let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::<Self>()]>(self);
 
-            core::mem::transmute::<u8, discriminant_IOError>(*bytes.as_ptr().add(0))
+            core::mem::transmute::<u8, discriminant_BindResult>(*bytes.as_ptr().add(8))
         }
     }
 
     /// Internal helper
-    fn set_discriminant(&mut self, discriminant: discriminant_IOError) {
-        let discriminant_ptr: *mut discriminant_IOError = (self as *mut IOError).cast();
+    fn set_discriminant(&mut self, discriminant: discriminant_BindResult) {
+        let discriminant_ptr: *mut discriminant_BindResult = (self as *mut BindResult).cast();
 
         unsafe {
-            *(discriminant_ptr.add(0)) = discriminant;
+            *(discriminant_ptr.add(8)) = discriminant;
         }
     }
 }
 
 #[repr(C)]
-pub struct IOError {
-    payload: union_IOError,
-    discriminant: discriminant_IOError,
+pub struct BindResult {
+    payload: union_BindResult,
+    discriminant: discriminant_BindResult,
 }
 
-impl Clone for IOError {
+impl Clone for BindResult {
     fn clone(&self) -> Self {
-        use discriminant_IOError::*;
+        use discriminant_BindResult::*;
 
         let payload = unsafe {
             match self.discriminant {
-                AddrInUse => union_IOError {
-                    AddrInUse: self.payload.AddrInUse.clone(),
-                },
-                AddrNotAvailable => union_IOError {
-                    AddrNotAvailable: self.payload.AddrNotAvailable.clone(),
-                },
-                AlreadyExists => union_IOError {
-                    AlreadyExists: self.payload.AlreadyExists.clone(),
-                },
-                ArgumentListTooLong => union_IOError {
-                    ArgumentListTooLong: self.payload.ArgumentListTooLong.clone(),
-                },
-                BrokenPipe => union_IOError {
-                    BrokenPipe: self.payload.BrokenPipe.clone(),
-                },
-                ConnectionAborted => union_IOError {
-                    ConnectionAborted: self.payload.ConnectionAborted.clone(),
-                },
-                ConnectionRefused => union_IOError {
-                    ConnectionRefused: self.payload.ConnectionRefused.clone(),
-                },
-                ConnectionReset => union_IOError {
-                    ConnectionReset: self.payload.ConnectionReset.clone(),
-                },
-                CrossesDevices => union_IOError {
-                    CrossesDevices: self.payload.CrossesDevices.clone(),
-                },
-                Deadlock => union_IOError {
-                    Deadlock: self.payload.Deadlock.clone(),
-                },
-                DirectoryNotEmpty => union_IOError {
-                    DirectoryNotEmpty: self.payload.DirectoryNotEmpty.clone(),
-                },
-                ExecutableFileBusy => union_IOError {
-                    ExecutableFileBusy: self.payload.ExecutableFileBusy.clone(),
-                },
-                FileTooLarge => union_IOError {
-                    FileTooLarge: self.payload.FileTooLarge.clone(),
-                },
-                FilesystemLoop => union_IOError {
-                    FilesystemLoop: self.payload.FilesystemLoop.clone(),
-                },
-                FilesystemQuotaExceeded => union_IOError {
-                    FilesystemQuotaExceeded: self.payload.FilesystemQuotaExceeded.clone(),
-                },
-                HostUnreachable => union_IOError {
-                    HostUnreachable: self.payload.HostUnreachable.clone(),
-                },
-                Interrupted => union_IOError {
-                    Interrupted: self.payload.Interrupted.clone(),
-                },
-                InvalidData => union_IOError {
-                    InvalidData: self.payload.InvalidData.clone(),
-                },
-                InvalidFilename => union_IOError {
-                    InvalidFilename: self.payload.InvalidFilename.clone(),
-                },
-                InvalidInput => union_IOError {
-                    InvalidInput: self.payload.InvalidInput.clone(),
-                },
-                IsADirectory => union_IOError {
-                    IsADirectory: self.payload.IsADirectory.clone(),
-                },
-                NetworkDown => union_IOError {
-                    NetworkDown: self.payload.NetworkDown.clone(),
-                },
-                NetworkUnreachable => union_IOError {
-                    NetworkUnreachable: self.payload.NetworkUnreachable.clone(),
-                },
-                NotADirectory => union_IOError {
-                    NotADirectory: self.payload.NotADirectory.clone(),
-                },
-                NotConnected => union_IOError {
-                    NotConnected: self.payload.NotConnected.clone(),
-                },
-                NotFound => union_IOError {
-                    NotFound: self.payload.NotFound.clone(),
-                },
-                NotSeekable => union_IOError {
-                    NotSeekable: self.payload.NotSeekable.clone(),
-                },
-                Other => union_IOError {
-                    Other: self.payload.Other.clone(),
-                },
-                OutOfMemory => union_IOError {
-                    OutOfMemory: self.payload.OutOfMemory.clone(),
-                },
-                PermissionDenied => union_IOError {
-                    PermissionDenied: self.payload.PermissionDenied.clone(),
-                },
-                ReadOnlyFilesystem => union_IOError {
-                    ReadOnlyFilesystem: self.payload.ReadOnlyFilesystem.clone(),
-                },
-                ResourceBusy => union_IOError {
-                    ResourceBusy: self.payload.ResourceBusy.clone(),
-                },
-                StaleNetworkFileHandle => union_IOError {
-                    StaleNetworkFileHandle: self.payload.StaleNetworkFileHandle.clone(),
-                },
-                StorageFull => union_IOError {
-                    StorageFull: self.payload.StorageFull.clone(),
-                },
-                TimedOut => union_IOError {
-                    TimedOut: self.payload.TimedOut.clone(),
-                },
-                TooManyLinks => union_IOError {
-                    TooManyLinks: self.payload.TooManyLinks.clone(),
-                },
-                UnexpectedEof => union_IOError {
-                    UnexpectedEof: self.payload.UnexpectedEof.clone(),
-                },
-                Unsupported => union_IOError {
-                    Unsupported: self.payload.Unsupported.clone(),
-                },
-                WouldBlock => union_IOError {
-                    WouldBlock: self.payload.WouldBlock.clone(),
+                Bound => union_BindResult {
+                    Bound: self.payload.Bound.clone(),
                 },
-                WriteZero => union_IOError {
-                    WriteZero: self.payload.WriteZero.clone(),
+                Error => union_BindResult {
+                    Error: self.payload.Error.clone(),
                 },
             }
         };
@@ -4640,182 +4446,30 @@ impl Clone for IOError {
     }
 }
 
-impl core::fmt::Debug for IOError {
+impl core::fmt::Debug for BindResult {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        use discriminant_IOError::*;
+        use discriminant_BindResult::*;
 
         unsafe {
             match self.discriminant {
-                AddrInUse => {
-                    let field: &() = &self.payload.AddrInUse;
-                    f.debug_tuple("IOError::AddrInUse").field(field).finish()
-                },
-                AddrNotAvailable => {
-                    let field: &() = &self.payload.AddrNotAvailable;
-                    f.debug_tuple("IOError::AddrNotAvailable").field(field).finish()
-                },
-                AlreadyExists => {
-                    let field: &() = &self.payload.AlreadyExists;
-                    f.debug_tuple("IOError::AlreadyExists").field(field).finish()
-                },
-                ArgumentListTooLong => {
-                    let field: &() = &self.payload.ArgumentListTooLong;
-                    f.debug_tuple("IOError::ArgumentListTooLong").field(field).finish()
-                },
-                BrokenPipe => {
-                    let field: &() = &self.payload.BrokenPipe;
-                    f.debug_tuple("IOError::BrokenPipe").field(field).finish()
-                },
-                ConnectionAborted => {
-                    let field: &() = &self.payload.ConnectionAborted;
-                    f.debug_tuple("IOError::ConnectionAborted").field(field).finish()
-                },
-                ConnectionRefused => {
-                    let field: &() = &self.payload.ConnectionRefused;
-                    f.debug_tuple("IOError::ConnectionRefused").field(field).finish()
+                Bound => {
+                    let field: &u64 = &self.payload.Bound;
+                    f.debug_tuple("BindResult::Bound").field(field).finish()
                 },
-                ConnectionReset => {
-                    let field: &() = &self.payload.ConnectionReset;
-                    f.debug_tuple("IOError::ConnectionReset").field(field).finish()
-                },
-                CrossesDevices => {
-                    let field: &() = &self.payload.CrossesDevices;
-                    f.debug_tuple("IOError::CrossesDevices").field(field).finish()
-                },
-                Deadlock => {
-                    let field: &() = &self.payload.Deadlock;
-                    f.debug_tuple("IOError::Deadlock").field(field).finish()
-                },
-                DirectoryNotEmpty => {
-                    let field: &() = &self.payload.DirectoryNotEmpty;
-                    f.debug_tuple("IOError::DirectoryNotEmpty").field(field).finish()
-                },
-                ExecutableFileBusy => {
-                    let field: &() = &self.payload.ExecutableFileBusy;
-                    f.debug_tuple("IOError::ExecutableFileBusy").field(field).finish()
-                },
-                FileTooLarge => {
-                    let field: &() = &self.payload.FileTooLarge;
-                    f.debug_tuple("IOError::FileTooLarge").field(field).finish()
-                },
-                FilesystemLoop => {
-                    let field: &() = &self.payload.FilesystemLoop;
-                    f.debug_tuple("IOError::FilesystemLoop").field(field).finish()
-                },
-                FilesystemQuotaExceeded => {
-                    let field: &() = &self.payload.FilesystemQuotaExceeded;
-                    f.debug_tuple("IOError::FilesystemQuotaExceeded").field(field).finish()
-                },
-                HostUnreachable => {
-                    let field: &() = &self.payload.HostUnreachable;
-                    f.debug_tuple("IOError::HostUnreachable").field(field).finish()
-                },
-                Interrupted => {
-                    let field: &() = &self.payload.Interrupted;
-                    f.debug_tuple("IOError::Interrupted").field(field).finish()
-                },
-                InvalidData => {
-                    let field: &() = &self.payload.InvalidData;
-                    f.debug_tuple("IOError::InvalidData").field(field).finish()
-                },
-                InvalidFilename => {
-                    let field: &() = &self.payload.InvalidFilename;
-                    f.debug_tuple("IOError::InvalidFilename").field(field).finish()
-                },
-                InvalidInput => {
-                    let field: &() = &self.payload.InvalidInput;
-                    f.debug_tuple("IOError::InvalidInput").field(field).finish()
-                },
-                IsADirectory => {
-                    let field: &() = &self.payload.IsADirectory;
-                    f.debug_tuple("IOError::IsADirectory").field(field).finish()
-                },
-                NetworkDown => {
-                    let field: &() = &self.payload.NetworkDown;
-                    f.debug_tuple("IOError::NetworkDown").field(field).finish()
-                },
-                NetworkUnreachable => {
-                    let field: &() = &self.payload.NetworkUnreachable;
-                    f.debug_tuple("IOError::NetworkUnreachable").field(field).finish()
-                },
-                NotADirectory => {
-                    let field: &() = &self.payload.NotADirectory;
-                    f.debug_tuple("IOError::NotADirectory").field(field).finish()
-                },
-                NotConnected => {
-                    let field: &() = &self.payload.NotConnected;
-                    f.debug_tuple("IOError::NotConnected").field(field).finish()
-                },
-                NotFound => {
-                    let field: &() = &self.payload.NotFound;
-                    f.debug_tuple("IOError::NotFound").field(field).finish()
-                },
-                NotSeekable => {
-                    let field: &() = &self.payload.NotSeekable;
-                    f.debug_tuple("IOError::NotSeekable").field(field).finish()
-                },
-                Other => {
-                    let field: &() = &self.payload.Other;
-                    f.debug_tuple("IOError::Other").field(field).finish()
-                },
-                OutOfMemory => {
-                    let field: &() = &self.payload.OutOfMemory;
-                    f.debug_tuple("IOError::OutOfMemory").field(field).finish()
-                },
-                PermissionDenied => {
-                    let field: &() = &self.payload.PermissionDenied;
-                    f.debug_tuple("IOError::PermissionDenied").field(field).finish()
-                },
-                ReadOnlyFilesystem => {
-                    let field: &() = &self.payload.ReadOnlyFilesystem;
-                    f.debug_tuple("IOError::ReadOnlyFilesystem").field(field).finish()
-                },
-                ResourceBusy => {
-                    let field: &() = &self.payload.ResourceBusy;
-                    f.debug_tuple("IOError::ResourceBusy").field(field).finish()
-                },
-                StaleNetworkFileHandle => {
-                    let field: &() = &self.payload.StaleNetworkFileHandle;
-                    f.debug_tuple("IOError::StaleNetworkFileHandle").field(field).finish()
-                },
-                StorageFull => {
-                    let field: &() = &self.payload.StorageFull;
-                    f.debug_tuple("IOError::StorageFull").field(field).finish()
-                },
-                TimedOut => {
-                    let field: &() = &self.payload.TimedOut;
-                    f.debug_tuple("IOError::TimedOut").field(field).finish()
-                },
-                TooManyLinks => {
-                    let field: &() = &self.payload.TooManyLinks;
-                    f.debug_tuple("IOError::TooManyLinks").field(field).finish()
-                },
-                UnexpectedEof => {
-                    let field: &() = &self.payload.UnexpectedEof;
-                    f.debug_tuple("IOError::UnexpectedEof").field(field).finish()
-                },
-                Unsupported => {
-                    let field: &() = &self.payload.Unsupported;
-                    f.debug_tuple("IOError::Unsupported").field(field).finish()
-                },
-                WouldBlock => {
-                    let field: &() = &self.payload.WouldBlock;
-                    f.debug_tuple("IOError::WouldBlock").field(field).finish()
-                },
-                WriteZero => {
-                    let field: &() = &self.payload.WriteZero;
-                    f.debug_tuple("IOError::WriteZero").field(field).finish()
+                Error => {
+                    let field: &BindErr = &self.payload.Error;
+                    f.debug_tuple("BindResult::Error").field(field).finish()
                 },
             }
         }
     }
 }
 
-impl Eq for IOError {}
+impl Eq for BindResult {}
 
-impl PartialEq for IOError {
+impl PartialEq for BindResult {
     fn eq(&self, other: &Self) -> bool {
-        use discriminant_IOError::*;
+        use discriminant_BindResult::*;
 
         if self.discriminant != other.discriminant {
             return false;
@@ -4823,60 +4477,22 @@ impl PartialEq for IOError {
 
         unsafe {
             match self.discriminant {
-                AddrInUse => self.payload.AddrInUse == other.payload.AddrInUse,
-                AddrNotAvailable => self.payload.AddrNotAvailable == other.payload.AddrNotAvailable,
-                AlreadyExists => self.payload.AlreadyExists == other.payload.AlreadyExists,
-                ArgumentListTooLong => self.payload.ArgumentListTooLong == other.payload.ArgumentListTooLong,
-                BrokenPipe => self.payload.BrokenPipe == other.payload.BrokenPipe,
-                ConnectionAborted => self.payload.ConnectionAborted == other.payload.ConnectionAborted,
-                ConnectionRefused => self.payload.ConnectionRefused == other.payload.ConnectionRefused,
-                ConnectionReset => self.payload.ConnectionReset == other.payload.ConnectionReset,
-                CrossesDevices => self.payload.CrossesDevices == other.payload.CrossesDevices,
-                Deadlock => self.payload.Deadlock == other.payload.Deadlock,
-                DirectoryNotEmpty => self.payload.DirectoryNotEmpty == other.payload.DirectoryNotEmpty,
-                ExecutableFileBusy => self.payload.ExecutableFileBusy == other.payload.ExecutableFileBusy,
-                FileTooLarge => self.payload.FileTooLarge == other.payload.FileTooLarge,
-                FilesystemLoop => self.payload.FilesystemLoop == other.payload.FilesystemLoop,
-                FilesystemQuotaExceeded => self.payload.FilesystemQuotaExceeded == other.payload.FilesystemQuotaExceeded,
-                HostUnreachable => self.payload.HostUnreachable == other.payload.HostUnreachable,
-                Interrupted => self.payload.Interrupted == other.payload.Interrupted,
-                InvalidData => self.payload.InvalidData == other.payload.InvalidData,
-                InvalidFilename => self.payload.InvalidFilename == other.payload.InvalidFilename,
-                InvalidInput => self.payload.InvalidInput == other.payload.InvalidInput,
-                IsADirectory => self.payload.IsADirectory == other.payload.IsADirectory,
-                NetworkDown => self.payload.NetworkDown == other.payload.NetworkDown,
-                NetworkUnreachable => self.payload.NetworkUnreachable == other.payload.NetworkUnreachable,
-                NotADirectory => self.payload.NotADirectory == other.payload.NotADirectory,
-                NotConnected => self.payload.NotConnected == other.payload.NotConnected,
-                NotFound => self.payload.NotFound == other.payload.NotFound,
-                NotSeekable => self.payload.NotSeekable == other.payload.NotSeekable,
-                Other => self.payload.Other == other.payload.Other,
-                OutOfMemory => self.payload.OutOfMemory == other.payload.OutOfMemory,
-                PermissionDenied => self.payload.PermissionDenied == other.payload.PermissionDenied,
-                ReadOnlyFilesystem => self.payload.ReadOnlyFilesystem == other.payload.ReadOnlyFilesystem,
-                ResourceBusy => self.payload.ResourceBusy == other.payload.ResourceBusy,
-                StaleNetworkFileHandle => self.payload.StaleNetworkFileHandle == other.payload.StaleNetworkFileHandle,
-                StorageFull => self.payload.StorageFull == other.payload.StorageFull,
-                TimedOut => self.payload.TimedOut == other.payload.TimedOut,
-                TooManyLinks => self.payload.TooManyLinks == other.payload.TooManyLinks,
-                UnexpectedEof => self.payload.UnexpectedEof == other.payload.UnexpectedEof,
-                Unsupported => self.payload.Unsupported == other.payload.Unsupported,
-                WouldBlock => self.payload.WouldBlock == other.payload.WouldBlock,
-                WriteZero => self.payload.WriteZero == other.payload.WriteZero,
+                Bound => self.payload.Bound == other.payload.Bound,
+                Error => self.payload.Error == other.payload.Error,
             }
         }
     }
 }
 
-impl Ord for IOError {
+impl Ord for BindResult {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         self.partial_cmp(other).unwrap()
     }
 }
 
-impl PartialOrd for IOError {
+impl PartialOrd for BindResult {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        use discriminant_IOError::*;
+        use discriminant_BindResult::*;
 
         use std::cmp::Ordering::*;
 
@@ -4885,627 +4501,273 @@ impl PartialOrd for IOError {
             Greater => Option::Some(Greater),
             Equal => unsafe {
                 match self.discriminant {
-                    AddrInUse => self.payload.AddrInUse.partial_cmp(&other.payload.AddrInUse),
-                    AddrNotAvailable => self.payload.AddrNotAvailable.partial_cmp(&other.payload.AddrNotAvailable),
-                    AlreadyExists => self.payload.AlreadyExists.partial_cmp(&other.payload.AlreadyExists),
-                    ArgumentListTooLong => self.payload.ArgumentListTooLong.partial_cmp(&other.payload.ArgumentListTooLong),
-                    BrokenPipe => self.payload.BrokenPipe.partial_cmp(&other.payload.BrokenPipe),
-                    ConnectionAborted => self.payload.ConnectionAborted.partial_cmp(&other.payload.ConnectionAborted),
-                    ConnectionRefused => self.payload.ConnectionRefused.partial_cmp(&other.payload.ConnectionRefused),
-                    ConnectionReset => self.payload.ConnectionReset.partial_cmp(&other.payload.ConnectionReset),
-                    CrossesDevices => self.payload.CrossesDevices.partial_cmp(&other.payload.CrossesDevices),
-                    Deadlock => self.payload.Deadlock.partial_cmp(&other.payload.Deadlock),
-                    DirectoryNotEmpty => self.payload.DirectoryNotEmpty.partial_cmp(&other.payload.DirectoryNotEmpty),
-                    ExecutableFileBusy => self.payload.ExecutableFileBusy.partial_cmp(&other.payload.ExecutableFileBusy),
-                    FileTooLarge => self.payload.FileTooLarge.partial_cmp(&other.payload.FileTooLarge),
-                    FilesystemLoop => self.payload.FilesystemLoop.partial_cmp(&other.payload.FilesystemLoop),
-                    FilesystemQuotaExceeded => self.payload.FilesystemQuotaExceeded.partial_cmp(&other.payload.FilesystemQuotaExceeded),
-                    HostUnreachable => self.payload.HostUnreachable.partial_cmp(&other.payload.HostUnreachable),
-                    Interrupted => self.payload.Interrupted.partial_cmp(&other.payload.Interrupted),
-                    InvalidData => self.payload.InvalidData.partial_cmp(&other.payload.InvalidData),
-                    InvalidFilename => self.payload.InvalidFilename.partial_cmp(&other.payload.InvalidFilename),
-                    InvalidInput => self.payload.InvalidInput.partial_cmp(&other.payload.InvalidInput),
-                    IsADirectory => self.payload.IsADirectory.partial_cmp(&other.payload.IsADirectory),
-                    NetworkDown => self.payload.NetworkDown.partial_cmp(&other.payload.NetworkDown),
-                    NetworkUnreachable => self.payload.NetworkUnreachable.partial_cmp(&other.payload.NetworkUnreachable),
-                    NotADirectory => self.payload.NotADirectory.partial_cmp(&other.payload.NotADirectory),
-                    NotConnected => self.payload.NotConnected.partial_cmp(&other.payload.NotConnected),
-                    NotFound => self.payload.NotFound.partial_cmp(&other.payload.NotFound),
-                    NotSeekable => self.payload.NotSeekable.partial_cmp(&other.payload.NotSeekable),
-                    Other => self.payload.Other.partial_cmp(&other.payload.Other),
-                    OutOfMemory => self.payload.OutOfMemory.partial_cmp(&other.payload.OutOfMemory),
-                    PermissionDenied => self.payload.PermissionDenied.partial_cmp(&other.payload.PermissionDenied),
-                    ReadOnlyFilesystem => self.payload.ReadOnlyFilesystem.partial_cmp(&other.payload.ReadOnlyFilesystem),
-                    ResourceBusy => self.payload.ResourceBusy.partial_cmp(&other.payload.ResourceBusy),
-                    StaleNetworkFileHandle => self.payload.StaleNetworkFileHandle.partial_cmp(&other.payload.StaleNetworkFileHandle),
-                    StorageFull => self.payload.StorageFull.partial_cmp(&other.payload.StorageFull),
-                    TimedOut => self.payload.TimedOut.partial_cmp(&other.payload.TimedOut),
-                    TooManyLinks => self.payload.TooManyLinks.partial_cmp(&other.payload.TooManyLinks),
-                    UnexpectedEof => self.payload.UnexpectedEof.partial_cmp(&other.payload.UnexpectedEof),
-                    Unsupported => self.payload.Unsupported.partial_cmp(&other.payload.Unsupported),
-                    WouldBlock => self.payload.WouldBlock.partial_cmp(&other.payload.WouldBlock),
-                    WriteZero => self.payload.WriteZero.partial_cmp(&other.payload.WriteZero),
+                    Bound => self.payload.Bound.partial_cmp(&other.payload.Bound),
+                    Error => self.payload.Error.partial_cmp(&other.payload.Error),
                 }
             },
         }
     }
 }
 
-impl core::hash::Hash for IOError {
+impl core::hash::Hash for BindResult {
     fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
-        use discriminant_IOError::*;
+        use discriminant_BindResult::*;
 
         unsafe {
             match self.discriminant {
-                AddrInUse => self.payload.AddrInUse.hash(state),
-                AddrNotAvailable => self.payload.AddrNotAvailable.hash(state),
-                AlreadyExists => self.payload.AlreadyExists.hash(state),
-                ArgumentListTooLong => self.payload.ArgumentListTooLong.hash(state),
-                BrokenPipe => self.payload.BrokenPipe.hash(state),
-                ConnectionAborted => self.payload.ConnectionAborted.hash(state),
-                ConnectionRefused => self.payload.ConnectionRefused.hash(state),
-                ConnectionReset => self.payload.ConnectionReset.hash(state),
-                CrossesDevices => self.payload.CrossesDevices.hash(state),
-                Deadlock => self.payload.Deadlock.hash(state),
-                DirectoryNotEmpty => self.payload.DirectoryNotEmpty.hash(state),
-                ExecutableFileBusy => self.payload.ExecutableFileBusy.hash(state),
-                FileTooLarge => self.payload.FileTooLarge.hash(state),
-                FilesystemLoop => self.payload.FilesystemLoop.hash(state),
-                FilesystemQuotaExceeded => self.payload.FilesystemQuotaExceeded.hash(state),
-                HostUnreachable => self.payload.HostUnreachable.hash(state),
-                Interrupted => self.payload.Interrupted.hash(state),
-                InvalidData => self.payload.InvalidData.hash(state),
-                InvalidFilename => self.payload.InvalidFilename.hash(state),
-                InvalidInput => self.payload.InvalidInput.hash(state),
-                IsADirectory => self.payload.IsADirectory.hash(state),
-                NetworkDown => self.payload.NetworkDown.hash(state),
-                NetworkUnreachable => self.payload.NetworkUnreachable.hash(state),
-                NotADirectory => self.payload.NotADirectory.hash(state),
-                NotConnected => self.payload.NotConnected.hash(state),
-                NotFound => self.payload.NotFound.hash(state),
-                NotSeekable => self.payload.NotSeekable.hash(state),
-                Other => self.payload.Other.hash(state),
-                OutOfMemory => self.payload.OutOfMemory.hash(state),
-                PermissionDenied => self.payload.PermissionDenied.hash(state),
-                ReadOnlyFilesystem => self.payload.ReadOnlyFilesystem.hash(state),
-                ResourceBusy => self.payload.ResourceBusy.hash(state),
-                StaleNetworkFileHandle => self.payload.StaleNetworkFileHandle.hash(state),
-                StorageFull => self.payload.StorageFull.hash(state),
-                TimedOut => self.payload.TimedOut.hash(state),
-                TooManyLinks => self.payload.TooManyLinks.hash(state),
-                UnexpectedEof => self.payload.UnexpectedEof.hash(state),
-                Unsupported => self.payload.Unsupported.hash(state),
-                WouldBlock => self.payload.WouldBlock.hash(state),
-                WriteZero => self.payload.WriteZero.hash(state),
+                Bound => self.payload.Bound.hash(state),
+                Error => self.payload.Error.hash(state),
             }
         }
     }
 }
 
-impl IOError {
-
-    pub fn is_AddrInUse(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::AddrInUse)
-    }
-
-    pub fn is_AddrNotAvailable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::AddrNotAvailable)
-    }
-
-    pub fn is_AlreadyExists(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::AlreadyExists)
-    }
-
-    pub fn is_ArgumentListTooLong(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ArgumentListTooLong)
-    }
-
-    pub fn is_BrokenPipe(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::BrokenPipe)
-    }
-
-    pub fn is_ConnectionAborted(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ConnectionAborted)
-    }
-
-    pub fn is_ConnectionRefused(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ConnectionRefused)
-    }
-
-    pub fn is_ConnectionReset(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ConnectionReset)
-    }
-
-    pub fn is_CrossesDevices(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::CrossesDevices)
-    }
-
-    pub fn is_Deadlock(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Deadlock)
-    }
-
-    pub fn is_DirectoryNotEmpty(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::DirectoryNotEmpty)
-    }
-
-    pub fn is_ExecutableFileBusy(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ExecutableFileBusy)
-    }
-
-    pub fn is_FileTooLarge(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::FileTooLarge)
-    }
-
-    pub fn is_FilesystemLoop(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::FilesystemLoop)
-    }
-
-    pub fn is_FilesystemQuotaExceeded(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::FilesystemQuotaExceeded)
-    }
-
-    pub fn is_HostUnreachable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::HostUnreachable)
-    }
-
-    pub fn is_Interrupted(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Interrupted)
-    }
-
-    pub fn is_InvalidData(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::InvalidData)
-    }
-
-    pub fn is_InvalidFilename(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::InvalidFilename)
-    }
-
-    pub fn is_InvalidInput(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::InvalidInput)
-    }
-
-    pub fn is_IsADirectory(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::IsADirectory)
-    }
-
-    pub fn is_NetworkDown(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NetworkDown)
-    }
-
-    pub fn is_NetworkUnreachable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NetworkUnreachable)
-    }
-
-    pub fn is_NotADirectory(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotADirectory)
-    }
-
-    pub fn is_NotConnected(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotConnected)
-    }
-
-    pub fn is_NotFound(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotFound)
-    }
-
-    pub fn is_NotSeekable(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::NotSeekable)
-    }
-
-    pub fn is_Other(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Other)
-    }
-
-    pub fn is_OutOfMemory(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::OutOfMemory)
-    }
-
-    pub fn is_PermissionDenied(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::PermissionDenied)
-    }
-
-    pub fn is_ReadOnlyFilesystem(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ReadOnlyFilesystem)
-    }
-
-    pub fn is_ResourceBusy(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::ResourceBusy)
-    }
+impl BindResult {
 
-    pub fn is_StaleNetworkFileHandle(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::StaleNetworkFileHandle)
+    pub fn unwrap_Bound(mut self) -> u64 {
+        debug_assert_eq!(self.discriminant, discriminant_BindResult::Bound);
+        unsafe { self.payload.Bound }
     }
 
-    pub fn is_StorageFull(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::StorageFull)
+    pub fn is_Bound(&self) -> bool {
+        matches!(self.discriminant, discriminant_BindResult::Bound)
     }
 
-    pub fn is_TimedOut(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::TimedOut)
+    pub fn unwrap_Error(mut self) -> BindErr {
+        debug_assert_eq!(self.discriminant, discriminant_BindResult::Error);
+        unsafe { self.payload.Error }
     }
 
-    pub fn is_TooManyLinks(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::TooManyLinks)
-    }
-
-    pub fn is_UnexpectedEof(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::UnexpectedEof)
-    }
-
-    pub fn is_Unsupported(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::Unsupported)
-    }
-
-    pub fn is_WouldBlock(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::WouldBlock)
-    }
-
-    pub fn is_WriteZero(&self) -> bool {
-        matches!(self.discriminant, discriminant_IOError::WriteZero)
+    pub fn is_Error(&self) -> bool {
+        matches!(self.discriminant, discriminant_BindResult::Error)
     }
 }
 
 
 
-impl IOError {
+impl BindResult {
 
-    pub fn AddrInUse() -> Self {
+    pub fn Bound(payload: u64) -> Self {
         Self {
-            discriminant: discriminant_IOError::AddrInUse,
-            payload: union_IOError {
-                AddrInUse: (),
+            discriminant: discriminant_BindResult::Bound,
+            payload: union_BindResult {
+                Bound: payload,
             }
         }
     }
 
-    pub fn AddrNotAvailable() -> Self {
+    pub fn Error(payload: BindErr) -> Self {
         Self {
-            discriminant: discriminant_IOError::AddrNotAvailable,
-            payload: union_IOError {
-                AddrNotAvailable: (),
-            }
-        }
-    }
-
-    pub fn AlreadyExists() -> Self {
-        Self {
-            discriminant: discriminant_IOError::AlreadyExists,
-            payload: union_IOError {
-                AlreadyExists: (),
-            }
-        }
-    }
-
-    pub fn ArgumentListTooLong() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ArgumentListTooLong,
-            payload: union_IOError {
-                ArgumentListTooLong: (),
+            discriminant: discriminant_BindResult::Error,
+            payload: union_BindResult {
+                Error: payload,
             }
         }
     }
+}
 
-    pub fn BrokenPipe() -> Self {
-        Self {
-            discriminant: discriminant_IOError::BrokenPipe,
-            payload: union_IOError {
-                BrokenPipe: (),
-            }
-        }
-    }
+#[derive(Clone, Copy, PartialEq, PartialOrd, Eq, Ord, Hash, )]
+#[repr(u8)]
+pub enum discriminant_ReceiveResult {
+    Error = 0,
+    Received = 1,
+}
 
-    pub fn ConnectionAborted() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ConnectionAborted,
-            payload: union_IOError {
-                ConnectionAborted: (),
-            }
+impl core::fmt::Debug for discriminant_ReceiveResult {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        match self {
+            Self::Error => f.write_str("discriminant_ReceiveResult::Error"),
+            Self::Received => f.write_str("discriminant_ReceiveResult::Received"),
         }
     }
+}
 
-    pub fn ConnectionRefused() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ConnectionRefused,
-            payload: union_IOError {
-                ConnectionRefused: (),
-            }
-        }
-    }
+#[repr(C, align(8))]
+pub union union_ReceiveResult {
+    Error: BindErr,
+    Received: core::mem::ManuallyDrop<roc_std::RocList<u8>>,
+}
 
-    pub fn ConnectionReset() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ConnectionReset,
-            payload: union_IOError {
-                ConnectionReset: (),
-            }
-        }
-    }
+const _SIZE_CHECK_union_ReceiveResult: () = assert!(core::mem::size_of::<union_ReceiveResult>() == 24);
+const _ALIGN_CHECK_union_ReceiveResult: () = assert!(core::mem::align_of::<union_ReceiveResult>() == 8);
 
-    pub fn CrossesDevices() -> Self {
-        Self {
-            discriminant: discriminant_IOError::CrossesDevices,
-            payload: union_IOError {
-                CrossesDevices: (),
-            }
-        }
-    }
+const _SIZE_CHECK_ReceiveResult: () = assert!(core::mem::size_of::<ReceiveResult>() == 32);
+const _ALIGN_CHECK_ReceiveResult: () = assert!(core::mem::align_of::<ReceiveResult>() == 8);
 
-    pub fn Deadlock() -> Self {
-        Self {
-            discriminant: discriminant_IOError::Deadlock,
-            payload: union_IOError {
-                Deadlock: (),
-            }
-        }
-    }
+impl ReceiveResult {
+    /// Returns which variant this tag union holds. Note that this never includes a payload!
+    pub fn discriminant(&self) -> discriminant_ReceiveResult {
+        unsafe {
+            let bytes = core::mem::transmute::<&Self, &[u8; core::mem::size_of::<Self>()]>(self);
 
-    pub fn DirectoryNotEmpty() -> Self {
-        Self {
-            discriminant: discriminant_IOError::DirectoryNotEmpty,
-            payload: union_IOError {
-                DirectoryNotEmpty: (),
-            }
+            core::mem::transmute::<u8, discriminant_ReceiveResult>(*bytes.as_ptr().add(24))
         }
     }
 
-    pub fn ExecutableFileBusy() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ExecutableFileBusy,
-            payload: union_IOError {
-                ExecutableFileBusy: (),
-            }
-        }
-    }
+    /// Internal helper
+    fn set_discriminant(&mut self, discriminant: discriminant_ReceiveResult) {
+        let discriminant_ptr: *mut discriminant_ReceiveResult = (self as *mut ReceiveResult).cast();
 
-    pub fn FileTooLarge() -> Self {
-        Self {
-            discriminant: discriminant_IOError::FileTooLarge,
-            payload: union_IOError {
-                FileTooLarge: (),
-            }
+        unsafe {
+            *(discriminant_ptr.add(24)) = discriminant;
         }
     }
+}
 
-    pub fn FilesystemLoop() -> Self {
-        Self {
-            discriminant: discriminant_IOError::FilesystemLoop,
-            payload: union_IOError {
-                FilesystemLoop: (),
-            }
-        }
-    }
+#[repr(C)]
+pub struct ReceiveResult {
+    payload: union_ReceiveResult,
+    discriminant: discriminant_ReceiveResult,
+}
 
-    pub fn FilesystemQuotaExceeded() -> Self {
-        Self {
-            discriminant: discriminant_IOError::FilesystemQuotaExceeded,
-            payload: union_IOError {
-                FilesystemQuotaExceeded: (),
-            }
-        }
-    }
+impl Clone for ReceiveResult {
+    fn clone(&self) -> Self {
+        use discriminant_ReceiveResult::*;
 
-    pub fn HostUnreachable() -> Self {
-        Self {
-            discriminant: discriminant_IOError::HostUnreachable,
-            payload: union_IOError {
-                HostUnreachable: (),
+        let payload = unsafe {
+            match self.discriminant {
+                Error => union_ReceiveResult {
+                    Error: self.payload.Error.clone(),
+                },
+                Received => union_ReceiveResult {
+                    Received: self.payload.Received.clone(),
+                },
             }
-        }
-    }
+        };
 
-    pub fn Interrupted() -> Self {
         Self {
-            discriminant: discriminant_IOError::Interrupted,
-            payload: union_IOError {
-                Interrupted: (),
-            }
+            discriminant: self.discriminant,
+            payload,
         }
     }
+}
 
-    pub fn InvalidData() -> Self {
-        Self {
-            discriminant: discriminant_IOError::InvalidData,
-            payload: union_IOError {
-                InvalidData: (),
-            }
-        }
-    }
+impl core::fmt::Debug for ReceiveResult {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        use discriminant_ReceiveResult::*;
 
-    pub fn InvalidFilename() -> Self {
-        Self {
-            discriminant: discriminant_IOError::InvalidFilename,
-            payload: union_IOError {
-                InvalidFilename: (),
+        unsafe {
+            match self.discriminant {
+                Error => {
+                    let field: &BindErr = &self.payload.Error;
+                    f.debug_tuple("ReceiveResult::Error").field(field).finish()
+                },
+                Received => {
+                    let field: &roc_std::RocList<u8> = &self.payload.Received;
+                    f.debug_tuple("ReceiveResult::Received").field(field).finish()
+                },
             }
         }
     }
+}
 
-    pub fn InvalidInput() -> Self {
-        Self {
-            discriminant: discriminant_IOError::InvalidInput,
-            payload: union_IOError {
-                InvalidInput: (),
-            }
-        }
-    }
+impl Eq for ReceiveResult {}
 
-    pub fn IsADirectory() -> Self {
-        Self {
-            discriminant: discriminant_IOError::IsADirectory,
-            payload: union_IOError {
-                IsADirectory: (),
-            }
-        }
-    }
+impl PartialEq for ReceiveResult {
+    fn eq(&self, other: &Self) -> bool {
+        use discriminant_ReceiveResult::*;
 
-    pub fn NetworkDown() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NetworkDown,
-            payload: union_IOError {
-                NetworkDown: (),
-            }
+        if self.discriminant != other.discriminant {
+            return false;
         }
-    }
 
-    pub fn NetworkUnreachable() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NetworkUnreachable,
-            payload: union_IOError {
-                NetworkUnreachable: (),
+        unsafe {
+            match self.discriminant {
+                Error => self.payload.Error == other.payload.Error,
+                Received => self.payload.Received == other.payload.Received,
             }
         }
     }
+}
 
-    pub fn NotADirectory() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotADirectory,
-            payload: union_IOError {
-                NotADirectory: (),
-            }
-        }
+impl Ord for ReceiveResult {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.partial_cmp(other).unwrap()
     }
+}
 
-    pub fn NotConnected() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotConnected,
-            payload: union_IOError {
-                NotConnected: (),
-            }
-        }
-    }
+impl PartialOrd for ReceiveResult {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        use discriminant_ReceiveResult::*;
 
-    pub fn NotFound() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotFound,
-            payload: union_IOError {
-                NotFound: (),
-            }
-        }
-    }
+        use std::cmp::Ordering::*;
 
-    pub fn NotSeekable() -> Self {
-        Self {
-            discriminant: discriminant_IOError::NotSeekable,
-            payload: union_IOError {
-                NotSeekable: (),
-            }
+        match self.discriminant.cmp(&other.discriminant) {
+            Less => Option::Some(Less),
+            Greater => Option::Some(Greater),
+            Equal => unsafe {
+                match self.discriminant {
+                    Error => self.payload.Error.partial_cmp(&other.payload.Error),
+                    Received => self.payload.Received.partial_cmp(&other.payload.Received),
+                }
+            },
         }
     }
+}
 
-    pub fn Other() -> Self {
-        Self {
-            discriminant: discriminant_IOError::Other,
-            payload: union_IOError {
-                Other: (),
-            }
-        }
-    }
+impl core::hash::Hash for ReceiveResult {
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        use discriminant_ReceiveResult::*;
 
-    pub fn OutOfMemory() -> Self {
-        Self {
-            discriminant: discriminant_IOError::OutOfMemory,
-            payload: union_IOError {
-                OutOfMemory: (),
+        unsafe {
+            match self.discriminant {
+                Error => self.payload.Error.hash(state),
+                Received => self.payload.Received.hash(state),
             }
         }
     }
+}
 
-    pub fn PermissionDenied() -> Self {
-        Self {
-            discriminant: discriminant_IOError::PermissionDenied,
-            payload: union_IOError {
-                PermissionDenied: (),
-            }
-        }
-    }
+impl ReceiveResult {
 
-    pub fn ReadOnlyFilesystem() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ReadOnlyFilesystem,
-            payload: union_IOError {
-                ReadOnlyFilesystem: (),
-            }
-        }
+    pub fn unwrap_Error(mut self) -> BindErr {
+        debug_assert_eq!(self.discriminant, discriminant_ReceiveResult::Error);
+        unsafe { self.payload.Error }
     }
 
-    pub fn ResourceBusy() -> Self {
-        Self {
-            discriminant: discriminant_IOError::ResourceBusy,
-            payload: union_IOError {
-                ResourceBusy: (),
-            }
-        }
+    pub fn is_Error(&self) -> bool {
+        matches!(self.discriminant, discriminant_ReceiveResult::Error)
     }
 
-    pub fn StaleNetworkFileHandle() -> Self {
-        Self {
-            discriminant: discriminant_IOError::StaleNetworkFileHandle,
-            payload: union_IOError {
-                StaleNetworkFileHandle: (),
-            }
-        }
+    pub fn unwrap_Received(mut self) -> roc_std::RocList<u8> {
+        debug_assert_eq!(self.discriminant, discriminant_ReceiveResult::Received);
+        unsafe { core::mem::ManuallyDrop::take(&mut self.payload.Received) }
     }
 
-    pub fn StorageFull() -> Self {
-        Self {
-            discriminant: discriminant_IOError::StorageFull,
-            payload: union_IOError {
-                StorageFull: (),
-            }
-        }
+    pub fn is_Received(&self) -> bool {
+        matches!(self.discriminant, discriminant_ReceiveResult::Received)
     }
+}
 
-    pub fn TimedOut() -> Self {
-        Self {
-            discriminant: discriminant_IOError::TimedOut,
-            payload: union_IOError {
-                TimedOut: (),
-            }
-        }
-    }
 
-    pub fn TooManyLinks() -> Self {
-        Self {
-            discriminant: discriminant_IOError::TooManyLinks,
-            payload: union_IOError {
-                TooManyLinks: (),
-            }
-        }
-    }
 
-    pub fn UnexpectedEof() -> Self {
-        Self {
-            discriminant: discriminant_IOError::UnexpectedEof,
-            payload: union_IOError {
-                UnexpectedEof: (),
-            }
-        }
-    }
+impl ReceiveResult {
 
-    pub fn Unsupported() -> Self {
+    pub fn Error(payload: BindErr) -> Self {
         Self {
-            discriminant: discriminant_IOError::Unsupported,
-            payload: union_IOError {
-                Unsupported: (),
+            discriminant: discriminant_ReceiveResult::Error,
+            payload: union_ReceiveResult {
+                Error: payload,
             }
         }
     }
 
-    pub fn WouldBlock() -> Self {
+    pub fn Received(payload: roc_std::RocList<u8>) -> Self {
         Self {
-            discriminant: discriminant_IOError::WouldBlock,
-            payload: union_IOError {
-                WouldBlock: (),
+            discriminant: discriminant_ReceiveResult::Received,
+            payload: union_ReceiveResult {
+                Received: core::mem::ManuallyDrop::new(payload),
             }
         }
     }
+}
 
-    pub fn WriteZero() -> Self {
-        Self {
-            discriminant: discriminant_IOError::WriteZero,
-            payload: union_IOError {
-                WriteZero: (),
-            }
+impl Drop for ReceiveResult {
+    fn drop(&mut self) {
+        // Drop the payloads
+        match self.discriminant() {
+            discriminant_ReceiveResult::Error => {}
+            discriminant_ReceiveResult::Received => unsafe { core::mem::ManuallyDrop::drop(&mut self.payload.Received) },
         }
     }
 }
@@ -5542,9 +4804,13 @@ pub struct GlueTypes {
     pub tcpe: WriteResult,
     pub tcpf: ReadResult,
     pub tcpg: ReadExactlyResult,
-    pub dir: IOError,
+    pub udpa: u64,
+    pub udpd: BindResult,
+    pub udpe: ReceiveResult,
     pub hb: Method,
     pub pd: InternalPathType,
+    pub udpb: BindErr,
+    pub udpc: BindErr,
 }
 
 
diff --git a/crates/roc_std/src/lib.rs b/crates/roc_std/src/lib.rs
index 677c4f63..30cdcdbb 100644
--- a/crates/roc_std/src/lib.rs
+++ b/crates/roc_std/src/lib.rs
@@ -377,10 +377,6 @@ impl RocDec {
         }
     }
 
-    pub fn from_str_to_i128_unsafe(val: &str) -> i128 {
-        Self::from_str(val).unwrap().as_i128()
-    }
-
     /// This is private because RocDec being an i128 is an implementation detail
     #[inline(always)]
     fn as_i128(&self) -> i128 {
diff --git a/crates/roc_std/src/roc_dict.rs b/crates/roc_std/src/roc_dict.rs
index 918c9558..e46c3a45 100644
--- a/crates/roc_std/src/roc_dict.rs
+++ b/crates/roc_std/src/roc_dict.rs
@@ -108,9 +108,7 @@ impl<K: Debug, V: Debug> Debug for RocDict<K, V> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("RocDict ")?;
 
-        f.debug_map()
-            .entries(self.iter().map(|(k, v)| (k, v)))
-            .finish()
+        f.debug_map().entries(self.iter()).finish()
     }
 }
 
diff --git a/examples/udp-server.roc b/examples/udp-server.roc
new file mode 100644
index 00000000..88d1f9d1
--- /dev/null
+++ b/examples/udp-server.roc
@@ -0,0 +1,28 @@
+app "udp-client"
+    packages { pf: platform "../platform/main.roc" }
+    imports [pf.Udp, pf.Task.{ Task, await }, pf.Stdout, pf.Stderr]
+    provides [main] to pf
+
+main = run |> Task.onErr handleErr
+
+handleErr = \_error ->
+    Stderr.line "butt"
+
+run =
+    Stdout.line! "Starting Connection"
+    socket = Udp.bind! "127.0.0.1" 8085
+    Stdout.line! "Connected!"
+
+    # Not yet in lib.rs
+    # Task.loop {} \_ -> Task.map (tick socket) Step
+
+
+getString = \bytes ->
+    Str.fromUtf8 bytes |> Task.fromResult!
+
+tick = \socket ->
+    inBytes = Udp.receiveUpTo! 64 socket
+
+    inMsg = getString inBytes!
+
+    Stdout.line "> $(inMsg)"
diff --git a/platform/Effect.roc b/platform/Effect.roc
index 880e4fbf..7deb51df 100644
--- a/platform/Effect.roc
+++ b/platform/Effect.roc
@@ -38,6 +38,8 @@ hosted Effect
         tcpReadExactly,
         tcpReadUntil,
         tcpWrite,
+        udpBind,
+        udpReceiveUpTo,
         sleepMillis,
         commandStatus,
         commandOutput,
@@ -46,6 +48,7 @@ hosted Effect
         InternalHttp.{ Request, InternalResponse },
         InternalFile,
         InternalTcp,
+        InternalUdp,
         InternalCommand,
         InternalPath,
     ]
@@ -85,6 +88,10 @@ tcpReadExactly : U64, InternalTcp.Stream -> Effect InternalTcp.ReadExactlyResult
 tcpReadUntil : U8, InternalTcp.Stream -> Effect InternalTcp.ReadResult
 tcpWrite : List U8, InternalTcp.Stream -> Effect InternalTcp.WriteResult
 
+udpBind : Str, U16 -> Effect InternalUdp.BindResult
+udpReceiveUpTo : U64, InternalUdp.Socket -> Effect InternalUdp.ReceiveResult
+
+
 pathType : List U8 -> Effect (Result InternalPath.InternalPathType InternalPath.GetMetadataErr)
 
 posixTime : Effect U128
diff --git a/platform/InternalUdp.roc b/platform/InternalUdp.roc
new file mode 100644
index 00000000..f603b8f7
--- /dev/null
+++ b/platform/InternalUdp.roc
@@ -0,0 +1,47 @@
+module [
+    Socket,
+    SocketErr,
+    BindErr,
+    BindResult,
+    ReceiveResult,
+    fromBindResult,
+    fromReceiveResult,
+]
+
+Socket := U64
+
+SocketErr : [
+    Nope,
+]
+
+BindErr : [
+    Nope,
+]
+
+BindResult : [
+    Bound Socket,
+    Error BindErr,
+]
+
+fromBindResult : BindResult -> Result Socket BindErr
+fromBindResult = \result ->
+    when result is
+        Bound socket ->
+            Ok socket
+
+        Error err ->
+            Err err
+
+ReceiveResult : [
+    Received (List U8),
+    Error SocketErr,
+]
+
+fromReceiveResult : ReceiveResult -> Result (List U8) SocketErr
+fromReceiveResult = \result ->
+    when result is
+        Received bytes ->
+            Ok bytes
+
+        Error err ->
+            Err err
diff --git a/platform/Udp.roc b/platform/Udp.roc
new file mode 100644
index 00000000..6133c7d2
--- /dev/null
+++ b/platform/Udp.roc
@@ -0,0 +1,32 @@
+module [
+    Socket,
+    BindErr,
+    SocketErr,
+    bind,
+    receiveUpTo,
+]
+
+import Effect
+import Task exposing [Task]
+import InternalTask
+import InternalUdp
+
+Socket : InternalUdp.Socket
+
+BindErr : InternalUdp.BindErr
+
+SocketErr : InternalUdp.SocketErr
+
+bind : Str, U16 -> Task Socket [Something BindErr]
+bind = \host, port ->
+    Effect.udpBind host port
+    |> Effect.map InternalUdp.fromBindResult
+    |> InternalTask.fromEffect
+    |> Task.mapErr Something
+
+receiveUpTo : U64, Socket -> Task (List U8) [UdpReceiveErr SocketErr]
+receiveUpTo = \bytesToRead, socket ->
+    Effect.udpReceiveUpTo bytesToRead socket
+      |> Effect.map InternalUdp.fromReceiveResult
+      |> InternalTask.fromEffect
+      |> Task.mapErr UdpReceiveErr
diff --git a/platform/main-glue.roc b/platform/main-glue.roc
index af472d6d..798066f9 100644
--- a/platform/main-glue.roc
+++ b/platform/main-glue.roc
@@ -8,6 +8,7 @@ platform "glue"
         InternalFile,
         InternalPath,
         InternalTcp,
+        InternalUdp,
     ]
     provides [mainForHost]
 
@@ -35,6 +36,11 @@ GlueTypes : {
     tcpe : InternalTcp.WriteResult,
     tcpf : InternalTcp.ReadResult,
     tcpg : InternalTcp.ReadExactlyResult,
+    udpa : InternalUdp.Socket,
+    udpb : InternalUdp.SocketErr,
+    udpc : InternalUdp.BindErr,
+    udpd : InternalUdp.BindResult,
+    udpe : InternalUdp.ReceiveResult,
 }
 
 mainForHost : GlueTypes
diff --git a/platform/main.roc b/platform/main.roc
index 7f3b8d47..dabcf8b6 100644
--- a/platform/main.roc
+++ b/platform/main.roc
@@ -13,6 +13,7 @@ platform "cli"
         Stdout,
         Task,
         Tcp,
+        Udp,
         Url,
         Utc,
         Sleep,
diff --git a/platform/src/lib.rs b/platform/src/lib.rs
index 7394be2d..67a12444 100644
--- a/platform/src/lib.rs
+++ b/platform/src/lib.rs
@@ -9,6 +9,7 @@ use std::ffi::OsStr;
 use std::fs::File;
 use std::io::{BufRead, BufReader, ErrorKind, Read, Write};
 use std::net::TcpStream;
+use std::net::UdpSocket;
 use std::path::Path;
 use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
@@ -941,6 +942,22 @@ fn to_tcp_stream_err(err: std::io::Error) -> roc_app::StreamErr {
     }
 }
 
+#[no_mangle]
+pub extern "C" fn roc_fx_udpBind(host: &RocStr, port: u16) -> roc_app::BindResult {
+    match UdpSocket::bind((host.as_str(), port)) {
+        Ok(socket) => {
+            let ptr = Box::into_raw(Box::new(socket)) as u64;
+
+            roc_app::BindResult::Bound(ptr)
+        }
+        Err(err) => roc_app::BindResult::Error(to_udp_bind_err(err)),
+    }
+}
+
+fn to_udp_bind_err(err: std::io::Error) -> roc_app::BindErr {
+    roc_app::BindErr::Nope()
+}
+
 #[no_mangle]
 pub extern "C" fn roc_fx_commandStatus(
     roc_cmd: &roc_app::Command,