freenode/#clasp - IRC Chatlog
Search
14:43:53
Bike
ok doing typeq in hir really isn't working very well, but having cleavir fix the space of typeqable types probably won't work either
14:45:49
Bike
having a typeq instruction that does some primitive type check mechanism makes perfect sense, but that's only partly related to inference
14:52:24
Bike
eg (typeq thing (array fixnum (3 4))) should be something like (and (typeq thing core::mdarray-fixnum-t) (eql (array-dimension thing 0) 3) (eql (array-dimension thing 1) 4))
14:53:29
Bike
well, it might work if the inferencer gets information from the implementation about what types are primitive
14:54:12
Bike
it's kind of the same deal as with array upgraded types, writ large, though. the runtime has some idea about some types, and cleavir shouldn't like, impose what that is
14:55:48
beach
Wouldn't the inferencer get type information from the implementation about what types are primitive by the fact that the implementation produced typeq instructions in the first place?
15:02:44
Bike
that means i have to rewrite some of type inference again but i'm getting used to that
15:04:21
beach
In fact, I think that's the only way of learning enough about a domain. Make a hypothesis, try it by coding it up, evaluate the result, iterate.
15:04:24
Bike
i like this a lot, actually, i can have type inference deal with joins and meets without giving a damn about the actual types involved, which is as it should be, the algorithm is insensitive
15:06:03
Bike
I guess that means we should only generate THE instructions that match primitive types?
15:06:31
Colleen
Kevslinger: drmeister said at 2017.07.13 08:14:57: I pushed my latest changes to the 'chris' branch of cl-jupyter. %remote-call appears to work now - but still no image. I've emailed Alex Rose to see if he can tell us how to debug ngl interaction. There must be some way to interact with the Javascript console to find out what is going on on the Javascript side.
15:07:30
Bike
well, it's not like the current "just throw the user object into an AST without looking at it besides values stuff" was tenable anyway
15:08:31
Bike
i guess we could just say the implementation has to provide the generate-ast (or cst->ast) method for THE
15:11:35
Bike
well yeah, i'm just wondering how. basically it does it for declarations, so we do want that information somehow
15:12:26
beach
So the transformation from the declaration to the THE should also be controlled by the implementation then it seems.
15:13:03
beach
I mean, the generation of the THE-AST from a declaration should be controlled by the implementation.
15:14:23
Bike
it's a little mixed up, like if you have a call to a function with an ftype, the arguments get the-asts based on the ftype
15:19:43
Bike
anyway, so if we have a declaration on a variable, we want uses (tangentially i think it should be definitions instead) to be turned into THE, and also THE might have to expand into a typep if we're doing type checks, and then the typep should expand into typeq
15:20:49
beach
Maybe so. The Common Lisp HyperSpec is pretty clear about where a THE is a result of a declaration as I recall.
15:20:51
Bike
maybe it would be easier to use some symbol macro like mechanism and do it source level
15:21:30
Bike
moving it to definitions wouldn't change the semantics, it would just reduce the number of checks
15:32:00
Bike
so the problem with a source level thing is that we want it to not recurse, like if we have x => (the declared-type x), the THE translator will call convert-something again and it will expand again
15:37:57
beach
I am not thinking straight at this point. Just submitting ideas. I have had a long day and I am very tired.
15:38:44
Bike
it's not that the translator emits THE, it's that it has to convert the form (as in (the type form)), and then the cleavir converter for forms will emit THE
15:40:13
Bike
we could have the translator convert the form immediately, and then pass it to an implementation defined function that uses it for a typecheck or whatnot
15:42:51
Bike
er, i mean. have the translator on lexical-variable pass the converted lexical variable to the function.
15:50:12
beach
What if it generates (the type (just form)) instead and then JUST could prevent the transformation. Would that work?
15:51:31
Bike
i'm not sure how the transformation would be prevented. either we put in some kind of one use switch everywhere, or we remove the type from the environment, but in that case we have to do it temporarily in case subforms of form use the same information
15:52:55
beach
We must somehow distinguish forms that have already been wrapped in THE and those that have not.
16:30:14
Bike
have the lexical-variable translator do its thing, and then convert `(the type (primop:ast ,its-thing))
16:37:31
Bike
well, per doing one thing at a time, first i have to make sure the low level type check works in clasp before i even do cleavir stuff
19:51:26
Bike
drmeister: if you're around - code you gave me refers to +cons-mask+, which i don't see a definition for