Hacker News Reader

Comment by WalterBright | Hacker News Reader

    const x: i32 = 92;

D has less syntax:

    const int x = 92;

Just for fun, read each declaration out loud.

View on HN

"less syntax" isn't necessarily better. The goal isn't to have as few characters as possible.

True, it is subjective. I prefer C, Go, PHP, ... and OCaml, Erlang, Elixir, Perl, and sometimes Ada and Common Lisp.

I like the syntaxes of each, although Ada is too verbose to me, and with Factor and Common Lisp I have a skill issue.

I agree. I'm not a fan of minimized syntax (see Haskell). But I am a fan of easy to read syntax!

If it were we would all be using APL.

Zig:

    fn ArrayListType(comptime T: type) type {

    T ArrayListType(T)() {

Why is omitting the fact that T is a type useful? T could be a normal value too.

This reminds me of C in the 1970s where the compiler assumed every typo was a new variable of type int. Explicit is good.

> Why is omitting the fact that T is a type useful?

It's the default, because most templates are templated on types. If you want a constant int as part of the template type,

    ArrayListType(int I)

> This reminds me of C in the 1970s where the compiler assumed every typo was a new variable of type int

I think you're referring to function declarations without prototypes. D's syntax does not suffer from that issue.

BTW,

    T func(T)(T x) { return x + 1; }

is a declaration of a "function template". The first parameter list consists of the template parameters, and are compile time types and constants. The second parameter list is the conventional function parameter list. If the first parameter list is omitted, then it's a function.

I don't know D but shouldn't that be

    struct ArrayListType(T) {

?

Walter is showing the equivalent function declaration... you will eventually create a generic type as you say, but in the Zig example, that was a function, not a struct.

If my understanding of D's template syntax is correct, then Walter is showing a the declaration of a function called ArrayListType which is generic over T and returns a T. The original Zig code returns the struct type itself, so it is functionally equivalent to my example, provided I understood how D templates work.

The Zig code returns any `type`, it's impossible to say what that is without looking at the implementation. It can be different types completely depending on the comptime arguments.

But I agree it probably returns a struct type.

Assuming that's the case, you're right and the equivalent would be:

Zig:

    fn ArrayListType(comptime T: type) type {

    ArrayList!T ArrayListType(T)() {

But now the D version is more specific about what it returns, so it's still not exactly equivalent.

No, you misunderstand. The function doesn't return any type, it returns _a_ type. Types are values in Zig and returning them from function is how generics are implemented.

I know how Zig works. `type` is some type the function will return, you must look at the implementation to know what actually got returned, given the comptime arguments given to it by the caller (as I already mentioned). Where is the misunderstanding??

Well, your example seems to do something completely different, which is return an ArrayList!T rather than a type.

It achieves the same result in practice. The reason Zig needs to return a type is because it lacks a way to represent `T!A` where T is a parameterized type, and A is the parameter. In this case, that would've been better because you would be able to tell exactly what the type being returned was.

If you must return different types depending on the argument in D, it's also possible.

Here's a silly example:

    struct ArrayList(T, alias capacity) {
      private T[capacity] array;
      private uint _length;
      uint length() const => _length;
      T get(uint index) const => array[index];
      void add(T t) {
        array[_length++] = t;
      }
    }

    struct EmptyList(T) {
      uint length() const => 0;
    }

    /// This will return a different type depending on the length argument,
    /// which is like a Zig comptime argument.
    /// We cannot return the type itself, but the result is very similar.
    auto createArrayList(T, alias length)() {
      static if (length == 0) {
        return EmptyList!T();
      } else {
        return ArrayList!(T, length)();
      }
    }

    void main()
    {
      import std.stdio;
      auto empty = createArrayList!(int, 0);
      writeln(empty);
      auto list = createArrayList!(int, 2);
      list.add(5);
      list.add(6);
      writeln(list);
    }

Result:

    EmptyList!int()
    ArrayList!(int, 2)([5, 6], 2)

It's now too late to edit my original comment but I've skimmed your code a little too fast and now I see that you do understand that Zig works with reified types. But in that case, why conflate too very different things? Returning values of different types is not the same as returning types.

Regardless, we are now very far removed from the original code I was commenting on, which doesn't use auto to return different types.

You still misunderstand the type type. "type" does not mean "generic over all types" but that you're returning a reified type. The original Zig function does not return an ArrayList value, it returns the ArrayList type.

Zig:

    const std = @import("std");

    import std;

I think this is not equivalent because in D, this imports all symbols in the package `std` while in Zig, you just get a "struct" called `std`. I think the equivalent D is:

    import std=std;

What I wrote is equivalent to the zig declaration. Google says:

    const my_module = @import("my_module.zig");

    This allows you to access pub (public) declarations from my_module.zig through the my_module identifier.

Yes, but how is that equivalent?

Zig:

    const std = @import("std");
    pub fn main() !void {
      // std is like a namespace here
      std.debug.print("Hello, World!\n", .{});
    }

    import std.stdio;
    void main()
    {
      // no namespace here, "writeln" and everything else in "std.stdio" is imported
      writeln("Hello, World!");
    }

The closest to Zig in D would be:

    import io = std.stdio;
    void main()
    {
      io.writeln("Hello, World!");
    }

You can write in D:

    std.stdio.writeln("Hello, world!");

Reply on news.ycombinator.com