{"payload":{"feedbackUrl":"https://github.com/orgs/community/discussions/53140","repo":{"id":674765027,"defaultBranch":"main","name":"mtcl","ownerLogin":"nilium","currentUserCanPush":false,"isFork":false,"isEmpty":false,"createdAt":"2023-08-04T18:05:21.000Z","ownerAvatar":"https://avatars.githubusercontent.com/u/44962?v=4","public":true,"private":false,"isOrgOwned":false},"refInfo":{"name":"","listCacheKey":"v0:1691215312.0","currentOid":""},"activityList":{"items":[{"before":"694180dcac9cfd7684ea82b7cda2d3de6544d853","after":"dee14d2e8fe969ee4d202d9aac7b1a800ee76e74","ref":"refs/heads/dev","pushedAt":"2023-09-13T19:25:18.000Z","pushType":"force_push","commitsCount":0,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"WIP\n\nThis commit to be rewritten.\n\n  * Split up prelude.go into a few files because it's getting unwieldy\n    to maintain.\n\n  * Add Float type, as well as guaranteed float/int types that cannot\n    return unexpected values. This does not mean the values will be\n    expected by the script, only that they got there through normal\n    operation (e.g., Inf, NaN). Unlike integers, this does not use\n    big.Float because it's generally understood that floats are going\n    to be lossy, and there's no avoiding that with big.Float. Using\n    big.Rat is an option but doesn't seem like a great plan.\n\n  * Adjust `set` to allow a `-multi` option to be passed, setting\n    multiple vars instead of one var with many values. This may get\n    removed because it was part of an experiment.\n\n  * Add LitInt, LitFloat types to wrap an integer / float with the\n    literal text value from their string. This affects the string value\n    of said values only until they're either explicitly converted to\n    a float / integer or used in arithmetic in some way. This is to\n    ensure that values the interpreter converts from literal text do\n    not lose their text form, as before with integers, but we also\n    don't lose the typical interpretation of a number. This should later\n    be moved into the parser where it can cache an interpreter-friendly\n    value to be used later.\n\n  * Add normal comparison operators in the form of commands (i.e.,\n    Lisp-y). These still need fixing up as they were implemented\n    after integers and before floats, so they're not fully-functional\n    yet. The plan for these should be the same as integers: if one\n    side of a comparison is an integer and the other side is a float,\n    degrade to a float.\n\n  * Add basic arithmetic operators in the form of commands. These\n    should support the current range of numeric types and some\n    operations on vecs (and nested vecs and so on).\n\n  * Add `car`, `cdr`, and `nth` (different than before)\n    functions. These operate on argument lists and don't care about\n    the exact arguments being passed to them. `car` and `cdr` will\n    return the head and tail of argument lists and `nth` will return\n    an exact item from an argument list.\n\n  * Len is no longer a required method for values and those that\n    implement it must now return an interpreter-friendly Int instead\n    of an int. This is purely an accomodation for the Seq type,\n    which can have a length in excess of a machine integer (as used\n    by Go, anyway).","shortMessageHtmlLink":"WIP"}},{"before":"bfb9f4fe8b616773c2bf4a508e320e24c9beb423","after":"0a82db0e9e6b8205cc5727f702f338da4211a30b","ref":"refs/heads/main","pushedAt":"2023-09-13T19:24:47.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Fix lookup scope for expr evaluation\n\nChange the lookup scope for expr evaluation in uplevel to be the calling\nscope instead of the script eval scope. This ensures that you can do\nuplevel N \"foo $bar baz\" and correctly interpolate `$bar` locally.","shortMessageHtmlLink":"Fix lookup scope for expr evaluation"}},{"before":"f6f7d0fc40a8ab524a03fb83042263080ab3c6ef","after":"694180dcac9cfd7684ea82b7cda2d3de6544d853","ref":"refs/heads/dev","pushedAt":"2023-09-13T08:16:56.000Z","pushType":"force_push","commitsCount":0,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"WIP\n\nThis commit to be rewritten.\n\n  * Split up prelude.go into a few files because it's getting unwieldy\n    to maintain.\n\n  * Add Float type, as well as guaranteed float/int types that cannot\n    return unexpected values. This does not mean the values will be\n    expected by the script, only that they got there through normal\n    operation (e.g., Inf, NaN). Unlike integers, this does not use\n    big.Float because it's generally understood that floats are going\n    to be lossy, and there's no avoiding that with big.Float. Using\n    big.Rat is an option but doesn't seem like a great plan.\n\n  * Adjust `set` to allow a `-multi` option to be passed, setting\n    multiple vars instead of one var with many values. This may get\n    removed because it was part of an experiment.\n\n  * Add LitInt, LitFloat types to wrap an integer / float with the\n    literal text value from their string. This affects the string value\n    of said values only until they're either explicitly converted to\n    a float / integer or used in arithmetic in some way. This is to\n    ensure that values the interpreter converts from literal text do\n    not lose their text form, as before with integers, but we also\n    don't lose the typical interpretation of a number. This should later\n    be moved into the parser where it can cache an interpreter-friendly\n    value to be used later.\n\n  * Add normal comparison operators in the form of commands (i.e.,\n    Lisp-y). These still need fixing up as they were implemented\n    after integers and before floats, so they're not fully-functional\n    yet. The plan for these should be the same as integers: if one\n    side of a comparison is an integer and the other side is a float,\n    degrade to a float.\n\n  * Add basic arithmetic operators in the form of commands. These\n    should support the current range of numeric types and some\n    operations on vecs (and nested vecs and so on).\n\n  * Add `car`, `cdr`, and `nth` (different than before)\n    functions. These operate on argument lists and don't care about\n    the exact arguments being passed to them. `car` and `cdr` will\n    return the head and tail of argument lists and `nth` will return\n    an exact item from an argument list.\n\n  * Len is no longer a required method for values and those that\n    implement it must now return an interpreter-friendly Int instead\n    of an int. This is purely an accomodation for the Seq type,\n    which can have a length in excess of a machine integer (as used\n    by Go, anyway).","shortMessageHtmlLink":"WIP"}},{"before":"05f375e1ae85c0effe2bed5d0d4fdb1018151df8","after":"f6f7d0fc40a8ab524a03fb83042263080ab3c6ef","ref":"refs/heads/dev","pushedAt":"2023-09-13T05:27:02.000Z","pushType":"force_push","commitsCount":0,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"WIP\n\nThis commit to be rewritten.\n\n  * Split up prelude.go into a few files because it's getting unwieldy\n    to maintain.\n\n  * Add Float type, as well as guaranteed float/int types that cannot\n    return unexpected values. This does not mean the values will be\n    expected by the script, only that they got there through normal\n    operation (e.g., Inf, NaN). Unlike integers, this does not use\n    big.Float because it's generally understood that floats are going\n    to be lossy, and there's no avoiding that with big.Float. Using\n    big.Rat is an option but doesn't seem like a great plan.\n\n  * Adjust `set` to allow a `-multi` option to be passed, setting\n    multiple vars instead of one var with many values. This may get\n    removed because it was part of an experiment.\n\n  * Add LitInt, LitFloat types to wrap an integer / float with the\n    literal text value from their string. This affects the string value\n    of said values only until they're either explicitly converted to\n    a float / integer or used in arithmetic in some way. This is to\n    ensure that values the interpreter converts from literal text do\n    not lose their text form, as before with integers, but we also\n    don't lose the typical interpretation of a number. This should later\n    be moved into the parser where it can cache an interpreter-friendly\n    value to be used later.\n\n  * Add normal comparison operators in the form of commands (i.e.,\n    Lisp-y). These still need fixing up as they were implemented\n    after integers and before floats, so they're not fully-functional\n    yet. The plan for these should be the same as integers: if one\n    side of a comparison is an integer and the other side is a float,\n    degrade to a float.\n\n  * Add basic arithmetic operators in the form of commands. These\n    should support the current range of numeric types aren't fully\n    functional around lists yet.\n\n  * Add `car`, `cdr`, and `nth` (different than before)\n    functions. These operate on argument lists and don't care about\n    the exact arguments being passed to them. `car` and `cdr` will\n    return the head and tail of argument lists and `nth` will return\n    an exact item from an argument list.\n\n  * Len is no longer a required method for values and those that\n    implement it must now return an interpreter-friendly Int instead\n    of an int. This is purely an accomodation for the Seq type,\n    which can have a length in excess of a machine integer (as used\n    by Go, anyway).","shortMessageHtmlLink":"WIP"}},{"before":"d0f7e030a41b6bbbb741f46aa21a1fd7071033b2","after":"bfb9f4fe8b616773c2bf4a508e320e24c9beb423","ref":"refs/heads/main","pushedAt":"2023-09-12T05:07:46.000Z","pushType":"push","commitsCount":2,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Fix error unwrapping for parser\n\nFix error unwrapping for the parser so that if it encounters an error,\nit correctly surfaces the error and allows unwrapping it. This is\nsomewhat useful in a REPL since you can handle ErrUnexpectedEOF for\na buffer by reading another line and retrying.","shortMessageHtmlLink":"Fix error unwrapping for parser"}},{"before":"1a4b39a8dab3d9ba5d048c4786d260c7849958c4","after":"05f375e1ae85c0effe2bed5d0d4fdb1018151df8","ref":"refs/heads/dev","pushedAt":"2023-09-12T01:45:55.000Z","pushType":"force_push","commitsCount":0,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"WIP\n\nThis commit to be rewritten.\n\n  * Split up prelude.go into a few files because it's getting unwieldy\n    to maintain.\n\n  * Add Float type, as well as guaranteed float/int types that cannot\n    return unexpected values. This does not mean the values will be\n    expected by the script, only that they got there through normal\n    operation (e.g., Inf, NaN). Unlike integers, this does not use\n    big.Float because it's generally understood that floats are going\n    to be lossy, and there's no avoiding that with big.Float. Using\n    big.Rat is an option but doesn't seem like a great plan.\n\n  * Adjust `set` to allow a `-multi` option to be passed, setting\n    multiple vars instead of one var with many values. This may get\n    removed because it was part of an experiment.\n\n  * Add LitInt, LitFloat types to wrap an integer / float with the\n    literal text value from their string. This affects the string value\n    of said values only until they're either explicitly converted to\n    a float / integer or used in arithmetic in some way. This is to\n    ensure that values the interpreter converts from literal text do\n    not lose their text form, as before with integers, but we also\n    don't lose the typical interpretation of a number. This should later\n    be moved into the parser where it can cache an interpreter-friendly\n    value to be used later.\n\n  * Add normal comparison operators in the form of commands (i.e.,\n    Lisp-y). These still need fixing up as they were implemented\n    after integers and before floats, so they're not fully-functional\n    yet. The plan for these should be the same as integers: if one\n    side of a comparison is an integer and the other side is a float,\n    degrade to a float.\n\n  * Add basic arithmetic operators in the form of commands. These\n    should support the current range of numeric types aren't fully\n    functional around lists yet.\n\n  * Add `car`, `cdr`, and `nth` (different than before)\n    functions. These operate on argument lists and don't care about\n    the exact arguments being passed to them. `car` and `cdr` will\n    return the head and tail of argument lists and `nth` will return\n    an exact item from an argument list.\n\n  * Len is no longer a required method for values and those that\n    implement it must now return an interpreter-friendly Int instead\n    of an int. This is purely an accomodation for the Seq type,\n    which can have a length in excess of a machine integer (as used\n    by Go, anyway).","shortMessageHtmlLink":"WIP"}},{"before":"70cc57a95d54411898d3d6827df35550ce53d777","after":"1a4b39a8dab3d9ba5d048c4786d260c7849958c4","ref":"refs/heads/dev","pushedAt":"2023-09-05T06:07:16.000Z","pushType":"force_push","commitsCount":0,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"WIP\n\nThis commit to be rewritten.\n\n  * Split up prelude.go into a few files because it's getting unwieldy\n    to maintain.\n\n  * Add Float type, as well as guaranteed float/int types that cannot\n    return unexpected values. This does not mean the values will be\n    expected by the script, only that they got there through normal\n    operation (e.g., Inf, NaN). Unlike integers, this does not use\n    big.Float because it's generally understood that floats are going\n    to be lossy, and there's no avoiding that with big.Float. Using\n    big.Rat is an option but doesn't seem like a great plan.\n\n  * Adjust `set` to allow a `-multi` option to be passed, setting\n    multiple vars instead of one var with many values. This may get\n    removed because it was part of an experiment.\n\n  * Add LitInt, LitFloat types to wrap an integer / float with the\n    literal text value from their string. This affects the string value\n    of said values only until they're either explicitly converted to\n    a float / integer or used in arithmetic in some way. This is to\n    ensure that values the interpreter converts from literal text do\n    not lose their text form, as before with integers, but we also\n    don't lose the typical interpretation of a number. This should later\n    be moved into the parser where it can cache an interpreter-friendly\n    value to be used later.\n\n  * Add normal comparison operators in the form of commands (i.e.,\n    Lisp-y). These still need fixing up as they were implemented\n    after integers and before floats, so they're not fully-functional\n    yet. The plan for these should be the same as integers: if one\n    side of a comparison is an integer and the other side is a float,\n    degrade to a float.\n\n  * Add basic arithmetic operators in the form of commands. These\n    should support the current range of numeric types aren't fully\n    functional around lists yet.\n\n  * Add `car`, `cdr`, and `nth` (different than before)\n    functions. These operate on argument lists and don't care about\n    the exact arguments being passed to them. `car` and `cdr` will\n    return the head and tail of argument lists and `nth` will return\n    an exact item from an argument list.\n\n  * Len is no longer a required method for values and those that\n    implement it must now return an interpreter-friendly Int instead\n    of an int. This is purely an accomodation for the Seq type,\n    which can have a length in excess of a machine integer (as used\n    by Go, anyway).","shortMessageHtmlLink":"WIP"}},{"before":"d0f7e030a41b6bbbb741f46aa21a1fd7071033b2","after":"70cc57a95d54411898d3d6827df35550ce53d777","ref":"refs/heads/dev","pushedAt":"2023-08-14T09:16:45.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"WIP\n\nThis commit to be rewritten.\n\n  * Split up prelude.go into a few files because it's getting unwieldy\n    to maintain.\n\n  * Add Float type, as well as guaranteed float/int types that cannot\n    return unexpected values. This does not mean the values will be\n    expected by the script, only that they got there through normal\n    operation (e.g., Inf, NaN). Unlike integers, this does not use\n    big.Float because it's generally understood that floats are going\n    to be lossy, and there's no avoiding that with big.Float. Using\n    big.Rat is an option but doesn't seem like a great plan.\n\n  * Adjust `set` to allow a `-multi` option to be passed, setting\n    multiple vars instead of one var with many values. This may get\n    removed because it was part of an experiment.\n\n  * Add LitInt, LitFloat types to wrap an integer / float with the\n    literal text value from their string. This affects the string value\n    of said values only until they're either explicitly converted to\n    a float / integer or used in arithmetic in some way. This is to\n    ensure that values the interpreter converts from literal text do\n    not lose their text form, as before with integers, but we also\n    don't lose the typical interpretation of a number. This should later\n    be moved into the parser where it can cache an interpreter-friendly\n    value to be used later.\n\n  * Add normal comparison operators in the form of commands (i.e.,\n    Lisp-y). These still need fixing up as they were implemented\n    after integers and before floats, so they're not fully-functional\n    yet. The plan for these should be the same as integers: if one\n    side of a comparison is an integer and the other side is a float,\n    degrade to a float.\n\n  * Add basic arithmetic operators in the form of commands. These\n    should support the current range of numeric types aren't fully\n    functional around lists yet.\n\n  * Add `car`, `cdr`, and `nth` (different than before)\n    functions. These operate on argument lists and don't care about\n    the exact arguments being passed to them. `car` and `cdr` will\n    return the head and tail of argument lists and `nth` will return\n    an exact item from an argument list.\n\n  * Len is no longer a required method for values and those that\n    implement it must now return an interpreter-friendly Int instead\n    of an int. This is purely an accomodation for the Seq type,\n    which can have a length in excess of a machine integer (as used\n    by Go, anyway).","shortMessageHtmlLink":"WIP"}},{"before":"9aab06eee6de9b5d743d4a251b67b95b8a92c5b0","after":"d0f7e030a41b6bbbb741f46aa21a1fd7071033b2","ref":"refs/heads/main","pushedAt":"2023-08-14T09:00:53.000Z","pushType":"push","commitsCount":2,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Add `while`, adjust command interpretation for `foreach`\n\nAdd a `while` command -- nothing really special about it. Does what\none would think. Adjust the `foreach` command to regenerate commands\nif necessary for each loop iteration. This should only be required if\nnot given a raw string and result in RawString command caches being\nused for all normal cases (I should probably verify this). I could\nalso restrict things to only allow raw strings, especially since\nthat'll make certain cases like bytecode generation later easier\n(since the amount of code that can be generated ahead of time is a\nlot easier to guarantee with raw strings).","shortMessageHtmlLink":"Add <code>while</code>, adjust command interpretation for <code>foreach</code>"}},{"before":"51e3eede1d13b6cda4d8e62527379e2d6c545be2","after":"d0f7e030a41b6bbbb741f46aa21a1fd7071033b2","ref":"refs/heads/dev","pushedAt":"2023-08-14T01:27:30.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Add `while`, adjust command interpretation for `foreach`\n\nAdd a `while` command -- nothing really special about it. Does what\none would think. Adjust the `foreach` command to regenerate commands\nif necessary for each loop iteration. This should only be required if\nnot given a raw string and result in RawString command caches being\nused for all normal cases (I should probably verify this). I could\nalso restrict things to only allow raw strings, especially since\nthat'll make certain cases like bytecode generation later easier\n(since the amount of code that can be generated ahead of time is a\nlot easier to guarantee with raw strings).","shortMessageHtmlLink":"Add <code>while</code>, adjust command interpretation for <code>foreach</code>"}},{"before":"9aab06eee6de9b5d743d4a251b67b95b8a92c5b0","after":"51e3eede1d13b6cda4d8e62527379e2d6c545be2","ref":"refs/heads/dev","pushedAt":"2023-08-14T01:23:43.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Fix for ints replacing strings that don't match 1:1\n\nFix previous behavior (that was supposed to be already committed) that\nwould allow an integer with, for example, a + sign to replace literal\ntext with an integer that did not match the original literal. May\nlater add something to store literal text in integers generated from\nliterals to keep their original string value, but not right now.","shortMessageHtmlLink":"Fix for ints replacing strings that don't match 1:1"}},{"before":"da3e1693c085bf1a95d1298d3e201ebd6474c8d6","after":"9aab06eee6de9b5d743d4a251b67b95b8a92c5b0","ref":"refs/heads/main","pushedAt":"2023-08-13T20:59:50.000Z","pushType":"push","commitsCount":7,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Add README\n\nAdd a very short README so the repo page isn't quite so barren.","shortMessageHtmlLink":"Add README"}},{"before":"4faea5dc5f21f33b643ec8ab3253bedbe363f1de","after":"9aab06eee6de9b5d743d4a251b67b95b8a92c5b0","ref":"refs/heads/dev","pushedAt":"2023-08-13T20:59:17.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Add README\n\nAdd a very short README so the repo page isn't quite so barren.","shortMessageHtmlLink":"Add README"}},{"before":"e009f1e400cf01fbfbbc0904e9411665eca9c40f","after":"4faea5dc5f21f33b643ec8ab3253bedbe363f1de","ref":"refs/heads/dev","pushedAt":"2023-08-13T20:44:47.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Split types up, add seq/bool/int, implement `if`\n\nThis is mostly cleaning and a bit of adding features. For the most part:\n\n  * Implement the `if` command, along with short-circuiting `and`\n    and `or` commands. This doesn't cover actual expressions and\n    comparisons and so on yet, I suspect that will go lisp-like instead\n    of `expr`-like for ease of implementation, but haven't decided yet.\n\n  * Implement `seq`, `int`, and `bool` types. The `int` type is a\n    big.Int under the hood to ensure that all integers in a particular\n    range can be represented. Literals that look like integers are\n    automatically converted to integers as long as their text and\n    integer-as-string representations are the same (otherwise, they\n    remain strings to ensure that someone passing a flag like `+1`\n    to a command doesn't result in the `+` being removed). And `int`\n    command is provided for manual conversions.\n\n    `bool` is straight-forward and just wraps Go's bool type. Literals\n    are converted to booleans if their string value is `true` or `false`\n    and otherwise are left alone.\n\n    The `seq` type covers a range from one number to another with\n    an arbitrary step. This is mainly intended for use with foreach\n    since it doesn't require generating a whole list of numbers. You\n    can expand it (`... [seq 100]`) to get a whole list of numbers,\n    but it probably isn't that useful most of the time.\n\n  * Move types into their own files, except for `Values` which\n    belongs to type_value.go because it's the general purpose type\n    for holding everything. This is just to get a bunch of stuff out\n    of interp.go.\n\n  * Remove `doInContext` and replace it with `Interp.Eval`. Similar\n    behavior, less clunky.\n\n  * Move the dump program to cmd/mtcldebug.","shortMessageHtmlLink":"Split types up, add seq/bool/int, implement <code>if</code>"}},{"before":"61ce4575d13588a8dca7d2feb1cf3b41ce25d9b9","after":"e009f1e400cf01fbfbbc0904e9411665eca9c40f","ref":"refs/heads/dev","pushedAt":"2023-08-12T05:23:22.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Refactor for callbacks hack\n\nSome necessary refactoring, partly for clean-up and partly to make\nsupporting callbacks easier.\n\nRemove the `Context` and `Interp` types and rename `interpScope` to\n`Interp`. This is to make it easier to build interpreter features\nfor now since the old `Interp` was never passed into anything and\nthe only relevant context type was `interpScope`. The `Context`\ntype may come back later if/when I decide to split the parser and\ninterpreter up to make it easier, especially if I want to move the\nprelude functions into another package.\n\nAdd a Func type that carries a Cmd and an optional set of argument\nbindings to pass to the Cmd before other arguments. This is produced\nby both the `fn` command and the `&` (informally 'bind') command. The\nlatter creates a `Func` with bound arguments, similar to if you\nused `fn` to wrap another function. Importantly, `&` will produce a\n`Func` that survives function renames, deletions, etc. while the `fn`\nwrapper relies on looking up the function each time.\n\nEach `Interp` now carries an `overlays` slice of other `Interp`\ninstances that influence `upvar` and command lookups, taking precedence\nover the caller `Interp` for those. Forking an `Interp` retains the\noverlays slice to ensure nesting multiple layers of procs continues\nworking. This might be replaced with flattening overlays down to\njust vars and making each `Fork` call clone the previous commands\nmap instead of the linked list for lookups -- this has the effect of\nmaking function bindings sticky for each scope, though. Would either\nneed to require that functions are defined in order to be accessed\nor retain the `Interp` traversal for functions defined out of order\nfrom one another. For now, this works, hacky as it is.\n\nAdditional changes:\n\n  - Add a ParseCommand function to the parser to parse just the next\n    command in line. This is useful with things like rlwrap if writing\n    a small REPL (which isn't included in this commit).\n\n  - Add a Map type and dict function, along with changing `nth` to `.`\n    for indexing lists and arrays. Should also probably add support\n    for indexing strings but that's not here yet.\n\n  - Rename `proc` to `fn`. Add a `-local` option to `fn` to bind the\n    function to the current scope instead of global scope. This should\n    probably be the default but isn't yet.\n\n  - Move the prelude functions into prelude.go and add a Prelude\n    function to return a command map for them. Add a bulk BindCmds\n    function and a SetPrelude to set built-in functions.\n\n  - Split commands into prelude and regular commands. Regular commands\n    can shadow prelude commands, but if undefined will not cause the\n    prelude commands to be overwritten and lost.","shortMessageHtmlLink":"Refactor for callbacks hack"}},{"before":"ad6010d25df9a2f4bc08bd20c4cecdb2124d1efb","after":"61ce4575d13588a8dca7d2feb1cf3b41ce25d9b9","ref":"refs/heads/dev","pushedAt":"2023-08-08T22:52:19.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Replace string arrays with arbitrary value arrays\n\nThis is to support things like vectors, maps, strings, numbers,\nand potentially other data as needed in the interpreter instead of\ntreating everything as a flat list of strings (with no nesting). With\nthis change it's possible to create just lists and strings, but lists\ncan be nested and so on.","shortMessageHtmlLink":"Replace string arrays with arbitrary value arrays"}},{"before":"f980f833a80e33c47c2a6bfbcf877dc52d138896","after":"ad6010d25df9a2f4bc08bd20c4cecdb2124d1efb","ref":"refs/heads/dev","pushedAt":"2023-08-07T06:20:24.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Add license text","shortMessageHtmlLink":"Add license text"}},{"before":"2e02938a0a7df56fa01ea96554fea81f4b4cdd23","after":"f980f833a80e33c47c2a6bfbcf877dc52d138896","ref":"refs/heads/dev","pushedAt":"2023-08-06T09:14:12.000Z","pushType":"push","commitsCount":1,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Implement basic interpreter\n\nImplement a basic interpreter for mtcl. This currently just allows\nfunction definition, uplevel, a `do` command (that in practice is just\na way of running an unnamed proc without args but doesn't behave like\none yet). It's still not clear to me how to handle return statuses\nfrom functions in script -- code can obviously check if something\nis a return error so it knows something exited early, but how script\nshould do that isn't clear to me yet. I don't want to add a script\nvariable that stores the return code, but maybe something like a\nreturn status stored in-scope with functions like `error?`, `ok?`,\n`break?`, `continue?`, etc. for metaprogramming.\n\nAnyway, not sure yet.","shortMessageHtmlLink":"Implement basic interpreter"}},{"before":"8eaee6a903441dea46c7ef42ba7fc2f3c979451b","after":"2e02938a0a7df56fa01ea96554fea81f4b4cdd23","ref":"refs/heads/dev","pushedAt":"2023-08-06T01:20:48.000Z","pushType":"force_push","commitsCount":0,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Split up lexer, tokens, parser\n\nSplit up the lexer, tokens, and parser so they're a little more\ncompartmentalized. For ease of maintenance, replace the parser with a\nboring recursive descent parser. This is partly necessary to make it\neasier to parse out nested expressions, which don't play especially\nnicely with the earlier janky parser that just skimmed tokens and\nparsed them as a sequence without much regard for how things were\nbroken up and parsed (in particular, variable access was very flaky --\nand it still is, but not as much).\n\nThe lexer's been adjusted to reduce semicolons and newlines to a\nsingle Stop token, indicating the end of a command. Continuations and\nwhitespace are now also treated the same, meaning that it's possible\nfor a Whitespace token to run into another (it would be necessary to\nlook ahead a rune for the lexer to run these together, which isn't\nreally worth the time), with one indicating the whitespace token from\nbefore and one indicating the continuation.\n\nNext up is to try to build a simple interpreter using the basic parsed\nAST and see how that goes.","shortMessageHtmlLink":"Split up lexer, tokens, parser"}},{"before":null,"after":"8eaee6a903441dea46c7ef42ba7fc2f3c979451b","ref":"refs/heads/dev","pushedAt":"2023-08-05T06:01:52.000Z","pushType":"branch_creation","commitsCount":0,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Split up lexer, tokens, parser\n\nSplit up the lexer, tokens, and parser so they're a little more\ncompartmentalized.","shortMessageHtmlLink":"Split up lexer, tokens, parser"}},{"before":null,"after":"da3e1693c085bf1a95d1298d3e201ebd6474c8d6","ref":"refs/heads/main","pushedAt":"2023-08-04T18:57:16.000Z","pushType":"branch_creation","commitsCount":0,"pusher":{"login":"nilium","name":"Noel","path":"/nilium","primaryAvatarUrl":"https://avatars.githubusercontent.com/u/44962?s=80&v=4"},"commit":{"message":"Initial commit","shortMessageHtmlLink":"Initial commit"}}],"hasNextPage":false,"hasPreviousPage":false,"activityType":"all","actor":null,"timePeriod":"all","sort":"DESC","perPage":30,"cursor":"Y3Vyc29yOnYyOpK7MjAyMy0wOS0xM1QxOToyNToxOC4wMDAwMDBazwAAAAN__YLc","startCursor":"Y3Vyc29yOnYyOpK7MjAyMy0wOS0xM1QxOToyNToxOC4wMDAwMDBazwAAAAN__YLc","endCursor":"Y3Vyc29yOnYyOpK7MjAyMy0wOC0wNFQxODo1NzoxNi4wMDAwMDBazwAAAANkPrtJ"}},"title":"Activity · nilium/mtcl"}