3f119b64501e22b9b652410bf043f00f58c3932e Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/b10069b0c92198f6f330d8f98788ff2e8d735101 b10069b0c92198f6f330d8f98788ff2e8d735101

2008-11-21T10:58:08-08:00

Releasing 1.0-α3 87afcca6e096d332154554242205f9a268583184 Douglas Creager dcreager@alum.mit.edu 5c1158fbe62dbad7efdc23bba89a11d0df98088e 48599d503f16233ef3b8ce0655f19ba2241fbbbe Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/3f119b64501e22b9b652410bf043f00f58c3932e 3f119b64501e22b9b652410bf043f00f58c3932e

2008-11-21T10:57:15-08:00

Merge branch 'master' into rel * master: (37 commits) “create-source-package” script now works with any version Updating README and INSTALL to mention CSPM library “let”s now allow pattern definitions and multiple-branch functions Functions defined in multiple branches Lambda expressions now implemented using patterns, too Patterns on left-hand sides of top-level definitions Lambdas now implemented using patterns Adding Show instance for patterns Initial pattern matching support Implementing built-in functions as keywords Allow newlines before and after binary operators Prefix CSPM expressions should create “event” CSP₀ statements CSP₀ identifiers can now contain periods Adding process expressions to CSPM parser Definitions no longer need to be in alphabetical order Allow trailing newlines at end of CSPM script Parentheses in expressions Adding additional (non-QuickCheck) testing harness Simple “channel” statement Top-level script no longer implemented as an implicit “let” statement ... a626fa31b5929a7cec483f5568dd231d78ce00d5 Douglas Creager dcreager@alum.mit.edu dedd0a41c52d715a92ce2d61f940e6a9e199f20a Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/48599d503f16233ef3b8ce0655f19ba2241fbbbe 48599d503f16233ef3b8ce0655f19ba2241fbbbe

2008-11-20T18:44:21-08:00

“create-source-package” script now works with any version The “create-source-package” script now takes the HST version as a parameter, so it can be used to reproduce the tar archive for any prior release. It has also been updated to work with the latest Git version, which no longer stores the (majority of the) git-* binaries in /usr/bin. 4ae7e26855c839b3cad4c13b93f42c9f539ba439 Douglas Creager dcreager@alum.mit.edu 712ada84eb96967ccda4008b9f7a089f158e4edc Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/dedd0a41c52d715a92ce2d61f940e6a9e199f20a dedd0a41c52d715a92ce2d61f940e6a9e199f20a

2008-11-20T18:27:34-08:00

Updating README and INSTALL to mention CSPM library This patch adds some information about the Haskell CSPM library to the README and INSTALL files. 37e2220be3fd96bc36d1427144da93737a0abd31 Douglas Creager dcreager@alum.mit.edu dc52e1d16eebfbca200add57115bf33d95f9962d Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/712ada84eb96967ccda4008b9f7a089f158e4edc 712ada84eb96967ccda4008b9f7a089f158e4edc

2008-11-20T17:51:47-08:00

2008-11-20T17:51:15-08:00

“let”s now allow pattern definitions and multiple-branch functions This patch extends the parser and AST evaluator to allow the same kinds of definitions in a “let” statement as can appear at the top level of a script. Specifically, the left-hand side of a let binding can now be an arbitrary pattern, or a function defined using multiple branches. 8cfea5323d285c3b93ab970eecd95453025578bf Douglas Creager dcreager@alum.mit.edu 3f306f37f3a138f587eca1ef93dbee325c929a76 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/dc52e1d16eebfbca200add57115bf33d95f9962d dc52e1d16eebfbca200add57115bf33d95f9962d

2008-11-19T20:32:34-08:00

Functions defined in multiple branches The CSPM parser now supports defining functions using multiple branches, such as: length(<>) = 0 length(<_>^xs) = 1 + length(xs) reverse(<>) = <> reverse(<x>^xs) = reverse(xs) ^ <x> (These two examples are included as test cases.) Since lambdas were already implemented using multiple pattern-based clauses, this patch only required syntax manipulations to create the right AST. No new evaluation logic was needed. 4a16fff0a961a8502b9f935eda7151bbda03e5fb Douglas Creager dcreager@alum.mit.edu 72a21eb5cb201615ffc64a7d5ef7dadf511544e0 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/3f306f37f3a138f587eca1ef93dbee325c929a76 3f306f37f3a138f587eca1ef93dbee325c929a76

2008-11-19T20:10:01-08:00

Lambda expressions now implemented using patterns, too The previous “lambdas using patterns” patch only applied to lambda *values*. This patch changes lambda expressions and bound expressions to be implemented using patterns, too. 8fcf39340410eb57d6a195bdd2930436d71920fb Douglas Creager dcreager@alum.mit.edu aa4f0a0fbe13d5ddaee85075421c916546d869e3 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/72a21eb5cb201615ffc64a7d5ef7dadf511544e0 72a21eb5cb201615ffc64a7d5ef7dadf511544e0

2008-11-19T05:33:11-08:00

Patterns on left-hand sides of top-level definitions This patch allows arbitrary patterns to occur on the left-hand side of a top-level definition. Evaluation of the pattern match is deferred until the usual evaluation phase. This required a new kind of Expression: a “pattern match extraction”. This expression evaluates the pattern match, and if it succeeds, extracts the value of the specified identifier from the list of bindings. Old-style definitions, with a single identifier on the left-hand side, are now special cases of a pattern definition. c993cc21d3f727eb37b659a8672b57a68666a448 Douglas Creager dcreager@alum.mit.edu aa51f35ee12ffb704183bdd0dfabe0f49a5e2037 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/aa4f0a0fbe13d5ddaee85075421c916546d869e3 aa4f0a0fbe13d5ddaee85075421c916546d869e3

2008-11-17T20:21:20-08:00

Lambdas now implemented using patterns Lambda abstractions are now implemented using pattern matching. A lambda consists of a list of “clauses”, each of which contains a pattern and an expression. When you apply a lambda function to a value, we search for the first pattern in this list that matches the value. The corresponding expression is then used as the function body. The pattern match will create bindings for any identifiers contained in the pattern, and an environment containing these bindings is created to evaluate the lambda body in. Currently there's no syntax (in either the Expression AST or the CSPM parser) for creating complex, multi-clause lambdas. Instead, the existing “\x @ «expression»” syntax creates a lambda with a single clause, and a tuple pattern of the lambda's formal parameters. Application creates a tuple value of the actual parameters to match against this pattern. a0ab2121b59b472bf0d681c303a05ab233ed59de Douglas Creager dcreager@alum.mit.edu 16bd7ca6cb94a2cb867977092d1fbdfedd81577f Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/aa51f35ee12ffb704183bdd0dfabe0f49a5e2037 aa51f35ee12ffb704183bdd0dfabe0f49a5e2037

2008-11-17T19:52:42-08:00

Adding Show instance for patterns This patch adds an instance of the Show type case for patterns, since we'll probably want to display them at some point. d048abb4db492ef8b9089cbcd7a6bf41665c5040 Douglas Creager dcreager@alum.mit.edu 846067b5d5a95e857ca96abbe5d136d14a2ddd4e Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/16bd7ca6cb94a2cb867977092d1fbdfedd81577f 16bd7ca6cb94a2cb867977092d1fbdfedd81577f

2008-11-14T15:46:49-08:00

Initial pattern matching support This pattern introduces some underlying functionality for implementing pattern matching. We've defined an ADT to represent patterns, and a “valueMatches” function that determines whether a particular value matches a pattern. Most of the patterns defined by CSPM are included; the two that are missing are channel names (which only match the corresponding event), and dotted channel expressions, which we haven't implemented yet at the expression level, either. This patch also doesn't add pattern support to the CSPM parser or expression evaluator. ea35e8c75b43ff3650ae48d7061a7918a6245994 Douglas Creager dcreager@alum.mit.edu f8e3caa3db95587d03fc54fc7d403ab1a0f79a84 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/846067b5d5a95e857ca96abbe5d136d14a2ddd4e 846067b5d5a95e857ca96abbe5d136d14a2ddd4e

2008-11-10T18:03:32-08:00

Implementing built-in functions as keywords This patch adds support in the CSPM compiler for the built-in CSPM functions. We've implemented these as keywords, instead of trying to pre-seed a root environment with actual function definitions. There are test cases for all of the functions except for “Seq”, since it returns an infinite set. (We can define a “take” function that would allow us to test, at least partially, infinite sequences. But currently we can't define an analogous function for sets.) 63d447c0bc7ed0452a9048c94b314e2754d54ca3 Douglas Creager dcreager@alum.mit.edu f4b77aca530fc358c54402ff372d5ed8e8aece25 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/f8e3caa3db95587d03fc54fc7d403ab1a0f79a84 f8e3caa3db95587d03fc54fc7d403ab1a0f79a84

2008-11-10T09:19:07-08:00

Allow newlines before and after binary operators The CSPM spec uses newlines to separate the definitions in a file and in a “let” statement, but also allows newlines to appear certain extra situations for readability — for instance, before and after any binary operator. Like in [Scattergood98], we handle these silent newlines in the lexer rather than the parser; any consecutive newlines are replaced with a single TNewline token, and any TNewlines that appear before or after a “soakable” token are removed from the token stream before it's passed on to the parser. [Scattergood98] J. B. Scattergood. /The semantics and implementation of Machine-Readable CSP/. D.Phil. dissertation, Oxford University, 1998. 08118e88fe7664be6ec3768c2e6fc3c484f83d40 Douglas Creager dcreager@alum.mit.edu d47497c50ce9a2b80f7bf7b8cf4ecd89eaf52ef3 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/f4b77aca530fc358c54402ff372d5ed8e8aece25 f4b77aca530fc358c54402ff372d5ed8e8aece25

2008-11-10T07:06:00-08:00

Prefix CSPM expressions should create “event” CSP₀ statements CSP₀ scripts require you to use an “event” statement to declare any event that's used in a “prefix” statement. The CSPM compiler wasn't creating the necessary “event” statements for the prefix expressions that it would encounter. This patch fixes the compiler so that it does create these statements. 71593370e0aa20d899e4ba907fbca534bb2c2bf2 Douglas Creager dcreager@alum.mit.edu a2d98032c9e2a1b0526b948876c81783156e9f71 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/d47497c50ce9a2b80f7bf7b8cf4ecd89eaf52ef3 d47497c50ce9a2b80f7bf7b8cf4ecd89eaf52ef3

2008-11-10T06:23:09-08:00

CSP₀ identifiers can now contain periods The CSP₀ scanner did not accept identifiers with periods in their names. The CSPM compiler uses periods to construct nested identifiers for constructs such as lambdas and lets. So, we've changed the scanner to allow these kinds of identifiers. 9056aea769f210cf911a70d4ce494679dd701df0 Douglas Creager dcreager@alum.mit.edu 900dcad0972a827542f9bff774d31fb2bb1534cb Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/a2d98032c9e2a1b0526b948876c81783156e9f71 a2d98032c9e2a1b0526b948876c81783156e9f71

2008-11-08T21:05:37-08:00

Adding process expressions to CSPM parser The CSPM parser now includes process expressions. We don't yet support all of the CSPM operators, but we do support all of them that the underlying code can evaluate and that the CSP₀ code can compile. 10543541a31386ba0b2e9d4632f801da20b01de6 Douglas Creager dcreager@alum.mit.edu e862ad863583088b9bce5eec6e5a172272419e35 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/900dcad0972a827542f9bff774d31fb2bb1534cb 900dcad0972a827542f9bff774d31fb2bb1534cb

2008-11-08T20:33:57-08:00

Definitions no longer need to be in alphabetical order Previously, the code for creating an environment would assume that the list of bindings were already ordered — which meant that the definitions in a file or “let” statement would have to be alphabetized. With this patch, this restriction is no longer in place. 1137a61224ce3158d941988a5c6931880d0d1f66 Douglas Creager dcreager@alum.mit.edu 08483818cdbfc8832f53bd0d14fd7186a8b004ab Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/e862ad863583088b9bce5eec6e5a172272419e35 e862ad863583088b9bce5eec6e5a172272419e35

2008-11-08T20:24:47-08:00

2008-11-08T20:10:17-08:00

Allow trailing newlines at end of CSPM script This patch modifies the CSPM parser to allow newlines to appear after the last definition in the script. 1f64d3f3783278c26e2ec80367b63e7018717a8a Douglas Creager dcreager@alum.mit.edu afc55eb4453ab4a9813491acbf6ef2a7276eaf42 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/08483818cdbfc8832f53bd0d14fd7186a8b004ab 08483818cdbfc8832f53bd0d14fd7186a8b004ab

2008-11-08T20:24:02-08:00

2008-11-08T08:37:07-08:00

Parentheses in expressions This patch adds a rule to the grammar that lets you use parentheses to group expressions. That was a bit of a brain fart that I left it out! 7c9292ae59b2aed1ca60ba5eedb65d44251a9721 Douglas Creager dcreager@alum.mit.edu 545d048bee82af04b56391cecd19ac8746625a1c Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/afc55eb4453ab4a9813491acbf6ef2a7276eaf42 afc55eb4453ab4a9813491acbf6ef2a7276eaf42

2008-11-08T20:23:46-08:00

2008-11-08T08:14:45-08:00

Adding additional (non-QuickCheck) testing harness This patch adds an additional testing harness for the CSPM library. It's based on a bunch of shell scripts in the tests directory. The existing QuickCheck tests are now run within this harness, instead of directly from the Cabal Setup script. 03a635a84f603f559a1e94275696344b40cce91c Douglas Creager dcreager@alum.mit.edu af5c2c1ec7c7a6bbce67caaf911a25e5f8edf6da Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/545d048bee82af04b56391cecd19ac8746625a1c 545d048bee82af04b56391cecd19ac8746625a1c

2008-11-06T19:03:30-08:00

Simple “channel” statement This patch adds the simple form of the “channel” statement. This binds a top-level identifier to a single event of the same name. A variable reference to this identifier will now correctly return the corresponding Event value. This will allow us to start implementing some basic process expressions. ba6db11e5049af2d0e01bd2514fe5e207ad05145 Douglas Creager dcreager@alum.mit.edu 8f7d2e0fd5068fcf74d12c94afbcfdb045f7f58c Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/af5c2c1ec7c7a6bbce67caaf911a25e5f8edf6da af5c2c1ec7c7a6bbce67caaf911a25e5f8edf6da

2008-11-06T18:59:40-08:00

Top-level script no longer implemented as an implicit “let” statement Before, we implemented the top level of a CSPM script the same way as a “let” statement — as a list of Bindings. This isn't exactly right, though, since there are statements that can appear at the top level of a script that aren't valid in a “let” statement. In Scattergood's grammar, this difference is encoded in the Defn and SimpleDefn rules. This patch implements that separation. This will allow us to start implementing the other possible top-level statements, such as “channel”. 97e0a502711ea7ee153d44a35c35b690bcecd199 Douglas Creager dcreager@alum.mit.edu 88bddf90f3f22143be928a9d0196cf1891102525 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/8f7d2e0fd5068fcf74d12c94afbcfdb045f7f58c 8f7d2e0fd5068fcf74d12c94afbcfdb045f7f58c

2008-11-06T18:33:18-08:00

2008-11-04T18:21:09-08:00

Basic CSPM parser and command-line utility This patch introduces a initial, basic CSPM parser. It does not yet support the entire CSPM language, or even the entire subset of the language that our underlying evaluation engine can handle. We can handle most basic expressions, except for those operations which are implemented as built-in functions in CSPM. We've also created a “cspm” command-line utility, which parallels the existing “csp0” utility. Currently, it only supports one command — “evaluate”. This command loads in a CSPM script (either from a file or specified on the command line), and evaluates a list of expressions in terms of that script. While a useful utility in its own right, this will also serve as the basis for a CSPM evaluation test suite. 05c48dad33f1a15e250a6b873f353bc1915f77d0 Douglas Creager dcreager@alum.mit.edu aa9d7b026e4d5b6c7d06ca08a849c33b0c680888 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/88bddf90f3f22143be928a9d0196cf1891102525 88bddf90f3f22143be928a9d0196cf1891102525

2008-11-06T18:30:38-08:00

2008-11-04T09:08:14-08:00

Helper methods for evaluating CSPM expressions This patch introduces two helper functions for evaluating CSPM expressions: evaluateWith and evaluate. They wrap together the act of binding an expression, creating an Eval monad instance, and running that instance. evaluateWith allows you to specify which evaluator to use, in case you need to coerce the value that results. In most cases, though, you can use evaluate as follows: evaluate env expr c80af1bcfc4fa484b2dc5d5a19e8d3605af694ca Douglas Creager dcreager@alum.mit.edu d67f471b5af179c9f0d865c425c0542dbe3fa9cd Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/aa9d7b026e4d5b6c7d06ca08a849c33b0c680888 aa9d7b026e4d5b6c7d06ca08a849c33b0c680888

2008-11-06T18:30:35-08:00

2008-10-09T18:12:06-07:00

Distinct process names for each application of a function Before, a process created by a function application would get its name based on the context in which the lambda was defined. This meant that if you called a function many times, each with different values for its parameters, you'd only get a single process definition in the output script. Ideally, we'd add to the process name some representation of the values that the function was called with. Unfortunately, that's not possible with the current design, since the parameters to a function are lazy. We bind the function application (thereby creating its process name) before evaluating the lambda's body, and we cannot evaluate any of the parameters before evaluating the lambda's body. Thus, we cannot use the parameter values to calculate the process name. We could probably reorganize things to get around this, but for now, we just keep track of a global counter of function applications, and append this counter to the process name created for any application. This means that if we apply a function many times with the same value, we will get distinct processes for each one. Lighthouse: [#2] 5837bf78411e683feae6e24b39bf2156c8f99fa7 Douglas Creager dcreager@alum.mit.edu 6257983d18e9ad718d8dbc9d7e528bda55098fcd Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/d67f471b5af179c9f0d865c425c0542dbe3fa9cd d67f471b5af179c9f0d865c425c0542dbe3fa9cd

2008-11-06T18:30:32-08:00

2008-10-09T17:37:17-07:00

Adding predefined SKIP and STOP processes This patch introduces CSPM keywords for the predefined SKIP and STOP processes. Lighthouse: [#2] 089ccda9a3a20853828305ff350fff27c677d4b1 Douglas Creager dcreager@alum.mit.edu 7ed2249fe1b6063e163cc121b3289f37bfdf5969 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/6257983d18e9ad718d8dbc9d7e528bda55098fcd 6257983d18e9ad718d8dbc9d7e528bda55098fcd

2008-11-06T18:29:27-08:00

2008-09-30T20:19:27-07:00

Evaluate process expressions This patch introduces initial support for evaluating process expressions into the equivalent CSP₀ scripts. There are still several important features to implement. Process names are based on the outermost named process term. Currently, these can only be introduced by a let statement. Functions that return processes don't completely work yet, since we'll need to encode the parameters of the function into the names of the processes that are generated by the function application. Finally, there isn't yet a good test suite for these new features. Lighthouse: [#2] ffca9f03abc44d96b25a7642ea81402e18fd5a1f Douglas Creager dcreager@alum.mit.edu 449a427b153538a6bd72d9128d1f3fb9471d19ff Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/7ed2249fe1b6063e163cc121b3289f37bfdf5969 7ed2249fe1b6063e163cc121b3289f37bfdf5969

2008-11-06T18:28:05-08:00

2008-09-13T21:14:30-07:00

Binding and evaluation now take place in a monad Once we add process terms to the CSPM language, we'll need a State monad to bind and evaluate them, since we'll need to generate new, unique process names during evaluation. This patch refactors the existing binding and evaluation code to use a State monad. Right now, the state is empty, but once we introduce processes, it will contain the list of used process names. Lighthouse: [#2] 2606d30a2b910cba10b55ed739fe34b487fe6f46 Douglas Creager dcreager@alum.mit.edu 86b9163741d52e3212bc93f57b7660a06e6deacf Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/449a427b153538a6bd72d9128d1f3fb9471d19ff 449a427b153538a6bd72d9128d1f3fb9471d19ff

2008-11-06T18:27:51-08:00

2008-09-11T21:06:11-07:00

Initial support for CSP₀ scripts This patch introduces support for CSP₀ scripts. It has functions for creating CSP₀ statements and scripts, but there's no functionality yet for translating CSPM into CSP₀. Lighthouse: [#2] b39f0e3251328397e9fbfc5f104c8196f3da4f7a Douglas Creager dcreager@alum.mit.edu 667366c6ebf41bc7b5ba2d6923339de02bbc56c9 Douglas Creager dcreager@alum.mit.edu http://github.com/dcreager/hst/commit/86b9163741d52e3212bc93f57b7660a06e6deacf 86b9163741d52e3212bc93f57b7660a06e6deacf

2008-09-09T12:27:18-07:00

Infinite sets This patch introduces another new implementation for sets, which supports any infinite set. (The previous implementation only supported open ranges.) A set is now defined by a “loader list”. The loader list can be infinite, and can contain duplicates. Sets can be accessed in one of two ways. The toSet function turns the set into an instance of the standard Data.Se t type. As such, it only works on finite sets. The toList function, on the other hand, returns the elements as a lazy list. It therefore supports infinite sets. As elements are extracted from the loader list, they are added to a “storage set”; the result is that the toList function returns the original loader list, with duplicates removed. Lighthouse: [#12 state:resolved] 23c14ef138352edd707b3f95cb60fc2da1da6a5b Douglas Creager dcreager@alum.mit.edu