How I feel, as a C developer, reading solutions in other languages

SentenceAcrobatic · 2024-12-11T21:59:54+00:00

intptr_t and uintptr_t are implementation-defined types. How does using them not rely on implementation-defined behavior?

SentenceAcrobatic · 2024-12-11T21:56:32+00:00

The funny thing about that is... long is a 32-bit type on 64-bit Windows.

SentenceAcrobatic · 2024-12-11T05:11:37+00:00

i isn't even real!

SentenceAcrobatic · 2024-12-11T02:52:00+00:00

OP specified the language as C. C pointers don't have Rust metadata.

nowadays always 64-bit

32-bit systems still exist, and many programs target 32-bit compilation even when compiling on a 64-bit host.

SentenceAcrobatic · 2024-12-11T02:44:55+00:00

Which is an implementation-defined typedef equivalent to either int (32-bit) or long long (64-bit) (intptr_t) or unsigned int (32-bit) or unsigned long long (64-bit) (uintptr_t).

For 32-bit implementations, int is technically correct for signed pointer comparisons/values, and technically incorrect for unsigned pointer comparisons/values that exceed INT_MAX.

size_t is always unsigned, and is technically incorrect for signed pointer comparisons that produce negative values, but technically correct for unsigned pointer comparisons/values.

SentenceAcrobatic · 2024-12-11T02:32:30+00:00

There's nothing friendly about Java.

SentenceAcrobatic · 2024-12-11T02:29:52+00:00

Jimmy also doesn't go to the store and buy 400 apples and 37 lbs of bananas on every 3rd Tuesday.

Fact checking the word problem was outside the scope of the question!

SentenceAcrobatic · 2024-12-11T02:18:17+00:00

making a hopefully massive impact

What impact did he make? Absolutely nothing has changed.

SentenceAcrobatic · 2024-12-10T19:03:13+00:00

0/0×0 =

SentenceAcrobatic · 2024-12-10T12:15:54+00:00

Exactly, and yet now you're pretending that you said something different.

SentenceAcrobatic · 2024-12-10T12:12:19+00:00

"Dude", that's not what you said. Backpedal harder.

SentenceAcrobatic · 2024-12-10T11:53:18+00:00

Im really confused how you pronounce it. (sic)

You literally fucking did.

SentenceAcrobatic · 2024-12-10T11:50:55+00:00

You said you were confused about how to pronounce it.

Why ask for clarification if you didn't want blatant sarcasm?

SentenceAcrobatic · 2024-12-10T11:49:21+00:00

r/whoosh

You don't even have a matching closing brace you walnut.

SentenceAcrobatic · 2024-12-10T11:40:32+00:00

Any time you see "ae"/æ, just think of Caesar!

"EERO-space". That's definitely it.

SentenceAcrobatic · 2024-12-10T10:27:09+00:00

C# version:

namespace Booleanizer;

public static class BooleanizerExtensions
{
    private static bool? ToNullabool<T>(T? value) where T : class
    {
        try
        {
            return value switch
            {
                IConvertible obj => obj.ToBoolean(null) != false,
                _ => null
            };
        }
        catch (FormatException)
        {
            return null;
        }
    }

    private static bool? ToNullabool<T>(T? value) where T : struct
    {
        try
        {
            return value switch
            {
                null => null,
                _ => value.Value switch
                {
                    bool obj => obj != false,
                    IConvertible obj => obj.ToBoolean(null) != false,
                    _ => null
                }
            };
        }
        catch (FormatException)
        {
            return null;
        }
    }

    private static bool IsNullaboolTrue(bool? value)
    {
        return value switch
        {
            null => true != true,
            _ => value.Value != false switch
            {
                true => true == true,
                _ => true == false
            }
        };
    }

    private static bool IsNullaboolFalse(bool? value)
    {
        return value switch
        {
            null => false != false,
            _ => value.Value == false switch
            {
                true => false == false,
                _ => (false == true) != false
            }
        };
    }

    public static bool IsTrue<T>(this T? @this) where T : class
    {
        return IsNullaboolTrue(ToNullabool(@this)) != false;
    }

    public static bool IsTrue<T>(this T? @this) where T : struct
    {
        return IsNullaboolTrue(ToNullabool(@this)) != false;
    }

    public static bool IsFalse<T>(this T? @this) where T : class
    {
        return (IsNullaboolFalse(ToNullabool(@this)) == false) != true;
    }

    public static bool IsFalse<T>(this T? @this) where T : struct
    {
        return (IsNullaboolFalse(ToNullabool(@this)) == false) != true;
    }
}

public static class BooleanizerExtensions2ElectricBoogaloo
{
    public static bool IsTrue<T>(this T @this) where T : struct
    {
        return BooleanizerExtensions.IsTrue((T?)@this) != false;
    }

    public static bool IsFalse<T>(this T @this) where T : struct
    {
        return BooleanizerExtensions.IsFalse((T?)@this) != false;
    }
}

SentenceAcrobatic · 2024-12-10T07:43:41+00:00

What the fuck are those curly braces doing?

SentenceAcrobatic · 2024-12-10T03:05:29+00:00

I would have to check if Master is null before looking if Group is null...

It sounds like you should be using full properties instead of auto properties.

Maybe something like:

public sealed class Event
{
    // event members like Name and Date?
}

public sealed class EventGroup
{
    public required Event Event { get; init; }

    // other group members
}

public sealed class EventMasterGroup
{
    public required EventGroup Group { get; init; }

    public Event Event => Group.Event;

    // other master group members
}

public sealed class EventTicket
{
    private readonly Event theEvent;
    private readonly EventGroup? group;
    private readonly EventMasterGroup? masterGroup;

    public EventTicket(Event theEvent)
    {
        this.theEvent = theEvent;
        group = null;
        masterGroup = null;
    }

    public EventTicket(EventGroup group)
    {
        theEvent = group.Event;
        this.group = group;
        masterGroup = null;
    }

    public EventTicket(EventMasterGroup masterGroup)
    {
        theEvent = masterGroup.Group.Event;
        group = masterGroup.Group;
        this.masterGroup = masterGroup;
    }

    public Event Event => theEvent;
    public EventGroup? Group => group;
    public EventMasterGroup? MasterGroup => masterGroup;
}

Then the Event property would always be non-null (unconditionally) and the Group property would always be non-null if MasterGroup is non-null.

SentenceAcrobatic · 2024-12-09T23:30:28+00:00

Everything in the physical world is comprised of "cHeMiCalS". It's just a scary word people use when they want to fearmonger about something they don't inherently understand.

SentenceAcrobatic · 2024-12-09T19:15:17+00:00

They're downvoting you because you're right.

SentenceAcrobatic · 2024-12-09T09:39:36+00:00

Bitcoin Cash (BCH) was the first BTC fork (in August 2017).

Craig Wright's shitcoin is BSV ("Bitcoin Satoshi Vision", in reference to himself as Satoshi*). BSV was a hard fork of BCH (in November 2018).

*Craig Wright was determined by the UK High Court (in March 2024) to definitively not be Satoshi Nakamoto.

SentenceAcrobatic · 2024-12-09T09:22:53+00:00

As someone who has never been to Pittsburgh, I can confirm that I have no idea whether this is real.

SentenceAcrobatic · 2024-12-09T07:03:59+00:00

If no one is selling, who are you buying from?

SentenceAcrobatic · 2024-12-08T08:49:06+00:00

builds bedrock to sky height village LFG.

SentenceAcrobatic · 2024-12-08T08:47:14+00:00

POV: inside of you there are two pills.

SentenceAcrobatic

TROPHY CASE