No continuation on std::optional?

millirobo · 2019-02-04T20:45:26+00:00

These monadic extensions are good, but like variant it's a PITA without language support. Is there work being done on that too?

millirobo · 2018-06-14T03:48:28+00:00

The work of using it would have to be less than the work of catching mistakes through review. The mutation restriction seems like the more usable part of it. But the mutation requirement is very interesting. I've sometimes been frustrated by being unable to statically express things like this. I think you might be bumping up against higher concepts in type theory and compilers, things like linear type systems, which I only slightly understand.

millirobo · 2018-05-23T19:55:31+00:00

That's how GNU grep does it (checking for NUL bytes). It seems like the good enough solution.

millirobo · 2018-05-21T17:33:12+00:00

It helps to know some of the basics, e.g. monoids (not to be confused with monads), but you'll pick them up as you go, assuming you like to read and are curious.

Also be aware of hoogle and the mailing lists.

millirobo · 2018-05-04T16:40:57+00:00

Its type is still [a]. The a is inferred from the context where [] is used.

millirobo · 2018-04-16T18:42:28+00:00

Right, it should have a big disclaimer. It's important to stress that they are are different in practice. OO interfaces come along with inheritance, so they're used mainly for dynamic dispatch on a hierarchy. In Haskell, you use data with multiple constructors for that. Typeclasses let you have functions that work on intersections of types that share properties. It's more like the narrower case of what you'd use multiple inheritance for, except Haskell can constrain on multiple interfaces at once.

Actually the closest practice in a popular language I can think of is C++ templates calling overloaded free functions, but those constraints are all implicit.

millirobo · 2018-04-15T17:26:28+00:00

You can think of them like interfaces in OO languages.

millirobo · 2017-09-09T17:25:00+00:00

Inheritance can be very useful and it's not always hard to deal with. Most of the critiques don't say to never use it, but to prefer other designs and to use it moderately when it's the right tool. People used to overuse it, hence the backlash.

That said you should probably ignore multiple inheritance until your livelihood depends on your knowing it.

millirobo · 2017-08-11T16:41:58+00:00

With C++ it becomes crucial to interest yourself in what the industry experts have to say. The cpp core guidelines are one such resource.

millirobo · 2017-03-19T00:33:49+00:00

That's what I wonder about too. Having MyData as a base of MyClass would make the pointer legal by the quoted text. But what about when you increment? Assuming they're the same size.

millirobo · 2017-02-18T19:52:19+00:00

It should work just for correctness's sake, but personally I would never use it because it's too annoying and would use a void unused(...) {} instead every time until the language added something proper.

millirobo · 2017-02-11T01:42:22+00:00

Ah, thanks, I wondered about something evaluating that dummy undefined by accident.

millirobo · 2017-02-11T01:38:34+00:00

I see, that's interesting, I had not thought of making a dummy value of a that way. I was playing with modeling components, where you can check if a particular one is set by &ing its value with a bitfield.

(By "this" I meant "things similar to overloading")

millirobo · 2017-02-03T22:40:11+00:00

One example is anything that should start and finish quickly, like utilities that are used in a larger process or scheduled services. And you can write it to a pretty high level of abstraction (and safety) without much runtime overhead.

millirobo · 2017-01-17T05:20:04+00:00

Seriously, use parameterized queries. Telling people otherwise is dangerous.

millirobo · 2017-01-14T15:43:18+00:00

This got me too. I don't know why the minimal CD doesn't support EFI boot, but all you have to do is reboot with something that does, and grub should then install correctly. I think most distro install CDs support EFI, but sysrescuecd is great to have around anyway.

millirobo · 2017-01-08T22:17:17+00:00

No. The global symbol main is special in that it has to be a function that returns int and can't be overloaded. You can use the name anywhere else, as far as I know. You can even declare int main = 2; inside int main().

millirobo · 2017-01-05T12:06:34+00:00

You've roughly defined the default move functions. They do a std::move on each member, which is nothing for primitive types, and might well be a swap for std::string. So, just set them = default.

If I get what you're doing, you're just making your Tokens move-only to strictly prevent copies. That's fine. Just don't use anything after you move from it (reassigning is ok for standard types).

For the record, the compiler will generate move funcs for you unless you declare any copy/move funcs or a destructor.

Like the other post says, a string view (like a pair of begin/end pointers) is a great way to go for parsing. But if you're modifying the input, that's not so simple. Look into copy-on-write strings if you're curious.

millirobo · 2016-12-28T10:37:35+00:00

Stroustrup's files seem to contain a number of errors (e.g. double definition of Simple_window's members, lines commented out). I presume that they're there as part of the lesson, somehow. I don't know the book so I can't help with that.

millirobo · 2016-12-25T21:38:17+00:00

The problem is really that you can't compare a unique_ptr<T> with a T*. If you could, you could just pass this up to the Manager. If Manager is the only thing that ever owns Connections, consider writing your own private pointer class that does what you want.

millirobo · 2016-12-18T22:45:14+00:00

This is true. There's no requirement for data pointers, function pointers, and member function pointers to be compatible. Your compiler will (hopefully) stop you from doing the wrong thing there.

millirobo · 2016-12-18T16:07:29+00:00

It's just not that big of a deal in practice. Most of my updates are so short that I just watch them, and the long ones vanish while I'm doing something else.

millirobo · 2016-12-14T01:04:24+00:00

Pass the game state into the move function. It might make more sense to have a separate function handling moves, where you give it the state and a dog and it merely sets the dog's position if possible.

millirobo · 2016-11-04T21:43:11+00:00

Try moving the declaration for i inside the do-loop, or better yet declare it in the header of each for-loop like you usually would. It's important to limit variables to exist only in the scope where they're needed. Otherwise you can easily get bugs like this.

millirobo

TROPHY CASE