> Things which don't have a logical value evaluate to `()` (the empty tuple), I believe.
If Rust follows Scala then `()` is not the empty tuple, but rather Unit (void in C*).
If Rust follows Scala then `()` is not the empty tuple, but rather Unit (void in C*).
The empty tuple:
scala> val empty = Tuple1(())
empty: (Unit,) = ((),)
scala> val empty = ()
empty: Unit = () trait Foo {
type ErrorType;
fn bar() -> Result<u8, Foo::ErrorType>;
}
struct Abc{}
impl Foo for Abc {
type ErrorType = ();
fn bar() -> Result<u8, ()> {
Err(()) // oops, we don't want to be able to do that!
}
}
enum Void{}
struct Xyz{}
impl Foo for Xyz {
type ErrorType = Void;
fn bar() -> Result<u8, Void> {
// No way to create a Void, so the only thing we can return is an Ok
Ok(1)
}
}
fn baz<F: Foo>(f: F) {
match f.bar() {
Ok(v) => println!("{}", v),
Err(e) => panic!("{}", e)
};
}
...
baz(Xyz); // The compiler can notice that f.bar() can never return a Result::Err, so strip off the match and assume it's a Result::Ok
Finally, similarly, you can specify that certain functions are uncallable by having them take Void as a parameter.
The question here was Unit vs empty tuple.
Up-thread was the question of whether C "void" is more like S/H/R Unit or S/H/R Void.
> If Rust follows Scala then `()` is not the empty tuple, but rather Unit (void in C*).
The implication is that () == Unit == void. The empty tuple and unit are essentially equivalent aside from name, void is something else.
In truth, C void is not exactly either Void or Unit. Like Void, you can't exactly make one... but you can call functions declared to take it and write functions that return it, and really it just means "I have no information to pass" - which is more like Unit.
However, () and Unit are.
enum Void{}
fn foo(v: &Void){ ... }
let bar : Void;
fn abc() -> &Void{ ...}
fn xyz() -> Void{ ... }
On the other hand, you can do all of these just fine:
fn foo(v: ()){ ... }
fn bar(v: &()){ ... }
...
let v = ();
bar(&v);
foo(v);
(All statements here are made within the safe subset of the language - unsafe allows access to intrinsics that would allow a Void to be made, and a reference to Void.)