Welcome to the Lounge

honey the monster, codewitch wrote:

i mean procedural as in procedures rather than objects to divvy up code.

honey the monster, codewitch wrote:

If there's a better word for that I'm unaware of it. You could say that all imperative languages are procedural if they have functions/methods but that's almost too general to be useful.

honey the monster, codewitch wrote:

As far as your yucks, i come from a C++ background and happen to like generic programming. to each their own.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]
"If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.

Eddy Vluggen wrote:

That's a non-complaint; like I said, you can put all your procedures in a God-object

Eddy Vluggen wrote:

I'd say you haven't worked in a strict procedural language

Eddy Vluggen wrote:

Haven't seen much of that, so not going to comment on it. But still, yuck.

honey the monster, codewitch wrote:

Now I wonder what you'd consider procedural.

honey the monster, codewitch wrote:

Spoken like someone that's never used it.

honey the monster, codewitch wrote:

I wish it was more available in places other than C++.

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]
"If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.

10 GOTO HELL

Bastard Programmer from Hell
If you can't read my code, try converting it here[^]
"If you just follow the bacon Eddy, wherever it leads you, then you won't have to think about politics." -- Some Bell.

public class SomeParsingData {}

public class FA<T> 
{
  // ...
  public virtual void MyOperation(SomeParsingData data) {}
}
public class CharFA : FA<char> 
{
  public override void MyOperation(SomeParsingData data) {}
}

static class FAUtil
{
  public static void MyOperation<T>(FA<T> target, SomeParsingData data) => target.MyOperation(data);
}

class FA<TInput,TAccept> {
}

class CharFA<TAccept> : FA<char,TAccept> {
}

var fa = new FA<char,string>(); // instantiate the specialization than
var fa = new CharFA<string>(); // <-- what i have to do now

void DoSomething<T>(T value) {
  switch (typeof(T)) {
    case typeof(double): DoDoubleThing((double)value); break;
    case typeof(int): DoIntThing((int)value); break;
    // ... all common base type
    default: DoDefaultThing(value); break;
  }
}

class A<T>
{
    public virtual void Do(T value)
    {
        Console.WriteLine("Value: " + value);
    }
}
class B : A<int>
{
    public override void Do(int value)
    {
        Console.WriteLine("Int: " + value);
    }
}
class Program
{
    static void Main(string[] args)
    {
        A<int> a = new B();
        a.Do(1);
    }
}

class A<T>
{
    public void Do(T value)
    {
        if (value is int intV) Do(intV);
        else DoDefault(value);
    }
    void DoDefault(T value)
    {
        Console.WriteLine("Value: " + value);
    }
    void Do(int value)
    {
        Console.WriteLine("Int: " + value);
    }
}
class Program
{
    static void Main(string[] args)
    {
        A<int> a = new A<int>();
        a.Do(1);
    }
}

void Do<int>(int value) {
  if (value is double d) { // dead end code prune by the compiler
  }
  if (value is int ii) Do (ii);
}

void Do<int>(int value) {
  Do (value);
}