Design todos
- change name? graphite? morphic? sapphire? metamorphic? garnet? jaspre? lapis? carnelian? sard? sardonyx? agate? chalcedony?
- good syntax to do what pandas dataframes do (also: generalize so uniform in dimensions unlike Series vs Dataframe, and not constrained to 2d
- note that dataframes has some graphy operations such as align, join left/right/inner/outer, combine_first, combine with
- learn Gremlins graph syntax and consider having something like that
- continue to improve the pattern match syntax
- should == really be isa?
- maybe <= should be isa instead?
- should subtyping be unified with types that contain types? if we have Any, should Any be the same as Type? e.g. 3 instanceOf Int and 3 instanceOf Num and 3 instanceOf Any, so should 3 instanceOf Type?
- related, is the relation between a value and its type <.?
- what's the problem with having a Type of Types anyways?
- how should we have syntax for kinds?
- how should we capture the 'most specific type' of a value, e.g. 3 isa Int and 3 isa Num, but it's "really" implemented as an Int
- should we have an Any? Should we have a Type?
- how to handle implicit coercion
- what's that problem in Scala again that lets you effectively have two steps in implicit coercions? (bad imo)
- structural vs. reference equality?
- concurrency syntax?
- Design FFI
- Design type checker overview
- Design Jasper Core
- Core library design (look at all langs mentioned above)
- be sure that conciseness of "data Tree a = Leaf a
- what restrictions on return type only polymorphism and related?
- constraint logic
- net patterns
- better define the 'handler' thing and how it interacts with continuations, multi IO fns
- how to do the exception tower
- type system
- implicit typecasting?
- see scala for custom implicit typecasting, i worry that this is bad tho
- but want to be able to cast str to numbers and numbers to str to make a good scripting language
- make sure we can support the kind of stuff that gremlin and the other tinkerpop property graph stuff can do
- ontology
- define various logics, constraint satisfaction languages
- RDF+ (see jasperLogicNotes)
- dataframes
- look at Coq
- when x.y.z = a, and x,y,z have custom __set__s, which __set__ gets control? (i think i had the usual idea to do it hierarchically, but i think there may have been some issue, need to check if there was in fact an unresolved issue or not)
- or is [] required for 'settable index' or 'settable slice' or just for 'slice'?
- when x is 3-d, and you do y = x 3 2 (a slice), then can you do y 4 = 5? do you have to make y a reference, e.g. &y =& x 3 2; &y 4 = 5?
- memory leaks in the presence of laziness
- see sections "design todos" in each jasper*.txt file in this directory
- if there is no distinction between a zero-ary function and a value (like in Haskell), and you don't have to explicitly deref a stateful variable (unlike Lisp), then how could a library add something like an implicit future? It seems like the answer should have something to do with the __get protocol, but should __get handle an 'access' without arguments, allowing something like a zero-ary function or thunk? for that matter, how would laziness or something like it be implemented in a library? in the case of both futures and laziness, once the value is finally known, it stays constant, but how would you implement binding/aliasing in a library (e.g. remove objects) in this fashion? perhaps in addition to __get we need to add a new Jasper attribute, like "__access" or (riffing on HTTP, since we already decided we want a __connect) __connect or __read? or mb the current __get should be renamed __apply, and the current __apply should either be renamed to __preapply, or merged with the new __apply, and then this new attribute should be named __get.
- late binding? (Alan Kay is a huge fan)
(from other list):
a) how are perspectives related to type coercion, if at all? b) how are perspectives combined? e.g. an "implicitly mapped set of ints". e.g. monadic lifting? c) what is the syntax for accessing a part of a combined perspective? do we need a 'path syntax', e.g. a.b.c.d can mean that path as a whole rather than == __get(__get(__get(__get(ENV, a), b), c), d)? couldn't we just use [a b c d] for that? c) how to control the passsage of sensor and effector access permissions down? d) how does the exception tower work? this should be a clean special case of perspective combination e) if both the function and the value are polymorphic, who polymorphs first? i'm guessing that first the value chooses what it does to the function, then that modified function looks at the value's type and polymorphs and applies f) ML's module system g) problem chaining calls when object-style calls and function-style calls are mixed (e.g. i cant think of an example but in ruby you can go a.b.c sometimes when the Python would intermix function calls with method calls, leading to a chain that goes in both directions). how to make prototype inheritance and Haskell-style polymorphic functional dispatch match up?
- what to do about the fundamental attribute __list?
- how to handle multigraphs? should __get returns a set or not? syntactic any/all operator to control this?
- how to do 'everything is an interface'?
- how to do pattern literals?
(from other list)
topics that i've thought about/to think about:
prototyping, inheritance, composition, delegation parameterized types marked arguments for mapping, ^annotation, data parallelism, strictness $resources, $i18n, KEYWORDS
>, power set graphs, level-shifting lang??
blocks as WHERE maybe' ?metavariables?, quoting graph patterns, predicate types, interfaces {impl attributes}, semantic vs. nonsemantic attributes views boundaries objects, topological/implicit refs, owners, reference aliasing, refs as values seq assertions ! exceptions slices modules, namespaces, dependency injection n-dim arrays CSP, ?metavariables -- or quoting?, probabilities types as sets semantic weby stuff - URIs, triples, inheritance versioning, sync, webdav, different ways of referring to the same thing ez to pass 'self' construction, destruction, field initialization, resource reference counting? read-only many-1 graph assignment state impl switch at runtime? multi-stage programming list expansion, variadic functions, syntactic fold relations
relations, hypergraphs, level-shifting lang, reification, semantic weby stuff - URIs, triples, inheritance; also, versioning, sync, webdav, different ways of referring to the same thing, kant graph patterns, predicate types, parallelism, quantifiers, state, seq CSP, ?metavariables -- or quoting?, probabilities parameterized types, inheritance, construction, destruction, field initialization resource manager, resource reference counting, components maybe' boundaries refs views modules, namespaces, dependency injection multi-stage programming
search in notes also for "Things to decide on", "remaining", "questions", "todos"