Ergonomic, hermetic, user-friendly software build system for Python, Go, Java, Kotlin, Protobuf, Scala, Shell. Pants lets you fearlessly scale up your codebase!

Pants

attrs has a way to use slots, but it involves passing explicit kwarg to enable

seems to me we could just make the change an internal detail of datatype

if we're going to need to figure out the serilization, should just make sure everything is serializable

which might mean using objects created by the serialization framework.

that’s relatively straight forward I think. Particularly for structs

yeah afaict, `__slots__` is pretty amenable to serialization

I wonder if we could use something even more low level, like <https://docs.python.org/2/library/ctypes.html#ctypes.Structure>

<@U066LC126>: so, what i meant was: serialization frameworks frequently come with an object impl

<@U054MQUPL>: this is supposed to be a public api =/

sure, but the backing impl shouldn’t matter

kinda think `__slots__` might be the best/most tame approach

and we can probably impl a super bare bones gen’d class in ~20 lines

and if we can avoid eval altogether, it’ll make traces much clearer

```&gt;&gt;&gt; import itertools
&gt;&gt;&gt; def datatype(type_name, params):
...   class DataType(object):
...     __slots__ = tuple(params)
...     def __init__(self, *args):
...       assert len(args) == len(params), 'invalid input'
...       for kw, v in itertools.izip(params, args):
...         setattr(self, kw, v)
...   DataType.__name__ = type_name
...   return DataType
...
&gt;&gt;&gt; RustLibrary = datatype('RustLibrary', ['sources', 'dependencies'])
&gt;&gt;&gt; rl = RustLibrary([1,2,3], [4,5,6])
&gt;&gt;&gt; rl.sources
[1, 2, 3]
&gt;&gt;&gt; rl.dependencies
[4, 5, 6]
&gt;&gt;&gt; rl.__slots__
('sources', 'dependencies')
&gt;&gt;&gt; rl.__dict__
Traceback (most recent call last):
  File "&lt;input&gt;", line 1, in &lt;module&gt;
AttributeError: 'RustLibrary' object has no attribute ‘__dict__’
&gt;&gt;&gt; isinstance(rl, RustLibrary)
True
```

do we care about whether the params are representable in python?

I think that’s a fundamental limitation?

but with the above you could create an object with a slot with the name ‘1'

namedtuple has a bunch of validation code to prevent that

```&gt;&gt;&gt; f = datatype('Foo', ['1'])
Traceback (most recent call last):
  File "&lt;input&gt;", line 1, in &lt;module&gt;
  File "&lt;input&gt;", line 2, in datatype
TypeError: Error when calling the metaclass bases
    __slots__ must be identifiers```