Change the name of ``LibCtruError`` to ``LibCtruResult``

Not everything wrapped in this struct is an error

ctru-rs/src/error.rs

@@ -9,9 +9,9 @@ pub type Result<T> = ::std::result::Result<T, Error>;
 
 #[derive(Debug, Clone, PartialEq, PartialOrd)]
 #[repr(transparent)]
-pub(crate) struct LibCtruError(pub i32);
+pub(crate) struct LibCtruResult(pub i32);
 
-impl Try for LibCtruError {
+impl Try for LibCtruResult {
     type Output = ();
     type Residual = crate::Result<core::convert::Infallible>;
 
@@ -28,7 +28,7 @@ impl Try for LibCtruError {
     }
 }
 
-impl FromResidual for LibCtruError {
+impl FromResidual for LibCtruResult {
     fn from_residual(e: <Self as Try>::Residual) -> Self {
         if let Some(e) = e.err() {
             match e {
@@ -74,8 +74,8 @@ impl From<ctru_sys::Result> for Error {
     }
 }
 
-impl From<LibCtruError> for Error {
-    fn from(err: LibCtruError) -> Self {
+impl From<LibCtruResult> for Error {
+    fn from(err: LibCtruResult) -> Self {
         Self::Os(err.0)
     }
 }

ctru-rs/src/romfs.rs

@@ -10,7 +10,7 @@
 //! romfs_dir = "romfs"
 //! ```
 
-use crate::error::LibCtruError;
+use crate::error::LibCtruResult;
 use once_cell::sync::Lazy;
 use std::ffi::CStr;
 use std::sync::Mutex;
@@ -31,7 +31,7 @@ impl RomFS {
             true,
             || {
                 let mount_name = CStr::from_bytes_with_nul(b"romfs\0").unwrap();
-                LibCtruError(unsafe { ctru_sys::romfsMountSelf(mount_name.as_ptr()) })?;
+                LibCtruResult(unsafe { ctru_sys::romfsMountSelf(mount_name.as_ptr()) })?;
                 Ok(())
             },
             || {

ctru-rs/src/services/apt.rs

@@ -1,11 +1,11 @@
-use crate::error::LibCtruError;
+use crate::error::LibCtruResult;
 
 pub struct Apt(());
 
 impl Apt {
     pub fn init() -> crate::Result<Apt> {
         unsafe {
-            LibCtruError(ctru_sys::aptInit())?;
+            LibCtruResult(ctru_sys::aptInit())?;
             Ok(Apt(()))
         }
     }
@@ -16,7 +16,7 @@ impl Apt {
 
     pub fn set_app_cpu_time_limit(&self, percent: u32) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::APT_SetAppCpuTimeLimit(percent))?;
+            LibCtruResult(ctru_sys::APT_SetAppCpuTimeLimit(percent))?;
             Ok(())
         }
     }

ctru-rs/src/services/cam.rs

@@ -3,7 +3,7 @@
 //! The CAM service provides access to the cameras. Cameras can return 2D images
 //! in the form of byte vectors which can be used for display or other usages.
 
-use crate::error::LibCtruError;
+use crate::error::LibCtruResult;
 use crate::services::gspgpu::FramebufferFormat;
 use bitflags::bitflags;
 use ctru_sys::Handle;
@@ -268,7 +268,7 @@ impl BothOutwardCam {
         brightness_synchronization: bool,
     ) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetBrightnessSynchronization(
+            LibCtruResult(ctru_sys::CAMU_SetBrightnessSynchronization(
                 brightness_synchronization,
             ))?;
             Ok(())
@@ -300,7 +300,7 @@ pub trait Camera {
     fn is_busy(&self) -> crate::Result<bool> {
         unsafe {
             let mut is_busy = false;
-            LibCtruError(ctru_sys::CAMU_IsBusy(&mut is_busy, self.port_as_raw()))?;
+            LibCtruResult(ctru_sys::CAMU_IsBusy(&mut is_busy, self.port_as_raw()))?;
             Ok(is_busy)
         }
     }
@@ -310,7 +310,7 @@ pub trait Camera {
     fn get_transfer_bytes(&self) -> crate::Result<u32> {
         unsafe {
             let mut transfer_bytes = 0;
-            LibCtruError(ctru_sys::CAMU_GetTransferBytes(
+            LibCtruResult(ctru_sys::CAMU_GetTransferBytes(
                 &mut transfer_bytes,
                 self.port_as_raw(),
             ))?;
@@ -322,7 +322,7 @@ pub trait Camera {
     /// [Camera::set_trimming_params]
     fn set_trimming(&mut self, enabled: bool) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetTrimming(self.port_as_raw(), enabled))?;
+            LibCtruResult(ctru_sys::CAMU_SetTrimming(self.port_as_raw(), enabled))?;
             Ok(())
         }
     }
@@ -331,7 +331,7 @@ pub trait Camera {
     fn is_trimming_enabled(&self) -> crate::Result<bool> {
         unsafe {
             let mut trimming = false;
-            LibCtruError(ctru_sys::CAMU_IsTrimming(&mut trimming, self.port_as_raw()))?;
+            LibCtruResult(ctru_sys::CAMU_IsTrimming(&mut trimming, self.port_as_raw()))?;
             Ok(trimming)
         }
     }
@@ -339,7 +339,7 @@ pub trait Camera {
     /// Sets trimming parameters based on coordinates specified inside a [CamTrimmingParams]
     fn set_trimming_params(&mut self, params: CamTrimmingParams) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetTrimmingParams(
+            LibCtruResult(ctru_sys::CAMU_SetTrimmingParams(
                 self.port_as_raw(),
                 params.x_start,
                 params.y_start,
@@ -357,7 +357,7 @@ pub trait Camera {
             let mut y_start = 0;
             let mut x_end = 0;
             let mut y_end = 0;
-            LibCtruError(ctru_sys::CAMU_GetTrimmingParams(
+            LibCtruResult(ctru_sys::CAMU_GetTrimmingParams(
                 &mut x_start,
                 &mut y_start,
                 &mut x_end,
@@ -385,7 +385,7 @@ pub trait Camera {
         cam_height: i16,
     ) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetTrimmingParamsCenter(
+            LibCtruResult(ctru_sys::CAMU_SetTrimmingParamsCenter(
                 self.port_as_raw(),
                 trim_width,
                 trim_height,
@@ -399,7 +399,7 @@ pub trait Camera {
     /// Sets the exposure level of the camera
     fn set_exposure(&mut self, exposure: i8) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetExposure(self.camera_as_raw(), exposure))?;
+            LibCtruResult(ctru_sys::CAMU_SetExposure(self.camera_as_raw(), exposure))?;
             Ok(())
         }
     }
@@ -407,7 +407,7 @@ pub trait Camera {
     /// Sets the white balance mod of the camera based on the passed [CamWhiteBalance] argument
     fn set_white_balance(&mut self, white_balance: CamWhiteBalance) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetWhiteBalance(
+            LibCtruResult(ctru_sys::CAMU_SetWhiteBalance(
                 self.camera_as_raw(),
                 white_balance.bits(),
             ))?;
@@ -422,7 +422,7 @@ pub trait Camera {
         white_balance: CamWhiteBalance,
     ) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetWhiteBalanceWithoutBaseUp(
+            LibCtruResult(ctru_sys::CAMU_SetWhiteBalanceWithoutBaseUp(
                 self.camera_as_raw(),
                 white_balance.bits(),
             ))?;
@@ -433,7 +433,7 @@ pub trait Camera {
     /// Sets the sharpness of the camera
     fn set_sharpness(&mut self, sharpness: i8) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetSharpness(self.camera_as_raw(), sharpness))?;
+            LibCtruResult(ctru_sys::CAMU_SetSharpness(self.camera_as_raw(), sharpness))?;
             Ok(())
         }
     }
@@ -441,7 +441,7 @@ pub trait Camera {
     /// Sets whether auto exposure is enabled or disabled for the camera
     fn set_auto_exposure(&mut self, enabled: bool) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetAutoExposure(
+            LibCtruResult(ctru_sys::CAMU_SetAutoExposure(
                 self.camera_as_raw(),
                 enabled,
             ))?;
@@ -453,7 +453,7 @@ pub trait Camera {
     fn is_auto_exposure_enabled(&self) -> crate::Result<bool> {
         unsafe {
             let mut enabled = false;
-            LibCtruError(ctru_sys::CAMU_IsAutoExposure(
+            LibCtruResult(ctru_sys::CAMU_IsAutoExposure(
                 &mut enabled,
                 self.camera_as_raw(),
             ))?;
@@ -464,7 +464,7 @@ pub trait Camera {
     /// Sets whether auto white balance is enabled or disabled for the camera
     fn set_auto_white_balance(&mut self, enabled: bool) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetAutoWhiteBalance(
+            LibCtruResult(ctru_sys::CAMU_SetAutoWhiteBalance(
                 self.camera_as_raw(),
                 enabled,
             ))?;
@@ -476,7 +476,7 @@ pub trait Camera {
     fn is_auto_white_balance_enabled(&self) -> crate::Result<bool> {
         unsafe {
             let mut enabled = false;
-            LibCtruError(ctru_sys::CAMU_IsAutoWhiteBalance(
+            LibCtruResult(ctru_sys::CAMU_IsAutoWhiteBalance(
                 &mut enabled,
                 self.camera_as_raw(),
             ))?;
@@ -487,7 +487,7 @@ pub trait Camera {
     /// Sets the flip direction of the camera's image based on the passed [CamFlip] argument
     fn flip_image(&mut self, flip: CamFlip) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_FlipImage(
+            LibCtruResult(ctru_sys::CAMU_FlipImage(
                 self.camera_as_raw(),
                 flip.bits(),
                 ctru_sys::CONTEXT_A,
@@ -516,7 +516,7 @@ pub trait Camera {
         crop_1: (i16, i16),
     ) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetDetailSize(
+            LibCtruResult(ctru_sys::CAMU_SetDetailSize(
                 self.camera_as_raw(),
                 width,
                 height,
@@ -533,7 +533,7 @@ pub trait Camera {
     /// Sets the view size of the camera based on the passed [CamSize] argument.
     fn set_view_size(&mut self, size: CamSize) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetSize(
+            LibCtruResult(ctru_sys::CAMU_SetSize(
                 self.camera_as_raw(),
                 size.bits(),
                 ctru_sys::CONTEXT_A,
@@ -545,7 +545,7 @@ pub trait Camera {
     /// Sets the frame rate of the camera based on the passed [CamFrameRate] argument.
     fn set_frame_rate(&mut self, frame_rate: CamFrameRate) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetFrameRate(
+            LibCtruResult(ctru_sys::CAMU_SetFrameRate(
                 self.camera_as_raw(),
                 frame_rate.bits(),
             ))?;
@@ -556,7 +556,7 @@ pub trait Camera {
     /// Sets the photo mode of the camera based on the passed [CamPhotoMode] argument.
     fn set_photo_mode(&mut self, photo_mode: CamPhotoMode) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetPhotoMode(
+            LibCtruResult(ctru_sys::CAMU_SetPhotoMode(
                 self.camera_as_raw(),
                 photo_mode.bits(),
             ))?;
@@ -569,7 +569,7 @@ pub trait Camera {
     /// Multiple effects can be set at once by combining the bitflags of [CamEffect]
     fn set_effect(&mut self, effect: CamEffect) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetEffect(
+            LibCtruResult(ctru_sys::CAMU_SetEffect(
                 self.camera_as_raw(),
                 effect.bits(),
                 ctru_sys::CONTEXT_A,
@@ -581,7 +581,7 @@ pub trait Camera {
     /// Sets the contrast of the camera based on the passed [CamContrast] argument.
     fn set_contrast(&mut self, contrast: CamContrast) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetContrast(
+            LibCtruResult(ctru_sys::CAMU_SetContrast(
                 self.camera_as_raw(),
                 contrast.bits(),
             ))?;
@@ -592,7 +592,7 @@ pub trait Camera {
     /// Sets the lens correction of the camera based on the passed [CamLensCorrection] argument.
     fn set_lens_correction(&mut self, lens_correction: CamLensCorrection) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetLensCorrection(
+            LibCtruResult(ctru_sys::CAMU_SetLensCorrection(
                 self.camera_as_raw(),
                 lens_correction.bits(),
             ))?;
@@ -603,7 +603,7 @@ pub trait Camera {
     /// Sets the output format of the camera based on the passed [CamOutputFormat] argument.
     fn set_output_format(&mut self, format: CamOutputFormat) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetOutputFormat(
+            LibCtruResult(ctru_sys::CAMU_SetOutputFormat(
                 self.camera_as_raw(),
                 format.bits(),
                 ctru_sys::CONTEXT_A,
@@ -628,7 +628,7 @@ pub trait Camera {
         height: i16,
     ) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetAutoExposureWindow(
+            LibCtruResult(ctru_sys::CAMU_SetAutoExposureWindow(
                 self.camera_as_raw(),
                 x,
                 y,
@@ -655,7 +655,7 @@ pub trait Camera {
         height: i16,
     ) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetAutoWhiteBalanceWindow(
+            LibCtruResult(ctru_sys::CAMU_SetAutoWhiteBalanceWindow(
                 self.camera_as_raw(),
                 x,
                 y,
@@ -669,7 +669,7 @@ pub trait Camera {
     /// Sets whether the noise filter should be enabled or disabled for the camera
     fn set_noise_filter(&mut self, enabled: bool) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetNoiseFilter(self.camera_as_raw(), enabled))?;
+            LibCtruResult(ctru_sys::CAMU_SetNoiseFilter(self.camera_as_raw(), enabled))?;
             Ok(())
         }
     }
@@ -681,7 +681,7 @@ pub trait Camera {
         data: ImageQualityCalibrationData,
     ) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetImageQualityCalibrationData(data.0))?;
+            LibCtruResult(ctru_sys::CAMU_SetImageQualityCalibrationData(data.0))?;
             Ok(())
         }
     }
@@ -690,7 +690,7 @@ pub trait Camera {
     fn get_image_quality_calibration_data(&self) -> crate::Result<ImageQualityCalibrationData> {
         unsafe {
             let mut data = ImageQualityCalibrationData::default();
-            LibCtruError(ctru_sys::CAMU_GetImageQualityCalibrationData(&mut data.0))?;
+            LibCtruResult(ctru_sys::CAMU_GetImageQualityCalibrationData(&mut data.0))?;
             Ok(data)
         }
     }
@@ -699,7 +699,7 @@ pub trait Camera {
     // TODO: Explain sleep camera
     fn set_sleep_camera(&mut self) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetSleepCamera(self.camera_as_raw()))?;
+            LibCtruResult(ctru_sys::CAMU_SetSleepCamera(self.camera_as_raw()))?;
             Ok(())
         }
     }
@@ -723,7 +723,7 @@ pub trait Camera {
     ) -> crate::Result<Vec<u8>> {
         let transfer_unit = unsafe {
             let mut buf_size = 0;
-            LibCtruError(ctru_sys::CAMU_GetMaxBytes(
+            LibCtruResult(ctru_sys::CAMU_GetMaxBytes(
                 &mut buf_size,
                 width as i16,
                 height as i16,
@@ -736,7 +736,7 @@ pub trait Camera {
         let mut buf = vec![0u8; usize::try_from(screen_size).unwrap()];
 
         unsafe {
-            LibCtruError(ctru_sys::CAMU_SetTransferBytes(
+            LibCtruResult(ctru_sys::CAMU_SetTransferBytes(
                 self.port_as_raw(),
                 transfer_unit,
                 width as i16,
@@ -745,14 +745,14 @@ pub trait Camera {
         };
 
         unsafe {
-            LibCtruError(ctru_sys::CAMU_Activate(self.camera_as_raw()))?;
-            LibCtruError(ctru_sys::CAMU_ClearBuffer(self.port_as_raw()))?;
-            LibCtruError(ctru_sys::CAMU_StartCapture(self.port_as_raw()))?;
+            LibCtruResult(ctru_sys::CAMU_Activate(self.camera_as_raw()))?;
+            LibCtruResult(ctru_sys::CAMU_ClearBuffer(self.port_as_raw()))?;
+            LibCtruResult(ctru_sys::CAMU_StartCapture(self.port_as_raw()))?;
         };
 
         let receive_event = unsafe {
             let mut completion_handle: Handle = 0;
-            LibCtruError(ctru_sys::CAMU_SetReceiving(
+            LibCtruResult(ctru_sys::CAMU_SetReceiving(
                 &mut completion_handle,
                 buf.as_mut_ptr() as *mut ::libc::c_void,
                 self.port_as_raw(),
@@ -763,13 +763,13 @@ pub trait Camera {
         }?;
 
         unsafe {
-            LibCtruError(ctru_sys::svcWaitSynchronization(
+            LibCtruResult(ctru_sys::svcWaitSynchronization(
                 receive_event,
                 timeout.as_nanos().try_into().unwrap(),
             ))?;
-            LibCtruError(ctru_sys::CAMU_StopCapture(self.port_as_raw()))?;
-            LibCtruError(ctru_sys::svcCloseHandle(receive_event))?;
-            LibCtruError(ctru_sys::CAMU_Activate(ctru_sys::SELECT_NONE))?;
+            LibCtruResult(ctru_sys::CAMU_StopCapture(self.port_as_raw()))?;
+            LibCtruResult(ctru_sys::svcCloseHandle(receive_event))?;
+            LibCtruResult(ctru_sys::CAMU_Activate(ctru_sys::SELECT_NONE))?;
         };
 
         Ok(buf)
@@ -786,7 +786,7 @@ impl Cam {
     /// rare in practice.
     pub fn init() -> crate::Result<Cam> {
         unsafe {
-            LibCtruError(ctru_sys::camInit())?;
+            LibCtruResult(ctru_sys::camInit())?;
             Ok(Cam {
                 inner_cam: InwardCam,
                 outer_right_cam: OutwardRightCam,
@@ -799,7 +799,7 @@ impl Cam {
     /// Plays the specified sound based on the [CamShutterSoundType] argument
     pub fn play_shutter_sound(&self, sound: CamShutterSoundType) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::CAMU_PlayShutterSound(sound.bits()))?;
+            LibCtruResult(ctru_sys::CAMU_PlayShutterSound(sound.bits()))?;
             Ok(())
         }
     }

ctru-rs/src/services/cfgu.rs

@@ -2,7 +2,7 @@
 //!
 //! This module contains basic methods to retrieve and change configuration from the console.
 
-use crate::error::LibCtruError;
+use crate::error::LibCtruResult;
 
 #[derive(Copy, Clone, Debug)]
 #[repr(u32)]
@@ -62,7 +62,7 @@ impl Cfgu {
     /// as many times as desired and the service will not exit until all
     /// instances of Cfgu drop out of scope.
     pub fn init() -> crate::Result<Cfgu> {
-        LibCtruError(unsafe { ctru_sys::cfguInit() })?;
+        LibCtruResult(unsafe { ctru_sys::cfguInit() })?;
         Ok(Cfgu(()))
     }
 
@@ -70,7 +70,7 @@ impl Cfgu {
     pub fn get_region(&self) -> crate::Result<Region> {
         let mut region: u8 = 0;
 
-        LibCtruError(unsafe { ctru_sys::CFGU_SecureInfoGetRegion(&mut region) })?;
+        LibCtruResult(unsafe { ctru_sys::CFGU_SecureInfoGetRegion(&mut region) })?;
         Ok(Region::try_from(region).unwrap())
     }
 
@@ -78,7 +78,7 @@ impl Cfgu {
     pub fn get_model(&self) -> crate::Result<SystemModel> {
         let mut model: u8 = 0;
 
-        LibCtruError(unsafe { ctru_sys::CFGU_GetSystemModel(&mut model) })?;
+        LibCtruResult(unsafe { ctru_sys::CFGU_GetSystemModel(&mut model) })?;
         Ok(SystemModel::try_from(model).unwrap())
     }
 
@@ -86,7 +86,7 @@ impl Cfgu {
     pub fn get_language(&self) -> crate::Result<Language> {
         let mut language: u8 = 0;
 
-        LibCtruError(unsafe { ctru_sys::CFGU_GetSystemLanguage(&mut language) })?;
+        LibCtruResult(unsafe { ctru_sys::CFGU_GetSystemLanguage(&mut language) })?;
         Ok(Language::try_from(language).unwrap())
     }
 
@@ -94,7 +94,7 @@ impl Cfgu {
     pub fn is_nfc_supported(&self) -> crate::Result<bool> {
         let mut supported: bool = false;
 
-        LibCtruError(unsafe { ctru_sys::CFGU_IsNFCSupported(&mut supported) })?;
+        LibCtruResult(unsafe { ctru_sys::CFGU_IsNFCSupported(&mut supported) })?;
         Ok(supported)
     }
 
@@ -102,7 +102,7 @@ impl Cfgu {
     pub fn is_2ds_family(&self) -> crate::Result<bool> {
         let mut is_2ds_family: u8 = 0;
 
-        LibCtruError(unsafe { ctru_sys::CFGU_GetModelNintendo2DS(&mut is_2ds_family) })?;
+        LibCtruResult(unsafe { ctru_sys::CFGU_GetModelNintendo2DS(&mut is_2ds_family) })?;
         Ok(is_2ds_family == 0)
     }
 }

ctru-rs/src/services/hid.rs

@@ -4,7 +4,7 @@
 //! and circle pad information. It also provides information from the sound volume slider,
 //! the accelerometer, and the gyroscope.
 
-use crate::error::LibCtruError;
+use crate::error::LibCtruResult;
 bitflags::bitflags! {
     /// A set of flags corresponding to the button and directional pad
     /// inputs on the 3DS
@@ -63,7 +63,7 @@ pub struct CirclePosition(ctru_sys::circlePosition);
 impl Hid {
     pub fn init() -> crate::Result<Hid> {
         unsafe {
-            LibCtruError(ctru_sys::hidInit())?;
+            LibCtruResult(ctru_sys::hidInit())?;
             Ok(Hid(()))
         }
     }

ctru-rs/src/services/ps.rs

@@ -4,7 +4,7 @@
 //! As such, it is initialized by default in `ctru::init` instead of having a safety handler
 //! See also <https://www.3dbrew.org/wiki/Process_Services>
 
-use crate::error::LibCtruError;
+use crate::error::LibCtruResult;
 
 #[repr(u32)]
 pub enum AESAlgorithm {
@@ -33,19 +33,19 @@ pub enum AESKeyType {
 pub fn local_friend_code_seed() -> crate::Result<u64> {
     let mut seed: u64 = 0;
 
-    LibCtruError(unsafe { ctru_sys::PS_GetLocalFriendCodeSeed(&mut seed) })?;
+    LibCtruResult(unsafe { ctru_sys::PS_GetLocalFriendCodeSeed(&mut seed) })?;
     Ok(seed)
 }
 
 pub fn device_id() -> crate::Result<u32> {
     let mut id: u32 = 0;
 
-    LibCtruError(unsafe { ctru_sys::PS_GetDeviceId(&mut id) })?;
+    LibCtruResult(unsafe { ctru_sys::PS_GetDeviceId(&mut id) })?;
     Ok(id)
 }
 
 pub fn generate_random_bytes(out: &mut [u8]) -> crate::Result<()> {
-    LibCtruError(unsafe {
+    LibCtruResult(unsafe {
         ctru_sys::PS_GenerateRandomBytes(out as *mut _ as *mut _, out.len() as u32)
     })?;
     Ok(())

ctru-rs/src/services/soc.rs

@@ -3,7 +3,7 @@ use once_cell::sync::Lazy;
 use std::net::Ipv4Addr;
 use std::sync::Mutex;
 
-use crate::error::LibCtruError;
+use crate::error::LibCtruResult;
 use crate::services::ServiceReference;
 use crate::Error;
 
@@ -39,7 +39,7 @@ impl Soc {
             false,
             || {
                 let soc_mem = unsafe { memalign(0x1000, num_bytes) } as *mut u32;
-                LibCtruError(unsafe { ctru_sys::socInit(soc_mem, num_bytes as u32) })?;
+                LibCtruResult(unsafe { ctru_sys::socInit(soc_mem, num_bytes as u32) })?;
 
                 Ok(())
             },

ctru-rs/src/services/sslc.rs

@@ -1,6 +1,6 @@
 // TODO: Implement remaining functions
 
-use crate::error::LibCtruError;
+use crate::error::LibCtruResult;
 
 pub struct SslC(());
 
@@ -8,7 +8,7 @@ impl SslC {
     /// Initialize sslc
     pub fn init() -> crate::Result<Self> {
         unsafe {
-            LibCtruError(ctru_sys::sslcInit(0))?;
+            LibCtruResult(ctru_sys::sslcInit(0))?;
             Ok(SslC(()))
         }
     }
@@ -16,7 +16,7 @@ impl SslC {
     /// Fill `buf` with `buf.len()` random bytes
     pub fn generate_random_data(&self, buf: &mut [u8]) -> crate::Result<()> {
         unsafe {
-            LibCtruError(ctru_sys::sslcGenerateRandomData(
+            LibCtruResult(ctru_sys::sslcGenerateRandomData(
                 buf.as_ptr() as _,
                 buf.len() as u32,
             ))?;