Remove ppp_types0.py
It is just an old version of ppp_types.py, before I probably rewrote the way types worked.
This commit is contained in:
parent
9b960e3ecf
commit
659c79373d
SSH Key Fingerprint:
SHA256:N3w+8798IMWBt7SYH8G1C0iJlIa2HIIcRCXwILT5FvM
180
ppp_types0.py
180
ppp_types0.py
@ -1,180 +0,0 @@
|
|||||||
from dataclasses import dataclass
|
|
||||||
from types import EllipsisType
|
|
||||||
from typing import Dict, Optional, Union as Union_, Tuple as Tuple_, List as List_
|
|
||||||
|
|
||||||
@dataclass
|
|
||||||
class StructContents:
|
|
||||||
generics: 'List_[Type]'
|
|
||||||
members: 'Dict[str, Type]'
|
|
||||||
|
|
||||||
@dataclass
|
|
||||||
class TupleContents:
|
|
||||||
elements: 'List_[Type]'
|
|
||||||
|
|
||||||
@dataclass
|
|
||||||
class EnumContents:
|
|
||||||
generics: 'List_[Type]'
|
|
||||||
members: 'Dict[str, Union_[Dict[str, Type], List_[Type]]]'
|
|
||||||
|
|
||||||
@dataclass
|
|
||||||
class UnknownContents:
|
|
||||||
pass
|
|
||||||
|
|
||||||
@dataclass
|
|
||||||
class FunctionContents:
|
|
||||||
arguments: 'List_[Type]'
|
|
||||||
return_type: 'Type'
|
|
||||||
|
|
||||||
@dataclass
|
|
||||||
class ListContents:
|
|
||||||
type: 'Optional[Type]'
|
|
||||||
|
|
||||||
@dataclass
|
|
||||||
class UnionContents:
|
|
||||||
types: 'List_[Type]'
|
|
||||||
|
|
||||||
@dataclass
|
|
||||||
class Type:
|
|
||||||
name: str
|
|
||||||
contents: Union_[EnumContents, StructContents, TupleContents, FunctionContents, ListContents, UnknownContents, UnionContents]
|
|
||||||
|
|
||||||
def specify(self, *types: 'Type') -> 'Type':
|
|
||||||
assert False, ("Unimplemented")
|
|
||||||
|
|
||||||
def is_subtype_of(self, other: 'Type') -> bool: # TODO: Maybe return any generics that match
|
|
||||||
if other.name == 'object': return True
|
|
||||||
match self.contents, other.contents:
|
|
||||||
case (EnumContents(self_members), EnumContents(other_members)) | (StructContents(self_members), StructContents(other_members)):
|
|
||||||
return self.name == other.name
|
|
||||||
case TupleContents(self_elements), TupleContents(other_elements):
|
|
||||||
if self.name != other.name: return False
|
|
||||||
if len(self_elements) != len(other_elements): return False
|
|
||||||
for (self_element, other_element) in zip(self_elements, other_elements):
|
|
||||||
if not self_element.is_subtype_of(other_element): return False
|
|
||||||
return True
|
|
||||||
case FunctionContents(self_arguments, self_return_type), FunctionContents(other_arguments, other_return_type):
|
|
||||||
for (self_argument, other_argument) in zip(self_arguments, other_arguments):
|
|
||||||
if not other_argument.is_subtype_of(self_argument): return False
|
|
||||||
return self_return_type.is_subtype_of(other_return_type)
|
|
||||||
case ListContents(self_type), ListContents(other_type):
|
|
||||||
if self_type is None: return True
|
|
||||||
if other_type is None: return True
|
|
||||||
return self_type.is_subtype_of(other_type)
|
|
||||||
case UnionContents(self_types), UnionContents(other_types):
|
|
||||||
for type_ in self_types:
|
|
||||||
if not type_.is_subtype_of(other): return False
|
|
||||||
return True
|
|
||||||
case a, b if type(a) == type(b):
|
|
||||||
assert False, ("Unimplemented", self, other)
|
|
||||||
case _, UnionContents(types):
|
|
||||||
for type_ in types:
|
|
||||||
if self.is_subtype_of(type_): return True
|
|
||||||
return False
|
|
||||||
case _, _:
|
|
||||||
return False
|
|
||||||
assert False, ("Unimplemented")
|
|
||||||
|
|
||||||
def fill(self, types: 'Dict[str, Type]') -> 'Type':
|
|
||||||
match self.contents:
|
|
||||||
case TupleContents(elements):
|
|
||||||
return Type(self.name, TupleContents([type.fill(types) for type in elements]))
|
|
||||||
case EnumContents(generics, members):
|
|
||||||
assert not generics # TODO
|
|
||||||
|
|
||||||
new_members: Dict[str, Union_[Dict[str, Type], List_[Type]]] = {}
|
|
||||||
for name in members:
|
|
||||||
member = members[name]
|
|
||||||
if isinstance(member, list):
|
|
||||||
new_members[name] = [type.fill(types) for type in member]
|
|
||||||
elif isinstance(member, dict):
|
|
||||||
new_members[name] = {field: member[field].fill(types) for field in member}
|
|
||||||
else:
|
|
||||||
assert False, "Unreachable"
|
|
||||||
|
|
||||||
return Type(self.name, EnumContents(generics, new_members))
|
|
||||||
case StructContents(generics, members):
|
|
||||||
assert not generics # TODO
|
|
||||||
return Type(self.name, StructContents(generics, {field: members[field].fill(types) for field in members}))
|
|
||||||
case ListContents(type):
|
|
||||||
return Type(self.name, ListContents(type.fill(types) if type else None))
|
|
||||||
case UnknownContents():
|
|
||||||
return types[self.name] if self.name in types else self
|
|
||||||
case UnionContents(types_):
|
|
||||||
return Type(self.name, UnionContents([type.fill(types) for type in types_]))
|
|
||||||
case FunctionContents(arguments, return_type):
|
|
||||||
return Type(self.name, FunctionContents([argument.fill(types) for argument in arguments], return_type.fill(types)))
|
|
||||||
case _:
|
|
||||||
assert False, ("Unimplemented", self.contents)
|
|
||||||
assert False, "Unreachable"
|
|
||||||
|
|
||||||
def represent(self) -> str:
|
|
||||||
match self.contents:
|
|
||||||
case EnumContents(generics, _) | StructContents(generics, _): return self.name + ("<"+', '.join([generic.represent() for generic in generics])+">" if generics else '')
|
|
||||||
case TupleContents(elements): return (self.name if self.name != "tuple" else '') + ('('+', '.join([generic.represent() for generic in elements])+')' if elements else '')
|
|
||||||
case ListContents(type): return (type.represent() if type else '')+'[]'
|
|
||||||
case UnknownContents(): return self.name+"?"
|
|
||||||
case UnionContents(types): return '('+'|'.join([type.represent() for type in types])+')'
|
|
||||||
case FunctionContents(arguments, return_type): return "("+', '.join([type.represent() for type in arguments])+") -> "+return_type.represent()
|
|
||||||
assert False, ("Unimplemented")
|
|
||||||
|
|
||||||
def __eq__(self, other) -> bool:
|
|
||||||
return isinstance(other, Type) and self.is_subtype_of(other) and other.is_subtype_of(self)
|
|
||||||
|
|
||||||
def __repr__(self) -> str:
|
|
||||||
try:
|
|
||||||
return self.represent()
|
|
||||||
except AssertionError:
|
|
||||||
return f"Unimplemented {self.contents.__class__.__name__}"
|
|
||||||
|
|
||||||
def primitive(name: str) -> Type: return Type(name, TupleContents([]))
|
|
||||||
Int = primitive("int")
|
|
||||||
Str = primitive("str")
|
|
||||||
Bool = primitive("bool")
|
|
||||||
Void = primitive("void")
|
|
||||||
TypeType = primitive("type")
|
|
||||||
|
|
||||||
def Tuple(*types: Type) -> Type: return Type("tuple", TupleContents(list(types)))
|
|
||||||
def List(type: Optional[Type]=None) -> Type: return Type("list", ListContents(type))
|
|
||||||
|
|
||||||
def Function(*arguments_and_return_type: Type) -> Type:
|
|
||||||
assert arguments_and_return_type, "Must have a return value"
|
|
||||||
return Type("function", FunctionContents(list(arguments_and_return_type[:-1]), arguments_and_return_type[-1]))
|
|
||||||
|
|
||||||
Unit = Tuple()
|
|
||||||
|
|
||||||
def Union(*types: Type) -> Type: return Type("union", UnionContents(list(types)))
|
|
||||||
def Return(type: Type) -> Type:
|
|
||||||
return Type('return', StructContents([type], {'value': type}))
|
|
||||||
|
|
||||||
Object = primitive('object')
|
|
||||||
|
|
||||||
# TODO: struct enum members
|
|
||||||
def EnumMember(enum_type: Type, *types: Type) -> Type: return Type('enum_tuple_member', FunctionContents(list(types), enum_type))
|
|
||||||
|
|
||||||
# def issubclassof(type1: Type, type2: Type) -> bool:
|
|
||||||
# if type1.name != 'union' and type2.name == 'union':
|
|
||||||
# return type1 in type2.generics
|
|
||||||
# if type1.name != type2.name: return False
|
|
||||||
# if not type2.generics: return True
|
|
||||||
# if len(type1.generics) != len(type2.generics): return False
|
|
||||||
# if type1.name == '->':
|
|
||||||
# for (type_a, type_b) in zip(type1.generics[:-1], type2.generics[:-1]):
|
|
||||||
# if not issubclassof(type_b, type_a): return False
|
|
||||||
# return issubclassof(type1.generics[-1], type2.generics[-1])
|
|
||||||
# if type1.name == 'union': assert False, ("Unimplemented", type1, type2)
|
|
||||||
# if type1.name == 'tuple': return all([issubclassof(type_a, type_b) for (type_a, type_b) in zip(type1.generics, type2.generics)])
|
|
||||||
# assert False, ("Unimplemented", type1, type2)
|
|
||||||
|
|
||||||
# Void = Type('void', TupleContents([]))
|
|
||||||
# AbstractFunction = Type('->', [])
|
|
||||||
# def Function(*arguments_and_return_type: Type) -> Type:
|
|
||||||
# assert arguments_and_return_type, "Must have a return value"
|
|
||||||
# return AbstractFunction.specify(*arguments_and_return_type)
|
|
||||||
|
|
||||||
# Int = Type('int', [], False)
|
|
||||||
# String = Type('str', [], False)
|
|
||||||
# Bool = Type('bool', [], False)
|
|
||||||
# def List(type: Type) -> Type: return Type('list', [type])
|
|
||||||
|
|
||||||
# Unit = Type('unit', [], False)
|
|
||||||
# def Tuple(*types: Type) -> Type: return Type('tuple', list(types)) if types else Unit
|
|
||||||
Loading…
Reference in New Issue
Block a user