4 ms·

It's not the same thing, a value of type Unit can only produce a side effect (or do nothing at all).

• dllthomas 10y ago
  How is that different from a value of type "empty tuple"?
  • virtualwhys 10y ago
    True, neither are useful as values, though Unit typically conveys programmer intent (to produce a side effect), whereas the empty tuple is, in Scala at any rate, quite rare. The empty tuple: scala> val empty = Tuple1(()) empty: (Unit,) = ((),) vs. Unit: scala> val empty = () empty: Unit = ()
    • vertex-four 10y ago
      Isn't that a tuple containing a unit, and therefore not empty?
      • virtualwhys 10y ago
        It's the closest you can get in Scala to represent an empty value whose type is `Tuple`.
        • Sharlin 10y ago
          Type names are irrelevant here. Unit could be called "Tuple0", or be defined as a synonym of a type named such. The semantics are identical.
        • vertex-four 10y ago
          The difference between an empty tuple (also known as unit) and void becomes obvious when you deal with vaguely complex trait impls. For example, if you have a trait: trait Foo { type ErrorType; fn bar() -> Result<u8, Foo::ErrorType>; } How would you specify that your type implements Foo in such a way that bar() cannot return an error? If you were to implement it using the empty tuple (unit), like this, it could actually return an error: struct Abc{} impl Foo for Abc { type ErrorType = (); fn bar() -> Result<u8, ()> { Err(()) // oops, we don't want to be able to do that! } } Instead, you can use Void here: 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) } } Aside from the obvious power to express intent (can we return an error without any information attached, or can we not error at all?), this would allow an optimizing compiler to assume that the result of Xyz::bar() is always a u8, allowing it to strip off the overhead of the Result: 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 A super-smart compiler would even make sure it's not storing the data for "is this an Ok or Err" in the Result<u8, Void> at all. Finally, similarly, you can specify that certain functions are uncallable by having them take Void as a parameter.
          • dllthomas 10y ago
            I don't think anyone is claiming Void in Scala/Haskell/Rust is equivalent to Unit in Scala/Haskell/Rust. 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.
            • vertex-four 10y ago
              Upthread was: > 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.
              • dllthomas 10y ago
                Regardless of who is right, you are arguing the wrong bit of it. I contend that, to a person, everyone saying "C void is Unit" doesn't think C void is Void. Arguing that Void is not Unit is just completely spurious. Of course Void is not Unit. No one disagrees. 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.