C#•2y ago

Creating a Printer class for my own type.

I am doing this for learning and am aware that if I want to work with JSON I can use System.Text.Json
This is the type to extend:

using System.Text;
namespace JSON.Types;

abstract class JSONValue {
    public abstract JSONValue this[string s] { get; }
    public abstract JSONValue this[int i] { get; }
}

class JSONNum(int val) : JSONValue {
    public int Val { get; set; } = val;
    public override JSONValue this[string s] { get => throw new IndexOutOfRangeException("Cannot index type JSONNum"); }
    public override JSONValue this[int i] { get => throw new IndexOutOfRangeException("Cannot index type JSONNum"); }
}

class JSONString(string val) : JSONValue {
    public string Val { get; set; } = val;
    public override JSONValue this[string s] { get => throw new IndexOutOfRangeException("Cannot index type JSONString"); }
    public override JSONValue this[int i] { get => throw new IndexOutOfRangeException("Cannot index type JSONString"); }
}

class JSONObject(Dictionary<string, JSONValue> val) : JSONValue {
    public Dictionary<string, JSONValue> Val { get; set; } = val;
    public override JSONValue this[string s] { get => Val[s]; }
    public override JSONValue this[int i] { get => throw new IndexOutOfRangeException("Type JSONArray cannot be indexed via int"); }
}

using System.Text;
namespace JSON.Types;

abstract class JSONValue {
    public abstract JSONValue this[string s] { get; }
    public abstract JSONValue this[int i] { get; }
}

class JSONNum(int val) : JSONValue {
    public int Val { get; set; } = val;
    public override JSONValue this[string s] { get => throw new IndexOutOfRangeException("Cannot index type JSONNum"); }
    public override JSONValue this[int i] { get => throw new IndexOutOfRangeException("Cannot index type JSONNum"); }
}

class JSONString(string val) : JSONValue {
    public string Val { get; set; } = val;
    public override JSONValue this[string s] { get => throw new IndexOutOfRangeException("Cannot index type JSONString"); }
    public override JSONValue this[int i] { get => throw new IndexOutOfRangeException("Cannot index type JSONString"); }
}

class JSONObject(Dictionary<string, JSONValue> val) : JSONValue {
    public Dictionary<string, JSONValue> Val { get; set; } = val;
    public override JSONValue this[string s] { get => Val[s]; }
    public override JSONValue this[int i] { get => throw new IndexOutOfRangeException("Type JSONArray cannot be indexed via int"); }
}

And want to define a class like:

using JSON.Types;

namespace JSON.Display;

class PrettyPrint() {
    public static void Print(JSONValue v) {}

    public static void PrintValue(string prefix, JSONNum v) {}
    public static void PrintValue(string prefix, JSONString v) {}
    public static void PrintValue(string prefix, JSONBool v) {}
    public static void PrintValue(string prefix, JSONNull v) {}
    public static void PrintValue(string prefix, JSONArray v) {}
    public static void PrintValue(string prefix, JSONObject v) {}
}

using JSON.Types;

namespace JSON.Display;

class PrettyPrint() {
    public static void Print(JSONValue v) {}

    public static void PrintValue(string prefix, JSONNum v) {}
    public static void PrintValue(string prefix, JSONString v) {}
    public static void PrintValue(string prefix, JSONBool v) {}
    public static void PrintValue(string prefix, JSONNull v) {}
    public static void PrintValue(string prefix, JSONArray v) {}
    public static void PrintValue(string prefix, JSONObject v) {}
}

How should I extend the functionality of the JSON types. I had a ToString() method, but it didnt deal with indents and single responsibility principle.

olaykOP•5/6/24, 4:45 PM

I considered a bunch of if statements and casting the JSONValue to its subclasses, but this didnt seem good

olaykOP•5/6/24, 4:49 PM

I have tried reading how this is implemented in std but it was a lot more complicated to understand

becquerel•5/6/24, 5:13 PM

this seems potentially like a case for interfaces?

becquerel•5/6/24, 5:14 PM

i.e. declare an IPrettyPrintable interface and implement it on JSONNUm, JSONString, JSONBool etc

becquerel•5/6/24, 5:14 PM

that way the relevant code for these types are kept with the rest of their functionality

becquerel•5/6/24, 5:14 PM

and you can just do myValue.PrettyPrint() if you implement it on the base JSONValue type or what have you

olaykOP•5/6/24, 5:28 PM

would I be able to separate the printing part into a diffent namespace with this?

olaykOP•5/6/24, 5:28 PM

ideally i would likee to be able to choose whether i care about the printing or not

becquerel•5/6/24, 6:05 PM

the implementation code for the interface would be in the same classes, and therefore namespaces, as the JSON types

becquerel•5/6/24, 6:05 PM

if you don't care about the printing you could not implement the interface for one of the classes

becquerel•5/6/24, 6:05 PM

i'm not sure how namespaces relate to that though

olaykOP•5/6/24, 7:22 PM

@Becquerel (ping on reply please) this is what I ended up with but I'm not sure if it is good code:

olaykOP•5/6/24, 7:23 PM

i couldn't think of a way to do it apart from this unless i wrote the code for printing inside the JSON.Types

olaykOP•5/6/24, 7:24 PM

i really want the printing of JSON to be separate to its representation

olaykOP•5/6/24, 7:24 PM

olaykOP•5/6/24, 7:25 PM

this is what the output looks like for an example jsonValuee

olaykOP•5/6/24, 7:26 PM

another reason i want the printing to be separate is because i can then do a toFile kind of print that prints it out in bytes, with no whitespace

olaykOP•5/6/24, 7:26 PM

is there a better way to do this using some OOP design pattern or does it need the dynamic dispatch based on the types

becquerel•5/6/24, 7:26 PM

that kind of separation is a valid concern and something to look into... i would look into the visitor pattern, perhaps

becquerel•5/6/24, 7:27 PM

a lesser-used pattern but i've seen it referenced as being particularly useful for parsing or consuming syntax-tree-like things

olaykOP•5/6/24, 7:29 PM

i think that is exactly what i was looking for thank you

olaykOP•5/6/24, 7:31 PM

i would just need to define an accept method in the JSONValue abstract class that accepts a PrettyPrinterVisitor and then define the prettyprintervisitor with the exact same methods that i have here

olaykOP•5/6/24, 7:31 PM

and i could avoid the if statements for the type

olaykOP•5/6/24, 7:33 PM

i will have a go at this tomorrow, and let you know how it turns out

olaykOP•5/6/24, 7:34 PM

this is the sort of pattern that i dont think i could have come up with myself

olaykOP•5/6/24, 7:34 PM

thank you @Becquerel (ping on reply please)

olaykOP•5/6/24, 7:44 PM

ive just read some articles slating the visitor pattern, but its surely still better than dynamic dispatch?

becquerel•5/6/24, 7:50 PM

if we're using the same definition of dynamic dispatch, i really wouldn't worry about it in c#

becquerel•5/6/24, 7:50 PM

since this is a GC language to begin with

becquerel•5/6/24, 7:50 PM

if performance is your concern

olaykOP•5/6/24, 8:19 PM

I’m not too sure about the definitions but I meant it as dynamically choosing which func to call at runtime based on these type checks

olaykOP•5/6/24, 8:20 PM

It seemed like bad code, but functionally I expect to pattern match on a type

olaykOP•5/6/24, 8:20 PM

I tried using a switch but encountered some errors

olaykOP•5/6/24, 8:24 PM

olaykOP•5/6/24, 8:24 PM

And then pattern matching on these, where the compiler knows the exhaustive list of patterns it can be

olaykOP•5/6/24, 8:24 PM

Defining a function to perform on each

Oolayk I’m not too sure about the definitions but I meant it as dynamically choosing wh...

becquerel•5/6/24, 8:35 PM

oh i see. in c# you don't really do that with pattern matching so much as you use inheritance and subtyping

becquerel•5/6/24, 8:35 PM

which also counts as dynamic dispatch because of vtable lookups etc. etc.

becquerel•5/6/24, 8:36 PM

that's what i was getting at earlier when i was talking about interfaces

becquerel•5/6/24, 8:36 PM

you work against variables of the IPrettyPrint type, and at runtime you dynamically get the implementation appropriate for the real type

becquerel•5/6/24, 8:36 PM

that kind of style would be very common and idiomatic in c#

Oolayk I was thinking something like data JsonVal = Num | String | Bool | Null | Array ...

becquerel•5/6/24, 8:37 PM

your style here sounds like something more common in rust, haskell or similar languages

becquerel•5/6/24, 8:37 PM

c# has functional features but its legacy and core is still OOP

olaykOP•5/6/24, 9:17 PM

Yeah I’ve been coding a lot in Haskell recently

Bbecquerel oh i see. in c# you don't really do that with pattern matching so much as you us...

olaykOP•5/6/24, 9:17 PM

What would this look like? Without the visitor pattern I can’t see how to implement the dynamic dispatch with interfaces

olaykOP•5/6/24, 9:18 PM

I’m not too good at OOP compared to more functional code at the moment

olaykOP•5/6/24, 9:19 PM

I was kinda expecting the dispatch to work so long as I implemented a PrintValue for each of the JSONValue subclasses but this isn’t the case

olaykOP•5/6/24, 9:22 PM

I believe that the vtable type code would require implementing a function for each subclass which it then chooses the correct one? I imagine this to be like defining Print on each JSONValue subclass

olaykOP•5/6/24, 9:22 PM

Again, not sure about this