Compiling with VS2015

[takkaria]

Well, they're good languages .

(Scala less so, but still a lot better than most things. Especially things that can target JS.)

Have you seen Elm? It's a very neat language, I think derived from Haskell, designed to be accessible for people who aren't into functional programming (which is me) but still has ADTs, and compiles into JS. I've not used it for anything yet but its design has heavily influenced a pure JS project I'm working on and made it a ton more manageable.

[t4nk]

Algebraic Data Types + pattern matching are absolutely amazing when you want to model a domain, though.

Well, even Angband has algebraic data types, you know

typedef union {
	ui_event_type type;
	struct mouseclick mouse;
	struct keypress key;
} ui_event;

Not sure if D can do ADTs, but you can probably hack something similar using macros.

Hm, I just discovered that it actually does have those in the standard library:

void main()
{
    import std.variant : Algebraic, visit;

    alias Option = Algebraic!(int, string);

    void print(const ref Option o)
    {
        import std.stdio : writeln;

        o.visit!((string s) => writeln("got string: ", s),
                 (int n)    => writeln("got number: ", n));
    }

    Option o = 99;
    print(o);

    o = "some text";
    print(o);

    o = 1024;
    print(o);
}

These things still don't strike me as a super cool feature, though

[AnonymousHero]

Well, even Angband has algebraic data types, you know

No, not event close. You can pretend all you like, though .

One of the major points of ADTs is to make illegal states undrepresentable -- and unions don't do that. In fact they possibly even make things worse because the programmer may easily get it wrong... leading to UB.

These things still don't strike me as a super cool feature, though

Have you tried actually using them with pattern matching... and "making illegal states unrepresentable", etc? (I'm talking in e.g. O'Caml, Haskell or the like. Not in toy programs either -- real programs.)

(Interesting to see that D has an emulation of ADTs. I haven't tried D enough to know whether they're useful there, but having to use visitors to deconstruct (rather than true pattern matching) seems like it would basically cripple them.)

I promise you, if you actually start using "true" ADTs + pattern matching, you'll change your mind .

Anyway, we've veered quite a bit off topic from VS2015, so I'll stop here .

[AnonymousHero]

Have you seen Elm? It's a very neat language, I think derived from Haskell, designed to be accessible for people who aren't into functional programming (which is me) but still has ADTs, and compiles into JS. I've not used it for anything yet but its design has heavily influenced a pure JS project I'm working on and made it a ton more manageable.

Yes, but only tried it a little bit. It's too anemic for my taste, but it's lovely for what it is. (Especially if you can live with the rather low power ceiling.)

[t4nk]

Have you tried actually using them with pattern matching... and "making illegal states unrepresentable", etc? (I'm talking in e.g. O'Caml, Haskell or the like. Not in toy programs either -- real programs.)

Hm, don't recall doing that. Most of my experience with functional programming is from tinkering with Common Lisp (hated that thing and it's not particularly functional anyway), and Erlang, which was pretty nice. I especially liked the huge amount of mutable state it had - that's probably because it was used to solve practical problems, not doing research or proving some theories
And, yeah, the C++ template language, which kind of scarred me for life

Anyway, we've veered quite a bit off topic from VS2015, so I'll stop here .

Yes, we haven't heard anything from the OP, so I guess he didn't manage to compile Angband with VC++.

[Siemelink]

Yes, we haven't heard anything from the OP, so I guess he didn't manage to compile Angband with VC++.

Still stuck. I've been distracted so haven't started debugging yet.

Willem.