from dataclasses import dataclass


@dataclass
class Person:
    name: str
    age: int
    likes: list

dan = Person("Dan", 33, ["Python", "David Bowie", "French Fries"])

print(dan.name)

data class User(val name: String, var age: Int)

>>> data class User(val name: String, var age: Int)

>>> val dan = User("Dan", 32)

>>> dan.name = "Johann Wolfgang von Goethe"
java.lang.IllegalAccessError: tried to access 
field Line2$User.name from class Line4

>>> dan.age = 33
>>> dan
User(name=Dan, age=33)

@dataclass
class User:
    name: str
    age: int


dan = User("Dan", 35)
print(dan)
print("Aging Dan by one year...")
dan.age = 36
print(dan)

@dataclass(frozen=True)
class FrozenUser:
    name: str
    age: int


guido = FrozenUser("Guido", 29)
print(guido)
print("Aging Guido by one year...")
guido.age = 30
print(guido)

FrozenUser(name='Guido', age=29)
Aging Guido by one year...
Traceback (most recent call last):
  File "demo.py", line 26, in <module>
    guido.age = 30
  File "<string>", line 4, in __setattr__
dataclasses.FrozenInstanceError: cannot assign to field 'age'

    if frozen:
        for fn in _frozen_get_del_attr(cls, field_list, globals):


def _frozen_get_del_attr(cls, fields, globals):
	...
    return (_create_fn('__setattr__',
                      ('self', 'name', 'value'),
                      (f'if type(self) is cls or name in {fields_str}:',
                        ' raise FrozenInstanceError(f"cannot assign to field {name!r}")',
                       f'super(cls, self).__setattr__(name, value)'),
                       locals=locals,
                       globals=globals),
            _create_fn('__delattr__',
                      ('self', 'name'),
                      (f'if type(self) is cls or name in {fields_str}:',
                        ' raise FrozenInstanceError(f"cannot delete field {name!r}")',
                       f'super(cls, self).__delattr__(name)'),
                       locals=locals,
                       globals=globals),
            )

def _init_fn(fields, frozen, has_post_init, self_name):
    ...
    return _create_fn('__init__',
                      [self_name] + [_init_param(f) for f in fields if f.init],
                      body_lines,
                      locals=locals,
                      globals=globals,
                      return_type=None)
  
def _repr_fn(fields):
    return _create_fn('__repr__',
                      ('self',),
                      ['return self.__class__.__qualname__ + f"(' +
                       ', '.join([f"{f.name}={{self.{f.name}!r}}"
                                  for f in fields]) +
                       ')"'])
  

def _create_fn(name, args, body, *, globals=None, locals=None,
               return_type=MISSING):
    # Note that we mutate locals when exec() is called.  Caller
    # beware!  The only callers are internal to this module, so no
    # worries about external callers.
    if locals is None:
        locals = {}
    if 'BUILTINS' not in locals:
        locals['BUILTINS'] = builtins
    return_annotation = ''
    if return_type is not MISSING:
        locals['_return_type'] = return_type
        return_annotation = '->_return_type'
    args = ','.join(args)
    body = '\n'.join(f'  {b}' for b in body)

    # Compute the text of the entire function.
    txt = f' def {name}({args}){return_annotation}:\n{body}'

    local_vars = ', '.join(locals.keys())
    txt = f"def __create_fn__({local_vars}):\n{txt}\n return {name}"
    ns = {}
    exec(txt, globals, ns)
    return ns['__create_fn__'](**locals)

add_two_numbers = _create_fn(
    "add_two_numbers",
    ["first_number", "second_number"],
    ["total = first_number + second_number", "print(f'The sum is: {total}')"],
)
add_two_numbers(34, 22)

>>> 56

# Same function, "By hand"
def add_two_numbers(first_number, second_number):
    total = first_number + second_number
    print(f'The sum is: {total}')
    

fields = ["id", "employee_kind"]
# NOTE: Slightly modified from the original source
repr_fun = _create_fn(
    "__repr__",
    ("self",),
    [
        'return self.__class__.__qualname__ + f"('
        + ", ".join([f"{f}={{self.{f}!r}}" for f in fields])
        + ')"'
    ],
)

class Crazy:
    def __init__(self):
        self.id = 123
        self.employee_kind = "Python Dev"

    def __repr__(self):
        return repr_fun(self)


c = Crazy()
print(repr(c))

>>> Crazy(id=123, employee_kind='Python Dev')

CPython != "Scary"