suzanne.soy/lexi-lambda.github.io
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: suzanne.soy:source
Branches Tags
suzanne.soy:source
suzanne.soy:patch-1
suzanne.soy:master
...
pull from: suzanne.soy:master
Branches Tags
suzanne.soy:patch-1
suzanne.soy:master
suzanne.soy:source

No commits in common. "source" and "master" have entirely different histories.
source ... master

77 changed files with 20527 additions and 1900 deletions
Show Stats Expand all files Collapse all files

110
.frogrc
View File

@ -1,110 +0,0 @@
# Required: Should NOT end in trailing slash.
scheme/host = http://lexi-lambda.github.io
# The title of the blog. Used when generating feeds.
title = Alexis King's Blog
# The author. Used when generating feeds, and provided to
# `page-template.html` as the template variable `@author`.
author = Alexis King
# What editor to launch with --edit. $EDITOR means to use $EDITOR from
# the environment
editor = $EDITOR
# The command to run, in case you need to customize how the editor is
# called. For example, {editor} {filename} will call:
# (system "$EDITOR 2012-01-01-a-blog-post.md")
# See the test submodule in paths.rkt for more examples
editor-command = {editor} {filename}
# Whether to show the count of posts next to each tag in the
# `page-template` variable `tags/feeds`.
show-tag-counts? = true
# Pattern for blog post permalinks
# Optional: Default is "/{year}/{month}/{title}.html".
# Here's an example of the Jekyll "pretty" style:
permalink = /blog/{year}/{month}/{day}/{title}/index.html
# There is also {filename}, which is the `this-part` portion of
# your post's YYYY-MM-DD-this-part.md file name. This is in case
# you don't like Frog's encoding of your post title and want to
# specify it exactly yourself, e.g. to match a previous blog URI.
# Should index page items contain full posts -- more than just the
# portion above "the jump" <!-- more --> marker (if any)?
index-full? = false
# Should feed items contain full posts -- more than just the portion
# above "the jump" <!-- more --> marker (if any)?
feed-full? = true
# How many posts per page for index pages?
posts-per-page = 10
# How many items to include in feeds?
# Older items in excess of this will not appear in the feed at all.
max-feed-items = 20
# Decorate feed URIs with Google Analytics query parameters like
# utm_source ?
decorate-feed-uris? = true
# Insert in each feed item an image bug whose URI is decorated with
# Google Analytics query parameters like utm_source ?
feed-image-bugs? = true
# Replace links to tweets with embedded tweets?
# In Markdown, must be auto-links alone in a pargraph (blank lines
# above and below), for example:
#
# <https://twitter.com/racketlang/status/332176422003163138>
#
auto-embed-tweets? = true
# Try to automatically link symbols in Markdown ```racket fenced code
# blocks, to Racket documentation?
racket-doc-link-code? = true
# Try to automatically link Markdown of the form `symbol`[racket] to
# Racket documentation? i.e. This is similar to the @racket[] form in
# Scribble.
racket-doc-link-prose? = true
# The URI for the index of blog posts. Defaults to /index.html but you
# could change to e.g. /blog/index.html or /posts-index.html, and use
# some other /index.html for your site. This also effects the URI used
# in the Atom and RSS feed files for posts.
posts-index-uri = /index.html
# The source directory. Defaults to "_src".
#
# If you deploy to GitHub pages then it is simplest to keep this under
# the repo/project top directory.
#
# This may be an absolute or relative path. If relative, it's relative
# to the project top directory, i.e. to where this .frogrc file is
# located.
source-dir = _src
# The output directory where generated HTML and other files should go.
#
# If you deploy to e.g. GitHub pages then it is simplest to put the
# output in the repo/project top directory, which is why this defaults
# to ".". But you may change it if you prefer to copy the output
# files to their final destination.
#
# This may be an absolute or relative path. If relative, it's relative
# to the project top directory, i.e. to where this .frogrc file is
# located.
output-dir = out
# Options controlling Pygments' HTML format.
## Python executable to be passed to the shell. If only a filename or
## relative path is given, Racket's find-executable-path will be used
## to locate the executable.
python-executable = python
## Whether to use line numbers.
pygments-linenos? = true
## CSS class for the wrapping <div> tag (default: 'highlight').
pygments-cssclass = source

9
.gitignore vendored
View File

@ -1,9 +0,0 @@
# configuration
/.frog
# managed by package managers
/node_modules
/bower_components
# generated files
/out

24
.travis.yml
View File

@ -1,24 +0,0 @@
language: python
python:
- '3.4'
branches:
only:
- source
env:
global:
- GH_REF: 'github.com/lexi-lambda/lexi-lambda.github.io.git'
- secure: "cWYfJKfWfn3qSlTX26NpIAC7+HWJc9tsJ2PUNnYNc60CFWBbVf2Srjrtt8CCYOMheA7K/jFNlT/px1+JKzruHMEVuUHFwIV7K8MGzSI5H6Y4gzOEfRMX8QZ/dNBEOJmkaXn70jBjYiefmg9Y20Tc41jppm6/nCb2KAfdUPcj6Hr1yit23BPRbbdf0lKWPFJFdYKk/7433LJbSZryDDBMHNioudn8fpE40ww34lbIb92qdbMEHV/O6N0KyAQMabfcgqGpsLt8VNECJNxnwZi8MBbf6EfyaG8e9XX8fBpdmCJ9K8ShjrpDbBqEmwFH7SowzdfTDu5OMcfc4TdES68G+CwbHG0htdNM9HCgf3XeFDO5gUopepeuCmnoBaZDmsXybTxXB7wt51bk+zz6GOrTfYHn93U82LNRvjFMiiwSOZz9xUC43LRF/dWBDBkpsK9EVA8l1mtoRs+4haZsCtxLs9BYuoGKDmSPU/4doCtDFh1+Lqgca3SNtOa4UwnZrhkSqiUszlqNvJcaEw0fBFsapxEIwFWbQz9A8k+yDgSv1rBmxK9IKnBLxM2LQxEIAZ1tIKfZtAWVu8IDiMF4acticQSwCaRXAE0XSBJ5zbmIshtgJQTVcxb1sefV5IRBbp6NDNIBnVGm+pSTXdMPqbGt8hha/C0xF0Wr9vc9xoti/Ig="
- RACKET_DIR: '~/racket'
- RACKET_VERSION: '6.2'
before_install:
- git clone https://github.com/greghendershott/travis-racket.git
- cat travis-racket/install-racket.sh | bash
- export PATH="${RACKET_DIR}/bin:${PATH}"
install:
- raco pkg install --deps search-auto frog
script: bash ./deploy.sh

11
_src/about.md
View File

@ -1,11 +0,0 @@
# About me
I'm Alexis King, and I'm a software developer.
I currently work at [Philosophie][philosophie] building modern web applications, primarily using Ruby on Rails, CoffeeScript, and Angular JS. In my free time, I try to build cool things with [Racket][racket].
Check out the things I'm working on on [GitHub][my-github].
[philosophie]: http://www.gophilosophie.com
[racket]: http://racket-lang.org
[my-github]: https://github.com/lexi-lambda/

14
_src/index-template.html
View File

@ -1,14 +0,0 @@
@(local-require srfi/19)
<article class="inline">
<header>
<h2 class="title"><a href='@|uri-path|'>@|title|</a></h2>
<div class='date-and-tags'>
<time datetime="@|date-8601|">
@(date->string date-struct "~1")
</time>
<span style="margin: 0 3px">⦿</span>
@|tags|
</div>
</header>
@|content|
</article>

18
_src/post-template.html
View File

@ -1,18 +0,0 @@
@(local-require srfi/19)
<article class="main">
<header>
<h1 class="title">@|title|</h1>
<div class='date-and-tags'>
<time datetime="@|date-8601|">
@(date->string date-struct "~1")
</time>
<span style="margin: 0 3px">⦿</span>
@|tags|
</div>
</header>
@|content|
<footer>
@disqus-comments["lexi-lambda"]
@older/newer-links[older-uri older-title newer-uri newer-title]
</footer>
</article>

156
_src/posts/2015-07-18-automatically-deploying-a-frog-powered-blog-to-github-pages.md
View File

@ -1,156 +0,0 @@
Title: Automatically deploying a Frog-powered blog to GitHub pages
Date: 2015-07-18T19:09:01
Tags: racket, frog, meta
So, I have a blog now. It's a simple static blog, but what's unique about it is that it's powered by Racket; specifically, it uses [Greg Hendershott][greghendershott]'s fantastic [Frog][frog] tool. I've taken this and moulded it to my tastes to build my blog, including configuring automatic deployment via [Travis CI][travis], so my blog is always up-to-date.
<!-- more -->
# Setting up Frog
I should note that Frog itself was wonderfully easy to drop in and get running. Just following the readme, a simple `raco pkg install frog` followed by `raco frog --init` and `raco frog -bp` created a running blog and opened it in my web browser. There was nothing more to it. Once that's done, all it takes to write a blog post is `raco frog -n "Post Title"`, and you're good to go.
By default, Frog uses Bootstrap, which provides a lot of the necessary scaffolding for you, but I opted to roll my own layout using flexbox. I also decided to use [Sass][sass] for my stylesheets, potentially with support for [CoffeeScript][coffeescript] later, so I wanted to have a good flow for compiling all the resources for deployment. To do that, I used [Gulp][gulp] in conjunction with [NPM][npm] for build and dependency management.
Going this route has a few advantages, primarily the fact that updating dependencies becomes much easier, and I can build and deploy my blog with just a couple of commands without needing to commit compiled or minified versions of my sources to version control.
# Configuring automatic deployment with Travis
Once Frog itself was configured and my styling was finished, I started looking into how to deploy my blog to a GitHub page without needing to check in any of the generated files to source control. I found a couple of resources, the most useful one being [this Gist](https://gist.github.com/domenic/ec8b0fc8ab45f39403dd), which describes how to set up deployment for any project. The basic idea is to create a deployment script which will automatically generate your project, initialize a git repository with the generated files, and push to GitHub's special `gh-pages` branch.
To make this easy, Frog can be configured to output to a separate directory via the `.frogrc` configuration file. I chose to output to the `out` directory:
```
output-dir = out
```
I also configured my Gulp build to output my CSS into the same output directory. Now, all that's necessary in order to deploy the blog to GitHub is to initialize a Git repository in the output directory, and push the files to the remote branch.
```
$ cd out
$ git init
$ git add .
$ git commit -m "Deploy to GitHub Pages"
$ git push --force "$REMOTE_URL" master:gh-pages
```
The next step is to configure Travis so that it can securely push to the GitHub repository with the required credentials. This can be done with Travis's [encryption keys][travis-encryption] along with a GitHub [personal access token][github-access-token]. Just install the Travis CLI client, copy the access token, and run a command:
```
$ gem install travis
$ travis encrypt GH_TOKEN=<access token...>
```
The output of that command is an encrypted value to be placed in an environment variable in the project's `.travis.yml` configuration file. The URL for the repository on GitHub will also need to be specified as well:
```yaml
env:
global:
- GH_REF: 'github.com/<gh-username>/<gh-repo>.git'
- secure: <encrypted data...>
```
Now all that's left is configuring the `.travis.yml` to run Frog. Since Travis doesn't natively support Racket at the time of this writing, the choice of "language" is somewhat arbitrary, but since I want Pygments installed for syntax highlighting, I set my project type to `python`, then installed Racket and Frog as pre-installation steps.
```yaml
env:
global:
- GH_REF: 'github.com/<gh-username>/<gh-repo>.git'
- secure: <encrypted data...>
- RACKET_DIR: '~/racket'
- RACKET_VERSION: '6.2'
before_install:
- git clone https://github.com/greghendershott/travis-racket.git
- cat travis-racket/install-racket.sh | bash
- export PATH="${RACKET_DIR}/bin:${PATH}"
install:
- raco pkg install --deps search-auto frog
```
(It might be worth noting that Greg Hendershott *also* maintains the repository that contains the above Travis build script!)
Finally, in my case, I wasn't deploying to a project-specific GitHub page. Instead, I wanted to deploy to my user page, which uses `master`, not `gh-pages`. Obviously, I didn't want Travis running on my `master` branch, since it would be deploying to that, so I added a branch whitelist:
```yaml
branches:
only:
- source
```
All that was left to do was to write up the actual deployment script to be used by Travis. Based on the one provided in the above Gist, mine looked like this:
```bash
#!/bin/bash
set -ev # exit with nonzero exit code if anything fails
# clear the output directory
rm -rf out || exit 0;
# build the blog files + install pygments for highlighting support
npm install
npm run build
pip install pygments
raco frog --build
# go to the out directory and create a *new* Git repo
cd out
git init
# inside this git repo we'll pretend to be a new user
git config user.name "Travis CI"
git config user.email "<your@email.here>"
# The first and only commit to this new Git repo contains all the
# files present with the commit message "Deploy to GitHub Pages".
git add .
git commit -m "Deploy to GitHub Pages"
# Force push from the current repo's master branch to the remote
# repo. (All previous history on the branch will be lost, since we are
# overwriting it.) We redirect any output to /dev/null to hide any sensitive
# credential data that might otherwise be exposed.
git push --force --quiet "https://${GH_TOKEN}@${GH_REF}" master > /dev/null 2>&1
```
For reference, my final `.travis.yml` looked like this:
```yaml
language: python
python:
- '3.4'
branches:
only:
- source
env:
global:
- GH_REF: 'github.com/lexi-lambda/lexi-lambda.github.io.git'
- secure: <long secure token...>
- RACKET_DIR: '~/racket'
- RACKET_VERSION: '6.2'
before_install:
- git clone https://github.com/greghendershott/travis-racket.git
- cat travis-racket/install-racket.sh | bash
- export PATH="${RACKET_DIR}/bin:${PATH}"
install:
- raco pkg install --deps search-auto frog
script: bash ./deploy.sh
```
That's it! Now I have a working blog that I can publish just by pushing to the `source` branch on GitHub.
[coffeescript]: http://coffeescript.org
[frog]: https://github.com/greghendershott/frog
[github-access-token]: https://github.com/settings/tokens
[greghendershott]: http://www.greghendershott.com
[gulp]: http://gulpjs.com
[npm]: https://www.npmjs.com
[sass]: http://sass-lang.com
[travis]: https://travis-ci.org
[travis-encryption]: http://docs.travis-ci.com/user/encryption-keys/

90
_src/posts/2015-08-22-deploying-racket-applications-on-heroku.md
View File

@ -1,90 +0,0 @@
Title: Deploying Racket applications on Heroku
Date: 2015-08-22T14:47:49
Tags: racket, heroku, 12factor
[Heroku][heroku] is a "platform as a service" that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but Racket is not currently among them. Fortunately, Heroku provides an interface for adding custom build processes for arbitrary types of applications, called “buildpacks”. I've built one for Racket apps, and with just a little bit of configuration, it’s possible to get a Racket webserver running on Heroku.
<!-- more -->
# Building the server
Racket's [web-server][racket-web-server] package makes building and running a simple server incredibly easy. Here's all the code we'll need to get going:
```racket
#lang racket
(require web-server/servlet
web-server/servlet-env)
(define (start req)
(response/xexpr
'(html (head (title "Racket Heroku App"))
(body (h1 "It works!")))))
(serve/servlet start #:servlet-path "/")
```
Running the above file will start up the server on the default port, 8080. When running on Heroku, however, we're required to bind to the port that Heroku provides via the `PORT` environment variable. We can access this using the Racket `getenv`[racket] function.
Additionally, the Racket web server specifically binds to localhost, but Heroku doesn't allow that restriction, so we need to pass `#f` for the `#:listen-ip` argument.
```racket
(define port (if (getenv "PORT")
(string->number (getenv "PORT"))
8080))
(serve/servlet start
#:servlet-path "/"
#:listen-ip #f
#:port port)
```
Also, by default, `serve/servlet`[racket] will open a web browser automatically when the program is run, which is very useful for rapid prototyping within something like DrRacket, but we'll want to turn that off.
```racket
(serve/servlet start
#:servlet-path "/"
#:listen-ip #f
#:port port
#:command-line? #t)
```
That's it! Now we have a Racket web server that can run on Heroku. Obviously it's not a very interesting application right now, but that's fine for our purposes.
# Setting up our app for Heroku
The next step is to actually create an app on Heroku. Don't worry—it's free! That said, explaining precisely how Heroku works is outside the scope of this article. Just make an account, then create an app. I called mine "racket-heroku-sample". Once you've created an app and set up Heroku's command-line tool, you can specify the proper buildpack:
```sh
$ git init
$ heroku git:remote -a racket-heroku-sample
$ heroku buildpacks:set https://github.com/lexi-lambda/heroku-buildpack-racket
```
We'll also need to pick a particular Racket version before we deploy our app. At the time of this writing, Racket 6.2.1 is the latest version, so I just set the `RACKET_VERSION` environment variable as follows:
```sh
$ heroku config:set RACKET_VERSION=6.2.1
```
Now there's just one thing left to do before we can push to Heroku: we need to tell Heroku what command to use to run our application. To do this, we use something called a "Procfile" that contains information about the process types for our app. Heroku supports multiple processes of different types, but we're just going to have a single web process.
Specifically, we just want to run our `serve.rkt` module. The Racket buildpack installs the repository as a package, so we can run `racket` with the `-l` flag to specify a module path, which will be more robust than specifying a filesystem path directly. Therefore, our Procfile will look like this:
```procfile
web: racket -l sample-heroku-app/server
```
Now all that's left to do is push our repository to Heroku's git remote. Once the build completes, we can [navigate to our app's URL and actually see it running live][app-url]!
# Conclusion
That's all that's needed to get a Racket app up and running on Heroku, but it probably isn't the best way to manage a real application. Usually it's best to use a continuous integration service to automatically deploy certain GitHub branches to Heroku, after running the tests, of course. Also, a real application would obviously be a little more complicated.
That said, this provides the foundation and shell. If you'd like to see the sample app used in this post, you can [find it on GitHub here][app-repo]. For more details on the buildpack itself, [it's also available on GitHub here][buildpack-repo].
[app-repo]: https://github.com/lexi-lambda/racket-sample-heroku-app
[app-url]: https://racket-heroku-sample.herokuapp.com
[buildpack-repo]: https://github.com/lexi-lambda/heroku-buildpack-racket
[heroku]: https://www.heroku.com
[racket-web-server]: http://docs.racket-lang.org/web-server/index.html

86
_src/posts/2015-08-30-managing-application-configuration-with-envy.md
View File

@ -1,86 +0,0 @@
Title: Managing application configuration with Envy
Date: 2015-08-30T16:05:37
Tags: envy, racket, 12factor
Application configuration can be a pain. Modern web apps don't live on dedicated boxes, they run on VPSes somewhere in the amorphous "cloud", and keeping configuration out of your application's repository can seem like more trouble than it's worth. Fortunately, [The Twelve-Factor App][12factor] provides a set of standards for keeping web apps sane, and [one of those guidelines advises keeping configuration in the environment][12factor-config].
[Envy][envy] is the declarative bridge between Racket code and the outside world of the environment.
<!-- more -->
# Introducing Envy
I built Envy to distill the common tasks needed when working with environment variables into a single, declarative interface that eliminates boilerplate and makes it easy to see which environment variables an application depends on (instead of having them littered throughout the codebase). Using it is simple. Just require `envy` and you're good to go.
The best way to use Envy is to create a "manifest" module that declares all the environment variables your application might use. For example, the following module is a manifest that describes an application that uses three environment variables:
```racket
; environment.rkt
#lang typed/racket/base
(require envy)
(define/provide-environment
api-token
[log-level : Symbol #:default 'info]
[parallel? : Boolean])
```
When this module is required, Envy will automatically do the following:
1. Envy will check the values of three environment variables: `API_TOKEN`, `LOG_LEVEL`, and `PARALLEL`.
2. If either `API_TOKEN` or `PARALLEL` is not set, an error will be raised:
envy: The required environment variable "API_TOKEN" is not defined.
3. The values for `LOG_LEVEL` and `PARALLEL` will be parsed to match their type annotations.
4. If `LOG_LEVEL` is not set, it will use the default value, `'info`.
5. The values will be stored in `api-token`, `log-level`, and `parallel?`, all of which will be provided by the enclosing module.
Now just `(require (prefix-in env: "environment.rkt"))`, and the environment variables are guaranteed to be available in your application's code.
# Working with Typed Racket
As you may have noticed by the example above, Envy is built with Typed Racket in mind. In fact, `define/provide-environment` will *only* work within a Typed Racket module, but that doesn't mean Envy can't be used with plain Racket—the manifest module can always be required by any kind of Racket module.
However, when using Typed Racket, Envy provides additional bonuses. Environment variables are inherently untyped—they're all just strings—but Envy assigns the proper type to each environment variable automatically, so no casting is necessary.
```
> parallel?
- : Boolean
#t
```
Envy really shines when using optional environment variables with the `#:default` option. The type of the value given to `#:default` doesn't need to be the same type of the environment variable itself, and if it isn't, Envy will assign the value a union type.
```
> (define-environment
[num-threads : Positive-Integer #:default #f])
> num-threads
- : (U Positive-Integer #f)
#f
```
This added level of type-safety means it's easy to manage optional variables that don't have reasonable defaults: the type system will enforce that all code considers the possibility that such variables do not exist.
# And more...
To see the full set of features that Envy already provides, [take a look at the documentation][envy-docs]. That said, this is just the first release based on my initial use-cases, but I'm sure there are more features Envy could have to accommodate common application configuration patterns. If you have an idea that could make Envy better, [open an issue and make a suggestion][envy-issues]! I already have plans for a `#lang envy` DSL, which will hopefully cut the boilerplate out in its entirety.
And finally, to give credit where credit is due, Envy is heavily inspired by [Envied][envied] (both in name and function), an environment variable manager for Ruby, which I've used to great effect.
Try it out!
- `raco pkg install envy`
- [Envy on GitHub][envy]
- [Envy documentation][envy-docs]
[12factor]: http://12factor.net
[12factor-config]: http://12factor.net/config
[envied]: https://github.com/eval/envied
[envy]: https://github.com/lexi-lambda/envy
[envy-docs]: https://lexi-lambda.github.io/envy/envy.html
[envy-issues]: https://github.com/lexi-lambda/envy/issues

92
_src/posts/2015-09-23-canonical-factories-for-testing-with-factory-girl-api.md
View File

@ -1,92 +0,0 @@
Title: Canonical factories for testing with factory_girl_api
Date: 2015-09-23T16:30:12
Tags: ruby, rails, javascript, angular
Modern web applications are often built as *single-page apps*, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won't catch the failure. I haven't found a very good solution to this problem aside from brittle, end-to-end integration tests.
To attempt to address a fraction of this problem, I built [factory_girl_api][factory_girl_api], a way to share context setup between both sides of the application.
<!-- more -->
# A brief overview of factory_girl
In the land of Ruby and Rails, [factory_girl][factory_girl] is a convenient gem for managing factories for models. Out of the box, it integrates with Rails' default ORM, ActiveRecord, and provides declarative syntax for describing what attributes factories should initialize. For example, a factory declaration used to create a widget might look like this:
```ruby
FactoryGirl.define do
factory :widget do
sequence(:name) { |id| 'Widget #' + id }
price 10
trait :expensive do
price 1000
end
end
end
```
This makes it easy to create new instances of `Widget` and use them for unit tests. For example, this would create and persist a widget with a unique name and a price of 10 units:
```ruby
widget = FactoryGirl.create :widget
```
We can also create more expensive widgets by using the `:expensive` trait.
```ruby
expensive_widget = FactoryGirl.create :widget, :expensive
```
Any number of traits can be specified at once. Additionally, it is possible to override individual attributes manually.
```ruby
fancy_widget = FactoryGirl.create :widget, :expensive, name: 'Fancy Widget'
```
It works well, and it keeps initialization boilerplate out of individual tests.
# Testing on the front-end
Trouble arises when we need to write tests for the JavaScript application that use the same models. Suddenly, we need to duplicate the same kind of logic in our front-end tests. We might start out by setting up object state manually:
```js
var fancyWidget = new Widget({
name: 'Fancy Widget',
price: 1000
});
```
Things can quickly get out of hand when models grow complex. Even if we use a factory library in JavaScript, it's possible for our front-end factories to diverge from their back-end counterparts. This means our integration tests will fail, but our unit tests will still blindly pass. Having to duplicate all that logic in two places is dangerous. It would be nice to have a *single, canonical source* for all of our factories.
## Reusing server-side factories with factory_girl_api
To help alleviate this problem, I created the [factory_girl_api][factory_girl_api] gem for Rails and the [angular-factory-girl-api][angular-factory-girl-api] Bower package for Angular. These packages cooperate with each other to allow server-side factories to be used in JavaScript tests.
The Angular module provides a service with syntax comparable to factory_girl itself. Both traits and custom attributes are supported:
```js
FactoryGirl.create('widget', 'expensive', { name: 'Fancy Widget' });
```
In this case, however, a round-trip API call must be made to the server in order to call the factory and return the result. Because of this, the Angular version of FactoryGirl returns a promise that is resolved with the serialized version of the model, which can then be used as sample data in unit tests.
## The problems with relying on the server for data
In my preliminary use of this tool, it works. In many ways, it's much nicer than duplicating logic in both places. However, I'm not *completely* convinced it's the right solution yet.
First of all, it couples the front-end to the back-end, even during unit testing, which is disappointing. It means that a server needs to be running (in test mode) in order for the tests to run at all. For the kinds of projects I work on, this isn't really a bad thing, and the benefits of the reduced duplication far outweigh the downsides.
My real concern is that this solves a very small facet of the general problem with fragile front-end test suites. Single-page applications usually depend wholly on their integration with back-end APIs. If those APIs change, the tests will continue to happily pass as long as the API is simply mocked, which seems to be the usual solution in the front-end universe. This is, frankly, unacceptable in real application development.
## Potential improvements and other paths to success
I am ultimately unsatisfied with this approach, but writing brittle end-to-end integration tests is not the solution. This *kind* of thing may be a step in the right direction: writing tests that aren't really pure unit tests, but also aren't fragile full-stack integration tests. This is a middle-ground that seems infrequently traveled, perhaps due to a lack of tooling (or perhaps because it just doesn't work). I don't know.
Either way, I'm interested in where this is headed, and I'll be curious to see if I run into any roadblocks using the workflow I've created. If anyone else is interested in playing with these two libraries, the READMEs are much more comprehensive than what I've covered here. Take a look, and give them a spin!
- [factory_girl_api][factory_girl_api]
- [angular-factory-girl-api][angular-factory-girl-api]
[factory_girl]: https://github.com/thoughtbot/factory_girl
[factory_girl_api]: https://github.com/lexi-lambda/factory_girl_api
[angular-factory-girl-api]: https://github.com/lexi-lambda/angular-factory-girl-api

235
_src/posts/2015-11-06-functionally-updating-record-types-in-elm.md
View File

@ -1,235 +0,0 @@
Title: Functionally updating record types in Elm
Date: 2015-11-06T19:58:40
Tags: elm
[Elm][elm-lang] is a wonderful language for building web apps, and I love so much of its approach to language design. Elm does so many things *right* straight out of the box, and that's a real breath of fresh air in the intersection of functional programming and web development. Still, it gets one thing wrong, and unfortunately, that one thing is incredibly important. Elm took the "functions" out of "functional record types".
<!-- more -->
Almost any software program, at its core, is all about data. Maybe it's about computing data, maybe it's about manipulating data, or maybe it's about displaying data, but at the end of the day, some sort of data model is going to be needed. The functional model is a breathtakingly elegant system for handling data and shuttling it around throughout a program, and [functional reactive programming][frp], which Elm uses to model event-like interactions, makes this model work even better. The really important thing, though, is what tools Elm actually gives you to model your data.
# A brief primer on Elm records
Elm supports all the core datatypes one would expect—numbers, strings, booleans, optionals, etc.—and it allows users to define their own types with ADTs. However, Elm also provides another datatype, which it calls "records". Records are similar to objects in JavaScript: they're effectively key-value mappings. They're cool data structures, and they work well. Here's an example of creating a `Point` datatype in Elm:
```elm
type alias Point =
{ x : Float, y : Float }
```
Notice that `Point` is declared as a type *alias*, not as a separate type like an ADT. This is because record types are truly encoded in the type system as values with named fields, not as disparate types. This allows for some fun tricks, but that's outside the scope of this blog post.
# The good
What I'd like to discuss is what it looks like to *manipulate* these data structures. Constructing them is completely painless, and reading from them is super simple. This is where the record system gets everything very *right*.
```elm
origin : Point
origin = { x = 0, y = 0 }
distanceBetween : Point -> Point -> Float
distanceBetween a b =
let dx = a.x - b.x
dy = a.y - b.y
in sqrt (dx*dx + dy*dy)
```
The syntax is clean and simple. Most importantly, however, the record system is functional (in the "functional programming" sense). In a functional system, it's useful to express concepts in terms of function composition, and this is very easy to do in Elm. Creating a function to access a field would normally be clunky if you always needed to do `record.field` to access the value. Fortunately, Elm provides some sugar:
```elm
-- These two expressions are equivalent:
(\record -> record.field)
.field
```
Using the `.field` shorthand allows writing some other functions in terms of composition, as most functional programmers would desire:
```elm
doubledX : Point -> Float
doubledX = ((*) 2) << .x
```
This satisfies me.
# The bad
So if everything in Elm is so great, what am I complaining about? Well, while the syntax to access fields is convenient, the syntax to *functionally set* fields is questionably clunky. Consider a function that accepts a point and returns a new point with its `x` field set to `0`:
```elm
zeroedX : Point -> Point
zeroedX point = { point | x <- 0 }
```
This doesn't look too bad, does it? It's clear and concise. To me, though, there's something deeply wrong here... this function has a lot of redundancy! It seems to me like we should be able to write this function more clearly in a point-free style. The `.field` shorthand "functionalizes" the record getter syntax, so there must be a function version of the update syntax, right? Maybe it would look something like this:
```elm
zeroedX : Point -> Point
zeroedX = !x 0
```
But alas, there is no such syntax.
Now you may ask... why does it matter? This seems trivial, and in fact, the explicit updater syntax may actually be more readable by virtue of how explicit it is. You'd be right, because so far, these examples have been horribly contrived. But let's consider a slightly more useful example: *functionally updating* a record.
What's the difference? Well, say I wanted to take a point and increment its `x` field by one. Well, I can easily write a function for that:
```elm
incrementX : Point -> Point
incrementX point = { point | x <- point.x + 1 }
```
Not terrible, though a *little* verbose. Still, what if we want to also add a function that *decrements* `x`?
```elm
decrementX : Point -> Point
decrementX point = { point | x <- point.x - 1 }
```
Oh, gosh. That's basically the exact same definition but with the operation flipped. Plus we probably want these operations for `y`, too. Fortunately, there's an easy solution: just pass a function in to *transform* the value! We can define an `updateX` function that allows us to do that easily, then we can define our derived operations in terms of that:
```elm
updateX : (Float -> Float) -> Point -> Point
updateX f point = { point | x <- f point.x }
incrementX : Point -> Point
incrementX = updateX ((+) 1)
decrementX : Point -> Point
decrementX = updateX (\x -> x - 1)
```
Not only is that much cleaner, but we can now use it to implement all sorts of other operations that allow us to add, subtract, multiply, or divide the `x` field. Now we just need to generalize our solution to work with the `x` *and* `y` fields!
Oh, wait. **We can't.**
# The ugly
This is where everything breaks down completely. Elm does not offer enough abstraction to reduce this level of crazy duplication:
```elm
updateX : (Float -> Float) -> Point -> Point
updateX f point = { point | x <- f point.x }
incrementX : Point -> Point
incrementX = updateX ((+) 1)
decrementX : Point -> Point
decrementX = updateX (\x -> x - 1)
updateY : (Float -> Float) -> Point -> Point
updateY f point = { point | y <- f point.y }
incrementY : Point -> Point
incrementY = updateY ((+) 1)
decrementY : Point -> Point
decrementY = updateY (\x -> x - 1)
```
We sure can give it a shot, though. At the very least, we *can* implement the increment and decrement functions in a more general way by passing in an updater function:
```elm
increment : ((Float -> Float) -> a -> a) -> a -> a
increment update = update ((+) 1)
```
Now, with `updateX` and `updateY`, we can increment either field very clearly and expressively. If we shorten the names to `uX` and `uY`, then the resulting code is actually very readable:
```elm
pointAbove = uY (\x -> x + 1)
pointBelow = uY (\x -> x - 1)
```
It's almost like English now: "update Y using this transformation". This is actually pretty satisfactory. The trouble arises when you have a struct with many fields:
```elm
type alias PlayerStats =
{ health : Integer
, strength : Integer
, charisma : Integer
, intellect : Integer
-- etc.
}
```
It might be very convenient to have generic functional updaters in this case. One could imagine a game that has `Potion` items:
```elm
type Potion = Potion String (PlayerStats -> PlayerStats)
```
And then some different kinds of potions:
```elm
potions =
[ (Potion "Health Potion" (uHealth ((+) 1))),
, (Potion "Greater Intellect Potion" (uIntellect ((+) 3)))
, (Potion "Potion of Weakness" (uStrength (\x -> x // 5)))
]
```
This is a really elegant way to think about items that can affect a player's stats! Unfortunately, it also means you have to define updater functions for *every single field in the record*. This can get tedious rather quickly:
```elm
uHealth : (Integer -> Integer) -> PlayerStats -> PlayerStats
uHealth f stats = { stats | health <- f stats.health }
uStrength : (Integer -> Integer) -> PlayerStats -> PlayerStats
uStrength f stats = { stats | strength <- f stats.strength }
uCharisma : (Integer -> Integer) -> PlayerStats -> PlayerStats
uCharisma f stats = { stats | charisma <- f stats.charisma }
-- etc.
```
This is pretty icky. Could there be a better way?
# Trying to create a more general abstraction
Interestingly, this pattern doesn't *need* to be this bad. There are better ways to do this. Let's revisit our updater functions.
Really, `update` can be defined in terms of two other primitive operations: a read and a (functional) write. What would it look like if we implemented it that way instead of requiring special updater functions to be defined? Well, it would look like this:
```elm
update : (a -> b) -> (b -> a -> a) -> (b -> b) -> a -> a
update get set f x = set (f (get x)) x
```
The type definition is a little long, but it's really pretty simple. We just supply a getter and a setter, then a function to do the transformation, and finally a record to actually transform. Of course, as you can see from the type, this function isn't actually specific to records: it can be used with any value for which a getter and setter can be provided.
The trouble here is that writing field setters isn't any easier in Elm than writing field updaters. They still look pretty verbose:
```elm
sHealth : Integer -> PlayerStats -> PlayerStats
sHealth x stats = { stats | health <- x }
uHealth : (Integer -> Integer) -> PlayerStats -> PlayerStats
uHealth = update .health sHealth
```
So, at the end of it all, this isn't really a better abstraction. Still remember my fantasy `!field` setter shorthand half a blog post ago? Now perhaps it makes a little more sense. *If* such a syntax existed, then defining the updater would be incredibly simple:
```elm
uHealth : (Integer -> Integer) -> PlayerStats -> PlayerStats
uHealth = update .health !health
```
Still, no syntax, no easy updaters, and by extension, no easy, declarative description of behavior without quite a bit of boilerplate.
# Conclusions and related work
Elm is a very promising language, and it seems to be in fairly rapid development. So far, its author, [Evan Czaplicki][czaplic], has taken a very cautious approach to implementing language features, especially potentially redundant ones. This caution is why things like operator slicing, "where" clauses, and special updater syntax have not yet made it into the language. Maybe at some point these will be deemed important enough to include, but for the time being, they've been excluded.
I obviously think that having this sort of thing is incredibly important to being able to write expressive code without a huge amount of overhead. However, I also do *not* want to give the impression that I think adding special setter syntax is the only way to do it.
Seasoned functional programmers will surely have noticed that many of these concepts sound a lot like lenses, and Elm actually already has a lens-like library authored by Evan himself, called [Focus][focus]. This, however, does not actually solve the problem: it requires manual description of setters just like the purely function based approach does. Really, lenses are just the logical next step in the line of abstraction I've already laid out above.
Interestingly, PureScript and Elm, the two Haskell-likes-on-the-frontend that I've paid attention to (though PureScript is much closer to Haskell than Elm), both have this very same problem. Haskell itself solves it with macros via Template Haskell. My favorite language, Racket, solves it with its own macro system. Is there another way to do these things that doesn't involve introducing a heavyweight macro system? Definitely. But I think this is a *necessary feature*, not a "nice to have", so if a macro system is out of the picture, then a simpler, less flexible solution is the obvious logical alternative.
I really like Elm, and most of my experiences with it have been more than enough to convince me that it is a fantastic language for the job. Unfortunately, the issue of functional record updaters has been quite the frustrating obstacle in my otherwise frictionless ride. I will continue to happily use Elm over other, far less accommodating tools, but I hope that issues like these will be smoothed out as the language and its ecosystem matures.
[czaplic]: https://twitter.com/czaplic
[elm-lang]: http://elm-lang.org
[focus]: https://github.com/evancz/focus
[frp]: https://en.wikipedia.org/wiki/Functional_reactive_programming

323
_src/posts/2015-12-21-adts-in-typed-racket-with-macros.md
View File

@ -1,323 +0,0 @@
Title: ADTs in Typed Racket with macros
Date: 2015-12-21T17:57:07
Tags: racket, typed racket, macros
Macros are one of Racket's flagship features, and its macro system really is state of the art. Of course, it can sometimes be difficult to demonstrate *why* macros are so highly esteemed, in part because it can be hard to find self-contained examples of using macros in practice. Of course, one thing that macros are perfect for is filling a "hole" in the language by introducing a feature a language lacks, and one of those features in Typed Racket is **ADTs**.
<!-- more -->
# Warning: this is not a macro tutorial
First, a disclaimer: this post assumes at least some knowledge of Scheme/Racket macros. Ideally, you would be familiar with Racket itself. But if you aren't, fear not: if you get lost, don't worry. Hold on to the bigger picture, and you'll likely learn more than someone who knows enough to follow all the way through. If you *are* interested in learning about macros, I must recommend Greg Hendershott's [Fear of Macros][fear-of-macros]. It is good. This is not that.
Now, with that out of the way, let's get started.
# What we're building
[Algebraic data types][adts], or *ADTs*, are a staple of the ML family of functional programming languages. I won't go into detail here—I want to focus on the implementation—but they're a very descriptive way of modeling data that encourages designing functions in terms of pattern-matching, something that Racket is already good at.
Racket also already has a facility for creating custom data structures in the form of *structs*, which are extremely flexible, but also a little verbose. Racket structs are more powerful than we need, but that means we can implement our ADTs in terms of Racket's struct system.
With that in mind, what should our syntax look like? Well, let's consider a quintessential example of ADTs: modeling a simple tree. For now, let's just consider a tree of integers. For reference, the Haskell syntax for such a data structure would look like this:
```haskell
data Tree = Empty
| Leaf Int
| Node Tree Tree
```
This already demonstrates a few of the core things we'll need to build:
1. Each ADT has a *data type*, in this case `Tree`. This name only exists in the world of types, it isn't a value.
2. Each ADT has various *data constructors*, in this case `Leaf` and `Node`.
3. Each data constructor may accept any number of arguments, each of which have a specific type.
4. The types that data constructors may accept include the ADT's datatype itself—that is, definitions can be recursive.
Of course, there's one more important feature we're missing: polymorphism. Our definition of a tree is overly-specific, and really, it should be able to hold any kind of data, not just integers. In Haskell, we can do that by adding a type parameter:
```haskell
data Tree a = Empty
| Leaf a
| Node (Tree a) (Tree a)
```
With this in mind, we can add a fifth and final point to our list:
<ol start="5"><li>ADTs must be able to be parametrically polymorphic.</li></ol>
That covers all of our requirements for basic ADTs. Now we're ready to port this idea to Racket.
## Describing ADTs in Racket
How should we take the Haskell syntax for an ADT definition and adapt it to Racket's parenthetical s-expressions? By taking some cues from the Haskell implementation, Typed Racket's type syntax, and Racket's naming conventions, a fairly logical syntax emerges:
```racket
(define-datatype (Tree a)
Empty
(Leaf a)
(Node (Tree a) (Tree a)))
```
This looks pretty good. Just like with the Haskell implementation, `Tree` should only exist at the type level, and `Empty`, `Leaf`, and `Node` should be constructor functions. Our syntax mirrors Racket function application, too—the proper way to create a leaf would be `(Leaf 7)`.
Now that we can create ADT values, how should we extract the values from them? Well, just like in ML-likes, we can use pattern-matching. We don't need to reinvent the wheel for this one; we should be able to just use Racket's `match`[racket] with our datatypes. For example, a function that sums all the values in a tree might look like this:
```racket
(: tree-sum ((Tree Integer) -> Integer))
(define (tree-sum tree)
(match tree
[(Empty) 0 ]
[(Leaf n) n ]
[(Node l r) (+ (tree-sum l)
(tree-sum r))]))
```
Given that Racket's `struct` form automatically produces identifiers that cooperate with `match`, this shouldn't be hard at all. And with our syntax settled, we're ready to begin implementation.
# Implementing ADTs as syntax
Now for the fun part. To implement our ADT syntax, we'll employ Racket's industrial-strength macro DSL, [`syntax/parse`][syntax-parse]. The `syntax/parse` library works like the traditional Scheme `syntax-case` on steroids, and one of the most useful features is the ability to define "syntax classes" that encapsulate reusable parsing rules into declarative components.
Since this is not a macro tutorial, the following implementation assumes you already know how to use `syntax/parse`. However, all of the concepts here are well within the reaches of any intermediate macrologist, so don't be intimidated by some of the more complex topics at play.
## Parsing types with a syntax class
To implement ADTs, we're going to want to define exactly one syntax class, a class that describes the grammar for a type. As we've seen, types can be bare identifiers, like `Tree`, or they can be identifiers with parameters, like `(Tree a)`. We'll want to cover both cases.
```racket
(begin-for-syntax
(define-syntax-class type
(pattern name:id #:attr [param 1] '())
(pattern (name:id param ...+))))
```
This syntax class has two rules, one that's a bare identifier, and one that's a list. The ellipsis followed by a plus (`...+`) in the second example means "one or more", so parsing those parameters will automatically be handled for us. In the bare identifier example, we use `#:attr` to give the `param` attribute the default value of an empty list, so this syntax class will actually *normalize* the input we get in addition to actually parsing it.
## A first attempt at `define-datatype`
Now we can move on to actually implementing `define-datatype`. The rules are simple: we need to generate a structure type for each one of the data constructors, and we need to generate a type definition for the parent type itself. This is pretty simple to implement using `syntax-parser`, which actually does the parsing for our macro.
```racket
(define-syntax define-datatype
(syntax-parser
[(_ type-name:type data-constructor:type ...)
]))
```
This definition will do all the parsing we need. It parses the entire macro "invocation", ignoring the first datum with `_` (which will just be the identifier `define-datatype`), then expecting a `type-name`, which uses the `type` syntax class we defined above. Next, we expect zero or more `data-constructor`s, which also use the `type` syntax class. That's all we have to do for parsing. We now have all the information we need to actually output the expansion for the macro.
Of course, it won't be that easy: this is the difficult part. The first step is to generate a Racket struct for each data constructor. We can do this pretty easily with some simple use of Racket's syntax templating facility. A naïve attempt would look like this:
```racket
(define-syntax define-datatype
(syntax-parser
[(_ type-name:type data-constructor:type ...)
#'(begin
(struct data-constructor.name ([f : data-constructor.param] ...)
...))]))
```
This is actually really close to being correct. This will generate a struct definition for each `data-constructor`, where each struct has the name of the data constructor and the same number of fields as arguments provided. The trouble is that in Racket structs, all of the fields have *names*, but in our ADTs, all the fields are anonymous and by-position. Currently, we're just using the same name for *all* the fields, `f`, so if any data constructor has two or more fields, we'll get an error.
Since we don't care about the field names, what we want to do is just generate random names for every field. To do this, we can use a Racket function called `generate-temporary`, which generates random identifiers. Our next attempt might look like this:
```racket
#`(begin
(struct data-constructor.name
([#,(generate-temporary) : data-constructor.param] ...)
...))
```
The `#,` lets us "escape" from the template to execute `(generate-temporary)` and interpolate its result into the syntax. Unfortunately, this doesn't work. We *do* generate a random field name, but the ellipsis will re-use the same generated value when it repeats the fields, rendering our whole effort pointless. We need to generate the field names once per type.
## More leveraging syntax classes
As it turns out, this is *also* easy to do with syntax classes. We can add an extra attribute to our `type` syntax class to generate a random identifier with each one. Again, we can use `#:attr` to do that automatically. Our new definition for `type` will look like this:
```racket
(begin-for-syntax
(define-syntax-class type
(pattern name:id
#:attr [param 1] '()
#:attr [field-id 1] '())
(pattern (name:id param ...+)
#:attr [field-id 1] (generate-temporaries #'(param ...)))))
```
Here we're using `generate-temporaries` instead of `generate-temporary`, which will conveniently generate a new identifier for each of the elements in the list we provide it. This way, we'll get a fresh identifier for each `param`.
We can now fix our macro to use this `field-id` attribute instead of the static field name:
```racket
#'(begin
(struct data-constructor.name
([data-constructor.field-id : data-constructor.param] ...))
...)
```
## Creating the supertype
We're almost done—now we just need to implement our overall type, the one defined by `type-name`. This is implemented as a trivial type alias, but we need to ensure that polymorphic types are properly handled. For example, a non-polymorphic type would need to be handled like this:
```racket
(define-type Tree (U Empty Leaf Node))
```
However, a polymorphic type alias would need to include the type parameters in each subtype, like this:
```racket
(define-type (Tree a) (U (Empty a) (Leaf a) (Node a)))
```
How can we do this? Well, so far, we've been very declarative by using syntax patterns, templates, and classes. However, this is a more pernicious problem to solve with our declarative tools. Fortunately, it's very easy to fall back to using **procedural macros**.
To build each properly-instantiated type, we'll use a combination of `define/with-syntax` and Racket's list comprehensions, `for/list`. The `define/with-syntax` form binds values to pattern identifiers, which can be used within syntax patterns just like the ones bound by `syntax-parser`. This will allow us to break up our result into multiple steps. Technically, `define/with-syntax` is not strictly necessary—we could just use `` #` `` and `#,`—but it's cleaner to work with.
We'll start by defining a set of instantiated data constructor types, one per `data-constructor`:
```racket
(define/with-syntax [data-type ...]
(for/list ([name (in-syntax #'(data-constructor.name ...))])
))
```
Now we can fill in the body with any code we'd like, so long as each body returns a syntax object. We can use some trivial branching logic to determine which form we need:
```racket
(define/with-syntax [data-type ...]
(for/list ([name (in-syntax #'(data-constructor.name ...))])
(if (stx-null? #'(type-name.param ...))
name
#`(#,name type-name.param ...))))
```
Now with our definition for `data-type`, we can implement our type alias for the supertype extremely easily:
```racket
#'(define-type type-name (U data-type ...))
```
## Putting it all together
There's just one more thing to do before we can call this macro finished: we need to ensure that all the type parameters defined by `type-name` are in scope for each data constructor's structure definition. We can do this by making use of `type-name.param` within each produced struct definition, resulting in this:
```racket
#'(begin
(struct data-constructor.name (type-name.param ...)
([data-constructor.field-id : data-constructor.param] ...))
...)
```
And we're done! The final macro, now completed, looks like this:
```racket
(begin-for-syntax
(define-syntax-class type
(pattern name:id
#:attr [param 1] '()
#:attr [field-id 1] '())
(pattern (name:id param ...+)
#:attr [field-id 1] (generate-temporaries #'(param ...)))))
(define-syntax define-datatype
(syntax-parser
[(_ type-name:type data-constructor:type ...)
(define/with-syntax [data-type ...]
(for/list ([name (in-syntax #'(data-constructor.name ...))])
(if (stx-null? #'(type-name.param ...))
name
#`(#,name type-name.param ...))))
#'(begin
(struct (type-name.param ...) data-constructor.name
([data-constructor.field-id : data-constructor.param] ...)) ...
(define-type type-name (U data-type ...)))]))
```
It's a little bit dense, certainly, but it is not as complicated or scary as it might seem. It's a simple, mostly declarative, powerful way to transform a DSL into ordinary Typed Racket syntax, and now all we have to do is put it to use.
# Using our ADTs
With the macro built, we can now actually use our ADTs using the syntax we described! The following is now *valid code*:
```racket
(define-datatype (Tree a)
Empty
(Leaf a)
(Node (Tree a) (Tree a)))
> (Node (Leaf 3) (Node (Empty) (Leaf 7)))
- : (Node Positive-Byte)
(Node (Leaf 3) (Node (Empty) (Leaf 7)))
```
We can use this to define common data types, such as Haskell's `Maybe`:
```racket
(define-datatype (Maybe a)
(Just a)
Nothing)
(: maybe-default (All [a] (Maybe a) a -> a))
(define (maybe-default m v)
(match m
[(Just a) a]
[(Nothing) v]))
(: maybe-then (All [a] (Maybe a) (a -> (Maybe a)) -> (Maybe a)))
(define (maybe-then m f)
(match m
[(Just a) (f a)]
[(Nothing) (Nothing)]))
```
And of course, we can also use it to define ADTs that use concrete types rather that type parameters, if we so desire. This implements a small mathematical language, along with a trivial interpreter:
```racket
(define-datatype Expr
(Value Number)
(Add Expr Expr)
(Subtract Expr Expr)
(Multiply Expr Expr)
(Divide Expr Expr))
(: evaluate (Expr -> Number))
(define (evaluate e)
(match e
[(Value x) x ]
[(Add a b) (+ (evaluate a) (evaluate b))]
[(Subtract a b) (- (evaluate a) (evaluate b))]
[(Multiply a b) (* (evaluate a) (evaluate b))]
[(Divide a b) (/ (evaluate a) (evaluate b))]))
> (evaluate (Add (Value 1)
(Multiply (Divide (Value 1) (Value 2))
(Value 7))))
4 1/2
```
There's all the power of ADTs, right in Racket, all implemented in 22 lines of code. If you'd like to see all the code together in a runnable form, [I've put together a gist here][adts-gist].
# Conclusions and credit
This isn't the simplest macro to create, nor is it the most complex. The code examples might not even make much sense until you try it out yourself. Macros, like any difficult concept, are not always easy to pick up, but they certainly *are* powerful. The ability to extend the language in such a way, in the matter of minutes, is unparalleled in languages other than Lisp.
This is, of course, a blessing and a curse. Lisps reject some of the syntactic landmarks that often aid in readability for the power to abstract programs into their bare components. In the end, is this uniform conciseness more or less readable? That's an incredibly subjective question, one that has prompted powerfully impassioned discussions, and I will not attempt to argue one way or the other here.
That said, I think it's pretty cool.
Finally, I must give credit where credit is due. Thanks to [Andrew M. Kent][andmkent] for the creation of the [datatype][racket-datatype] package, which served as the inspiration for this blog post. Many thanks to [Sam Tobin-Hochstadt][samth] for his work creating Typed Racket, as well as helping me dramatically simplify the implementation used in this blog post. Also thanks to [Ryan Culpepper][ryanc] and [Matthias Felleisen][matthias] for their work on creating `syntax/parse`, which is truly a marvelous tool for exploring the world of macros, and, of course, a big thanks to [Matthew Flatt][mflatt] for his implementation of hygiene in Racket, as well as much of the rest of Racket itself. Not to mention the entire legacy of those who formulated the foundations of the Scheme macro system and created the framework for all of this to be possible so many decades later.
Truly, working in Racket feels like standing on the shoulders of giants. If you're intrigued, give it a shot. It's a fun feeling.
[adts]: https://en.wikipedia.org/wiki/Algebraic_data_type
[adts-gist]: https://gist.github.com/lexi-lambda/18cf7a9156f743a1317e
[andmkent]: http://andmkent.com
[fear-of-macros]: http://www.greghendershott.com/fear-of-macros/
[matthias]: http://www.ccs.neu.edu/home/matthias/
[mflatt]: http://www.cs.utah.edu/~mflatt/
[racket-datatype]: https://github.com/andmkent/datatype
[ryanc]: http://www.ccs.neu.edu/home/ryanc/
[samth]: http://www.ccs.neu.edu/home/samth/
[syntax-parse]: http://docs.racket-lang.org/syntax/stxparse.html

279
_src/posts/2016-02-18-simple-safe-multimethods-in-racket.md
View File

@ -1,279 +0,0 @@
Title: Simple, safe multimethods in Racket
Date: 2016-02-18T18:48:32
Tags: racket, macros
Racket ships with `racket/generic`, a system for defining *generic methods*, functions that work differently depending on what sort of value they are supplied. I have made heavy use of this feature in my collections library, and it has worked well for my needs, but that system does have a bit of a limitation: it only supports *single dispatch*. Method implementations may only be chosen based on a single argument, so multiple dispatch is impossible.
<!-- more -->
# Motivating multiple dispatch
What is multiple dispatch and why is it necessary? Well, in most cases, it *isn’t* necessary at all. [It has been shown that multiple dispatch is much rarer than single dispatch in practice.][multiple-dispatch-in-practice] However, when actually needed, having multiple dispatch in the toolbox is a valuable asset.
A classic example of multiple dispatch is multiplication over both scalars and vectors. Ideally, all of the following operations should work:
```
2 × 3 = 6
2 × ⟨3, 4⟩ = ⟨6, 8⟩
⟨3, 4⟩ × 2 = ⟨6, 8⟩
```
In practice, most languages do not support such flexible dispatch rules without fairly complicated branching constructs to handle each permutation of input types. Furthermore, since most languages only support single dispatch (such as most object-oriented languages), it is nearly impossible to add support for a new combination of types to an existing method.
To illustrate the above, even if a language supported operator overloading *and* it included a `Vector` class that overloaded multiplication to properly work with numbers and vectors, it might not implement matrix multiplication. If a user defines a `Matrix` class, they may overload *its* multiplication to support numbers, vectors, and matrices, but it is impossible to extend the multiplication implementation for the `Vector` class. That method is now completely set in stone, unless it is edited directly (and the programmer may not have access to `Vector`’s implementation).
Multiple dispatch solves all of these problems. Rather than specify implementations of functions for singular types, it is possible to specify implementations for sets of types. In the above example, a programmer would be able to define a new function that operates on `Vector` and `Matrix` arguments. Since each definition does not “belong” to any given type, extending this set of operations is trivial.
# Multiple dispatch in Racket
This blog post is somewhat long and technical, so before proceeding any further, I want to show some real code that actually works so you can get a feel for what I’m talking about. As a proof-of-concept, I have created [a very simple implementation of multiple dispatch in Racket][racket-multimethod]. The above example would look like this in Racket using my module:
```racket
#lang racket
(require multimethod)
(provide mul
(struct-out num)
(struct-out vals))
(struct num (val))
(struct vec (vals))
(define-generic (mul a b))
(define-instance ((mul num num) x y)
(num (* (num-val x) (num-val y))))
(define-instance ((mul num vec) n v)
(vec (map (curry * (num-val n)) (vec-vals v))))
(define-instance ((mul vec num) v n)
(mul n v))
```
Pardon the somewhat clunky syntax, but the functionality is there. Using the above code works as expected:
```
> (mul (num 2) (num 3))
(num 6)
> (mul (num 2) (vec '(3 4)))
(vec '(6 8))
> (mul (vec '(3 4)) (num 2))
(vec '(6 8))
```
Making the above snippet work is not particularly hard. In fact, it’s likely that most competent Racketeers could do it without much thought. However, there’s a tiny bit more going on behind the scenes than it may seem.
# The problem with multiple dispatch
The single-dispatch design limitation of `racket/generic` comes directly from a desire to avoid what has been described as “spooky action at a distance”, a problem that is prevalent in many systems that support methods with multiple dispatch (aka *multimethods*). Specifically, the issue arises when new method implementations are defined for existing datatypes, which can have far-reaching effects throughout a program because the method table is global state. Both CLOS and Clojure suffer from this shortcoming.
Interestingly, Haskell with multi-parameter typeclasses (a nonstandard but highly useful extension) makes it quite trivial to create constructs similar to multiple dispatch (though the overload resolution is done at compile-time). The similarities are significant: Haskell *also* suffers from the possibility of a certain sort of “spooky action”. However, Haskell’s static typing and resolution allows the compiler to catch these potential issues, known as “orphan instances”, at compile time. Even though Racket does not support the same sort of static typing, the same idea can be used to keep multiple dispatch safe using the macro system.
# Safe, dynamically-typed multiple dispatch
In order to make multiple dispatch safe, we first need to determine exactly what is unsafe. Haskell has rules for determining what constitutes an “orphan instance”, and these rules are equally applicable for determining dangerous multimethod implementations. Specifically, a definition can be considered unsafe if *both* of the following conditions are true:
1. The multimethod that is being implemented was declared in a different module from the implementation.
2. *All* of the types used for dispatch in the multimethod instance were declared in a different module from the implementation.
Conversely, a multimethod implementation is safe if *either* of the following conditions are true:
1. The multimethod that is being implemented is declared in the same module as the implementation.
2. *Any* of the types used for dispatch in the multimethod instance are declared in the same module as the implementation.
Why do these two rules provide a strong enough guarantee to eliminate the dangers created by global state? Well, to understand that, we need to understand what can go wrong if these rules are ignored.
## Multimethods and dangerous instances
What exactly is this dangerous-sounding “spooky action”, and what causes it? Well, the trouble stems from the side-effectful nature of multimethod instance definitions. Consider the Racket module from earlier, which defines multiplication instances for scalars and vectors:
```racket
(provide mul
(struct-out num)
(struct-out vals))
(struct num (val))
(struct vec (vals))
(define-generic (mul a b))
(define-instance ((mul num num) x y)
(num (* (num-val x) (num-val y))))
(define-instance ((mul num vec) n v)
(vec (map (curry * (num-val n)) (vec-vals v))))
(define-instance ((mul vec num) v n)
(mul n v))
```
Note that there is not actually a `(mul vec vec)` implementation. This is intentional: there are *two* ways to take the product of two vectors, so no default implementation is provided. However, it is possible that another module might desire an instance for `mul` that takes the dot product, and the programmer might write the following definition:
```racket
(define-instance ((mul vec vec) x y)
(num (foldl + 0 (map * (vec-vals x) (vec-vals y)))))
```
However, there is something fishy about the above definition: it doesn’t need to be exported with `provide` to work! Since instances don’t create new bindings, they only add dispatch options, they don’t ever need to `provide` anything. This is problematic, though: it means that a program could continue to happily compile *even if* the module containing the dot product instance was never loaded with `require`, but an attempt to multiply two vectors would fail at runtime, claiming that there was no `(mul vec vec)` implementation. This drastic change of behavior violates Racket programmers’ assumptions about the guarantees made by modules (`require` should not cause any side-effects if the module’s bindings are not used).
Of course, while this seems potentially unexpected, it is workable: just be careful to `require` modules containing instances. Unfortunately, it gets much worse—what if a different library defines *its own* `(mul vec vec)` instance? What if that instance takes the cross product instead? That library may function entirely properly on its own, but when loaded alongside the program that defines a dot product instance, it is impossible to determine which instance should be used where. Because `define-instance` operates by modifying the aforementioned global state, the implementations clash, and the two systems *cannot* continue to operate together as written.
This is pretty bad. Defining extra instances is a reasonable use-case for multiple dispatch, but if these instances can break *third-party code*, how can they be trusted? This sort of problem can make multiple dispatch difficult to reason about and even more difficult to trust.
## What determines safety?
With those problems in mind, we can turn back to the two rules for *safe* multiple dispatch. How do they prevent the above issues? Well, let’s take them one at a time.
Remember that an instance can be unequivocally determined to be safe if either of the two conditions are true, so we can consider them entirely independently. The first one is simple—an instance is safe if the following condition holds:
> The multimethod that is being implemented is declared in the same module as the implementation.
This one is pretty obvious. It is impossible to create a “bad” instance of a method declared in the same module because it is impossible to import the method without also bringing in the instance. Furthermore, a conflicting instance cannot be defined at the place where the types themselves are defined because that would require a circular module dependency, which Racket does not permit.
With the above explanation in mind, the second condition should make sense, too:
> *Any* of the types used for dispatch in the multimethod instance are declared in the same module as the implementation.
The same argument for the first point holds for the second, but with the parties swapped. Again, it is impossible to use the instance without somehow requiring the module that defines the datatype itself, so the instance would always be required, anyway. The most interesting aspect of this condition is that it demonstrates that instances can be defined for existing datatypes (that are defined in other modules) just so long as *at least one* of the datatypes is defined in the same module. This continues to permit the important use-case of extending the interfaces of existing types.
## Encoding the safety rules into Racket’s macro system
In order to keep track of which methods and instances are defined where, I leveraged a technique based on the one [used by Typed Racket to keep track of whether or not a typed identifier is used in a typed or untyped context][typed-racket-scheme2007]. However, instead of using a simple mutable boolean flag, I used a mutable [free identifier set][free-id-set], which keeps track of the identifiers within a given module that should be considered “privileged”.
```racket
#lang racket/base
(require syntax/id-set)
(provide mark-id-as-privileged!
id-privileged?)
(define privileged-ids (mutable-free-id-set))
(define (mark-id-as-privileged! id)
(free-id-set-add! privileged-ids id))
(define (id-privileged? id)
(free-id-set-member? privileged-ids id))
```
Making this work with `define-generic` is obvious: just invoke `mark-id-as-privileged!` on the method name to note that the method is “privileged” in the scope of the current module. Keeping track of privileged structs is similarly straightforward, though it is a little more devious: the `multimethod` module provides a custom `struct` macro that just expands to `struct` from `racket/base`, but adds privilege information.
The `define-instance` macro does all the heavy lifting to ensure that only privileged identifiers can be used in instance definitions. A simple check for the identifier annotations is performed before proceeding with macro expansion:
```racket
(unless (or privileged? (ormap id-privileged? types))
(assert-privileged-struct! (first types)))
```
When the privilege checks fail, an error is raised:
```racket
(define (assert-privileged-struct! id)
(unless (id-privileged? id)
(raise-syntax-error 'define-instance
"expected name of struct defined in current module"
id)))
```
With the above safeguards in place, the dangerous dot product implementation from above **would not be allowed**. The checks manage to encode both of the safety rules into the macro system such that invalid instances will fail *at compile time*, preventing dangerous uses of multimethods from ever slipping by unnoticed.
## Actually implementing multiple dispatch
The rest of the multimethod implementation is relatively straightforward and is not even particularly robust. If anything, it is the bare minimum of what would be needed to allow the safety mechanisms above to work. Lots of features that would likely be needed in a real implementation are not included, and graceful error handling is largely ignored.
Multimethods themselves are implemented as Racket [transformer bindings][transformer-binding] containing custom data, including a reference to the multimethod’s arity and dispatch table. The custom datatype includes a `prop:procedure` structure type property, which allows such bindings to also function as macros. The macro procedure expands to an operation that looks up the proper instance to use in the multimethod’s dispatch table and invokes it with the supplied arguments.
The relevant code for defining multimethods is reproduced below:
```racket
(begin-for-syntax
(struct multimethod (arity dispatch-table)
#:property prop:procedure
(λ (method stx)
(syntax-parse stx
[(method arg ...)
#'(apply-multimethod method (list arg ...))]
[method
#'(λ args (apply-multimethod method args))]))))
(define-syntax define-generic
(syntax-parser
[(_ (method:id arg:id ...+))
(with-syntax ([arity (length (attribute arg))]
[dispatch-table (generate-temporary #'method)])
(mark-id-as-privileged! #'method)
#'(begin
(define dispatch-table (make-hash))
(define-syntax method (multimethod arity #'dispatch-table))))]))
```
The dispatch tables are implemented entirely in terms of Racket’s structure types, so while they can be defined on arbitrary structure types (including ones defined in the Racket standard library), they *cannot* be defined on primitives such as pairs or vectors. Implementations are registered in the dispatch table using the compile-time information associated with structs’ transformer bindings, and the same information is retrieved from struct instances at runtime to look up the proper implementation to call. Notably, this only works if the struct is `#:transparent`, or more generally and accurately, if the calling code has access to the struct’s inspector. All structs defined by the `struct` form from the `multimethod` module are automatically marked as `#:transparent`.
The following code implements defining multimethod instances:
```racket
(begin-for-syntax
(define (assert-privileged-struct! id)
(unless (id-privileged? id)
(raise-syntax-error 'define-instance
"expected name of struct defined in current module"
id))))
(define-syntax define-instance
(syntax-parser
; standard (define (proc ...) ...) shorthand
[(_ ((method type:id ...+) . args) body:expr ...+)
#'(define-instance (method type ...) (λ args body ...))]
; full (define proc lambda-expr) notation
[(_ (method type:id ...+) proc:expr)
(let* ([multimethod (syntax-local-value #'method)]
[privileged? (id-privileged? #'method)])
(unless (or privileged? (ormap id-privileged? (attribute type)))
(assert-privileged-struct! (first (attribute type))))
(with-syntax ([dispatch-table (multimethod-dispatch-table multimethod)]
[(struct-type-id ...) (map (compose1 first extract-struct-info syntax-local-value)
(attribute type))])
#'(let ([struct-types (list struct-type-id ...)])
(hash-set! dispatch-table struct-types proc))))]))
```
The resulting implementation is a useful, if certainly incomplete implementation of multimethods in Racket that does not sacrifice the safety provided by `racket/generic`’s single-dispatch approach.
# Related work, advantages and disadvantages, and areas for future improvement
As previously mentioned, this implementation of multiple dispatch was inspired by the types of APIs offered by CLOS and Clojure while also maintaining the safety of `racket/generic`. The inspiration for the safety rules came from GHC’s detection of orphan instances. Although most of the ideas presented above exist in other places, I am unsure if the concept of safety checking has been used before in any dynamically-typed programming languages.
The primary advantage offered over Racket’s existing generics system is obvious: multiple dispatch. Furthermore, this system can supersede many uses of `racket/generic` simply by dispatching on a single type. However, the current implementation does *not* support all of the features of `racket/generic`, such as supporting non-structure types and allowing fallback implementations. While those are well within the realm of possibility, other things like attaching structure type properties are probably not possible with this approach, so it is unlikely that the existing system could be subsumed by one like this one.
Additionally, this implementation would almost certainly need numerous improvements before being useful to most programmers:
- **Good error reporting for failure cases.** Right now, even something obvious like calling a method on values that do not implement it simply fails with an error produced by `hash-ref`. In a more interesting sense, using the arity to generate compile-time error messages for `define-instance` would be a nice improvement.
- **Support for Racket primitive data types.** This might require some cooperation from Racket itself to permit an elegant implementation, but they could also just be special-cased. So long as lookup for primitives was done *after* consulting the main dispatch table, there wouldn’t be any performance hit for non-primitive types.
- **Option to supply fallback implementations.** This wouldn’t be too hard at all, though it’s questionable whether or not it would be useful without method groupings like `define/generic` provides. There would likely also need to be some sort of way to check if a set of values implements a particular method.
- **Better cooperation with structure inspectors to alleviate the need for all structures to be transparent.** It’s currently unclear to me how exactly this works and how it *should* work. There might be a better way to do this without mucking with inspectors.
- **Much more flexible argument lists, including the ability to specify arguments that are not used for dispatch.** This is really a pretty fundamental requirement, but the parsing required was significant enough for me to put it off for this initial prototype.
- **Scribble forms to document generic methods and their instances.** This is something `racket/generic` *doesn’t* have, and it has suffered for it. It would be very nice to have easy documentation forms for multimethods.
- **Proper consideration of struct subtyping.** Racket structs support subtyping, which I have not given much thought for this prototype. It is possible that subtyping violates constraints I had assumed would hold, so reviewing the existing code with that context would be useful.
I’m not sure how much effort is involved in most of the above ideas, and in fact I’m not even completely sure how useful this system is to begin with. I have not found myself reaching much for multiple dispatch in my time as a Racket programmer, but that could simply be because it was previously unavailable. It will be interesting to see if that changes now that I have built this system, even if it is a bit rough around the edges.
# Conclusion
Despite the lack of need for multiple dispatch to solve most problems, as indicated by its general lack of support in mainstream programming languages, it’s a nice tool to have in the toolbox, and it *is* asked for in the Racket community from time to time (perhaps due to its familiarity in other parts of the Lisp world). Time will tell if pointing people to something like this will create or stifle interest in multiple dispatch for Racket.
The source for the [`multimethod` package can be found here][racket-multimethod] if you are at all interested in playing with it yourself.
[free-id-set]: http://docs.racket-lang.org/syntax/syntax-helpers.html#%28tech._identifier._set%29
[multiple-dispatch-in-practice]: http://dl.acm.org/citation.cfm?doid=1449764.1449808
[racket-multimethod]: https://github.com/lexi-lambda/racket-multimethod
[transformer-binding]: http://docs.racket-lang.org/guide/proc-macros.html#%28tech._transformer._binding%29
[typed-racket-scheme2007]: http://www.ccs.neu.edu/racket/pubs/scheme2007-ctf.pdf

50
_src/page-template.html → about.html
View File

@ -1,30 +1,36 @@
@(local-require racket/date)
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>@|title|</title>
<meta name="description" content="@|description|">
<meta name="author" content="@|author|">
<meta name="keywords" content="@|keywords|">
<title>About me</title>
<meta name="description" content="About me: I'm Alexis King, and I'm a software developer. I currently work at Philosophie building modern web applications, primarily using Ruby on Rails, CoffeeScript, and Angular JS. In my free time, I try to build cool things with Racket. Check out the ...">
<meta name="author" content="Alexis King">
<meta name="keywords" content="">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="@|full-uri|">
@(when rel-next @list{<link rel="next" href="@|rel-next|">})
@(when rel-prev @list{<link rel="prev" href="@|rel-prev|">})
<link rel="canonical" href="http://lexi-lambda.github.io/about.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="@|atom-feed-uri|" title="Atom Feed">
href="/feeds/all.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="@|rss-feed-uri|" title="RSS Feed">
href="/feeds/all.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
@google-universal-analytics["UA-65250372-1"]
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
@ -44,16 +50,22 @@
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
@;{ Index pages for posts have @tag that's not #f }
@(when tag
@list{<h1>Posts tagged <em>@|tag|</em></h1>})
@;{ The main page contents are in @contents }
@|contents|
<h1 id="about-me">About me</h1>
<p>I&rsquo;m Alexis King, and I&rsquo;m a software developer.</p>
<p>I currently work at <a href="http://www.gophilosophie.com">Philosophie</a> building modern web applications, primarily using Ruby on Rails, CoffeeScript, and Angular JS. In my free time, I try to build cool things with <a href="http://racket-lang.org">Racket</a>.</p>
<p>Check out the things I&rsquo;m working on on <a href="https://github.com/lexi-lambda/">GitHub</a>.</p>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© @date-year[(current-date)], Alexis King</h2>
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
@ -66,4 +78,4 @@
</footer>
</div>
</body>
</html>
</html>

360
blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/index.html Normal file
View File

@ -0,0 +1,360 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Automatically deploying a Frog-powered blog to GitHub pages</title>
<meta name="description" content="So, I have a blog now. It's a simple static blog, but what's unique about it is that it's powered by Racket; specifically, it uses Greg Hendershott's fantastic Frog tool. I've taken this and moulded it to my tastes to build my blog, including configuring ...">
<meta name="author" content="Alexis King">
<meta name="keywords" content="racket, frog, meta">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/">
<link rel="prev" href="/blog/2015/08/22/deploying-racket-applications-on-heroku/">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/all.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/all.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<article class="main">
<header>
<h1 class="title">Automatically deploying a Frog-powered blog to GitHub pages</h1>
<div class='date-and-tags'>
<time datetime="2015-07-18T19:09:01">
2015-07-18
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/frog.html">frog</a>, <a href="/tags/meta.html">meta</a></span>
</div>
</header>
<p>So, I have a blog now. It&rsquo;s a simple static blog, but what&rsquo;s unique about it is that it&rsquo;s powered by Racket; specifically, it uses <a href="http://www.greghendershott.com">Greg Hendershott</a>&rsquo;s fantastic <a href="https://github.com/greghendershott/frog">Frog</a> tool. I&rsquo;ve taken this and moulded it to my tastes to build my blog, including configuring automatic deployment via <a href="https://travis-ci.org">Travis CI</a>, so my blog is always up-to-date.</p>
<!-- more-->
<h1 id="setting-up-frog">Setting up Frog</h1>
<p>I should note that Frog itself was wonderfully easy to drop in and get running. Just following the readme, a simple <code>raco pkg install frog</code> followed by <code>raco frog --init</code> and <code>raco frog -bp</code> created a running blog and opened it in my web browser. There was nothing more to it. Once that&rsquo;s done, all it takes to write a blog post is <code>raco frog -n "Post Title"</code>, and you&rsquo;re good to go.</p>
<p>By default, Frog uses Bootstrap, which provides a lot of the necessary scaffolding for you, but I opted to roll my own layout using flexbox. I also decided to use <a href="http://sass-lang.com">Sass</a> for my stylesheets, potentially with support for <a href="http://coffeescript.org">CoffeeScript</a> later, so I wanted to have a good flow for compiling all the resources for deployment. To do that, I used <a href="http://gulpjs.com">Gulp</a> in conjunction with <a href="https://www.npmjs.com">NPM</a> for build and dependency management.</p>
<p>Going this route has a few advantages, primarily the fact that updating dependencies becomes much easier, and I can build and deploy my blog with just a couple of commands without needing to commit compiled or minified versions of my sources to version control.</p>
<h1 id="configuring-automatic-deployment-with-travis">Configuring automatic deployment with Travis</h1>
<p>Once Frog itself was configured and my styling was finished, I started looking into how to deploy my blog to a GitHub page without needing to check in any of the generated files to source control. I found a couple of resources, the most useful one being <a href="https://gist.github.com/domenic/ec8b0fc8ab45f39403dd">this Gist</a>, which describes how to set up deployment for any project. The basic idea is to create a deployment script which will automatically generate your project, initialize a git repository with the generated files, and push to GitHub&rsquo;s special <code>gh-pages</code> branch.</p>
<p>To make this easy, Frog can be configured to output to a separate directory via the <code>.frogrc</code> configuration file. I chose to output to the <code>out</code> directory:</p>
<pre><code>output-dir = out</code></pre>
<p>I also configured my Gulp build to output my CSS into the same output directory. Now, all that&rsquo;s necessary in order to deploy the blog to GitHub is to initialize a Git repository in the output directory, and push the files to the remote branch.</p>
<pre><code>$ cd out
$ git init
$ git add .
$ git commit -m "Deploy to GitHub Pages"
$ git push --force "$REMOTE_URL" master:gh-pages</code></pre>
<p>The next step is to configure Travis so that it can securely push to the GitHub repository with the required credentials. This can be done with Travis&rsquo;s <a href="http://docs.travis-ci.com/user/encryption-keys/">encryption keys</a> along with a GitHub <a href="https://github.com/settings/tokens">personal access token</a>. Just install the Travis CLI client, copy the access token, and run a command:</p>
<pre><code>$ gem install travis
$ travis encrypt GH_TOKEN=&lt;access token...&gt;</code></pre>
<p>The output of that command is an encrypted value to be placed in an environment variable in the project&rsquo;s <code>.travis.yml</code> configuration file. The URL for the repository on GitHub will also need to be specified as well:</p>
<div class="brush: yaml">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="l l-Scalar l-Scalar-Plain">env</span><span class="p p-Indicator">:</span>
<span class="l l-Scalar l-Scalar-Plain">global</span><span class="p p-Indicator">:</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">GH_REF</span><span class="p p-Indicator">:</span> <span class="s">&#39;github.com/&lt;gh-username&gt;/&lt;gh-repo&gt;.git&#39;</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">secure</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">&lt;encrypted data...&gt;</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Now all that&rsquo;s left is configuring the <code>.travis.yml</code> to run Frog. Since Travis doesn&rsquo;t natively support Racket at the time of this writing, the choice of &ldquo;language&rdquo; is somewhat arbitrary, but since I want Pygments installed for syntax highlighting, I set my project type to <code>python</code>, then installed Racket and Frog as pre-installation steps.</p>
<div class="brush: yaml">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="l l-Scalar l-Scalar-Plain">env</span><span class="p p-Indicator">:</span>
<span class="l l-Scalar l-Scalar-Plain">global</span><span class="p p-Indicator">:</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">GH_REF</span><span class="p p-Indicator">:</span> <span class="s">&#39;github.com/&lt;gh-username&gt;/&lt;gh-repo&gt;.git&#39;</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">secure</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">&lt;encrypted data...&gt;</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">RACKET_DIR</span><span class="p p-Indicator">:</span> <span class="s">&#39;~/racket&#39;</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">RACKET_VERSION</span><span class="p p-Indicator">:</span> <span class="s">&#39;6.2&#39;</span>
<span class="l l-Scalar l-Scalar-Plain">before_install</span><span class="p p-Indicator">:</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">git clone https://github.com/greghendershott/travis-racket.git</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">cat travis-racket/install-racket.sh | bash</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">export PATH="${RACKET_DIR}/bin:${PATH}"</span>
<span class="l l-Scalar l-Scalar-Plain">install</span><span class="p p-Indicator">:</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">raco pkg install --deps search-auto frog</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>(It might be worth noting that Greg Hendershott <em>also</em> maintains the repository that contains the above Travis build script!)</p>
<p>Finally, in my case, I wasn&rsquo;t deploying to a project-specific GitHub page. Instead, I wanted to deploy to my user page, which uses <code>master</code>, not <code>gh-pages</code>. Obviously, I didn&rsquo;t want Travis running on my <code>master</code> branch, since it would be deploying to that, so I added a branch whitelist:</p>
<div class="brush: yaml">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="l l-Scalar l-Scalar-Plain">branches</span><span class="p p-Indicator">:</span>
<span class="l l-Scalar l-Scalar-Plain">only</span><span class="p p-Indicator">:</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">source</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>All that was left to do was to write up the actual deployment script to be used by Travis. Based on the one provided in the above Gist, mine looked like this:</p>
<div class="brush: bash">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="ch">#!/bin/bash</span>
<span class="nb">set</span> -ev <span class="c1"># exit with nonzero exit code if anything fails</span>
<span class="c1"># clear the output directory</span>
rm -rf out <span class="o">||</span> <span class="nb">exit</span> 0<span class="p">;</span>
<span class="c1"># build the blog files + install pygments for highlighting support</span>
npm install
npm run build
pip install pygments
raco frog --build
<span class="c1"># go to the out directory and create a *new* Git repo</span>
<span class="nb">cd</span> out
git init
<span class="c1"># inside this git repo we&#39;ll pretend to be a new user</span>
git config user.name <span class="s2">"Travis CI"</span>
git config user.email <span class="s2">"&lt;your@email.here&gt;"</span>
<span class="c1"># The first and only commit to this new Git repo contains all the</span>
<span class="c1"># files present with the commit message "Deploy to GitHub Pages".</span>
git add .
git commit -m <span class="s2">"Deploy to GitHub Pages"</span>
<span class="c1"># Force push from the current repo&#39;s master branch to the remote</span>
<span class="c1"># repo. (All previous history on the branch will be lost, since we are</span>
<span class="c1"># overwriting it.) We redirect any output to /dev/null to hide any sensitive</span>
<span class="c1"># credential data that might otherwise be exposed.</span>
git push --force --quiet <span class="s2">"https://</span><span class="si">${</span><span class="nv">GH_TOKEN</span><span class="si">}</span><span class="s2">@</span><span class="si">${</span><span class="nv">GH_REF</span><span class="si">}</span><span class="s2">"</span> master &gt; /dev/null 2&gt;<span class="p">&amp;</span>1
</pre></div>
</td></tr></tbody></table>
</div>
<p>For reference, my final <code>.travis.yml</code> looked like this:</p>
<div class="brush: yaml">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="l l-Scalar l-Scalar-Plain">language</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">python</span>
<span class="l l-Scalar l-Scalar-Plain">python</span><span class="p p-Indicator">:</span>
<span class="p p-Indicator">-</span> <span class="s">&#39;3.4&#39;</span>
<span class="l l-Scalar l-Scalar-Plain">branches</span><span class="p p-Indicator">:</span>
<span class="l l-Scalar l-Scalar-Plain">only</span><span class="p p-Indicator">:</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">source</span>
<span class="l l-Scalar l-Scalar-Plain">env</span><span class="p p-Indicator">:</span>
<span class="l l-Scalar l-Scalar-Plain">global</span><span class="p p-Indicator">:</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">GH_REF</span><span class="p p-Indicator">:</span> <span class="s">&#39;github.com/lexi-lambda/lexi-lambda.github.io.git&#39;</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">secure</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">&lt;long secure token...&gt;</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">RACKET_DIR</span><span class="p p-Indicator">:</span> <span class="s">&#39;~/racket&#39;</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">RACKET_VERSION</span><span class="p p-Indicator">:</span> <span class="s">&#39;6.2&#39;</span>
<span class="l l-Scalar l-Scalar-Plain">before_install</span><span class="p p-Indicator">:</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">git clone https://github.com/greghendershott/travis-racket.git</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">cat travis-racket/install-racket.sh | bash</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">export PATH="${RACKET_DIR}/bin:${PATH}"</span>
<span class="l l-Scalar l-Scalar-Plain">install</span><span class="p p-Indicator">:</span>
<span class="p p-Indicator">-</span> <span class="l l-Scalar l-Scalar-Plain">raco pkg install --deps search-auto frog</span>
<span class="l l-Scalar l-Scalar-Plain">script</span><span class="p p-Indicator">:</span> <span class="l l-Scalar l-Scalar-Plain">bash ./deploy.sh</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>That&rsquo;s it! Now I have a working blog that I can publish just by pushing to the <code>source</code> branch on GitHub.</p>
<footer>
<script type="text/javascript">
var disqus_shortname = 'lexi-lambda';
(function() {
var dsq = document.createElement('script');
dsq.type = 'text/javascript';
dsq.async = true;
dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();
</script>
<div id="disqus_thread"></div>
<ul class="pager">
<li class="previous">
<a href="/blog/2015/08/22/deploying-racket-applications-on-heroku/">&larr; <em>Deploying Racket applications on Heroku</em></a>
</li>
</ul>
</footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

267
blog/2015/08/22/deploying-racket-applications-on-heroku/index.html Normal file
View File

@ -0,0 +1,267 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Deploying Racket applications on Heroku</title>
<meta name="description" content="Heroku is a &quot;platform as a service&quot; that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but R...">
<meta name="author" content="Alexis King">
<meta name="keywords" content="racket, heroku, 12factor">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/blog/2015/08/22/deploying-racket-applications-on-heroku/">
<link rel="next" href="/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/">
<link rel="prev" href="/blog/2015/08/30/managing-application-configuration-with-envy/">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/all.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/all.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<article class="main">
<header>
<h1 class="title">Deploying Racket applications on Heroku</h1>
<div class='date-and-tags'>
<time datetime="2015-08-22T14:47:49">
2015-08-22
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/heroku.html">heroku</a>, <a href="/tags/12factor.html">12factor</a></span>
</div>
</header>
<p><a href="https://www.heroku.com">Heroku</a> is a &ldquo;platform as a service&rdquo; that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but Racket is not currently among them. Fortunately, Heroku provides an interface for adding custom build processes for arbitrary types of applications, called “buildpacks”. I&rsquo;ve built one for Racket apps, and with just a little bit of configuration, it’s possible to get a Racket webserver running on Heroku.</p>
<!-- more-->
<h1 id="building-the-server">Building the server</h1>
<p>Racket&rsquo;s <a href="http://docs.racket-lang.org/web-server/index.html">web-server</a> package makes building and running a simple server incredibly easy. Here&rsquo;s all the code we&rsquo;ll need to get going:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="kn">#lang </span><span class="nn">racket</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit">require</a></span> <span class="n">web-server/servlet</span>
<span class="n">web-server/servlet-env</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">start</span> <span class="n">req</span><span class="p">)</span>
<span class="p">(</span><span class="n">response/xexpr</span>
<span class="o">'</span><span class="p">(</span><span class="ss">html</span> <span class="p">(</span><span class="ss">head</span> <span class="p">(</span><span class="ss">title</span> <span class="s2">"Racket Heroku App"</span><span class="p">))</span>
<span class="p">(</span><span class="ss">body</span> <span class="p">(</span><span class="ss">h1</span> <span class="s2">"It works!"</span><span class="p">)))))</span>
<span class="p">(</span><span class="n">serve/servlet</span> <span class="n">start</span> <span class="kd">#:servlet-path</span> <span class="s2">"/"</span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Running the above file will start up the server on the default port, 8080. When running on Heroku, however, we&rsquo;re required to bind to the port that Heroku provides via the <code>PORT</code> environment variable. We can access this using the Racket <code><a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit">getenv</a></code> function.</p>
<p>Additionally, the Racket web server specifically binds to localhost, but Heroku doesn&rsquo;t allow that restriction, so we need to pass <code>#f</code> for the <code>#:listen-ip</code> argument.</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5
6
7</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="n">port</span> <span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit">if</a></span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit">getenv</a></span> <span class="s2">"PORT"</span><span class="p">)</span>
<span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._string-~3enumber))" style="color: inherit">string-&gt;number</a></span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit">getenv</a></span> <span class="s2">"PORT"</span><span class="p">))</span>
<span class="mi">8080</span><span class="p">))</span>
<span class="p">(</span><span class="n">serve/servlet</span> <span class="n">start</span>
<span class="kd">#:servlet-path</span> <span class="s2">"/"</span>
<span class="kd">#:listen-ip</span> <span class="no">#f</span>
<span class="kd">#:port</span> <span class="n">port</span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Also, by default, <code>serve/servlet</code> will open a web browser automatically when the program is run, which is very useful for rapid prototyping within something like DrRacket, but we&rsquo;ll want to turn that off.</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n">serve/servlet</span> <span class="n">start</span>
<span class="kd">#:servlet-path</span> <span class="s2">"/"</span>
<span class="kd">#:listen-ip</span> <span class="no">#f</span>
<span class="kd">#:port</span> <span class="n">port</span>
<span class="kd">#:command-line?</span> <span class="no">#t</span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>That&rsquo;s it! Now we have a Racket web server that can run on Heroku. Obviously it&rsquo;s not a very interesting application right now, but that&rsquo;s fine for our purposes.</p>
<h1 id="setting-up-our-app-for-heroku">Setting up our app for Heroku</h1>
<p>The next step is to actually create an app on Heroku. Don&rsquo;t worry—it&rsquo;s free! That said, explaining precisely how Heroku works is outside the scope of this article. Just make an account, then create an app. I called mine &ldquo;racket-heroku-sample&rdquo;. Once you&rsquo;ve created an app and set up Heroku&rsquo;s command-line tool, you can specify the proper buildpack:</p>
<div class="brush: sh">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span>$ git init
$ heroku git:remote -a racket-heroku-sample
$ heroku buildpacks:set https://github.com/lexi-lambda/heroku-buildpack-racket
</pre></div>
</td></tr></tbody></table>
</div>
<p>We&rsquo;ll also need to pick a particular Racket version before we deploy our app. At the time of this writing, Racket 6.2.1 is the latest version, so I just set the <code>RACKET_VERSION</code> environment variable as follows:</p>
<div class="brush: sh">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span>$ heroku config:set <span class="nv">RACKET_VERSION</span><span class="o">=</span>6.2.1
</pre></div>
</td></tr></tbody></table>
</div>
<p>Now there&rsquo;s just one thing left to do before we can push to Heroku: we need to tell Heroku what command to use to run our application. To do this, we use something called a &ldquo;Procfile&rdquo; that contains information about the process types for our app. Heroku supports multiple processes of different types, but we&rsquo;re just going to have a single web process.</p>
<p>Specifically, we just want to run our <code>serve.rkt</code> module. The Racket buildpack installs the repository as a package, so we can run <code>racket</code> with the <code>-l</code> flag to specify a module path, which will be more robust than specifying a filesystem path directly. Therefore, our Procfile will look like this:</p>
<div class="brush: procfile">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span>web: racket -l sample-heroku-app/server
</pre></div>
</td></tr></tbody></table>
</div>
<p>Now all that&rsquo;s left to do is push our repository to Heroku&rsquo;s git remote. Once the build completes, we can <a href="https://racket-heroku-sample.herokuapp.com">navigate to our app&rsquo;s URL and actually see it running live</a>!</p>
<h1 id="conclusion">Conclusion</h1>
<p>That&rsquo;s all that&rsquo;s needed to get a Racket app up and running on Heroku, but it probably isn&rsquo;t the best way to manage a real application. Usually it&rsquo;s best to use a continuous integration service to automatically deploy certain GitHub branches to Heroku, after running the tests, of course. Also, a real application would obviously be a little more complicated.</p>
<p>That said, this provides the foundation and shell. If you&rsquo;d like to see the sample app used in this post, you can <a href="https://github.com/lexi-lambda/racket-sample-heroku-app">find it on GitHub here</a>. For more details on the buildpack itself, <a href="https://github.com/lexi-lambda/heroku-buildpack-racket">it&rsquo;s also available on GitHub here</a>.</p>
<footer>
<script type="text/javascript">
var disqus_shortname = 'lexi-lambda';
(function() {
var dsq = document.createElement('script');
dsq.type = 'text/javascript';
dsq.async = true;
dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();
</script>
<div id="disqus_thread"></div>
<ul class="pager">
<li class="previous">
<a href="/blog/2015/08/30/managing-application-configuration-with-envy/">&larr; <em>Managing application configuration with Envy</em></a>
</li>
<li class="next">
<a href="/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/"><em>Automatically deploying a Frog-powered blog to GitHub pages</em> &rarr;</a>
</li>
</ul>
</footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

197
blog/2015/08/30/managing-application-configuration-with-envy/index.html Normal file
View File

@ -0,0 +1,197 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Managing application configuration with Envy</title>
<meta name="description" content="Application configuration can be a pain. Modern web apps don't live on dedicated boxes, they run on VPSes somewhere in the amorphous &quot;cloud&quot;, and keeping configuration out of your application's repository can seem like more trouble than it's worth. Fortun...">
<meta name="author" content="Alexis King">
<meta name="keywords" content="envy, racket, 12factor">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/blog/2015/08/30/managing-application-configuration-with-envy/">
<link rel="next" href="/blog/2015/08/22/deploying-racket-applications-on-heroku/">
<link rel="prev" href="/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/all.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/all.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<article class="main">
<header>
<h1 class="title">Managing application configuration with Envy</h1>
<div class='date-and-tags'>
<time datetime="2015-08-30T16:05:37">
2015-08-30
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/envy.html">envy</a>, <a href="/tags/racket.html">racket</a>, <a href="/tags/12factor.html">12factor</a></span>
</div>
</header>
<p>Application configuration can be a pain. Modern web apps don&rsquo;t live on dedicated boxes, they run on VPSes somewhere in the amorphous &ldquo;cloud&rdquo;, and keeping configuration out of your application&rsquo;s repository can seem like more trouble than it&rsquo;s worth. Fortunately, <a href="http://12factor.net">The Twelve-Factor App</a> provides a set of standards for keeping web apps sane, and <a href="http://12factor.net/config">one of those guidelines advises keeping configuration in the environment</a>.</p>
<p><a href="https://github.com/lexi-lambda/envy">Envy</a> is the declarative bridge between Racket code and the outside world of the environment.</p>
<!-- more-->
<h1 id="introducing-envy">Introducing Envy</h1>
<p>I built Envy to distill the common tasks needed when working with environment variables into a single, declarative interface that eliminates boilerplate and makes it easy to see which environment variables an application depends on (instead of having them littered throughout the codebase). Using it is simple. Just require <code>envy</code> and you&rsquo;re good to go.</p>
<p>The best way to use Envy is to create a &ldquo;manifest&rdquo; module that declares all the environment variables your application might use. For example, the following module is a manifest that describes an application that uses three environment variables:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5
6
7
8
9</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="c1">; environment.rkt</span>
<span class="kn">#lang </span><span class="nn">typed/racket/base</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit">require</a></span> <span class="n">envy</span><span class="p">)</span>
<span class="p">(</span><span class="n">define/provide-environment</span>
<span class="n">api-token</span>
<span class="p">[</span><span class="n">log-level</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Symbol))" style="color: inherit">Symbol</a></span> <span class="kd">#:default</span> <span class="o">'</span><span class="ss">info</span><span class="p">]</span>
<span class="p">[</span><span class="n">parallel?</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Boolean))" style="color: inherit">Boolean</a></span><span class="p">])</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>When this module is required, Envy will automatically do the following:</p>
<ol>
<li>
<p>Envy will check the values of three environment variables: <code>API_TOKEN</code>, <code>LOG_LEVEL</code>, and <code>PARALLEL</code>.</p></li>
<li>
<p>If either <code>API_TOKEN</code> or <code>PARALLEL</code> is not set, an error will be raised:</p>
<pre><code>envy: The required environment variable "API_TOKEN" is not defined.</code></pre></li>
<li>
<p>The values for <code>LOG_LEVEL</code> and <code>PARALLEL</code> will be parsed to match their type annotations.</p></li>
<li>
<p>If <code>LOG_LEVEL</code> is not set, it will use the default value, <code>'info</code>.</p></li>
<li>
<p>The values will be stored in <code>api-token</code>, <code>log-level</code>, and <code>parallel?</code>, all of which will be provided by the enclosing module.</p></li></ol>
<p>Now just <code>(require (prefix-in env: "environment.rkt"))</code>, and the environment variables are guaranteed to be available in your application&rsquo;s code.</p>
<h1 id="working-with-typed-racket">Working with Typed Racket</h1>
<p>As you may have noticed by the example above, Envy is built with Typed Racket in mind. In fact, <code>define/provide-environment</code> will <em>only</em> work within a Typed Racket module, but that doesn&rsquo;t mean Envy can&rsquo;t be used with plain Racket—the manifest module can always be required by any kind of Racket module.</p>
<p>However, when using Typed Racket, Envy provides additional bonuses. Environment variables are inherently untyped—they&rsquo;re all just strings—but Envy assigns the proper type to each environment variable automatically, so no casting is necessary.</p>
<pre><code>&gt; parallel?
- : Boolean
#t</code></pre>
<p>Envy really shines when using optional environment variables with the <code>#:default</code> option. The type of the value given to <code>#:default</code> doesn&rsquo;t need to be the same type of the environment variable itself, and if it isn&rsquo;t, Envy will assign the value a union type.</p>
<pre><code>&gt; (define-environment
[num-threads : Positive-Integer #:default #f])
&gt; num-threads
- : (U Positive-Integer #f)
#f</code></pre>
<p>This added level of type-safety means it&rsquo;s easy to manage optional variables that don&rsquo;t have reasonable defaults: the type system will enforce that all code considers the possibility that such variables do not exist.</p>
<h1 id="and-more">And more&hellip;</h1>
<p>To see the full set of features that Envy already provides, <a href="https://lexi-lambda.github.io/envy/envy.html">take a look at the documentation</a>. That said, this is just the first release based on my initial use-cases, but I&rsquo;m sure there are more features Envy could have to accommodate common application configuration patterns. If you have an idea that could make Envy better, <a href="https://github.com/lexi-lambda/envy/issues">open an issue and make a suggestion</a>! I already have plans for a <code>#lang envy</code> DSL, which will hopefully cut the boilerplate out in its entirety.</p>
<p>And finally, to give credit where credit is due, Envy is heavily inspired by <a href="https://github.com/eval/envied">Envied</a> (both in name and function), an environment variable manager for Ruby, which I&rsquo;ve used to great effect.</p>
<p>Try it out!</p>
<ul>
<li><code>raco pkg install envy</code></li>
<li><a href="https://github.com/lexi-lambda/envy">Envy on GitHub</a></li>
<li><a href="https://lexi-lambda.github.io/envy/envy.html">Envy documentation</a></li></ul>
<footer>
<script type="text/javascript">
var disqus_shortname = 'lexi-lambda';
(function() {
var dsq = document.createElement('script');
dsq.type = 'text/javascript';
dsq.async = true;
dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();
</script>
<div id="disqus_thread"></div>
<ul class="pager">
<li class="previous">
<a href="/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/">&larr; <em>Canonical factories for testing with factory_girl_api</em></a>
</li>
<li class="next">
<a href="/blog/2015/08/22/deploying-racket-applications-on-heroku/"><em>Deploying Racket applications on Heroku</em> &rarr;</a>
</li>
</ul>
</footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

263
blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/index.html Normal file
View File

@ -0,0 +1,263 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Canonical factories for testing with factory_girl_api</title>
<meta name="description" content="Modern web applications are often built as _single-page apps_, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won't catch...">
<meta name="author" content="Alexis King">
<meta name="keywords" content="ruby, rails, javascript, angular">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/">
<link rel="next" href="/blog/2015/08/30/managing-application-configuration-with-envy/">
<link rel="prev" href="/blog/2015/11/06/functionally-updating-record-types-in-elm/">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/all.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/all.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<article class="main">
<header>
<h1 class="title">Canonical factories for testing with factory_girl_api</h1>
<div class='date-and-tags'>
<time datetime="2015-09-23T16:30:12">
2015-09-23
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/ruby.html">ruby</a>, <a href="/tags/rails.html">rails</a>, <a href="/tags/javascript.html">javascript</a>, <a href="/tags/angular.html">angular</a></span>
</div>
</header>
<p>Modern web applications are often built as <em>single-page apps</em>, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&rsquo;t catch the failure. I haven&rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.</p>
<p>To attempt to address a fraction of this problem, I built <a href="https://github.com/lexi-lambda/factory_girl_api">factory_girl_api</a>, a way to share context setup between both sides of the application.</p>
<!-- more-->
<h1 id="a-brief-overview-of-factorygirl">A brief overview of factory_girl</h1>
<p>In the land of Ruby and Rails, <a href="https://github.com/thoughtbot/factory_girl">factory_girl</a> is a convenient gem for managing factories for models. Out of the box, it integrates with Rails&rsquo; default ORM, ActiveRecord, and provides declarative syntax for describing what attributes factories should initialize. For example, a factory declaration used to create a widget might look like this:</p>
<div class="brush: ruby">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="no">FactoryGirl</span><span class="o">.</span><span class="n">define</span> <span class="k">do</span>
<span class="n">factory</span> <span class="ss">:widget</span> <span class="k">do</span>
<span class="n">sequence</span><span class="p">(</span><span class="ss">:name</span><span class="p">)</span> <span class="p">{</span> <span class="o">|</span><span class="nb">id</span><span class="o">|</span> <span class="s1">&#39;Widget #&#39;</span> <span class="o">+</span> <span class="nb">id</span> <span class="p">}</span>
<span class="n">price</span> <span class="mi">10</span>
<span class="n">trait</span> <span class="ss">:expensive</span> <span class="k">do</span>
<span class="n">price</span> <span class="mi">1000</span>
<span class="k">end</span>
<span class="k">end</span>
<span class="k">end</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>This makes it easy to create new instances of <code>Widget</code> and use them for unit tests. For example, this would create and persist a widget with a unique name and a price of 10 units:</p>
<div class="brush: ruby">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="n">widget</span> <span class="o">=</span> <span class="no">FactoryGirl</span><span class="o">.</span><span class="n">create</span> <span class="ss">:widget</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>We can also create more expensive widgets by using the <code>:expensive</code> trait.</p>
<div class="brush: ruby">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="n">expensive_widget</span> <span class="o">=</span> <span class="no">FactoryGirl</span><span class="o">.</span><span class="n">create</span> <span class="ss">:widget</span><span class="p">,</span> <span class="ss">:expensive</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Any number of traits can be specified at once. Additionally, it is possible to override individual attributes manually.</p>
<div class="brush: ruby">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="n">fancy_widget</span> <span class="o">=</span> <span class="no">FactoryGirl</span><span class="o">.</span><span class="n">create</span> <span class="ss">:widget</span><span class="p">,</span> <span class="ss">:expensive</span><span class="p">,</span> <span class="nb">name</span><span class="p">:</span> <span class="s1">&#39;Fancy Widget&#39;</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>It works well, and it keeps initialization boilerplate out of individual tests.</p>
<h1 id="testing-on-the-front-end">Testing on the front-end</h1>
<p>Trouble arises when we need to write tests for the JavaScript application that use the same models. Suddenly, we need to duplicate the same kind of logic in our front-end tests. We might start out by setting up object state manually:</p>
<div class="brush: js">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="kd">var</span> <span class="nx">fancyWidget</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Widget</span><span class="p">({</span>
<span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;Fancy Widget&#39;</span><span class="p">,</span>
<span class="nx">price</span><span class="o">:</span> <span class="mi">1000</span>
<span class="p">});</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Things can quickly get out of hand when models grow complex. Even if we use a factory library in JavaScript, it&rsquo;s possible for our front-end factories to diverge from their back-end counterparts. This means our integration tests will fail, but our unit tests will still blindly pass. Having to duplicate all that logic in two places is dangerous. It would be nice to have a <em>single, canonical source</em> for all of our factories.</p>
<h2 id="reusing-server-side-factories-with-factorygirlapi">Reusing server-side factories with factory_girl_api</h2>
<p>To help alleviate this problem, I created the <a href="https://github.com/lexi-lambda/factory_girl_api">factory_girl_api</a> gem for Rails and the <a href="https://github.com/lexi-lambda/angular-factory-girl-api">angular-factory-girl-api</a> Bower package for Angular. These packages cooperate with each other to allow server-side factories to be used in JavaScript tests.</p>
<p>The Angular module provides a service with syntax comparable to factory_girl itself. Both traits and custom attributes are supported:</p>
<div class="brush: js">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nx">FactoryGirl</span><span class="p">.</span><span class="nx">create</span><span class="p">(</span><span class="s1">&#39;widget&#39;</span><span class="p">,</span> <span class="s1">&#39;expensive&#39;</span><span class="p">,</span> <span class="p">{</span> <span class="nx">name</span><span class="o">:</span> <span class="s1">&#39;Fancy Widget&#39;</span> <span class="p">});</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>In this case, however, a round-trip API call must be made to the server in order to call the factory and return the result. Because of this, the Angular version of FactoryGirl returns a promise that is resolved with the serialized version of the model, which can then be used as sample data in unit tests.</p>
<h2 id="the-problems-with-relying-on-the-server-for-data">The problems with relying on the server for data</h2>
<p>In my preliminary use of this tool, it works. In many ways, it&rsquo;s much nicer than duplicating logic in both places. However, I&rsquo;m not <em>completely</em> convinced it&rsquo;s the right solution yet.</p>
<p>First of all, it couples the front-end to the back-end, even during unit testing, which is disappointing. It means that a server needs to be running (in test mode) in order for the tests to run at all. For the kinds of projects I work on, this isn&rsquo;t really a bad thing, and the benefits of the reduced duplication far outweigh the downsides.</p>
<p>My real concern is that this solves a very small facet of the general problem with fragile front-end test suites. Single-page applications usually depend wholly on their integration with back-end APIs. If those APIs change, the tests will continue to happily pass as long as the API is simply mocked, which seems to be the usual solution in the front-end universe. This is, frankly, unacceptable in real application development.</p>
<h2 id="potential-improvements-and-other-paths-to-success">Potential improvements and other paths to success</h2>
<p>I am ultimately unsatisfied with this approach, but writing brittle end-to-end integration tests is not the solution. This <em>kind</em> of thing may be a step in the right direction: writing tests that aren&rsquo;t really pure unit tests, but also aren&rsquo;t fragile full-stack integration tests. This is a middle-ground that seems infrequently traveled, perhaps due to a lack of tooling (or perhaps because it just doesn&rsquo;t work). I don&rsquo;t know.</p>
<p>Either way, I&rsquo;m interested in where this is headed, and I&rsquo;ll be curious to see if I run into any roadblocks using the workflow I&rsquo;ve created. If anyone else is interested in playing with these two libraries, the READMEs are much more comprehensive than what I&rsquo;ve covered here. Take a look, and give them a spin!</p>
<ul>
<li><a href="https://github.com/lexi-lambda/factory_girl_api">factory_girl_api</a></li>
<li><a href="https://github.com/lexi-lambda/angular-factory-girl-api">angular-factory-girl-api</a></li></ul>
<footer>
<script type="text/javascript">
var disqus_shortname = 'lexi-lambda';
(function() {
var dsq = document.createElement('script');
dsq.type = 'text/javascript';
dsq.async = true;
dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();
</script>
<div id="disqus_thread"></div>
<ul class="pager">
<li class="previous">
<a href="/blog/2015/11/06/functionally-updating-record-types-in-elm/">&larr; <em>Functionally updating record types in Elm</em></a>
</li>
<li class="next">
<a href="/blog/2015/08/30/managing-application-configuration-with-envy/"><em>Managing application configuration with Envy</em> &rarr;</a>
</li>
</ul>
</footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

587
blog/2015/11/06/functionally-updating-record-types-in-elm/index.html Normal file
View File

@ -0,0 +1,587 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Functionally updating record types in Elm</title>
<meta name="description" content="Elm is a wonderful language for building web apps, and I love so much of its approach to language design. Elm does so many things _right_ straight out of the box, and that's a real breath of fresh air in the intersection of functional programming and web ...">
<meta name="author" content="Alexis King">
<meta name="keywords" content="elm">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/blog/2015/11/06/functionally-updating-record-types-in-elm/">
<link rel="next" href="/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/">
<link rel="prev" href="/blog/2015/12/21/adts-in-typed-racket-with-macros/">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/all.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/all.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<article class="main">
<header>
<h1 class="title">Functionally updating record types in Elm</h1>
<div class='date-and-tags'>
<time datetime="2015-11-06T19:58:40">
2015-11-06
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/elm.html">elm</a></span>
</div>
</header>
<p><a href="http://elm-lang.org">Elm</a> is a wonderful language for building web apps, and I love so much of its approach to language design. Elm does so many things <em>right</em> straight out of the box, and that&rsquo;s a real breath of fresh air in the intersection of functional programming and web development. Still, it gets one thing wrong, and unfortunately, that one thing is incredibly important. Elm took the &ldquo;functions&rdquo; out of &ldquo;functional record types&rdquo;.</p>
<!-- more-->
<p>Almost any software program, at its core, is all about data. Maybe it&rsquo;s about computing data, maybe it&rsquo;s about manipulating data, or maybe it&rsquo;s about displaying data, but at the end of the day, some sort of data model is going to be needed. The functional model is a breathtakingly elegant system for handling data and shuttling it around throughout a program, and <a href="https://en.wikipedia.org/wiki/Functional_reactive_programming">functional reactive programming</a>, which Elm uses to model event-like interactions, makes this model work even better. The really important thing, though, is what tools Elm actually gives you to model your data.</p>
<h1 id="a-brief-primer-on-elm-records">A brief primer on Elm records</h1>
<p>Elm supports all the core datatypes one would expect—numbers, strings, booleans, optionals, etc.—and it allows users to define their own types with ADTs. However, Elm also provides another datatype, which it calls &ldquo;records&rdquo;. Records are similar to objects in JavaScript: they&rsquo;re effectively key-value mappings. They&rsquo;re cool data structures, and they work well. Here&rsquo;s an example of creating a <code>Point</code> datatype in Elm:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="kr">type</span> <span class="kr">alias</span> <span class="kt">Point</span> <span class="nf">=</span>
<span class="p">{</span> <span class="nv">x</span> <span class="nf">:</span> <span class="kt">Float</span><span class="p">,</span> <span class="nv">y</span> <span class="nf">:</span> <span class="kt">Float</span> <span class="p">}</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Notice that <code>Point</code> is declared as a type <em>alias</em>, not as a separate type like an ADT. This is because record types are truly encoded in the type system as values with named fields, not as disparate types. This allows for some fun tricks, but that&rsquo;s outside the scope of this blog post.</p>
<h1 id="the-good">The good</h1>
<p>What I&rsquo;d like to discuss is what it looks like to <em>manipulate</em> these data structures. Constructing them is completely painless, and reading from them is super simple. This is where the record system gets everything very <em>right</em>.</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5
6
7
8</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">origin</span> <span class="nf">:</span> <span class="kt">Point</span>
<span class="nv">origin</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">x</span> <span class="nf">=</span> <span class="mi">0</span><span class="p">,</span> <span class="nv">y</span> <span class="nf">=</span> <span class="mi">0</span> <span class="p">}</span>
<span class="nv">distanceBetween</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Float</span>
<span class="nv">distanceBetween</span> <span class="nv">a</span> <span class="nv">b</span> <span class="nf">=</span>
<span class="kr">let</span> <span class="nv">dx</span> <span class="nf">=</span> <span class="nv">a</span><span class="nf">.</span><span class="nv">x</span> <span class="nf">-</span> <span class="nv">b</span><span class="nf">.</span><span class="nv">x</span>
<span class="nv">dy</span> <span class="nf">=</span> <span class="nv">a</span><span class="nf">.</span><span class="nv">y</span> <span class="nf">-</span> <span class="nv">b</span><span class="nf">.</span><span class="nv">y</span>
<span class="kr">in</span> <span class="nv">sqrt</span> <span class="p">(</span><span class="nv">dx</span><span class="nf">*</span><span class="nv">dx</span> <span class="nf">+</span> <span class="nv">dy</span><span class="nf">*</span><span class="nv">dy</span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>The syntax is clean and simple. Most importantly, however, the record system is functional (in the &ldquo;functional programming&rdquo; sense). In a functional system, it&rsquo;s useful to express concepts in terms of function composition, and this is very easy to do in Elm. Creating a function to access a field would normally be clunky if you always needed to do <code>record.field</code> to access the value. Fortunately, Elm provides some sugar:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="c1">-- These two expressions are equivalent:</span>
<span class="p">(</span><span class="nf">\</span><span class="nv">record</span> <span class="nf">-&gt;</span> <span class="nv">record</span><span class="nf">.</span><span class="nv">field</span><span class="p">)</span>
<span class="nf">.</span><span class="nv">field</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Using the <code>.field</code> shorthand allows writing some other functions in terms of composition, as most functional programmers would desire:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">doubledX</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Float</span>
<span class="nv">doubledX</span> <span class="nf">=</span> <span class="p">(</span><span class="nf">(*)</span> <span class="mi">2</span><span class="p">)</span> <span class="nf">&lt;&lt;</span> <span class="nf">.</span><span class="nv">x</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>This satisfies me.</p>
<h1 id="the-bad">The bad</h1>
<p>So if everything in Elm is so great, what am I complaining about? Well, while the syntax to access fields is convenient, the syntax to <em>functionally set</em> fields is questionably clunky. Consider a function that accepts a point and returns a new point with its <code>x</code> field set to <code>0</code>:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">zeroedX</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">zeroedX</span> <span class="nv">point</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">point</span> <span class="nf">|</span> <span class="nv">x</span> <span class="nf">&lt;-</span> <span class="mi">0</span> <span class="p">}</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>This doesn&rsquo;t look too bad, does it? It&rsquo;s clear and concise. To me, though, there&rsquo;s something deeply wrong here&hellip; this function has a lot of redundancy! It seems to me like we should be able to write this function more clearly in a point-free style. The <code>.field</code> shorthand &ldquo;functionalizes&rdquo; the record getter syntax, so there must be a function version of the update syntax, right? Maybe it would look something like this:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">zeroedX</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">zeroedX</span> <span class="nf">=</span> <span class="err">!</span><span class="nv">x</span> <span class="mi">0</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>But alas, there is no such syntax.</p>
<p>Now you may ask&hellip; why does it matter? This seems trivial, and in fact, the explicit updater syntax may actually be more readable by virtue of how explicit it is. You&rsquo;d be right, because so far, these examples have been horribly contrived. But let&rsquo;s consider a slightly more useful example: <em>functionally updating</em> a record.</p>
<p>What&rsquo;s the difference? Well, say I wanted to take a point and increment its <code>x</code> field by one. Well, I can easily write a function for that:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">incrementX</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">incrementX</span> <span class="nv">point</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">point</span> <span class="nf">|</span> <span class="nv">x</span> <span class="nf">&lt;-</span> <span class="nv">point</span><span class="nf">.</span><span class="nv">x</span> <span class="nf">+</span> <span class="mi">1</span> <span class="p">}</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Not terrible, though a <em>little</em> verbose. Still, what if we want to also add a function that <em>decrements</em> <code>x</code>?</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">decrementX</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">decrementX</span> <span class="nv">point</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">point</span> <span class="nf">|</span> <span class="nv">x</span> <span class="nf">&lt;-</span> <span class="nv">point</span><span class="nf">.</span><span class="nv">x</span> <span class="nf">-</span> <span class="mi">1</span> <span class="p">}</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Oh, gosh. That&rsquo;s basically the exact same definition but with the operation flipped. Plus we probably want these operations for <code>y</code>, too. Fortunately, there&rsquo;s an easy solution: just pass a function in to <em>transform</em> the value! We can define an <code>updateX</code> function that allows us to do that easily, then we can define our derived operations in terms of that:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5
6
7
8</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">updateX</span> <span class="nf">:</span> <span class="p">(</span><span class="kt">Float</span> <span class="nf">-&gt;</span> <span class="kt">Float</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">updateX</span> <span class="nv">f</span> <span class="nv">point</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">point</span> <span class="nf">|</span> <span class="nv">x</span> <span class="nf">&lt;-</span> <span class="nv">f</span> <span class="nv">point</span><span class="nf">.</span><span class="nv">x</span> <span class="p">}</span>
<span class="nv">incrementX</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">incrementX</span> <span class="nf">=</span> <span class="nv">updateX</span> <span class="p">(</span><span class="nf">(+)</span> <span class="mi">1</span><span class="p">)</span>
<span class="nv">decrementX</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">decrementX</span> <span class="nf">=</span> <span class="nv">updateX</span> <span class="p">(</span><span class="nf">\</span><span class="nv">x</span> <span class="nf">-&gt;</span> <span class="nv">x</span> <span class="nf">-</span> <span class="mi">1</span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Not only is that much cleaner, but we can now use it to implement all sorts of other operations that allow us to add, subtract, multiply, or divide the <code>x</code> field. Now we just need to generalize our solution to work with the <code>x</code> <em>and</em> <code>y</code> fields!</p>
<p>Oh, wait. <strong>We can&rsquo;t.</strong></p>
<h1 id="the-ugly">The ugly</h1>
<p>This is where everything breaks down completely. Elm does not offer enough abstraction to reduce this level of crazy duplication:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">updateX</span> <span class="nf">:</span> <span class="p">(</span><span class="kt">Float</span> <span class="nf">-&gt;</span> <span class="kt">Float</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">updateX</span> <span class="nv">f</span> <span class="nv">point</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">point</span> <span class="nf">|</span> <span class="nv">x</span> <span class="nf">&lt;-</span> <span class="nv">f</span> <span class="nv">point</span><span class="nf">.</span><span class="nv">x</span> <span class="p">}</span>
<span class="nv">incrementX</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">incrementX</span> <span class="nf">=</span> <span class="nv">updateX</span> <span class="p">(</span><span class="nf">(+)</span> <span class="mi">1</span><span class="p">)</span>
<span class="nv">decrementX</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">decrementX</span> <span class="nf">=</span> <span class="nv">updateX</span> <span class="p">(</span><span class="nf">\</span><span class="nv">x</span> <span class="nf">-&gt;</span> <span class="nv">x</span> <span class="nf">-</span> <span class="mi">1</span><span class="p">)</span>
<span class="nv">updateY</span> <span class="nf">:</span> <span class="p">(</span><span class="kt">Float</span> <span class="nf">-&gt;</span> <span class="kt">Float</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">updateY</span> <span class="nv">f</span> <span class="nv">point</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">point</span> <span class="nf">|</span> <span class="nv">y</span> <span class="nf">&lt;-</span> <span class="nv">f</span> <span class="nv">point</span><span class="nf">.</span><span class="nv">y</span> <span class="p">}</span>
<span class="nv">incrementY</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">incrementY</span> <span class="nf">=</span> <span class="nv">updateY</span> <span class="p">(</span><span class="nf">(+)</span> <span class="mi">1</span><span class="p">)</span>
<span class="nv">decrementY</span> <span class="nf">:</span> <span class="kt">Point</span> <span class="nf">-&gt;</span> <span class="kt">Point</span>
<span class="nv">decrementY</span> <span class="nf">=</span> <span class="nv">updateY</span> <span class="p">(</span><span class="nf">\</span><span class="nv">x</span> <span class="nf">-&gt;</span> <span class="nv">x</span> <span class="nf">-</span> <span class="mi">1</span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>We sure can give it a shot, though. At the very least, we <em>can</em> implement the increment and decrement functions in a more general way by passing in an updater function:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">increment</span> <span class="nf">:</span> <span class="p">((</span><span class="kt">Float</span> <span class="nf">-&gt;</span> <span class="kt">Float</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="nv">a</span> <span class="nf">-&gt;</span> <span class="nv">a</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="nv">a</span> <span class="nf">-&gt;</span> <span class="nv">a</span>
<span class="nv">increment</span> <span class="nv">update</span> <span class="nf">=</span> <span class="nv">update</span> <span class="p">(</span><span class="nf">(+)</span> <span class="mi">1</span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Now, with <code>updateX</code> and <code>updateY</code>, we can increment either field very clearly and expressively. If we shorten the names to <code>uX</code> and <code>uY</code>, then the resulting code is actually very readable:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">pointAbove</span> <span class="nf">=</span> <span class="nv">uY</span> <span class="p">(</span><span class="nf">\</span><span class="nv">x</span> <span class="nf">-&gt;</span> <span class="nv">x</span> <span class="nf">+</span> <span class="mi">1</span><span class="p">)</span>
<span class="nv">pointBelow</span> <span class="nf">=</span> <span class="nv">uY</span> <span class="p">(</span><span class="nf">\</span><span class="nv">x</span> <span class="nf">-&gt;</span> <span class="nv">x</span> <span class="nf">-</span> <span class="mi">1</span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>It&rsquo;s almost like English now: &ldquo;update Y using this transformation&rdquo;. This is actually pretty satisfactory. The trouble arises when you have a struct with many fields:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5
6
7</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="kr">type</span> <span class="kr">alias</span> <span class="kt">PlayerStats</span> <span class="nf">=</span>
<span class="p">{</span> <span class="nv">health</span> <span class="nf">:</span> <span class="kt">Integer</span>
<span class="p">,</span> <span class="nv">strength</span> <span class="nf">:</span> <span class="kt">Integer</span>
<span class="p">,</span> <span class="nv">charisma</span> <span class="nf">:</span> <span class="kt">Integer</span>
<span class="p">,</span> <span class="nv">intellect</span> <span class="nf">:</span> <span class="kt">Integer</span>
<span class="c1">-- etc.</span>
<span class="p">}</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>It might be very convenient to have generic functional updaters in this case. One could imagine a game that has <code>Potion</code> items:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="kr">type</span> <span class="kt">Potion</span> <span class="nf">=</span> <span class="kt">Potion</span> <span class="kt">String</span> <span class="p">(</span><span class="kt">PlayerStats</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>And then some different kinds of potions:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">potions</span> <span class="nf">=</span>
<span class="p">[</span> <span class="p">(</span><span class="kt">Potion</span> <span class="s">"Health Potion"</span> <span class="p">(</span><span class="nv">uHealth</span> <span class="p">(</span><span class="nf">(+)</span> <span class="mi">1</span><span class="p">))),</span>
<span class="p">,</span> <span class="p">(</span><span class="kt">Potion</span> <span class="s">"Greater Intellect Potion"</span> <span class="p">(</span><span class="nv">uIntellect</span> <span class="p">(</span><span class="nf">(+)</span> <span class="mi">3</span><span class="p">)))</span>
<span class="p">,</span> <span class="p">(</span><span class="kt">Potion</span> <span class="s">"Potion of Weakness"</span> <span class="p">(</span><span class="nv">uStrength</span> <span class="p">(</span><span class="nf">\</span><span class="nv">x</span> <span class="nf">-&gt;</span> <span class="nv">x</span> <span class="nf">//</span> <span class="mi">5</span><span class="p">)))</span>
<span class="p">]</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>This is a really elegant way to think about items that can affect a player&rsquo;s stats! Unfortunately, it also means you have to define updater functions for <em>every single field in the record</em>. This can get tedious rather quickly:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">uHealth</span> <span class="nf">:</span> <span class="p">(</span><span class="kt">Integer</span> <span class="nf">-&gt;</span> <span class="kt">Integer</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span>
<span class="nv">uHealth</span> <span class="nv">f</span> <span class="nv">stats</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">stats</span> <span class="nf">|</span> <span class="nv">health</span> <span class="nf">&lt;-</span> <span class="nv">f</span> <span class="nv">stats</span><span class="nf">.</span><span class="nv">health</span> <span class="p">}</span>
<span class="nv">uStrength</span> <span class="nf">:</span> <span class="p">(</span><span class="kt">Integer</span> <span class="nf">-&gt;</span> <span class="kt">Integer</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span>
<span class="nv">uStrength</span> <span class="nv">f</span> <span class="nv">stats</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">stats</span> <span class="nf">|</span> <span class="nv">strength</span> <span class="nf">&lt;-</span> <span class="nv">f</span> <span class="nv">stats</span><span class="nf">.</span><span class="nv">strength</span> <span class="p">}</span>
<span class="nv">uCharisma</span> <span class="nf">:</span> <span class="p">(</span><span class="kt">Integer</span> <span class="nf">-&gt;</span> <span class="kt">Integer</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span>
<span class="nv">uCharisma</span> <span class="nv">f</span> <span class="nv">stats</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">stats</span> <span class="nf">|</span> <span class="nv">charisma</span> <span class="nf">&lt;-</span> <span class="nv">f</span> <span class="nv">stats</span><span class="nf">.</span><span class="nv">charisma</span> <span class="p">}</span>
<span class="c1">-- etc.</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>This is pretty icky. Could there be a better way?</p>
<h1 id="trying-to-create-a-more-general-abstraction">Trying to create a more general abstraction</h1>
<p>Interestingly, this pattern doesn&rsquo;t <em>need</em> to be this bad. There are better ways to do this. Let&rsquo;s revisit our updater functions.</p>
<p>Really, <code>update</code> can be defined in terms of two other primitive operations: a read and a (functional) write. What would it look like if we implemented it that way instead of requiring special updater functions to be defined? Well, it would look like this:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">update</span> <span class="nf">:</span> <span class="p">(</span><span class="nv">a</span> <span class="nf">-&gt;</span> <span class="nv">b</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="p">(</span><span class="nv">b</span> <span class="nf">-&gt;</span> <span class="nv">a</span> <span class="nf">-&gt;</span> <span class="nv">a</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="p">(</span><span class="nv">b</span> <span class="nf">-&gt;</span> <span class="nv">b</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="nv">a</span> <span class="nf">-&gt;</span> <span class="nv">a</span>
<span class="nv">update</span> <span class="nv">get</span> <span class="nv">set</span> <span class="nv">f</span> <span class="nv">x</span> <span class="nf">=</span> <span class="nv">set</span> <span class="p">(</span><span class="nv">f</span> <span class="p">(</span><span class="nv">get</span> <span class="nv">x</span><span class="p">))</span> <span class="nv">x</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>The type definition is a little long, but it&rsquo;s really pretty simple. We just supply a getter and a setter, then a function to do the transformation, and finally a record to actually transform. Of course, as you can see from the type, this function isn&rsquo;t actually specific to records: it can be used with any value for which a getter and setter can be provided.</p>
<p>The trouble here is that writing field setters isn&rsquo;t any easier in Elm than writing field updaters. They still look pretty verbose:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">sHealth</span> <span class="nf">:</span> <span class="kt">Integer</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span>
<span class="nv">sHealth</span> <span class="nv">x</span> <span class="nv">stats</span> <span class="nf">=</span> <span class="p">{</span> <span class="nv">stats</span> <span class="nf">|</span> <span class="nv">health</span> <span class="nf">&lt;-</span> <span class="nv">x</span> <span class="p">}</span>
<span class="nv">uHealth</span> <span class="nf">:</span> <span class="p">(</span><span class="kt">Integer</span> <span class="nf">-&gt;</span> <span class="kt">Integer</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span>
<span class="nv">uHealth</span> <span class="nf">=</span> <span class="nv">update</span> <span class="nf">.</span><span class="nv">health</span> <span class="nv">sHealth</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>So, at the end of it all, this isn&rsquo;t really a better abstraction. Still remember my fantasy <code>!field</code> setter shorthand half a blog post ago? Now perhaps it makes a little more sense. <em>If</em> such a syntax existed, then defining the updater would be incredibly simple:</p>
<div class="brush: elm">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="nv">uHealth</span> <span class="nf">:</span> <span class="p">(</span><span class="kt">Integer</span> <span class="nf">-&gt;</span> <span class="kt">Integer</span><span class="p">)</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span> <span class="nf">-&gt;</span> <span class="kt">PlayerStats</span>
<span class="nv">uHealth</span> <span class="nf">=</span> <span class="nv">update</span> <span class="nf">.</span><span class="nv">health</span> <span class="err">!</span><span class="nv">health</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Still, no syntax, no easy updaters, and by extension, no easy, declarative description of behavior without quite a bit of boilerplate.</p>
<h1 id="conclusions-and-related-work">Conclusions and related work</h1>
<p>Elm is a very promising language, and it seems to be in fairly rapid development. So far, its author, <a href="https://twitter.com/czaplic">Evan Czaplicki</a>, has taken a very cautious approach to implementing language features, especially potentially redundant ones. This caution is why things like operator slicing, &ldquo;where&rdquo; clauses, and special updater syntax have not yet made it into the language. Maybe at some point these will be deemed important enough to include, but for the time being, they&rsquo;ve been excluded.</p>
<p>I obviously think that having this sort of thing is incredibly important to being able to write expressive code without a huge amount of overhead. However, I also do <em>not</em> want to give the impression that I think adding special setter syntax is the only way to do it.</p>
<p>Seasoned functional programmers will surely have noticed that many of these concepts sound a lot like lenses, and Elm actually already has a lens-like library authored by Evan himself, called <a href="https://github.com/evancz/focus">Focus</a>. This, however, does not actually solve the problem: it requires manual description of setters just like the purely function based approach does. Really, lenses are just the logical next step in the line of abstraction I&rsquo;ve already laid out above.</p>
<p>Interestingly, PureScript and Elm, the two Haskell-likes-on-the-frontend that I&rsquo;ve paid attention to (though PureScript is much closer to Haskell than Elm), both have this very same problem. Haskell itself solves it with macros via Template Haskell. My favorite language, Racket, solves it with its own macro system. Is there another way to do these things that doesn&rsquo;t involve introducing a heavyweight macro system? Definitely. But I think this is a <em>necessary feature</em>, not a &ldquo;nice to have&rdquo;, so if a macro system is out of the picture, then a simpler, less flexible solution is the obvious logical alternative.</p>
<p>I really like Elm, and most of my experiences with it have been more than enough to convince me that it is a fantastic language for the job. Unfortunately, the issue of functional record updaters has been quite the frustrating obstacle in my otherwise frictionless ride. I will continue to happily use Elm over other, far less accommodating tools, but I hope that issues like these will be smoothed out as the language and its ecosystem matures.</p>
<footer>
<script type="text/javascript">
var disqus_shortname = 'lexi-lambda';
(function() {
var dsq = document.createElement('script');
dsq.type = 'text/javascript';
dsq.async = true;
dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();
</script>
<div id="disqus_thread"></div>
<ul class="pager">
<li class="previous">
<a href="/blog/2015/12/21/adts-in-typed-racket-with-macros/">&larr; <em>ADTs in Typed Racket with macros</em></a>
</li>
<li class="next">
<a href="/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/"><em>Canonical factories for testing with factory_girl_api</em> &rarr;</a>
</li>
</ul>
</footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

723
blog/2015/12/21/adts-in-typed-racket-with-macros/index.html Normal file
View File

@ -0,0 +1,723 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>ADTs in Typed Racket with macros</title>
<meta name="description" content="Macros are one of Racket's flagship features, and its macro system really is state of the art. Of course, it can sometimes be difficult to demonstrate _why_ macros are so highly esteemed, in part because it can be hard to find self-contained examples of u...">
<meta name="author" content="Alexis King">
<meta name="keywords" content="racket, typed racket, macros">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/blog/2015/12/21/adts-in-typed-racket-with-macros/">
<link rel="next" href="/blog/2015/11/06/functionally-updating-record-types-in-elm/">
<link rel="prev" href="/blog/2016/02/18/simple-safe-multimethods-in-racket/">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/all.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/all.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<article class="main">
<header>
<h1 class="title">ADTs in Typed Racket with macros</h1>
<div class='date-and-tags'>
<time datetime="2015-12-21T17:57:07">
2015-12-21
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/typed-racket.html">typed racket</a>, <a href="/tags/macros.html">macros</a></span>
</div>
</header>
<p>Macros are one of Racket&rsquo;s flagship features, and its macro system really is state of the art. Of course, it can sometimes be difficult to demonstrate <em>why</em> macros are so highly esteemed, in part because it can be hard to find self-contained examples of using macros in practice. Of course, one thing that macros are perfect for is filling a &ldquo;hole&rdquo; in the language by introducing a feature a language lacks, and one of those features in Typed Racket is <strong>ADTs</strong>.</p>
<!-- more-->
<h1 id="warning-this-is-not-a-macro-tutorial">Warning: this is not a macro tutorial</h1>
<p>First, a disclaimer: this post assumes at least some knowledge of Scheme/Racket macros. Ideally, you would be familiar with Racket itself. But if you aren&rsquo;t, fear not: if you get lost, don&rsquo;t worry. Hold on to the bigger picture, and you&rsquo;ll likely learn more than someone who knows enough to follow all the way through. If you <em>are</em> interested in learning about macros, I must recommend Greg Hendershott&rsquo;s <a href="http://www.greghendershott.com/fear-of-macros/">Fear of Macros</a>. It is good. This is not that.</p>
<p>Now, with that out of the way, let&rsquo;s get started.</p>
<h1 id="what-were-building">What we&rsquo;re building</h1>
<p><a href="https://en.wikipedia.org/wiki/Algebraic_data_type">Algebraic data types</a>, or <em>ADTs</em>, are a staple of the ML family of functional programming languages. I won&rsquo;t go into detail here—I want to focus on the implementation—but they&rsquo;re a very descriptive way of modeling data that encourages designing functions in terms of pattern-matching, something that Racket is already good at.</p>
<p>Racket also already has a facility for creating custom data structures in the form of <em>structs</em>, which are extremely flexible, but also a little verbose. Racket structs are more powerful than we need, but that means we can implement our ADTs in terms of Racket&rsquo;s struct system.</p>
<p>With that in mind, what should our syntax look like? Well, let&rsquo;s consider a quintessential example of ADTs: modeling a simple tree. For now, let&rsquo;s just consider a tree of integers. For reference, the Haskell syntax for such a data structure would look like this:</p>
<div class="brush: haskell">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="kr">data</span> <span class="kt">Tree</span> <span class="ow">=</span> <span class="kt">Empty</span>
<span class="o">|</span> <span class="kt">Leaf</span> <span class="kt">Int</span>
<span class="o">|</span> <span class="kt">Node</span> <span class="kt">Tree</span> <span class="kt">Tree</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>This already demonstrates a few of the core things we&rsquo;ll need to build:</p>
<ol>
<li>Each ADT has a <em>data type</em>, in this case <code>Tree</code>. This name only exists in the world of types, it isn&rsquo;t a value.</li>
<li>Each ADT has various <em>data constructors</em>, in this case <code>Leaf</code> and <code>Node</code>.</li>
<li>Each data constructor may accept any number of arguments, each of which have a specific type.</li>
<li>The types that data constructors may accept include the ADT&rsquo;s datatype itself—that is, definitions can be recursive.</li></ol>
<p>Of course, there&rsquo;s one more important feature we&rsquo;re missing: polymorphism. Our definition of a tree is overly-specific, and really, it should be able to hold any kind of data, not just integers. In Haskell, we can do that by adding a type parameter:</p>
<div class="brush: haskell">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="kr">data</span> <span class="kt">Tree</span> <span class="n">a</span> <span class="ow">=</span> <span class="kt">Empty</span>
<span class="o">|</span> <span class="kt">Leaf</span> <span class="n">a</span>
<span class="o">|</span> <span class="kt">Node</span> <span class="p">(</span><span class="kt">Tree</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="kt">Tree</span> <span class="n">a</span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>With this in mind, we can add a fifth and final point to our list:</p>
<p>
<ol start="5">
<li>ADTs must be able to be parametrically polymorphic.</li></ol></p>
<p>That covers all of our requirements for basic ADTs. Now we&rsquo;re ready to port this idea to Racket.</p>
<h2 id="describing-adts-in-racket">Describing ADTs in Racket</h2>
<p>How should we take the Haskell syntax for an ADT definition and adapt it to Racket&rsquo;s parenthetical s-expressions? By taking some cues from the Haskell implementation, Typed Racket&rsquo;s type syntax, and Racket&rsquo;s naming conventions, a fairly logical syntax emerges:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n">define-datatype</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)</span>
<span class="n">Empty</span>
<span class="p">(</span><span class="n">Leaf</span> <span class="n">a</span><span class="p">)</span>
<span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>This looks pretty good. Just like with the Haskell implementation, <code>Tree</code> should only exist at the type level, and <code>Empty</code>, <code>Leaf</code>, and <code>Node</code> should be constructor functions. Our syntax mirrors Racket function application, too—the proper way to create a leaf would be <code>(Leaf 7)</code>.</p>
<p>Now that we can create ADT values, how should we extract the values from them? Well, just like in ML-likes, we can use pattern-matching. We don&rsquo;t need to reinvent the wheel for this one; we should be able to just use Racket&rsquo;s <code><a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit">match</a></code> with our datatypes. For example, a function that sums all the values in a tree might look like this:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5
6
7</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">tree-sum</span> <span class="p">((</span><span class="n">Tree</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Integer))" style="color: inherit">Integer</a></span><span class="p">)</span> <span class="k"><a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit">-&gt;</a></span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Integer))" style="color: inherit">Integer</a></span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">tree-sum</span> <span class="n">tree</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit">match</a></span> <span class="n">tree</span>
<span class="p">[(</span><span class="n">Empty</span><span class="p">)</span> <span class="mi">0</span> <span class="p">]</span>
<span class="p">[(</span><span class="n">Leaf</span> <span class="n">n</span><span class="p">)</span> <span class="n">n</span> <span class="p">]</span>
<span class="p">[(</span><span class="n">Node</span> <span class="n">l</span> <span class="n">r</span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._+))" style="color: inherit">+</a></span> <span class="p">(</span><span class="n">tree-sum</span> <span class="n">l</span><span class="p">)</span>
<span class="p">(</span><span class="n">tree-sum</span> <span class="n">r</span><span class="p">))]))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Given that Racket&rsquo;s <code>struct</code> form automatically produces identifiers that cooperate with <code>match</code>, this shouldn&rsquo;t be hard at all. And with our syntax settled, we&rsquo;re ready to begin implementation.</p>
<h1 id="implementing-adts-as-syntax">Implementing ADTs as syntax</h1>
<p>Now for the fun part. To implement our ADT syntax, we&rsquo;ll employ Racket&rsquo;s industrial-strength macro DSL, <a href="http://docs.racket-lang.org/syntax/stxparse.html"><code>syntax/parse</code></a>. The <code>syntax/parse</code> library works like the traditional Scheme <code>syntax-case</code> on steroids, and one of the most useful features is the ability to define &ldquo;syntax classes&rdquo; that encapsulate reusable parsing rules into declarative components.</p>
<p>Since this is not a macro tutorial, the following implementation assumes you already know how to use <code>syntax/parse</code>. However, all of the concepts here are well within the reaches of any intermediate macrologist, so don&rsquo;t be intimidated by some of the more complex topics at play.</p>
<h2 id="parsing-types-with-a-syntax-class">Parsing types with a syntax class</h2>
<p>To implement ADTs, we&rsquo;re going to want to define exactly one syntax class, a class that describes the grammar for a type. As we&rsquo;ve seen, types can be bare identifiers, like <code>Tree</code>, or they can be identifiers with parameters, like <code>(Tree a)</code>. We&rsquo;ll want to cover both cases.</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit">begin-for-syntax</a></span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit">define-syntax-class</a></span> <span class="n">type</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="n">name:id</span> <span class="kd">#:attr</span> <span class="p">[</span><span class="n">param</span> <span class="mi">1</span><span class="p">]</span> <span class="o">'</span><span class="p">())</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="p">(</span><span class="n">name:id</span> <span class="n">param</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">))))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>This syntax class has two rules, one that&rsquo;s a bare identifier, and one that&rsquo;s a list. The ellipsis followed by a plus (<code>...+</code>) in the second example means &ldquo;one or more&rdquo;, so parsing those parameters will automatically be handled for us. In the bare identifier example, we use <code>#:attr</code> to give the <code>param</code> attribute the default value of an empty list, so this syntax class will actually <em>normalize</em> the input we get in addition to actually parsing it.</p>
<h2 id="a-first-attempt-at-define-datatype">A first attempt at <code>define-datatype</code></h2>
<p>Now we can move on to actually implementing <code>define-datatype</code>. The rules are simple: we need to generate a structure type for each one of the data constructors, and we need to generate a type definition for the parent type itself. This is pretty simple to implement using <code>syntax-parser</code>, which actually does the parsing for our macro.</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">define-datatype</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit">syntax-parser</a></span>
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="n">type-name:type</span> <span class="n">data-constructor:type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
<span class="p">]))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>This definition will do all the parsing we need. It parses the entire macro &ldquo;invocation&rdquo;, ignoring the first datum with <code>_</code> (which will just be the identifier <code>define-datatype</code>), then expecting a <code>type-name</code>, which uses the <code>type</code> syntax class we defined above. Next, we expect zero or more <code>data-constructor</code>s, which also use the <code>type</code> syntax class. That&rsquo;s all we have to do for parsing. We now have all the information we need to actually output the expansion for the macro.</p>
<p>Of course, it won&rsquo;t be that easy: this is the difficult part. The first step is to generate a Racket struct for each data constructor. We can do this pretty easily with some simple use of Racket&rsquo;s syntax templating facility. A naïve attempt would look like this:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5
6</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">define-datatype</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit">syntax-parser</a></span>
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="n">type-name:type</span> <span class="n">data-constructor:type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
<span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">data-constructor.name</span> <span class="p">([</span><span class="n">f</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">data-constructor.param</span><span class="p">]</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
<span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))]))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>This is actually really close to being correct. This will generate a struct definition for each <code>data-constructor</code>, where each struct has the name of the data constructor and the same number of fields as arguments provided. The trouble is that in Racket structs, all of the fields have <em>names</em>, but in our ADTs, all the fields are anonymous and by-position. Currently, we&rsquo;re just using the same name for <em>all</em> the fields, <code>f</code>, so if any data constructor has two or more fields, we&rsquo;ll get an error.</p>
<p>Since we don&rsquo;t care about the field names, what we want to do is just generate random names for every field. To do this, we can use a Racket function called <code>generate-temporary</code>, which generates random identifiers. Our next attempt might look like this:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="o">#`</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">data-constructor.name</span>
<span class="p">([</span><span class="o">#,</span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/reference/syntax-util.html#(def._((lib._racket/syntax..rkt)._generate-temporary))" style="color: inherit">generate-temporary</a></span><span class="p">)</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">data-constructor.param</span><span class="p">]</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
<span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>The <code>#,</code> lets us &ldquo;escape&rdquo; from the template to execute <code>(generate-temporary)</code> and interpolate its result into the syntax. Unfortunately, this doesn&rsquo;t work. We <em>do</em> generate a random field name, but the ellipsis will re-use the same generated value when it repeats the fields, rendering our whole effort pointless. We need to generate the field names once per type.</p>
<h2 id="more-leveraging-syntax-classes">More leveraging syntax classes</h2>
<p>As it turns out, this is <em>also</em> easy to do with syntax classes. We can add an extra attribute to our <code>type</code> syntax class to generate a random identifier with each one. Again, we can use <code>#:attr</code> to do that automatically. Our new definition for <code>type</code> will look like this:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5
6
7</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit">begin-for-syntax</a></span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit">define-syntax-class</a></span> <span class="n">type</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="n">name:id</span>
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">param</span> <span class="mi">1</span><span class="p">]</span> <span class="o">'</span><span class="p">()</span>
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">field-id</span> <span class="mi">1</span><span class="p">]</span> <span class="o">'</span><span class="p">())</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="p">(</span><span class="n">name:id</span> <span class="n">param</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">)</span>
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">field-id</span> <span class="mi">1</span><span class="p">]</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/stxops.html#(def._((lib._racket/private/stxcase-scheme..rkt)._generate-temporaries))" style="color: inherit">generate-temporaries</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)))))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Here we&rsquo;re using <code>generate-temporaries</code> instead of <code>generate-temporary</code>, which will conveniently generate a new identifier for each of the elements in the list we provide it. This way, we&rsquo;ll get a fresh identifier for each <code>param</code>.</p>
<p>We can now fix our macro to use this <code>field-id</code> attribute instead of the static field name:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">data-constructor.name</span>
<span class="p">([</span><span class="n">data-constructor.field-id</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">data-constructor.param</span><span class="p">]</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
<span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<h2 id="creating-the-supertype">Creating the supertype</h2>
<p>We&rsquo;re almost done—now we just need to implement our overall type, the one defined by <code>type-name</code>. This is implemented as a trivial type alias, but we need to ensure that polymorphic types are properly handled. For example, a non-polymorphic type would need to be handled like this:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit">define-type</a></span> <span class="n">Tree</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit">U</a></span> <span class="n">Empty</span> <span class="n">Leaf</span> <span class="n">Node</span><span class="p">))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>However, a polymorphic type alias would need to include the type parameters in each subtype, like this:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit">define-type</a></span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit">U</a></span> <span class="p">(</span><span class="n">Empty</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">Leaf</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">Node</span> <span class="n">a</span><span class="p">)))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>How can we do this? Well, so far, we&rsquo;ve been very declarative by using syntax patterns, templates, and classes. However, this is a more pernicious problem to solve with our declarative tools. Fortunately, it&rsquo;s very easy to fall back to using <strong>procedural macros</strong>.</p>
<p>To build each properly-instantiated type, we&rsquo;ll use a combination of <code>define/with-syntax</code> and Racket&rsquo;s list comprehensions, <code>for/list</code>. The <code>define/with-syntax</code> form binds values to pattern identifiers, which can be used within syntax patterns just like the ones bound by <code>syntax-parser</code>. This will allow us to break up our result into multiple steps. Technically, <code>define/with-syntax</code> is not strictly necessary—we could just use <code>#`</code> and <code>#,</code>—but it&rsquo;s cleaner to work with.</p>
<p>We&rsquo;ll start by defining a set of instantiated data constructor types, one per <code>data-constructor</code>:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit">define/with-syntax</a></span> <span class="p">[</span><span class="n">data-type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">]</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit">for/list</a></span> <span class="p">([</span><span class="n">name</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit">in-syntax</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">data-constructor.name</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))])</span>
<span class="p">))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Now we can fill in the body with any code we&rsquo;d like, so long as each body returns a syntax object. We can use some trivial branching logic to determine which form we need:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit">define/with-syntax</a></span> <span class="p">[</span><span class="n">data-type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">]</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit">for/list</a></span> <span class="p">([</span><span class="n">name</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit">in-syntax</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">data-constructor.name</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))])</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit">if</a></span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/syntax-helpers.html#(def._((lib._syntax/stx..rkt)._stx-null~3f))" style="color: inherit">stx-null?</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
<span class="n">name</span>
<span class="o">#`</span><span class="p">(</span><span class="o">#,</span><span class="n">name</span> <span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Now with our definition for <code>data-type</code>, we can implement our type alias for the supertype extremely easily:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="o">#'</span><span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit">define-type</a></span> <span class="n">type-name</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit">U</a></span> <span class="n">data-type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<h2 id="putting-it-all-together">Putting it all together</h2>
<p>There&rsquo;s just one more thing to do before we can call this macro finished: we need to ensure that all the type parameters defined by <code>type-name</code> are in scope for each data constructor&rsquo;s structure definition. We can do this by making use of <code>type-name.param</code> within each produced struct definition, resulting in this:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">data-constructor.name</span> <span class="p">(</span><span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
<span class="p">([</span><span class="n">data-constructor.field-id</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">data-constructor.param</span><span class="p">]</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
<span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>And we&rsquo;re done! The final macro, now completed, looks like this:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit">begin-for-syntax</a></span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit">define-syntax-class</a></span> <span class="n">type</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="n">name:id</span>
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">param</span> <span class="mi">1</span><span class="p">]</span> <span class="o">'</span><span class="p">()</span>
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">field-id</span> <span class="mi">1</span><span class="p">]</span> <span class="o">'</span><span class="p">())</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit">pattern</a></span> <span class="p">(</span><span class="n">name:id</span> <span class="n">param</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">)</span>
<span class="kd">#:attr</span> <span class="p">[</span><span class="n">field-id</span> <span class="mi">1</span><span class="p">]</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/stxops.html#(def._((lib._racket/private/stxcase-scheme..rkt)._generate-temporaries))" style="color: inherit">generate-temporaries</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)))))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">define-datatype</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit">syntax-parser</a></span>
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="n">type-name:type</span> <span class="n">data-constructor:type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit">define/with-syntax</a></span> <span class="p">[</span><span class="n">data-type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">]</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit">for/list</a></span> <span class="p">([</span><span class="n">name</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit">in-syntax</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">data-constructor.name</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))])</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit">if</a></span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/syntax-helpers.html#(def._((lib._syntax/stx..rkt)._stx-null~3f))" style="color: inherit">stx-null?</a></span> <span class="o">#'</span><span class="p">(</span><span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span>
<span class="n">name</span>
<span class="o">#`</span><span class="p">(</span><span class="o">#,</span><span class="n">name</span> <span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))))</span>
<span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="p">(</span><span class="n">type-name.param</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span> <span class="n">data-constructor.name</span>
<span class="p">([</span><span class="n">data-constructor.field-id</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">data-constructor.param</span><span class="p">]</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit">define-type</a></span> <span class="n">type-name</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit">U</a></span> <span class="n">data-type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)))]))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>It&rsquo;s a little bit dense, certainly, but it is not as complicated or scary as it might seem. It&rsquo;s a simple, mostly declarative, powerful way to transform a DSL into ordinary Typed Racket syntax, and now all we have to do is put it to use.</p>
<h1 id="using-our-adts">Using our ADTs</h1>
<p>With the macro built, we can now actually use our ADTs using the syntax we described! The following is now <em>valid code</em>:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5
6
7
8</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n">define-datatype</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)</span>
<span class="n">Empty</span>
<span class="p">(</span><span class="n">Leaf</span> <span class="n">a</span><span class="p">)</span>
<span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">Tree</span> <span class="n">a</span><span class="p">)))</span>
<span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._~3e))" style="color: inherit">&gt;</a></span> <span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Leaf</span> <span class="mi">3</span><span class="p">)</span> <span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Empty</span><span class="p">)</span> <span class="p">(</span><span class="n">Leaf</span> <span class="mi">7</span><span class="p">)))</span>
<span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._-))" style="color: inherit">-</a></span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="p">(</span><span class="n">Node</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Positive-.Byte))" style="color: inherit">Positive-Byte</a></span><span class="p">)</span>
<span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Leaf</span> <span class="mi">3</span><span class="p">)</span> <span class="p">(</span><span class="n">Node</span> <span class="p">(</span><span class="n">Empty</span><span class="p">)</span> <span class="p">(</span><span class="n">Leaf</span> <span class="mi">7</span><span class="p">)))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>We can use this to define common data types, such as Haskell&rsquo;s <code>Maybe</code>:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n">define-datatype</span> <span class="p">(</span><span class="n">Maybe</span> <span class="n">a</span><span class="p">)</span>
<span class="p">(</span><span class="n">Just</span> <span class="n">a</span><span class="p">)</span>
<span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit">Nothing</a></span><span class="p">)</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">maybe-default</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.All))" style="color: inherit">All</a></span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">(</span><span class="n">Maybe</span> <span class="n">a</span><span class="p">)</span> <span class="n">a</span> <span class="k"><a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit">-&gt;</a></span> <span class="n">a</span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">maybe-default</span> <span class="n">m</span> <span class="n">v</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit">match</a></span> <span class="n">m</span>
<span class="p">[(</span><span class="n">Just</span> <span class="n">a</span><span class="p">)</span> <span class="n">a</span><span class="p">]</span>
<span class="p">[(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit">Nothing</a></span><span class="p">)</span> <span class="n">v</span><span class="p">]))</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">maybe-then</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.All))" style="color: inherit">All</a></span> <span class="p">[</span><span class="n">a</span><span class="p">]</span> <span class="p">(</span><span class="n">Maybe</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">a</span> <span class="k"><a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit">-&gt;</a></span> <span class="p">(</span><span class="n">Maybe</span> <span class="n">a</span><span class="p">))</span> <span class="k"><a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit">-&gt;</a></span> <span class="p">(</span><span class="n">Maybe</span> <span class="n">a</span><span class="p">)))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">maybe-then</span> <span class="n">m</span> <span class="n">f</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit">match</a></span> <span class="n">m</span>
<span class="p">[(</span><span class="n">Just</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">f</span> <span class="n">a</span><span class="p">)]</span>
<span class="p">[(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit">Nothing</a></span><span class="p">)</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit">Nothing</a></span><span class="p">)]))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>And of course, we can also use it to define ADTs that use concrete types rather that type parameters, if we so desire. This implements a small mathematical language, along with a trivial interpreter:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n">define-datatype</span> <span class="n">Expr</span>
<span class="p">(</span><span class="n">Value</span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Number))" style="color: inherit">Number</a></span><span class="p">)</span>
<span class="p">(</span><span class="n">Add</span> <span class="n">Expr</span> <span class="n">Expr</span><span class="p">)</span>
<span class="p">(</span><span class="n">Subtract</span> <span class="n">Expr</span> <span class="n">Expr</span><span class="p">)</span>
<span class="p">(</span><span class="n">Multiply</span> <span class="n">Expr</span> <span class="n">Expr</span><span class="p">)</span>
<span class="p">(</span><span class="n">Divide</span> <span class="n">Expr</span> <span class="n">Expr</span><span class="p">))</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit">:</a></span> <span class="n">evaluate</span> <span class="p">(</span><span class="n">Expr</span> <span class="k"><a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit">-&gt;</a></span> <span class="n"><a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Number))" style="color: inherit">Number</a></span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">e</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit">match</a></span> <span class="n">e</span>
<span class="p">[(</span><span class="n">Value</span> <span class="n">x</span><span class="p">)</span> <span class="n">x</span> <span class="p">]</span>
<span class="p">[(</span><span class="n">Add</span> <span class="n">a</span> <span class="n">b</span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._+))" style="color: inherit">+</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">b</span><span class="p">))]</span>
<span class="p">[(</span><span class="n">Subtract</span> <span class="n">a</span> <span class="n">b</span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._-))" style="color: inherit">-</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">b</span><span class="p">))]</span>
<span class="p">[(</span><span class="n">Multiply</span> <span class="n">a</span> <span class="n">b</span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">b</span><span class="p">))]</span>
<span class="p">[(</span><span class="n">Divide</span> <span class="n">a</span> <span class="n">b</span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._/))" style="color: inherit">/</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">a</span><span class="p">)</span> <span class="p">(</span><span class="n">evaluate</span> <span class="n">b</span><span class="p">))]))</span>
<span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._~3e))" style="color: inherit">&gt;</a></span> <span class="p">(</span><span class="n">evaluate</span> <span class="p">(</span><span class="n">Add</span> <span class="p">(</span><span class="n">Value</span> <span class="mi">1</span><span class="p">)</span>
<span class="p">(</span><span class="n">Multiply</span> <span class="p">(</span><span class="n">Divide</span> <span class="p">(</span><span class="n">Value</span> <span class="mi">1</span><span class="p">)</span> <span class="p">(</span><span class="n">Value</span> <span class="mi">2</span><span class="p">))</span>
<span class="p">(</span><span class="n">Value</span> <span class="mi">7</span><span class="p">))))</span>
<span class="mi">4</span> <span class="m">1/2</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>There&rsquo;s all the power of ADTs, right in Racket, all implemented in 22 lines of code. If you&rsquo;d like to see all the code together in a runnable form, <a href="https://gist.github.com/lexi-lambda/18cf7a9156f743a1317e">I&rsquo;ve put together a gist here</a>.</p>
<h1 id="conclusions-and-credit">Conclusions and credit</h1>
<p>This isn&rsquo;t the simplest macro to create, nor is it the most complex. The code examples might not even make much sense until you try it out yourself. Macros, like any difficult concept, are not always easy to pick up, but they certainly <em>are</em> powerful. The ability to extend the language in such a way, in the matter of minutes, is unparalleled in languages other than Lisp.</p>
<p>This is, of course, a blessing and a curse. Lisps reject some of the syntactic landmarks that often aid in readability for the power to abstract programs into their bare components. In the end, is this uniform conciseness more or less readable? That&rsquo;s an incredibly subjective question, one that has prompted powerfully impassioned discussions, and I will not attempt to argue one way or the other here.</p>
<p>That said, I think it&rsquo;s pretty cool.</p>
<p>Finally, I must give credit where credit is due. Thanks to <a href="http://andmkent.com">Andrew M. Kent</a> for the creation of the <a href="https://github.com/andmkent/datatype">datatype</a> package, which served as the inspiration for this blog post. Many thanks to <a href="http://www.ccs.neu.edu/home/samth/">Sam Tobin-Hochstadt</a> for his work creating Typed Racket, as well as helping me dramatically simplify the implementation used in this blog post. Also thanks to <a href="http://www.ccs.neu.edu/home/ryanc/">Ryan Culpepper</a> and <a href="http://www.ccs.neu.edu/home/matthias/">Matthias Felleisen</a> for their work on creating <code>syntax/parse</code>, which is truly a marvelous tool for exploring the world of macros, and, of course, a big thanks to <a href="http://www.cs.utah.edu/~mflatt/">Matthew Flatt</a> for his implementation of hygiene in Racket, as well as much of the rest of Racket itself. Not to mention the entire legacy of those who formulated the foundations of the Scheme macro system and created the framework for all of this to be possible so many decades later.</p>
<p>Truly, working in Racket feels like standing on the shoulders of giants. If you&rsquo;re intrigued, give it a shot. It&rsquo;s a fun feeling.</p>
<footer>
<script type="text/javascript">
var disqus_shortname = 'lexi-lambda';
(function() {
var dsq = document.createElement('script');
dsq.type = 'text/javascript';
dsq.async = true;
dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();
</script>
<div id="disqus_thread"></div>
<ul class="pager">
<li class="previous">
<a href="/blog/2016/02/18/simple-safe-multimethods-in-racket/">&larr; <em>Simple, safe multimethods in Racket</em></a>
</li>
<li class="next">
<a href="/blog/2015/11/06/functionally-updating-record-types-in-elm/"><em>Functionally updating record types in Elm</em> &rarr;</a>
</li>
</ul>
</footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

550
blog/2016/02/18/simple-safe-multimethods-in-racket/index.html Normal file
View File

@ -0,0 +1,550 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Simple, safe multimethods in Racket</title>
<meta name="description" content="Racket ships with `racket/generic`, a system for defining _generic methods_, functions that work differently depending on what sort of value they are supplied. I have made heavy use of this feature in my collections library, and it has worked well for my ...">
<meta name="author" content="Alexis King">
<meta name="keywords" content="racket, macros">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/blog/2016/02/18/simple-safe-multimethods-in-racket/">
<link rel="next" href="/blog/2015/12/21/adts-in-typed-racket-with-macros/">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/all.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/all.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<article class="main">
<header>
<h1 class="title">Simple, safe multimethods in Racket</h1>
<div class='date-and-tags'>
<time datetime="2016-02-18T18:48:32">
2016-02-18
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/macros.html">macros</a></span>
</div>
</header>
<p>Racket ships with <code>racket/generic</code>, a system for defining <em>generic methods</em>, functions that work differently depending on what sort of value they are supplied. I have made heavy use of this feature in my collections library, and it has worked well for my needs, but that system does have a bit of a limitation: it only supports <em>single dispatch</em>. Method implementations may only be chosen based on a single argument, so multiple dispatch is impossible.</p>
<!-- more-->
<h1 id="motivating-multiple-dispatch">Motivating multiple dispatch</h1>
<p>What is multiple dispatch and why is it necessary? Well, in most cases, it <em>isn’t</em> necessary at all. <a href="http://dl.acm.org/citation.cfm?doid=1449764.1449808">It has been shown that multiple dispatch is much rarer than single dispatch in practice.</a> However, when actually needed, having multiple dispatch in the toolbox is a valuable asset.</p>
<p>A classic example of multiple dispatch is multiplication over both scalars and vectors. Ideally, all of the following operations should work:</p>
<pre><code>2 × 3 = 6
2 × ⟨3, 4⟩ = ⟨6, 8⟩
⟨3, 4⟩ × 2 = ⟨6, 8⟩</code></pre>
<p>In practice, most languages do not support such flexible dispatch rules without fairly complicated branching constructs to handle each permutation of input types. Furthermore, since most languages only support single dispatch (such as most object-oriented languages), it is nearly impossible to add support for a new combination of types to an existing method.</p>
<p>To illustrate the above, even if a language supported operator overloading <em>and</em> it included a <code>Vector</code> class that overloaded multiplication to properly work with numbers and vectors, it might not implement matrix multiplication. If a user defines a <code>Matrix</code> class, they may overload <em>its</em> multiplication to support numbers, vectors, and matrices, but it is impossible to extend the multiplication implementation for the <code>Vector</code> class. That method is now completely set in stone, unless it is edited directly (and the programmer may not have access to <code>Vector</code>’s implementation).</p>
<p>Multiple dispatch solves all of these problems. Rather than specify implementations of functions for singular types, it is possible to specify implementations for sets of types. In the above example, a programmer would be able to define a new function that operates on <code>Vector</code> and <code>Matrix</code> arguments. Since each definition does not “belong” to any given type, extending this set of operations is trivial.</p>
<h1 id="multiple-dispatch-in-racket">Multiple dispatch in Racket</h1>
<p>This blog post is somewhat long and technical, so before proceeding any further, I want to show some real code that actually works so you can get a feel for what I’m talking about. As a proof-of-concept, I have created <a href="https://github.com/lexi-lambda/racket-multimethod">a very simple implementation of multiple dispatch in Racket</a>. The above example would look like this in Racket using my module:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="kn">#lang </span><span class="nn">racket</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit">require</a></span> <span class="n">multimethod</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._provide))" style="color: inherit">provide</a></span> <span class="n">mul</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._struct-out))" style="color: inherit">struct-out</a></span> <span class="n">num</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._struct-out))" style="color: inherit">struct-out</a></span> <span class="n">vals</span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">num</span> <span class="p">(</span><span class="n">val</span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">vec</span> <span class="p">(</span><span class="n">vals</span><span class="p">))</span>
<span class="p">(</span><span class="n">define-generic</span> <span class="p">(</span><span class="n">mul</span> <span class="n">a</span> <span class="n">b</span><span class="p">))</span>
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">num</span> <span class="n">num</span><span class="p">)</span> <span class="n">x</span> <span class="n">y</span><span class="p">)</span>
<span class="p">(</span><span class="n">num</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">num-val</span> <span class="n">x</span><span class="p">)</span> <span class="p">(</span><span class="n">num-val</span> <span class="n">y</span><span class="p">))))</span>
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">num</span> <span class="n">vec</span><span class="p">)</span> <span class="n">n</span> <span class="n">v</span><span class="p">)</span>
<span class="p">(</span><span class="n">vec</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._map))" style="color: inherit">map</a></span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/procedures.html#(def._((lib._racket/function..rkt)._curry))" style="color: inherit">curry</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">num-val</span> <span class="n">n</span><span class="p">))</span> <span class="p">(</span><span class="n">vec-vals</span> <span class="n">v</span><span class="p">))))</span>
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">vec</span> <span class="n">num</span><span class="p">)</span> <span class="n">v</span> <span class="n">n</span><span class="p">)</span>
<span class="p">(</span><span class="n">mul</span> <span class="n">n</span> <span class="n">v</span><span class="p">))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Pardon the somewhat clunky syntax, but the functionality is there. Using the above code works as expected:</p>
<pre><code>&gt; (mul (num 2) (num 3))
(num 6)
&gt; (mul (num 2) (vec '(3 4)))
(vec '(6 8))
&gt; (mul (vec '(3 4)) (num 2))
(vec '(6 8))</code></pre>
<p>Making the above snippet work is not particularly hard. In fact, it’s likely that most competent Racketeers could do it without much thought. However, there’s a tiny bit more going on behind the scenes than it may seem.</p>
<h1 id="the-problem-with-multiple-dispatch">The problem with multiple dispatch</h1>
<p>The single-dispatch design limitation of <code>racket/generic</code> comes directly from a desire to avoid what has been described as “spooky action at a distance”, a problem that is prevalent in many systems that support methods with multiple dispatch (aka <em>multimethods</em>). Specifically, the issue arises when new method implementations are defined for existing datatypes, which can have far-reaching effects throughout a program because the method table is global state. Both CLOS and Clojure suffer from this shortcoming.</p>
<p>Interestingly, Haskell with multi-parameter typeclasses (a nonstandard but highly useful extension) makes it quite trivial to create constructs similar to multiple dispatch (though the overload resolution is done at compile-time). The similarities are significant: Haskell <em>also</em> suffers from the possibility of a certain sort of “spooky action”. However, Haskell’s static typing and resolution allows the compiler to catch these potential issues, known as “orphan instances”, at compile time. Even though Racket does not support the same sort of static typing, the same idea can be used to keep multiple dispatch safe using the macro system.</p>
<h1 id="safe-dynamically-typed-multiple-dispatch">Safe, dynamically-typed multiple dispatch</h1>
<p>In order to make multiple dispatch safe, we first need to determine exactly what is unsafe. Haskell has rules for determining what constitutes an “orphan instance”, and these rules are equally applicable for determining dangerous multimethod implementations. Specifically, a definition can be considered unsafe if <em>both</em> of the following conditions are true:</p>
<ol>
<li>The multimethod that is being implemented was declared in a different module from the implementation.</li>
<li><em>All</em> of the types used for dispatch in the multimethod instance were declared in a different module from the implementation.</li></ol>
<p>Conversely, a multimethod implementation is safe if <em>either</em> of the following conditions are true:</p>
<ol>
<li>The multimethod that is being implemented is declared in the same module as the implementation.</li>
<li><em>Any</em> of the types used for dispatch in the multimethod instance are declared in the same module as the implementation.</li></ol>
<p>Why do these two rules provide a strong enough guarantee to eliminate the dangers created by global state? Well, to understand that, we need to understand what can go wrong if these rules are ignored.</p>
<h2 id="multimethods-and-dangerous-instances">Multimethods and dangerous instances</h2>
<p>What exactly is this dangerous-sounding “spooky action”, and what causes it? Well, the trouble stems from the side-effectful nature of multimethod instance definitions. Consider the Racket module from earlier, which defines multiplication instances for scalars and vectors:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._provide))" style="color: inherit">provide</a></span> <span class="n">mul</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._struct-out))" style="color: inherit">struct-out</a></span> <span class="n">num</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._struct-out))" style="color: inherit">struct-out</a></span> <span class="n">vals</span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">num</span> <span class="p">(</span><span class="n">val</span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">vec</span> <span class="p">(</span><span class="n">vals</span><span class="p">))</span>
<span class="p">(</span><span class="n">define-generic</span> <span class="p">(</span><span class="n">mul</span> <span class="n">a</span> <span class="n">b</span><span class="p">))</span>
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">num</span> <span class="n">num</span><span class="p">)</span> <span class="n">x</span> <span class="n">y</span><span class="p">)</span>
<span class="p">(</span><span class="n">num</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">num-val</span> <span class="n">x</span><span class="p">)</span> <span class="p">(</span><span class="n">num-val</span> <span class="n">y</span><span class="p">))))</span>
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">num</span> <span class="n">vec</span><span class="p">)</span> <span class="n">n</span> <span class="n">v</span><span class="p">)</span>
<span class="p">(</span><span class="n">vec</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._map))" style="color: inherit">map</a></span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/procedures.html#(def._((lib._racket/function..rkt)._curry))" style="color: inherit">curry</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">num-val</span> <span class="n">n</span><span class="p">))</span> <span class="p">(</span><span class="n">vec-vals</span> <span class="n">v</span><span class="p">))))</span>
<span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">vec</span> <span class="n">num</span><span class="p">)</span> <span class="n">v</span> <span class="n">n</span><span class="p">)</span>
<span class="p">(</span><span class="n">mul</span> <span class="n">n</span> <span class="n">v</span><span class="p">))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Note that there is not actually a <code>(mul vec vec)</code> implementation. This is intentional: there are <em>two</em> ways to take the product of two vectors, so no default implementation is provided. However, it is possible that another module might desire an instance for <code>mul</code> that takes the dot product, and the programmer might write the following definition:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="n">define-instance</span> <span class="p">((</span><span class="n">mul</span> <span class="n">vec</span> <span class="n">vec</span><span class="p">)</span> <span class="n">x</span> <span class="n">y</span><span class="p">)</span>
<span class="p">(</span><span class="n">num</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/list..rkt)._foldl))" style="color: inherit">foldl</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._+))" style="color: inherit">+</a></span> <span class="mi">0</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._map))" style="color: inherit">map</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit">*</a></span> <span class="p">(</span><span class="n">vec-vals</span> <span class="n">x</span><span class="p">)</span> <span class="p">(</span><span class="n">vec-vals</span> <span class="n">y</span><span class="p">)))))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>However, there is something fishy about the above definition: it doesn’t need to be exported with <code>provide</code> to work! Since instances don’t create new bindings, they only add dispatch options, they don’t ever need to <code>provide</code> anything. This is problematic, though: it means that a program could continue to happily compile <em>even if</em> the module containing the dot product instance was never loaded with <code>require</code>, but an attempt to multiply two vectors would fail at runtime, claiming that there was no <code>(mul vec vec)</code> implementation. This drastic change of behavior violates Racket programmers’ assumptions about the guarantees made by modules (<code>require</code> should not cause any side-effects if the module’s bindings are not used).</p>
<p>Of course, while this seems potentially unexpected, it is workable: just be careful to <code>require</code> modules containing instances. Unfortunately, it gets much worse—what if a different library defines <em>its own</em> <code>(mul vec vec)</code> instance? What if that instance takes the cross product instead? That library may function entirely properly on its own, but when loaded alongside the program that defines a dot product instance, it is impossible to determine which instance should be used where. Because <code>define-instance</code> operates by modifying the aforementioned global state, the implementations clash, and the two systems <em>cannot</em> continue to operate together as written.</p>
<p>This is pretty bad. Defining extra instances is a reasonable use-case for multiple dispatch, but if these instances can break <em>third-party code</em>, how can they be trusted? This sort of problem can make multiple dispatch difficult to reason about and even more difficult to trust.</p>
<h2 id="what-determines-safety">What determines safety?</h2>
<p>With those problems in mind, we can turn back to the two rules for <em>safe</em> multiple dispatch. How do they prevent the above issues? Well, let’s take them one at a time.</p>
<p>Remember that an instance can be unequivocally determined to be safe if either of the two conditions are true, so we can consider them entirely independently. The first one is simple—an instance is safe if the following condition holds:</p>
<blockquote>
<p>The multimethod that is being implemented is declared in the same module as the implementation.</p></blockquote>
<p>This one is pretty obvious. It is impossible to create a “bad” instance of a method declared in the same module because it is impossible to import the method without also bringing in the instance. Furthermore, a conflicting instance cannot be defined at the place where the types themselves are defined because that would require a circular module dependency, which Racket does not permit.</p>
<p>With the above explanation in mind, the second condition should make sense, too:</p>
<blockquote>
<p><em>Any</em> of the types used for dispatch in the multimethod instance are declared in the same module as the implementation.</p></blockquote>
<p>The same argument for the first point holds for the second, but with the parties swapped. Again, it is impossible to use the instance without somehow requiring the module that defines the datatype itself, so the instance would always be required, anyway. The most interesting aspect of this condition is that it demonstrates that instances can be defined for existing datatypes (that are defined in other modules) just so long as <em>at least one</em> of the datatypes is defined in the same module. This continues to permit the important use-case of extending the interfaces of existing types.</p>
<h2 id="encoding-the-safety-rules-into-rackets-macro-system">Encoding the safety rules into Racket’s macro system</h2>
<p>In order to keep track of which methods and instances are defined where, I leveraged a technique based on the one <a href="http://www.ccs.neu.edu/racket/pubs/scheme2007-ctf.pdf">used by Typed Racket to keep track of whether or not a typed identifier is used in a typed or untyped context</a>. However, instead of using a simple mutable boolean flag, I used a mutable <a href="http://docs.racket-lang.org/syntax/syntax-helpers.html#%28tech._identifier._set%29">free identifier set</a>, which keeps track of the identifiers within a given module that should be considered “privileged”.</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="kn">#lang </span><span class="nn">racket/base</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit">require</a></span> <span class="n">syntax/id-set</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._provide))" style="color: inherit">provide</a></span> <span class="n">mark-id-as-privileged!</span>
<span class="n">id-privileged?</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="n">privileged-ids</span> <span class="p">(</span><span class="n">mutable-free-id-set</span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">mark-id-as-privileged!</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
<span class="p">(</span><span class="n">free-id-set-add!</span> <span class="n">privileged-ids</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">id-privileged?</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
<span class="p">(</span><span class="n">free-id-set-member?</span> <span class="n">privileged-ids</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>Making this work with <code>define-generic</code> is obvious: just invoke <code>mark-id-as-privileged!</code> on the method name to note that the method is “privileged” in the scope of the current module. Keeping track of privileged structs is similarly straightforward, though it is a little more devious: the <code>multimethod</code> module provides a custom <code>struct</code> macro that just expands to <code>struct</code> from <code>racket/base</code>, but adds privilege information.</p>
<p>The <code>define-instance</code> macro does all the heavy lifting to ensure that only privileged identifiers can be used in instance definitions. A simple check for the identifier annotations is performed before proceeding with macro expansion:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/when_unless.html#(form._((lib._racket/private/letstx-scheme..rkt)._unless))" style="color: inherit">unless</a></span> <span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/if.html#(form._((lib._racket/private/letstx-scheme..rkt)._or))" style="color: inherit">or</a></span> <span class="n">privileged?</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._ormap))" style="color: inherit">ormap</a></span> <span class="n">id-privileged?</span> <span class="n">types</span><span class="p">))</span>
<span class="p">(</span><span class="n">assert-privileged-struct!</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/list..rkt)._first))" style="color: inherit">first</a></span> <span class="n">types</span><span class="p">)))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>When the privilege checks fail, an error is raised:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre>1
2
3
4
5</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">assert-privileged-struct!</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/when_unless.html#(form._((lib._racket/private/letstx-scheme..rkt)._unless))" style="color: inherit">unless</a></span> <span class="p">(</span><span class="n">id-privileged?</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
<span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/exns.html#(def._((quote._~23~25kernel)._raise-syntax-error))" style="color: inherit">raise-syntax-error</a></span> <span class="o">'</span><span class="ss">define-instance</span>
<span class="s2">"expected name of <a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a> defined in current module"</span>
<span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>With the above safeguards in place, the dangerous dot product implementation from above <strong>would not be allowed</strong>. The checks manage to encode both of the safety rules into the macro system such that invalid instances will fail <em>at compile time</em>, preventing dangerous uses of multimethods from ever slipping by unnoticed.</p>
<h2 id="actually-implementing-multiple-dispatch">Actually implementing multiple dispatch</h2>
<p>The rest of the multimethod implementation is relatively straightforward and is not even particularly robust. If anything, it is the bare minimum of what would be needed to allow the safety mechanisms above to work. Lots of features that would likely be needed in a real implementation are not included, and graceful error handling is largely ignored.</p>
<p>Multimethods themselves are implemented as Racket <a href="http://docs.racket-lang.org/guide/proc-macros.html#%28tech._transformer._binding%29">transformer bindings</a> containing custom data, including a reference to the multimethod’s arity and dispatch table. The custom datatype includes a <code>prop:procedure</code> structure type property, which allows such bindings to also function as macros. The macro procedure expands to an operation that looks up the proper instance to use in the multimethod’s dispatch table and invokes it with the supplied arguments.</p>
<p>The relevant code for defining multimethods is reproduced below:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit">begin-for-syntax</a></span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a></span> <span class="n">multimethod</span> <span class="p">(</span><span class="n">arity</span> <span class="n">dispatch-table</span><span class="p">)</span>
<span class="kd">#:property</span> <span class="nb"><a href="http://docs.racket-lang.org/reference/procedures.html#(def._((lib._racket/private/base..rkt)._prop~3aprocedure))" style="color: inherit">prop:procedure</a></span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/lambda.html#(form._((lib._racket/private/base..rkt)._~ce~bb))" style="color: inherit">λ</a></span> <span class="p">(</span><span class="n">method</span> <span class="n">stx</span><span class="p">)</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parse))" style="color: inherit">syntax-parse</a></span> <span class="n">stx</span>
<span class="p">[(</span><span class="n">method</span> <span class="n">arg</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span>
<span class="o">#'</span><span class="p">(</span><span class="n">apply-multimethod</span> <span class="n">method</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((quote._~23~25kernel)._list))" style="color: inherit">list</a></span> <span class="n">arg</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))]</span>
<span class="p">[</span><span class="n">method</span>
<span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/lambda.html#(form._((lib._racket/private/base..rkt)._~ce~bb))" style="color: inherit">λ</a></span> <span class="n">args</span> <span class="p">(</span><span class="n">apply-multimethod</span> <span class="n">method</span> <span class="n">args</span><span class="p">))]))))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">define-generic</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit">syntax-parser</a></span>
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="p">(</span><span class="n">method:id</span> <span class="n">arg:id</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._with-syntax))" style="color: inherit">with-syntax</a></span> <span class="p">([</span><span class="n">arity</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((quote._~23~25kernel)._length))" style="color: inherit">length</a></span> <span class="p">(</span><span class="n">attribute</span> <span class="n">arg</span><span class="p">))]</span>
<span class="p">[</span><span class="n">dispatch-table</span> <span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/reference/syntax-util.html#(def._((lib._racket/syntax..rkt)._generate-temporary))" style="color: inherit">generate-temporary</a></span> <span class="o">#'</span><span class="n">method</span><span class="p">)])</span>
<span class="p">(</span><span class="n">mark-id-as-privileged!</span> <span class="o">#'</span><span class="n">method</span><span class="p">)</span>
<span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit">begin</a></span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="n">dispatch-table</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/hashtables.html#(def._((quote._~23~25kernel)._make-hash))" style="color: inherit">make-hash</a></span><span class="p">))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">method</span> <span class="p">(</span><span class="n">multimethod</span> <span class="n">arity</span> <span class="o">#'</span><span class="n">dispatch-table</span><span class="p">))))]))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>The dispatch tables are implemented entirely in terms of Racket’s structure types, so while they can be defined on arbitrary structure types (including ones defined in the Racket standard library), they <em>cannot</em> be defined on primitives such as pairs or vectors. Implementations are registered in the dispatch table using the compile-time information associated with structs’ transformer bindings, and the same information is retrieved from struct instances at runtime to look up the proper implementation to call. Notably, this only works if the struct is <code>#:transparent</code>, or more generally and accurately, if the calling code has access to the struct’s inspector. All structs defined by the <code>struct</code> form from the <code>multimethod</code> module are automatically marked as <code>#:transparent</code>.</p>
<p>The following code implements defining multimethod instances:</p>
<div class="brush: racket">
<table class="sourcetable">
<tbody>
<tr>
<td class="linenos">
<div class="linenodiv">
<pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23</pre></div></td>
<td class="code">
<div class="source">
<pre><span></span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit">begin-for-syntax</a></span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit">define</a></span> <span class="p">(</span><span class="n">assert-privileged-struct!</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/when_unless.html#(form._((lib._racket/private/letstx-scheme..rkt)._unless))" style="color: inherit">unless</a></span> <span class="p">(</span><span class="n">id-privileged?</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">)</span>
<span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/exns.html#(def._((quote._~23~25kernel)._raise-syntax-error))" style="color: inherit">raise-syntax-error</a></span> <span class="o">'</span><span class="ss">define-instance</span>
<span class="s2">"expected name of <a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit">struct</a> defined in current module"</span>
<span class="n"><a href="http://docs.racket-lang.org/syntax/Library_Syntax_Classes_and_Literal_Sets.html#(form._((lib._syntax/parse..rkt)._id))" style="color: inherit">id</a></span><span class="p">))))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit">define-syntax</a></span> <span class="n">define-instance</span>
<span class="p">(</span><span class="n"><a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit">syntax-parser</a></span>
<span class="c1">; standard (define (proc ...) ...) shorthand</span>
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="p">((</span><span class="n">method</span> <span class="n">type:id</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">)</span> <span class="o">.</span> <span class="n">args</span><span class="p">)</span> <span class="n">body:expr</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">)</span>
<span class="o">#'</span><span class="p">(</span><span class="n">define-instance</span> <span class="p">(</span><span class="n">method</span> <span class="n">type</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span> <span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/lambda.html#(form._((lib._racket/private/base..rkt)._~ce~bb))" style="color: inherit">λ</a></span> <span class="n">args</span> <span class="n">body</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">))]</span>
<span class="c1">; full (define proc lambda-expr) notation</span>
<span class="p">[(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit">_</a></span> <span class="p">(</span><span class="n">method</span> <span class="n">type:id</span> <span class="n"><a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit">...+</a></span><span class="p">)</span> <span class="n">proc:expr</span><span class="p">)</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/let.html#(form._((lib._racket/private/letstx-scheme..rkt)._let*))" style="color: inherit">let*</a></span> <span class="p">([</span><span class="n">multimethod</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/stxtrans.html#(def._((quote._~23~25kernel)._syntax-local-value))" style="color: inherit">syntax-local-value</a></span> <span class="o">#'</span><span class="n">method</span><span class="p">)]</span>
<span class="p">[</span><span class="n">privileged?</span> <span class="p">(</span><span class="n">id-privileged?</span> <span class="o">#'</span><span class="n">method</span><span class="p">)])</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/when_unless.html#(form._((lib._racket/private/letstx-scheme..rkt)._unless))" style="color: inherit">unless</a></span> <span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/if.html#(form._((lib._racket/private/letstx-scheme..rkt)._or))" style="color: inherit">or</a></span> <span class="n">privileged?</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._ormap))" style="color: inherit">ormap</a></span> <span class="n">id-privileged?</span> <span class="p">(</span><span class="n">attribute</span> <span class="n">type</span><span class="p">)))</span>
<span class="p">(</span><span class="n">assert-privileged-struct!</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/list..rkt)._first))" style="color: inherit">first</a></span> <span class="p">(</span><span class="n">attribute</span> <span class="n">type</span><span class="p">))))</span>
<span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._with-syntax))" style="color: inherit">with-syntax</a></span> <span class="p">([</span><span class="n">dispatch-table</span> <span class="p">(</span><span class="n">multimethod-dispatch-table</span> <span class="n">multimethod</span><span class="p">)]</span>
<span class="p">[(</span><span class="n">struct-type-id</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/private/map..rkt)._map))" style="color: inherit">map</a></span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/procedures.html#(def._((lib._racket/private/list..rkt)._compose1))" style="color: inherit">compose1</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((lib._racket/list..rkt)._first))" style="color: inherit">first</a></span> <span class="n"><a href="http://docs.racket-lang.org/reference/structinfo.html#(def._((lib._racket/struct-info..rkt)._extract-struct-info))" style="color: inherit">extract-struct-info</a></span> <span class="nb"><a href="http://docs.racket-lang.org/reference/stxtrans.html#(def._((quote._~23~25kernel)._syntax-local-value))" style="color: inherit">syntax-local-value</a></span><span class="p">)</span>
<span class="p">(</span><span class="n">attribute</span> <span class="n">type</span><span class="p">))])</span>
<span class="o">#'</span><span class="p">(</span><span class="k"><a href="http://docs.racket-lang.org/reference/let.html#(form._((lib._racket/private/letstx-scheme..rkt)._let))" style="color: inherit">let</a></span> <span class="p">([</span><span class="n">struct-types</span> <span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/pairs.html#(def._((quote._~23~25kernel)._list))" style="color: inherit">list</a></span> <span class="n">struct-type-id</span> <span class="k"><a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit">...</a></span><span class="p">)])</span>
<span class="p">(</span><span class="nb"><a href="http://docs.racket-lang.org/reference/hashtables.html#(def._((quote._~23~25kernel)._hash-set!))" style="color: inherit">hash-set!</a></span> <span class="n">dispatch-table</span> <span class="n">struct-types</span> <span class="n">proc</span><span class="p">))))]))</span>
</pre></div>
</td></tr></tbody></table>
</div>
<p>The resulting implementation is a useful, if certainly incomplete implementation of multimethods in Racket that does not sacrifice the safety provided by <code>racket/generic</code>’s single-dispatch approach.</p>
<h1 id="related-work-advantages-and-disadvantages-and-areas-for-future-improvement">Related work, advantages and disadvantages, and areas for future improvement</h1>
<p>As previously mentioned, this implementation of multiple dispatch was inspired by the types of APIs offered by CLOS and Clojure while also maintaining the safety of <code>racket/generic</code>. The inspiration for the safety rules came from GHC’s detection of orphan instances. Although most of the ideas presented above exist in other places, I am unsure if the concept of safety checking has been used before in any dynamically-typed programming languages.</p>
<p>The primary advantage offered over Racket’s existing generics system is obvious: multiple dispatch. Furthermore, this system can supersede many uses of <code>racket/generic</code> simply by dispatching on a single type. However, the current implementation does <em>not</em> support all of the features of <code>racket/generic</code>, such as supporting non-structure types and allowing fallback implementations. While those are well within the realm of possibility, other things like attaching structure type properties are probably not possible with this approach, so it is unlikely that the existing system could be subsumed by one like this one.</p>
<p>Additionally, this implementation would almost certainly need numerous improvements before being useful to most programmers:</p>
<ul>
<li>
<p><strong>Good error reporting for failure cases.</strong> Right now, even something obvious like calling a method on values that do not implement it simply fails with an error produced by <code>hash-ref</code>. In a more interesting sense, using the arity to generate compile-time error messages for <code>define-instance</code> would be a nice improvement.</p></li>
<li>
<p><strong>Support for Racket primitive data types.</strong> This might require some cooperation from Racket itself to permit an elegant implementation, but they could also just be special-cased. So long as lookup for primitives was done <em>after</em> consulting the main dispatch table, there wouldn’t be any performance hit for non-primitive types.</p></li>
<li>
<p><strong>Option to supply fallback implementations.</strong> This wouldn’t be too hard at all, though it’s questionable whether or not it would be useful without method groupings like <code>define/generic</code> provides. There would likely also need to be some sort of way to check if a set of values implements a particular method.</p></li>
<li>
<p><strong>Better cooperation with structure inspectors to alleviate the need for all structures to be transparent.</strong> It’s currently unclear to me how exactly this works and how it <em>should</em> work. There might be a better way to do this without mucking with inspectors.</p></li>
<li>
<p><strong>Much more flexible argument lists, including the ability to specify arguments that are not used for dispatch.</strong> This is really a pretty fundamental requirement, but the parsing required was significant enough for me to put it off for this initial prototype.</p></li>
<li>
<p><strong>Scribble forms to document generic methods and their instances.</strong> This is something <code>racket/generic</code> <em>doesn’t</em> have, and it has suffered for it. It would be very nice to have easy documentation forms for multimethods.</p></li>
<li>
<p><strong>Proper consideration of struct subtyping.</strong> Racket structs support subtyping, which I have not given much thought for this prototype. It is possible that subtyping violates constraints I had assumed would hold, so reviewing the existing code with that context would be useful.</p></li></ul>
<p>I’m not sure how much effort is involved in most of the above ideas, and in fact I’m not even completely sure how useful this system is to begin with. I have not found myself reaching much for multiple dispatch in my time as a Racket programmer, but that could simply be because it was previously unavailable. It will be interesting to see if that changes now that I have built this system, even if it is a bit rough around the edges.</p>
<h1 id="conclusion">Conclusion</h1>
<p>Despite the lack of need for multiple dispatch to solve most problems, as indicated by its general lack of support in mainstream programming languages, it’s a nice tool to have in the toolbox, and it <em>is</em> asked for in the Racket community from time to time (perhaps due to its familiarity in other parts of the Lisp world). Time will tell if pointing people to something like this will create or stifle interest in multiple dispatch for Racket.</p>
<p>The source for the <a href="https://github.com/lexi-lambda/racket-multimethod"><code>multimethod</code> package can be found here</a> if you are at all interested in playing with it yourself.</p>
<footer>
<script type="text/javascript">
var disqus_shortname = 'lexi-lambda';
(function() {
var dsq = document.createElement('script');
dsq.type = 'text/javascript';
dsq.async = true;
dsq.src = '//' + disqus_shortname + '.disqus.com/embed.js';
(document.getElementsByTagName('head')[0] || document.getElementsByTagName('body')[0]).appendChild(dsq);
})();
</script>
<div id="disqus_thread"></div>
<ul class="pager">
<li class="next">
<a href="/blog/2015/12/21/adts-in-typed-racket-with-macros/"><em>ADTs in Typed Racket with macros</em> &rarr;</a>
</li>
</ul>
</footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

4
bower.json
View File

@ -1,4 +0,0 @@
{
"name": "blog",
"dependencies": {}
}

182
css/application.min.css vendored Normal file
View File

File diff suppressed because one or more lines are too long

197
css/pygments.min.css vendored Normal file
View File

File diff suppressed because one or more lines are too long

30
deploy.sh
View File

@ -1,30 +0,0 @@
#!/bin/bash
set -ev # exit with nonzero exit code if anything fails
# clear the output directory
rm -rf out || exit 0;
# build the blog files + install pygments for highlighting support
npm install
npm run build
pip install pygments
raco frog --build
# go to the out directory and create a *new* Git repo
cd out
git init
# inside this git repo we'll pretend to be a new user
git config user.name "Travis CI"
git config user.email "lexi.lambda@gmail.com"
# The first and only commit to this new Git repo contains all the
# files present with the commit message "Deploy to GitHub Pages".
git add .
git commit -m "Deploy to GitHub Pages"
# Force push from the current repo's master branch to the remote
# repo. (All previous history on the branch will be lost, since we are
# overwriting it.) We redirect any output to /dev/null to hide any sensitive
# credential data that might otherwise be exposed.
git push --force --quiet "https://${GH_TOKEN}@${GH_REF}" master > /dev/null 2>&1

275
feeds/12factor.atom.xml Normal file
View File

@ -0,0 +1,275 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged '12factor'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/12factor.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/12factor.html" />
<id>urn:http-lexi-lambda-github-io:-tags-12factor-html</id>
<updated>2015-08-30T16:05:37Z</updated>
<entry>
<title type="text">Managing application configuration with Envy</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/08/30/managing-application-configuration-with-envy/?utm_source=12factor&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-08-30-managing-application-configuration-with-envy</id>
<published>2015-08-30T16:05:37Z</published>
<updated>2015-08-30T16:05:37Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;Application configuration can be a pain. Modern web apps don&amp;rsquo;t live on dedicated boxes, they run on VPSes somewhere in the amorphous &amp;ldquo;cloud&amp;rdquo;, and keeping configuration out of your application&amp;rsquo;s repository can seem like more trouble than it&amp;rsquo;s worth. Fortunately, &lt;a href="http://12factor.net"&gt;The Twelve-Factor App&lt;/a&gt; provides a set of standards for keeping web apps sane, and &lt;a href="http://12factor.net/config"&gt;one of those guidelines advises keeping configuration in the environment&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;a href="https://github.com/lexi-lambda/envy"&gt;Envy&lt;/a&gt; is the declarative bridge between Racket code and the outside world of the environment.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="introducing-envy"&gt;Introducing Envy&lt;/h1&gt;
&lt;p&gt;I built Envy to distill the common tasks needed when working with environment variables into a single, declarative interface that eliminates boilerplate and makes it easy to see which environment variables an application depends on (instead of having them littered throughout the codebase). Using it is simple. Just require &lt;code&gt;envy&lt;/code&gt; and you&amp;rsquo;re good to go.&lt;/p&gt;
&lt;p&gt;The best way to use Envy is to create a &amp;ldquo;manifest&amp;rdquo; module that declares all the environment variables your application might use. For example, the following module is a manifest that describes an application that uses three environment variables:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7
8
9&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="c1"&gt;; environment.rkt&lt;/span&gt;
&lt;span class="kn"&gt;#lang &lt;/span&gt;&lt;span class="nn"&gt;typed/racket/base&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit"&gt;require&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;envy&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define/provide-environment&lt;/span&gt;
&lt;span class="n"&gt;api-token&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;log-level&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Symbol))" style="color: inherit"&gt;Symbol&lt;/a&gt;&lt;/span&gt; &lt;span class="kd"&gt;#:default&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="ss"&gt;info&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;parallel?&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Boolean))" style="color: inherit"&gt;Boolean&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;When this module is required, Envy will automatically do the following:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Envy will check the values of three environment variables: &lt;code&gt;API_TOKEN&lt;/code&gt;, &lt;code&gt;LOG_LEVEL&lt;/code&gt;, and &lt;code&gt;PARALLEL&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;If either &lt;code&gt;API_TOKEN&lt;/code&gt; or &lt;code&gt;PARALLEL&lt;/code&gt; is not set, an error will be raised:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;envy: The required environment variable "API_TOKEN" is not defined.&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The values for &lt;code&gt;LOG_LEVEL&lt;/code&gt; and &lt;code&gt;PARALLEL&lt;/code&gt; will be parsed to match their type annotations.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;If &lt;code&gt;LOG_LEVEL&lt;/code&gt; is not set, it will use the default value, &lt;code&gt;'info&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The values will be stored in &lt;code&gt;api-token&lt;/code&gt;, &lt;code&gt;log-level&lt;/code&gt;, and &lt;code&gt;parallel?&lt;/code&gt;, all of which will be provided by the enclosing module.&lt;/p&gt;&lt;/li&gt;&lt;/ol&gt;
&lt;p&gt;Now just &lt;code&gt;(require (prefix-in env: "environment.rkt"))&lt;/code&gt;, and the environment variables are guaranteed to be available in your application&amp;rsquo;s code.&lt;/p&gt;
&lt;h1 id="working-with-typed-racket"&gt;Working with Typed Racket&lt;/h1&gt;
&lt;p&gt;As you may have noticed by the example above, Envy is built with Typed Racket in mind. In fact, &lt;code&gt;define/provide-environment&lt;/code&gt; will &lt;em&gt;only&lt;/em&gt; work within a Typed Racket module, but that doesn&amp;rsquo;t mean Envy can&amp;rsquo;t be used with plain Racket—the manifest module can always be required by any kind of Racket module.&lt;/p&gt;
&lt;p&gt;However, when using Typed Racket, Envy provides additional bonuses. Environment variables are inherently untyped—they&amp;rsquo;re all just strings—but Envy assigns the proper type to each environment variable automatically, so no casting is necessary.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;gt; parallel?
- : Boolean
#t&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Envy really shines when using optional environment variables with the &lt;code&gt;#:default&lt;/code&gt; option. The type of the value given to &lt;code&gt;#:default&lt;/code&gt; doesn&amp;rsquo;t need to be the same type of the environment variable itself, and if it isn&amp;rsquo;t, Envy will assign the value a union type.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;gt; (define-environment
[num-threads : Positive-Integer #:default #f])
&amp;gt; num-threads
- : (U Positive-Integer #f)
#f&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This added level of type-safety means it&amp;rsquo;s easy to manage optional variables that don&amp;rsquo;t have reasonable defaults: the type system will enforce that all code considers the possibility that such variables do not exist.&lt;/p&gt;
&lt;h1 id="and-more"&gt;And more&amp;hellip;&lt;/h1&gt;
&lt;p&gt;To see the full set of features that Envy already provides, &lt;a href="https://lexi-lambda.github.io/envy/envy.html"&gt;take a look at the documentation&lt;/a&gt;. That said, this is just the first release based on my initial use-cases, but I&amp;rsquo;m sure there are more features Envy could have to accommodate common application configuration patterns. If you have an idea that could make Envy better, &lt;a href="https://github.com/lexi-lambda/envy/issues"&gt;open an issue and make a suggestion&lt;/a&gt;! I already have plans for a &lt;code&gt;#lang envy&lt;/code&gt; DSL, which will hopefully cut the boilerplate out in its entirety.&lt;/p&gt;
&lt;p&gt;And finally, to give credit where credit is due, Envy is heavily inspired by &lt;a href="https://github.com/eval/envied"&gt;Envied&lt;/a&gt; (both in name and function), an environment variable manager for Ruby, which I&amp;rsquo;ve used to great effect.&lt;/p&gt;
&lt;p&gt;Try it out!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;raco pkg install envy&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/envy"&gt;Envy on GitHub&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://lexi-lambda.github.io/envy/envy.html"&gt;Envy documentation&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</content></entry>
<entry>
<title type="text">Deploying Racket applications on Heroku</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/08/22/deploying-racket-applications-on-heroku/?utm_source=12factor&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-08-22-deploying-racket-applications-on-heroku</id>
<published>2015-08-22T14:47:49Z</published>
<updated>2015-08-22T14:47:49Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;&lt;a href="https://www.heroku.com"&gt;Heroku&lt;/a&gt; is a &amp;ldquo;platform as a service&amp;rdquo; that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but Racket is not currently among them. Fortunately, Heroku provides an interface for adding custom build processes for arbitrary types of applications, called “buildpacks”. I&amp;rsquo;ve built one for Racket apps, and with just a little bit of configuration, it’s possible to get a Racket webserver running on Heroku.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="building-the-server"&gt;Building the server&lt;/h1&gt;
&lt;p&gt;Racket&amp;rsquo;s &lt;a href="http://docs.racket-lang.org/web-server/index.html"&gt;web-server&lt;/a&gt; package makes building and running a simple server incredibly easy. Here&amp;rsquo;s all the code we&amp;rsquo;ll need to get going:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kn"&gt;#lang &lt;/span&gt;&lt;span class="nn"&gt;racket&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit"&gt;require&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;web-server/servlet&lt;/span&gt;
&lt;span class="n"&gt;web-server/servlet-env&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;start&lt;/span&gt; &lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;response/xexpr&lt;/span&gt;
&lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;html&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;head&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;title&lt;/span&gt; &lt;span class="s2"&gt;"Racket Heroku App"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;body&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;h1&lt;/span&gt; &lt;span class="s2"&gt;"It works!"&lt;/span&gt;&lt;span class="p"&gt;)))))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt; &lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Running the above file will start up the server on the default port, 8080. When running on Heroku, however, we&amp;rsquo;re required to bind to the port that Heroku provides via the &lt;code&gt;PORT&lt;/code&gt; environment variable. We can access this using the Racket &lt;code&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/code&gt; function.&lt;/p&gt;
&lt;p&gt;Additionally, the Racket web server specifically binds to localhost, but Heroku doesn&amp;rsquo;t allow that restriction, so we need to pass &lt;code&gt;#f&lt;/code&gt; for the &lt;code&gt;#:listen-ip&lt;/code&gt; argument.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit"&gt;if&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/span&gt; &lt;span class="s2"&gt;"PORT"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._string-~3enumber))" style="color: inherit"&gt;string-&amp;gt;number&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/span&gt; &lt;span class="s2"&gt;"PORT"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="mi"&gt;8080&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt;
&lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;
&lt;span class="kd"&gt;#:listen-ip&lt;/span&gt; &lt;span class="no"&gt;#f&lt;/span&gt;
&lt;span class="kd"&gt;#:port&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Also, by default, &lt;code&gt;serve/servlet&lt;/code&gt; will open a web browser automatically when the program is run, which is very useful for rapid prototyping within something like DrRacket, but we&amp;rsquo;ll want to turn that off.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt;
&lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;
&lt;span class="kd"&gt;#:listen-ip&lt;/span&gt; &lt;span class="no"&gt;#f&lt;/span&gt;
&lt;span class="kd"&gt;#:port&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;
&lt;span class="kd"&gt;#:command-line?&lt;/span&gt; &lt;span class="no"&gt;#t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;That&amp;rsquo;s it! Now we have a Racket web server that can run on Heroku. Obviously it&amp;rsquo;s not a very interesting application right now, but that&amp;rsquo;s fine for our purposes.&lt;/p&gt;
&lt;h1 id="setting-up-our-app-for-heroku"&gt;Setting up our app for Heroku&lt;/h1&gt;
&lt;p&gt;The next step is to actually create an app on Heroku. Don&amp;rsquo;t worry—it&amp;rsquo;s free! That said, explaining precisely how Heroku works is outside the scope of this article. Just make an account, then create an app. I called mine &amp;ldquo;racket-heroku-sample&amp;rdquo;. Once you&amp;rsquo;ve created an app and set up Heroku&amp;rsquo;s command-line tool, you can specify the proper buildpack:&lt;/p&gt;
&lt;div class="brush: sh"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;$ git init
$ heroku git:remote -a racket-heroku-sample
$ heroku buildpacks:set https://github.com/lexi-lambda/heroku-buildpack-racket
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We&amp;rsquo;ll also need to pick a particular Racket version before we deploy our app. At the time of this writing, Racket 6.2.1 is the latest version, so I just set the &lt;code&gt;RACKET_VERSION&lt;/code&gt; environment variable as follows:&lt;/p&gt;
&lt;div class="brush: sh"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;$ heroku config:set &lt;span class="nv"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;6.2.1
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now there&amp;rsquo;s just one thing left to do before we can push to Heroku: we need to tell Heroku what command to use to run our application. To do this, we use something called a &amp;ldquo;Procfile&amp;rdquo; that contains information about the process types for our app. Heroku supports multiple processes of different types, but we&amp;rsquo;re just going to have a single web process.&lt;/p&gt;
&lt;p&gt;Specifically, we just want to run our &lt;code&gt;serve.rkt&lt;/code&gt; module. The Racket buildpack installs the repository as a package, so we can run &lt;code&gt;racket&lt;/code&gt; with the &lt;code&gt;-l&lt;/code&gt; flag to specify a module path, which will be more robust than specifying a filesystem path directly. Therefore, our Procfile will look like this:&lt;/p&gt;
&lt;div class="brush: procfile"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;web: racket -l sample-heroku-app/server
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now all that&amp;rsquo;s left to do is push our repository to Heroku&amp;rsquo;s git remote. Once the build completes, we can &lt;a href="https://racket-heroku-sample.herokuapp.com"&gt;navigate to our app&amp;rsquo;s URL and actually see it running live&lt;/a&gt;!&lt;/p&gt;
&lt;h1 id="conclusion"&gt;Conclusion&lt;/h1&gt;
&lt;p&gt;That&amp;rsquo;s all that&amp;rsquo;s needed to get a Racket app up and running on Heroku, but it probably isn&amp;rsquo;t the best way to manage a real application. Usually it&amp;rsquo;s best to use a continuous integration service to automatically deploy certain GitHub branches to Heroku, after running the tests, of course. Also, a real application would obviously be a little more complicated.&lt;/p&gt;
&lt;p&gt;That said, this provides the foundation and shell. If you&amp;rsquo;d like to see the sample app used in this post, you can &lt;a href="https://github.com/lexi-lambda/racket-sample-heroku-app"&gt;find it on GitHub here&lt;/a&gt;. For more details on the buildpack itself, &lt;a href="https://github.com/lexi-lambda/heroku-buildpack-racket"&gt;it&amp;rsquo;s also available on GitHub here&lt;/a&gt;.&lt;/p&gt;&lt;/html&gt;</content></entry></feed>

271
feeds/12factor.rss.xml Normal file
View File

@ -0,0 +1,271 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged '12factor'</title>
<description>Alexis King's Blog: Posts tagged '12factor'</description>
<link>http://lexi-lambda.github.io/tags/12factor.html</link>
<lastBuildDate>Sun, 30 Aug 2015 16:05:37 UT</lastBuildDate>
<pubDate>Sun, 30 Aug 2015 16:05:37 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>Managing application configuration with Envy</title>
<link>http://lexi-lambda.github.io/blog/2015/08/30/managing-application-configuration-with-envy/?utm_source=12factor&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-08-30-managing-application-configuration-with-envy</guid>
<pubDate>Sun, 30 Aug 2015 16:05:37 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;Application configuration can be a pain. Modern web apps don&amp;rsquo;t live on dedicated boxes, they run on VPSes somewhere in the amorphous &amp;ldquo;cloud&amp;rdquo;, and keeping configuration out of your application&amp;rsquo;s repository can seem like more trouble than it&amp;rsquo;s worth. Fortunately, &lt;a href="http://12factor.net"&gt;The Twelve-Factor App&lt;/a&gt; provides a set of standards for keeping web apps sane, and &lt;a href="http://12factor.net/config"&gt;one of those guidelines advises keeping configuration in the environment&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;a href="https://github.com/lexi-lambda/envy"&gt;Envy&lt;/a&gt; is the declarative bridge between Racket code and the outside world of the environment.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="introducing-envy"&gt;Introducing Envy&lt;/h1&gt;
&lt;p&gt;I built Envy to distill the common tasks needed when working with environment variables into a single, declarative interface that eliminates boilerplate and makes it easy to see which environment variables an application depends on (instead of having them littered throughout the codebase). Using it is simple. Just require &lt;code&gt;envy&lt;/code&gt; and you&amp;rsquo;re good to go.&lt;/p&gt;
&lt;p&gt;The best way to use Envy is to create a &amp;ldquo;manifest&amp;rdquo; module that declares all the environment variables your application might use. For example, the following module is a manifest that describes an application that uses three environment variables:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7
8
9&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="c1"&gt;; environment.rkt&lt;/span&gt;
&lt;span class="kn"&gt;#lang &lt;/span&gt;&lt;span class="nn"&gt;typed/racket/base&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit"&gt;require&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;envy&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define/provide-environment&lt;/span&gt;
&lt;span class="n"&gt;api-token&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;log-level&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Symbol))" style="color: inherit"&gt;Symbol&lt;/a&gt;&lt;/span&gt; &lt;span class="kd"&gt;#:default&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="ss"&gt;info&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;parallel?&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Boolean))" style="color: inherit"&gt;Boolean&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;When this module is required, Envy will automatically do the following:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Envy will check the values of three environment variables: &lt;code&gt;API_TOKEN&lt;/code&gt;, &lt;code&gt;LOG_LEVEL&lt;/code&gt;, and &lt;code&gt;PARALLEL&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;If either &lt;code&gt;API_TOKEN&lt;/code&gt; or &lt;code&gt;PARALLEL&lt;/code&gt; is not set, an error will be raised:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;envy: The required environment variable "API_TOKEN" is not defined.&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The values for &lt;code&gt;LOG_LEVEL&lt;/code&gt; and &lt;code&gt;PARALLEL&lt;/code&gt; will be parsed to match their type annotations.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;If &lt;code&gt;LOG_LEVEL&lt;/code&gt; is not set, it will use the default value, &lt;code&gt;'info&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The values will be stored in &lt;code&gt;api-token&lt;/code&gt;, &lt;code&gt;log-level&lt;/code&gt;, and &lt;code&gt;parallel?&lt;/code&gt;, all of which will be provided by the enclosing module.&lt;/p&gt;&lt;/li&gt;&lt;/ol&gt;
&lt;p&gt;Now just &lt;code&gt;(require (prefix-in env: "environment.rkt"))&lt;/code&gt;, and the environment variables are guaranteed to be available in your application&amp;rsquo;s code.&lt;/p&gt;
&lt;h1 id="working-with-typed-racket"&gt;Working with Typed Racket&lt;/h1&gt;
&lt;p&gt;As you may have noticed by the example above, Envy is built with Typed Racket in mind. In fact, &lt;code&gt;define/provide-environment&lt;/code&gt; will &lt;em&gt;only&lt;/em&gt; work within a Typed Racket module, but that doesn&amp;rsquo;t mean Envy can&amp;rsquo;t be used with plain Racket—the manifest module can always be required by any kind of Racket module.&lt;/p&gt;
&lt;p&gt;However, when using Typed Racket, Envy provides additional bonuses. Environment variables are inherently untyped—they&amp;rsquo;re all just strings—but Envy assigns the proper type to each environment variable automatically, so no casting is necessary.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;gt; parallel?
- : Boolean
#t&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Envy really shines when using optional environment variables with the &lt;code&gt;#:default&lt;/code&gt; option. The type of the value given to &lt;code&gt;#:default&lt;/code&gt; doesn&amp;rsquo;t need to be the same type of the environment variable itself, and if it isn&amp;rsquo;t, Envy will assign the value a union type.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;gt; (define-environment
[num-threads : Positive-Integer #:default #f])
&amp;gt; num-threads
- : (U Positive-Integer #f)
#f&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This added level of type-safety means it&amp;rsquo;s easy to manage optional variables that don&amp;rsquo;t have reasonable defaults: the type system will enforce that all code considers the possibility that such variables do not exist.&lt;/p&gt;
&lt;h1 id="and-more"&gt;And more&amp;hellip;&lt;/h1&gt;
&lt;p&gt;To see the full set of features that Envy already provides, &lt;a href="https://lexi-lambda.github.io/envy/envy.html"&gt;take a look at the documentation&lt;/a&gt;. That said, this is just the first release based on my initial use-cases, but I&amp;rsquo;m sure there are more features Envy could have to accommodate common application configuration patterns. If you have an idea that could make Envy better, &lt;a href="https://github.com/lexi-lambda/envy/issues"&gt;open an issue and make a suggestion&lt;/a&gt;! I already have plans for a &lt;code&gt;#lang envy&lt;/code&gt; DSL, which will hopefully cut the boilerplate out in its entirety.&lt;/p&gt;
&lt;p&gt;And finally, to give credit where credit is due, Envy is heavily inspired by &lt;a href="https://github.com/eval/envied"&gt;Envied&lt;/a&gt; (both in name and function), an environment variable manager for Ruby, which I&amp;rsquo;ve used to great effect.&lt;/p&gt;
&lt;p&gt;Try it out!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;raco pkg install envy&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/envy"&gt;Envy on GitHub&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://lexi-lambda.github.io/envy/envy.html"&gt;Envy documentation&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</description></item>
<item>
<title>Deploying Racket applications on Heroku</title>
<link>http://lexi-lambda.github.io/blog/2015/08/22/deploying-racket-applications-on-heroku/?utm_source=12factor&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-08-22-deploying-racket-applications-on-heroku</guid>
<pubDate>Sat, 22 Aug 2015 14:47:49 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;&lt;a href="https://www.heroku.com"&gt;Heroku&lt;/a&gt; is a &amp;ldquo;platform as a service&amp;rdquo; that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but Racket is not currently among them. Fortunately, Heroku provides an interface for adding custom build processes for arbitrary types of applications, called “buildpacks”. I&amp;rsquo;ve built one for Racket apps, and with just a little bit of configuration, it’s possible to get a Racket webserver running on Heroku.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="building-the-server"&gt;Building the server&lt;/h1&gt;
&lt;p&gt;Racket&amp;rsquo;s &lt;a href="http://docs.racket-lang.org/web-server/index.html"&gt;web-server&lt;/a&gt; package makes building and running a simple server incredibly easy. Here&amp;rsquo;s all the code we&amp;rsquo;ll need to get going:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kn"&gt;#lang &lt;/span&gt;&lt;span class="nn"&gt;racket&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit"&gt;require&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;web-server/servlet&lt;/span&gt;
&lt;span class="n"&gt;web-server/servlet-env&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;start&lt;/span&gt; &lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;response/xexpr&lt;/span&gt;
&lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;html&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;head&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;title&lt;/span&gt; &lt;span class="s2"&gt;"Racket Heroku App"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;body&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;h1&lt;/span&gt; &lt;span class="s2"&gt;"It works!"&lt;/span&gt;&lt;span class="p"&gt;)))))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt; &lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Running the above file will start up the server on the default port, 8080. When running on Heroku, however, we&amp;rsquo;re required to bind to the port that Heroku provides via the &lt;code&gt;PORT&lt;/code&gt; environment variable. We can access this using the Racket &lt;code&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/code&gt; function.&lt;/p&gt;
&lt;p&gt;Additionally, the Racket web server specifically binds to localhost, but Heroku doesn&amp;rsquo;t allow that restriction, so we need to pass &lt;code&gt;#f&lt;/code&gt; for the &lt;code&gt;#:listen-ip&lt;/code&gt; argument.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit"&gt;if&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/span&gt; &lt;span class="s2"&gt;"PORT"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._string-~3enumber))" style="color: inherit"&gt;string-&amp;gt;number&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/span&gt; &lt;span class="s2"&gt;"PORT"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="mi"&gt;8080&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt;
&lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;
&lt;span class="kd"&gt;#:listen-ip&lt;/span&gt; &lt;span class="no"&gt;#f&lt;/span&gt;
&lt;span class="kd"&gt;#:port&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Also, by default, &lt;code&gt;serve/servlet&lt;/code&gt; will open a web browser automatically when the program is run, which is very useful for rapid prototyping within something like DrRacket, but we&amp;rsquo;ll want to turn that off.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt;
&lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;
&lt;span class="kd"&gt;#:listen-ip&lt;/span&gt; &lt;span class="no"&gt;#f&lt;/span&gt;
&lt;span class="kd"&gt;#:port&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;
&lt;span class="kd"&gt;#:command-line?&lt;/span&gt; &lt;span class="no"&gt;#t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;That&amp;rsquo;s it! Now we have a Racket web server that can run on Heroku. Obviously it&amp;rsquo;s not a very interesting application right now, but that&amp;rsquo;s fine for our purposes.&lt;/p&gt;
&lt;h1 id="setting-up-our-app-for-heroku"&gt;Setting up our app for Heroku&lt;/h1&gt;
&lt;p&gt;The next step is to actually create an app on Heroku. Don&amp;rsquo;t worry—it&amp;rsquo;s free! That said, explaining precisely how Heroku works is outside the scope of this article. Just make an account, then create an app. I called mine &amp;ldquo;racket-heroku-sample&amp;rdquo;. Once you&amp;rsquo;ve created an app and set up Heroku&amp;rsquo;s command-line tool, you can specify the proper buildpack:&lt;/p&gt;
&lt;div class="brush: sh"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;$ git init
$ heroku git:remote -a racket-heroku-sample
$ heroku buildpacks:set https://github.com/lexi-lambda/heroku-buildpack-racket
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We&amp;rsquo;ll also need to pick a particular Racket version before we deploy our app. At the time of this writing, Racket 6.2.1 is the latest version, so I just set the &lt;code&gt;RACKET_VERSION&lt;/code&gt; environment variable as follows:&lt;/p&gt;
&lt;div class="brush: sh"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;$ heroku config:set &lt;span class="nv"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;6.2.1
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now there&amp;rsquo;s just one thing left to do before we can push to Heroku: we need to tell Heroku what command to use to run our application. To do this, we use something called a &amp;ldquo;Procfile&amp;rdquo; that contains information about the process types for our app. Heroku supports multiple processes of different types, but we&amp;rsquo;re just going to have a single web process.&lt;/p&gt;
&lt;p&gt;Specifically, we just want to run our &lt;code&gt;serve.rkt&lt;/code&gt; module. The Racket buildpack installs the repository as a package, so we can run &lt;code&gt;racket&lt;/code&gt; with the &lt;code&gt;-l&lt;/code&gt; flag to specify a module path, which will be more robust than specifying a filesystem path directly. Therefore, our Procfile will look like this:&lt;/p&gt;
&lt;div class="brush: procfile"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;web: racket -l sample-heroku-app/server
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now all that&amp;rsquo;s left to do is push our repository to Heroku&amp;rsquo;s git remote. Once the build completes, we can &lt;a href="https://racket-heroku-sample.herokuapp.com"&gt;navigate to our app&amp;rsquo;s URL and actually see it running live&lt;/a&gt;!&lt;/p&gt;
&lt;h1 id="conclusion"&gt;Conclusion&lt;/h1&gt;
&lt;p&gt;That&amp;rsquo;s all that&amp;rsquo;s needed to get a Racket app up and running on Heroku, but it probably isn&amp;rsquo;t the best way to manage a real application. Usually it&amp;rsquo;s best to use a continuous integration service to automatically deploy certain GitHub branches to Heroku, after running the tests, of course. Also, a real application would obviously be a little more complicated.&lt;/p&gt;
&lt;p&gt;That said, this provides the foundation and shell. If you&amp;rsquo;d like to see the sample app used in this post, you can &lt;a href="https://github.com/lexi-lambda/racket-sample-heroku-app"&gt;find it on GitHub here&lt;/a&gt;. For more details on the buildpack itself, &lt;a href="https://github.com/lexi-lambda/heroku-buildpack-racket"&gt;it&amp;rsquo;s also available on GitHub here&lt;/a&gt;.&lt;/p&gt;&lt;/html&gt;</description></item></channel></rss>

2272
feeds/all.atom.xml Normal file
View File

File diff suppressed because it is too large Load Diff

2253
feeds/all.rss.xml Normal file
View File

File diff suppressed because it is too large Load Diff

172
feeds/angular.atom.xml Normal file
View File

@ -0,0 +1,172 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged 'angular'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/angular.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/angular.html" />
<id>urn:http-lexi-lambda-github-io:-tags-angular-html</id>
<updated>2015-09-23T16:30:12Z</updated>
<entry>
<title type="text">Canonical factories for testing with factory_girl_api</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/?utm_source=angular&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-09-23-canonical-factories-for-testing-with-factory-girl-api</id>
<published>2015-09-23T16:30:12Z</published>
<updated>2015-09-23T16:30:12Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;Modern web applications are often built as &lt;em&gt;single-page apps&lt;/em&gt;, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&amp;rsquo;t catch the failure. I haven&amp;rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.&lt;/p&gt;
&lt;p&gt;To attempt to address a fraction of this problem, I built &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;, a way to share context setup between both sides of the application.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="a-brief-overview-of-factorygirl"&gt;A brief overview of factory_girl&lt;/h1&gt;
&lt;p&gt;In the land of Ruby and Rails, &lt;a href="https://github.com/thoughtbot/factory_girl"&gt;factory_girl&lt;/a&gt; is a convenient gem for managing factories for models. Out of the box, it integrates with Rails&amp;rsquo; default ORM, ActiveRecord, and provides declarative syntax for describing what attributes factories should initialize. For example, a factory declaration used to create a widget might look like this:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;define&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;factory&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;sequence&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;:name&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Widget #&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nb"&gt;id&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;
&lt;span class="n"&gt;trait&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This makes it easy to create new instances of &lt;code&gt;Widget&lt;/code&gt; and use them for unit tests. For example, this would create and persist a widget with a unique name and a price of 10 units:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We can also create more expensive widgets by using the &lt;code&gt;:expensive&lt;/code&gt; trait.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;expensive_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Any number of traits can be specified at once. Additionally, it is possible to override individual attributes manually.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;fancy_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It works well, and it keeps initialization boilerplate out of individual tests.&lt;/p&gt;
&lt;h1 id="testing-on-the-front-end"&gt;Testing on the front-end&lt;/h1&gt;
&lt;p&gt;Trouble arises when we need to write tests for the JavaScript application that use the same models. Suddenly, we need to duplicate the same kind of logic in our front-end tests. We might start out by setting up object state manually:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="nx"&gt;fancyWidget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
&lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="nx"&gt;price&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Things can quickly get out of hand when models grow complex. Even if we use a factory library in JavaScript, it&amp;rsquo;s possible for our front-end factories to diverge from their back-end counterparts. This means our integration tests will fail, but our unit tests will still blindly pass. Having to duplicate all that logic in two places is dangerous. It would be nice to have a &lt;em&gt;single, canonical source&lt;/em&gt; for all of our factories.&lt;/p&gt;
&lt;h2 id="reusing-server-side-factories-with-factorygirlapi"&gt;Reusing server-side factories with factory_girl_api&lt;/h2&gt;
&lt;p&gt;To help alleviate this problem, I created the &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt; gem for Rails and the &lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt; Bower package for Angular. These packages cooperate with each other to allow server-side factories to be used in JavaScript tests.&lt;/p&gt;
&lt;p&gt;The Angular module provides a service with syntax comparable to factory_girl itself. Both traits and custom attributes are supported:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nx"&gt;FactoryGirl&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;&amp;#39;widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;expensive&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;In this case, however, a round-trip API call must be made to the server in order to call the factory and return the result. Because of this, the Angular version of FactoryGirl returns a promise that is resolved with the serialized version of the model, which can then be used as sample data in unit tests.&lt;/p&gt;
&lt;h2 id="the-problems-with-relying-on-the-server-for-data"&gt;The problems with relying on the server for data&lt;/h2&gt;
&lt;p&gt;In my preliminary use of this tool, it works. In many ways, it&amp;rsquo;s much nicer than duplicating logic in both places. However, I&amp;rsquo;m not &lt;em&gt;completely&lt;/em&gt; convinced it&amp;rsquo;s the right solution yet.&lt;/p&gt;
&lt;p&gt;First of all, it couples the front-end to the back-end, even during unit testing, which is disappointing. It means that a server needs to be running (in test mode) in order for the tests to run at all. For the kinds of projects I work on, this isn&amp;rsquo;t really a bad thing, and the benefits of the reduced duplication far outweigh the downsides.&lt;/p&gt;
&lt;p&gt;My real concern is that this solves a very small facet of the general problem with fragile front-end test suites. Single-page applications usually depend wholly on their integration with back-end APIs. If those APIs change, the tests will continue to happily pass as long as the API is simply mocked, which seems to be the usual solution in the front-end universe. This is, frankly, unacceptable in real application development.&lt;/p&gt;
&lt;h2 id="potential-improvements-and-other-paths-to-success"&gt;Potential improvements and other paths to success&lt;/h2&gt;
&lt;p&gt;I am ultimately unsatisfied with this approach, but writing brittle end-to-end integration tests is not the solution. This &lt;em&gt;kind&lt;/em&gt; of thing may be a step in the right direction: writing tests that aren&amp;rsquo;t really pure unit tests, but also aren&amp;rsquo;t fragile full-stack integration tests. This is a middle-ground that seems infrequently traveled, perhaps due to a lack of tooling (or perhaps because it just doesn&amp;rsquo;t work). I don&amp;rsquo;t know.&lt;/p&gt;
&lt;p&gt;Either way, I&amp;rsquo;m interested in where this is headed, and I&amp;rsquo;ll be curious to see if I run into any roadblocks using the workflow I&amp;rsquo;ve created. If anyone else is interested in playing with these two libraries, the READMEs are much more comprehensive than what I&amp;rsquo;ve covered here. Take a look, and give them a spin!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</content></entry></feed>

171
feeds/angular.rss.xml Normal file
View File

@ -0,0 +1,171 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged 'angular'</title>
<description>Alexis King's Blog: Posts tagged 'angular'</description>
<link>http://lexi-lambda.github.io/tags/angular.html</link>
<lastBuildDate>Wed, 23 Sep 2015 16:30:12 UT</lastBuildDate>
<pubDate>Wed, 23 Sep 2015 16:30:12 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>Canonical factories for testing with factory_girl_api</title>
<link>http://lexi-lambda.github.io/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/?utm_source=angular&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-09-23-canonical-factories-for-testing-with-factory-girl-api</guid>
<pubDate>Wed, 23 Sep 2015 16:30:12 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;Modern web applications are often built as &lt;em&gt;single-page apps&lt;/em&gt;, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&amp;rsquo;t catch the failure. I haven&amp;rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.&lt;/p&gt;
&lt;p&gt;To attempt to address a fraction of this problem, I built &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;, a way to share context setup between both sides of the application.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="a-brief-overview-of-factorygirl"&gt;A brief overview of factory_girl&lt;/h1&gt;
&lt;p&gt;In the land of Ruby and Rails, &lt;a href="https://github.com/thoughtbot/factory_girl"&gt;factory_girl&lt;/a&gt; is a convenient gem for managing factories for models. Out of the box, it integrates with Rails&amp;rsquo; default ORM, ActiveRecord, and provides declarative syntax for describing what attributes factories should initialize. For example, a factory declaration used to create a widget might look like this:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;define&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;factory&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;sequence&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;:name&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Widget #&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nb"&gt;id&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;
&lt;span class="n"&gt;trait&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This makes it easy to create new instances of &lt;code&gt;Widget&lt;/code&gt; and use them for unit tests. For example, this would create and persist a widget with a unique name and a price of 10 units:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We can also create more expensive widgets by using the &lt;code&gt;:expensive&lt;/code&gt; trait.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;expensive_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Any number of traits can be specified at once. Additionally, it is possible to override individual attributes manually.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;fancy_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It works well, and it keeps initialization boilerplate out of individual tests.&lt;/p&gt;
&lt;h1 id="testing-on-the-front-end"&gt;Testing on the front-end&lt;/h1&gt;
&lt;p&gt;Trouble arises when we need to write tests for the JavaScript application that use the same models. Suddenly, we need to duplicate the same kind of logic in our front-end tests. We might start out by setting up object state manually:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="nx"&gt;fancyWidget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
&lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="nx"&gt;price&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Things can quickly get out of hand when models grow complex. Even if we use a factory library in JavaScript, it&amp;rsquo;s possible for our front-end factories to diverge from their back-end counterparts. This means our integration tests will fail, but our unit tests will still blindly pass. Having to duplicate all that logic in two places is dangerous. It would be nice to have a &lt;em&gt;single, canonical source&lt;/em&gt; for all of our factories.&lt;/p&gt;
&lt;h2 id="reusing-server-side-factories-with-factorygirlapi"&gt;Reusing server-side factories with factory_girl_api&lt;/h2&gt;
&lt;p&gt;To help alleviate this problem, I created the &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt; gem for Rails and the &lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt; Bower package for Angular. These packages cooperate with each other to allow server-side factories to be used in JavaScript tests.&lt;/p&gt;
&lt;p&gt;The Angular module provides a service with syntax comparable to factory_girl itself. Both traits and custom attributes are supported:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nx"&gt;FactoryGirl&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;&amp;#39;widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;expensive&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;In this case, however, a round-trip API call must be made to the server in order to call the factory and return the result. Because of this, the Angular version of FactoryGirl returns a promise that is resolved with the serialized version of the model, which can then be used as sample data in unit tests.&lt;/p&gt;
&lt;h2 id="the-problems-with-relying-on-the-server-for-data"&gt;The problems with relying on the server for data&lt;/h2&gt;
&lt;p&gt;In my preliminary use of this tool, it works. In many ways, it&amp;rsquo;s much nicer than duplicating logic in both places. However, I&amp;rsquo;m not &lt;em&gt;completely&lt;/em&gt; convinced it&amp;rsquo;s the right solution yet.&lt;/p&gt;
&lt;p&gt;First of all, it couples the front-end to the back-end, even during unit testing, which is disappointing. It means that a server needs to be running (in test mode) in order for the tests to run at all. For the kinds of projects I work on, this isn&amp;rsquo;t really a bad thing, and the benefits of the reduced duplication far outweigh the downsides.&lt;/p&gt;
&lt;p&gt;My real concern is that this solves a very small facet of the general problem with fragile front-end test suites. Single-page applications usually depend wholly on their integration with back-end APIs. If those APIs change, the tests will continue to happily pass as long as the API is simply mocked, which seems to be the usual solution in the front-end universe. This is, frankly, unacceptable in real application development.&lt;/p&gt;
&lt;h2 id="potential-improvements-and-other-paths-to-success"&gt;Potential improvements and other paths to success&lt;/h2&gt;
&lt;p&gt;I am ultimately unsatisfied with this approach, but writing brittle end-to-end integration tests is not the solution. This &lt;em&gt;kind&lt;/em&gt; of thing may be a step in the right direction: writing tests that aren&amp;rsquo;t really pure unit tests, but also aren&amp;rsquo;t fragile full-stack integration tests. This is a middle-ground that seems infrequently traveled, perhaps due to a lack of tooling (or perhaps because it just doesn&amp;rsquo;t work). I don&amp;rsquo;t know.&lt;/p&gt;
&lt;p&gt;Either way, I&amp;rsquo;m interested in where this is headed, and I&amp;rsquo;ll be curious to see if I run into any roadblocks using the workflow I&amp;rsquo;ve created. If anyone else is interested in playing with these two libraries, the READMEs are much more comprehensive than what I&amp;rsquo;ve covered here. Take a look, and give them a spin!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</description></item></channel></rss>

496
feeds/elm.atom.xml Normal file
View File

@ -0,0 +1,496 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged 'elm'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/elm.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/elm.html" />
<id>urn:http-lexi-lambda-github-io:-tags-elm-html</id>
<updated>2015-11-06T19:58:40Z</updated>
<entry>
<title type="text">Functionally updating record types in Elm</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/11/06/functionally-updating-record-types-in-elm/?utm_source=elm&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-11-06-functionally-updating-record-types-in-elm</id>
<published>2015-11-06T19:58:40Z</published>
<updated>2015-11-06T19:58:40Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;&lt;a href="http://elm-lang.org"&gt;Elm&lt;/a&gt; is a wonderful language for building web apps, and I love so much of its approach to language design. Elm does so many things &lt;em&gt;right&lt;/em&gt; straight out of the box, and that&amp;rsquo;s a real breath of fresh air in the intersection of functional programming and web development. Still, it gets one thing wrong, and unfortunately, that one thing is incredibly important. Elm took the &amp;ldquo;functions&amp;rdquo; out of &amp;ldquo;functional record types&amp;rdquo;.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;p&gt;Almost any software program, at its core, is all about data. Maybe it&amp;rsquo;s about computing data, maybe it&amp;rsquo;s about manipulating data, or maybe it&amp;rsquo;s about displaying data, but at the end of the day, some sort of data model is going to be needed. The functional model is a breathtakingly elegant system for handling data and shuttling it around throughout a program, and &lt;a href="https://en.wikipedia.org/wiki/Functional_reactive_programming"&gt;functional reactive programming&lt;/a&gt;, which Elm uses to model event-like interactions, makes this model work even better. The really important thing, though, is what tools Elm actually gives you to model your data.&lt;/p&gt;
&lt;h1 id="a-brief-primer-on-elm-records"&gt;A brief primer on Elm records&lt;/h1&gt;
&lt;p&gt;Elm supports all the core datatypes one would expect—numbers, strings, booleans, optionals, etc.—and it allows users to define their own types with ADTs. However, Elm also provides another datatype, which it calls &amp;ldquo;records&amp;rdquo;. Records are similar to objects in JavaScript: they&amp;rsquo;re effectively key-value mappings. They&amp;rsquo;re cool data structures, and they work well. Here&amp;rsquo;s an example of creating a &lt;code&gt;Point&lt;/code&gt; datatype in Elm:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kr"&gt;type&lt;/span&gt; &lt;span class="kr"&gt;alias&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;y&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Notice that &lt;code&gt;Point&lt;/code&gt; is declared as a type &lt;em&gt;alias&lt;/em&gt;, not as a separate type like an ADT. This is because record types are truly encoded in the type system as values with named fields, not as disparate types. This allows for some fun tricks, but that&amp;rsquo;s outside the scope of this blog post.&lt;/p&gt;
&lt;h1 id="the-good"&gt;The good&lt;/h1&gt;
&lt;p&gt;What I&amp;rsquo;d like to discuss is what it looks like to &lt;em&gt;manipulate&lt;/em&gt; these data structures. Constructing them is completely painless, and reading from them is super simple. This is where the record system gets everything very &lt;em&gt;right&lt;/em&gt;.&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7
8&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;origin&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;origin&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;y&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;distanceBetween&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;
&lt;span class="nv"&gt;distanceBetween&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nv"&gt;b&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt;
&lt;span class="kr"&gt;let&lt;/span&gt; &lt;span class="nv"&gt;dx&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="nv"&gt;b&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt;
&lt;span class="nv"&gt;dy&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;y&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="nv"&gt;b&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;y&lt;/span&gt;
&lt;span class="kr"&gt;in&lt;/span&gt; &lt;span class="nv"&gt;sqrt&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;dx&lt;/span&gt;&lt;span class="nf"&gt;*&lt;/span&gt;&lt;span class="nv"&gt;dx&lt;/span&gt; &lt;span class="nf"&gt;+&lt;/span&gt; &lt;span class="nv"&gt;dy&lt;/span&gt;&lt;span class="nf"&gt;*&lt;/span&gt;&lt;span class="nv"&gt;dy&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;The syntax is clean and simple. Most importantly, however, the record system is functional (in the &amp;ldquo;functional programming&amp;rdquo; sense). In a functional system, it&amp;rsquo;s useful to express concepts in terms of function composition, and this is very easy to do in Elm. Creating a function to access a field would normally be clunky if you always needed to do &lt;code&gt;record.field&lt;/code&gt; to access the value. Fortunately, Elm provides some sugar:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="c1"&gt;-- These two expressions are equivalent:&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;record&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;record&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;field&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;field&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Using the &lt;code&gt;.field&lt;/code&gt; shorthand allows writing some other functions in terms of composition, as most functional programmers would desire:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;doubledX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;
&lt;span class="nv"&gt;doubledX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(*)&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This satisfies me.&lt;/p&gt;
&lt;h1 id="the-bad"&gt;The bad&lt;/h1&gt;
&lt;p&gt;So if everything in Elm is so great, what am I complaining about? Well, while the syntax to access fields is convenient, the syntax to &lt;em&gt;functionally set&lt;/em&gt; fields is questionably clunky. Consider a function that accepts a point and returns a new point with its &lt;code&gt;x&lt;/code&gt; field set to &lt;code&gt;0&lt;/code&gt;:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;zeroedX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;zeroedX&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This doesn&amp;rsquo;t look too bad, does it? It&amp;rsquo;s clear and concise. To me, though, there&amp;rsquo;s something deeply wrong here&amp;hellip; this function has a lot of redundancy! It seems to me like we should be able to write this function more clearly in a point-free style. The &lt;code&gt;.field&lt;/code&gt; shorthand &amp;ldquo;functionalizes&amp;rdquo; the record getter syntax, so there must be a function version of the update syntax, right? Maybe it would look something like this:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;zeroedX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;zeroedX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="err"&gt;!&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;But alas, there is no such syntax.&lt;/p&gt;
&lt;p&gt;Now you may ask&amp;hellip; why does it matter? This seems trivial, and in fact, the explicit updater syntax may actually be more readable by virtue of how explicit it is. You&amp;rsquo;d be right, because so far, these examples have been horribly contrived. But let&amp;rsquo;s consider a slightly more useful example: &lt;em&gt;functionally updating&lt;/em&gt; a record.&lt;/p&gt;
&lt;p&gt;What&amp;rsquo;s the difference? Well, say I wanted to take a point and increment its &lt;code&gt;x&lt;/code&gt; field by one. Well, I can easily write a function for that:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Not terrible, though a &lt;em&gt;little&lt;/em&gt; verbose. Still, what if we want to also add a function that &lt;em&gt;decrements&lt;/em&gt; &lt;code&gt;x&lt;/code&gt;?&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Oh, gosh. That&amp;rsquo;s basically the exact same definition but with the operation flipped. Plus we probably want these operations for &lt;code&gt;y&lt;/code&gt;, too. Fortunately, there&amp;rsquo;s an easy solution: just pass a function in to &lt;em&gt;transform&lt;/em&gt; the value! We can define an &lt;code&gt;updateX&lt;/code&gt; function that allows us to do that easily, then we can define our derived operations in terms of that:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7
8&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Float&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Not only is that much cleaner, but we can now use it to implement all sorts of other operations that allow us to add, subtract, multiply, or divide the &lt;code&gt;x&lt;/code&gt; field. Now we just need to generalize our solution to work with the &lt;code&gt;x&lt;/code&gt; &lt;em&gt;and&lt;/em&gt; &lt;code&gt;y&lt;/code&gt; fields!&lt;/p&gt;
&lt;p&gt;Oh, wait. &lt;strong&gt;We can&amp;rsquo;t.&lt;/strong&gt;&lt;/p&gt;
&lt;h1 id="the-ugly"&gt;The ugly&lt;/h1&gt;
&lt;p&gt;This is where everything breaks down completely. Elm does not offer enough abstraction to reduce this level of crazy duplication:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Float&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;updateY&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Float&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;updateY&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;y&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;y&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;incrementY&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;incrementY&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateY&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;decrementY&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;decrementY&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateY&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We sure can give it a shot, though. At the very least, we &lt;em&gt;can&lt;/em&gt; implement the increment and decrement functions in a more general way by passing in an updater function:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;increment&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="kt"&gt;Float&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;
&lt;span class="nv"&gt;increment&lt;/span&gt; &lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now, with &lt;code&gt;updateX&lt;/code&gt; and &lt;code&gt;updateY&lt;/code&gt;, we can increment either field very clearly and expressively. If we shorten the names to &lt;code&gt;uX&lt;/code&gt; and &lt;code&gt;uY&lt;/code&gt;, then the resulting code is actually very readable:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;pointAbove&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;uY&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;pointBelow&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;uY&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It&amp;rsquo;s almost like English now: &amp;ldquo;update Y using this transformation&amp;rdquo;. This is actually pretty satisfactory. The trouble arises when you have a struct with many fields:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kr"&gt;type&lt;/span&gt; &lt;span class="kr"&gt;alias&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;
&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;strength&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;
&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;charisma&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;
&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;intellect&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;
&lt;span class="c1"&gt;-- etc.&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It might be very convenient to have generic functional updaters in this case. One could imagine a game that has &lt;code&gt;Potion&lt;/code&gt; items:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kr"&gt;type&lt;/span&gt; &lt;span class="kt"&gt;Potion&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;Potion&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;And then some different kinds of potions:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;potions&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Potion&lt;/span&gt; &lt;span class="s"&gt;"Health Potion"&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;))),&lt;/span&gt;
&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Potion&lt;/span&gt; &lt;span class="s"&gt;"Greater Intellect Potion"&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;uIntellect&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Potion&lt;/span&gt; &lt;span class="s"&gt;"Potion of Weakness"&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;uStrength&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;//&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This is a really elegant way to think about items that can affect a player&amp;rsquo;s stats! Unfortunately, it also means you have to define updater functions for &lt;em&gt;every single field in the record&lt;/em&gt;. This can get tedious rather quickly:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;uStrength&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;uStrength&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;strength&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;strength&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;uCharisma&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;uCharisma&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;charisma&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;charisma&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="c1"&gt;-- etc.&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This is pretty icky. Could there be a better way?&lt;/p&gt;
&lt;h1 id="trying-to-create-a-more-general-abstraction"&gt;Trying to create a more general abstraction&lt;/h1&gt;
&lt;p&gt;Interestingly, this pattern doesn&amp;rsquo;t &lt;em&gt;need&lt;/em&gt; to be this bad. There are better ways to do this. Let&amp;rsquo;s revisit our updater functions.&lt;/p&gt;
&lt;p&gt;Really, &lt;code&gt;update&lt;/code&gt; can be defined in terms of two other primitive operations: a read and a (functional) write. What would it look like if we implemented it that way instead of requiring special updater functions to be defined? Well, it would look like this:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;b&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;b&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;
&lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="nv"&gt;get&lt;/span&gt; &lt;span class="nv"&gt;set&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;set&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;get&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;The type definition is a little long, but it&amp;rsquo;s really pretty simple. We just supply a getter and a setter, then a function to do the transformation, and finally a record to actually transform. Of course, as you can see from the type, this function isn&amp;rsquo;t actually specific to records: it can be used with any value for which a getter and setter can be provided.&lt;/p&gt;
&lt;p&gt;The trouble here is that writing field setters isn&amp;rsquo;t any easier in Elm than writing field updaters. They still look pretty verbose:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;sHealth&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;sHealth&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="nv"&gt;sHealth&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;So, at the end of it all, this isn&amp;rsquo;t really a better abstraction. Still remember my fantasy &lt;code&gt;!field&lt;/code&gt; setter shorthand half a blog post ago? Now perhaps it makes a little more sense. &lt;em&gt;If&lt;/em&gt; such a syntax existed, then defining the updater would be incredibly simple:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="err"&gt;!&lt;/span&gt;&lt;span class="nv"&gt;health&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Still, no syntax, no easy updaters, and by extension, no easy, declarative description of behavior without quite a bit of boilerplate.&lt;/p&gt;
&lt;h1 id="conclusions-and-related-work"&gt;Conclusions and related work&lt;/h1&gt;
&lt;p&gt;Elm is a very promising language, and it seems to be in fairly rapid development. So far, its author, &lt;a href="https://twitter.com/czaplic"&gt;Evan Czaplicki&lt;/a&gt;, has taken a very cautious approach to implementing language features, especially potentially redundant ones. This caution is why things like operator slicing, &amp;ldquo;where&amp;rdquo; clauses, and special updater syntax have not yet made it into the language. Maybe at some point these will be deemed important enough to include, but for the time being, they&amp;rsquo;ve been excluded.&lt;/p&gt;
&lt;p&gt;I obviously think that having this sort of thing is incredibly important to being able to write expressive code without a huge amount of overhead. However, I also do &lt;em&gt;not&lt;/em&gt; want to give the impression that I think adding special setter syntax is the only way to do it.&lt;/p&gt;
&lt;p&gt;Seasoned functional programmers will surely have noticed that many of these concepts sound a lot like lenses, and Elm actually already has a lens-like library authored by Evan himself, called &lt;a href="https://github.com/evancz/focus"&gt;Focus&lt;/a&gt;. This, however, does not actually solve the problem: it requires manual description of setters just like the purely function based approach does. Really, lenses are just the logical next step in the line of abstraction I&amp;rsquo;ve already laid out above.&lt;/p&gt;
&lt;p&gt;Interestingly, PureScript and Elm, the two Haskell-likes-on-the-frontend that I&amp;rsquo;ve paid attention to (though PureScript is much closer to Haskell than Elm), both have this very same problem. Haskell itself solves it with macros via Template Haskell. My favorite language, Racket, solves it with its own macro system. Is there another way to do these things that doesn&amp;rsquo;t involve introducing a heavyweight macro system? Definitely. But I think this is a &lt;em&gt;necessary feature&lt;/em&gt;, not a &amp;ldquo;nice to have&amp;rdquo;, so if a macro system is out of the picture, then a simpler, less flexible solution is the obvious logical alternative.&lt;/p&gt;
&lt;p&gt;I really like Elm, and most of my experiences with it have been more than enough to convince me that it is a fantastic language for the job. Unfortunately, the issue of functional record updaters has been quite the frustrating obstacle in my otherwise frictionless ride. I will continue to happily use Elm over other, far less accommodating tools, but I hope that issues like these will be smoothed out as the language and its ecosystem matures.&lt;/p&gt;&lt;/html&gt;</content></entry></feed>

495
feeds/elm.rss.xml Normal file
View File

@ -0,0 +1,495 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged 'elm'</title>
<description>Alexis King's Blog: Posts tagged 'elm'</description>
<link>http://lexi-lambda.github.io/tags/elm.html</link>
<lastBuildDate>Fri, 06 Nov 2015 19:58:40 UT</lastBuildDate>
<pubDate>Fri, 06 Nov 2015 19:58:40 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>Functionally updating record types in Elm</title>
<link>http://lexi-lambda.github.io/blog/2015/11/06/functionally-updating-record-types-in-elm/?utm_source=elm&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-11-06-functionally-updating-record-types-in-elm</guid>
<pubDate>Fri, 06 Nov 2015 19:58:40 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;&lt;a href="http://elm-lang.org"&gt;Elm&lt;/a&gt; is a wonderful language for building web apps, and I love so much of its approach to language design. Elm does so many things &lt;em&gt;right&lt;/em&gt; straight out of the box, and that&amp;rsquo;s a real breath of fresh air in the intersection of functional programming and web development. Still, it gets one thing wrong, and unfortunately, that one thing is incredibly important. Elm took the &amp;ldquo;functions&amp;rdquo; out of &amp;ldquo;functional record types&amp;rdquo;.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;p&gt;Almost any software program, at its core, is all about data. Maybe it&amp;rsquo;s about computing data, maybe it&amp;rsquo;s about manipulating data, or maybe it&amp;rsquo;s about displaying data, but at the end of the day, some sort of data model is going to be needed. The functional model is a breathtakingly elegant system for handling data and shuttling it around throughout a program, and &lt;a href="https://en.wikipedia.org/wiki/Functional_reactive_programming"&gt;functional reactive programming&lt;/a&gt;, which Elm uses to model event-like interactions, makes this model work even better. The really important thing, though, is what tools Elm actually gives you to model your data.&lt;/p&gt;
&lt;h1 id="a-brief-primer-on-elm-records"&gt;A brief primer on Elm records&lt;/h1&gt;
&lt;p&gt;Elm supports all the core datatypes one would expect—numbers, strings, booleans, optionals, etc.—and it allows users to define their own types with ADTs. However, Elm also provides another datatype, which it calls &amp;ldquo;records&amp;rdquo;. Records are similar to objects in JavaScript: they&amp;rsquo;re effectively key-value mappings. They&amp;rsquo;re cool data structures, and they work well. Here&amp;rsquo;s an example of creating a &lt;code&gt;Point&lt;/code&gt; datatype in Elm:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kr"&gt;type&lt;/span&gt; &lt;span class="kr"&gt;alias&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;y&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Notice that &lt;code&gt;Point&lt;/code&gt; is declared as a type &lt;em&gt;alias&lt;/em&gt;, not as a separate type like an ADT. This is because record types are truly encoded in the type system as values with named fields, not as disparate types. This allows for some fun tricks, but that&amp;rsquo;s outside the scope of this blog post.&lt;/p&gt;
&lt;h1 id="the-good"&gt;The good&lt;/h1&gt;
&lt;p&gt;What I&amp;rsquo;d like to discuss is what it looks like to &lt;em&gt;manipulate&lt;/em&gt; these data structures. Constructing them is completely painless, and reading from them is super simple. This is where the record system gets everything very &lt;em&gt;right&lt;/em&gt;.&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7
8&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;origin&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;origin&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;y&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;distanceBetween&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;
&lt;span class="nv"&gt;distanceBetween&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nv"&gt;b&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt;
&lt;span class="kr"&gt;let&lt;/span&gt; &lt;span class="nv"&gt;dx&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="nv"&gt;b&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt;
&lt;span class="nv"&gt;dy&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;y&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="nv"&gt;b&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;y&lt;/span&gt;
&lt;span class="kr"&gt;in&lt;/span&gt; &lt;span class="nv"&gt;sqrt&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;dx&lt;/span&gt;&lt;span class="nf"&gt;*&lt;/span&gt;&lt;span class="nv"&gt;dx&lt;/span&gt; &lt;span class="nf"&gt;+&lt;/span&gt; &lt;span class="nv"&gt;dy&lt;/span&gt;&lt;span class="nf"&gt;*&lt;/span&gt;&lt;span class="nv"&gt;dy&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;The syntax is clean and simple. Most importantly, however, the record system is functional (in the &amp;ldquo;functional programming&amp;rdquo; sense). In a functional system, it&amp;rsquo;s useful to express concepts in terms of function composition, and this is very easy to do in Elm. Creating a function to access a field would normally be clunky if you always needed to do &lt;code&gt;record.field&lt;/code&gt; to access the value. Fortunately, Elm provides some sugar:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="c1"&gt;-- These two expressions are equivalent:&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;record&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;record&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;field&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;field&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Using the &lt;code&gt;.field&lt;/code&gt; shorthand allows writing some other functions in terms of composition, as most functional programmers would desire:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;doubledX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;
&lt;span class="nv"&gt;doubledX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(*)&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;&amp;lt;&lt;/span&gt; &lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This satisfies me.&lt;/p&gt;
&lt;h1 id="the-bad"&gt;The bad&lt;/h1&gt;
&lt;p&gt;So if everything in Elm is so great, what am I complaining about? Well, while the syntax to access fields is convenient, the syntax to &lt;em&gt;functionally set&lt;/em&gt; fields is questionably clunky. Consider a function that accepts a point and returns a new point with its &lt;code&gt;x&lt;/code&gt; field set to &lt;code&gt;0&lt;/code&gt;:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;zeroedX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;zeroedX&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This doesn&amp;rsquo;t look too bad, does it? It&amp;rsquo;s clear and concise. To me, though, there&amp;rsquo;s something deeply wrong here&amp;hellip; this function has a lot of redundancy! It seems to me like we should be able to write this function more clearly in a point-free style. The &lt;code&gt;.field&lt;/code&gt; shorthand &amp;ldquo;functionalizes&amp;rdquo; the record getter syntax, so there must be a function version of the update syntax, right? Maybe it would look something like this:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;zeroedX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;zeroedX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="err"&gt;!&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;But alas, there is no such syntax.&lt;/p&gt;
&lt;p&gt;Now you may ask&amp;hellip; why does it matter? This seems trivial, and in fact, the explicit updater syntax may actually be more readable by virtue of how explicit it is. You&amp;rsquo;d be right, because so far, these examples have been horribly contrived. But let&amp;rsquo;s consider a slightly more useful example: &lt;em&gt;functionally updating&lt;/em&gt; a record.&lt;/p&gt;
&lt;p&gt;What&amp;rsquo;s the difference? Well, say I wanted to take a point and increment its &lt;code&gt;x&lt;/code&gt; field by one. Well, I can easily write a function for that:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Not terrible, though a &lt;em&gt;little&lt;/em&gt; verbose. Still, what if we want to also add a function that &lt;em&gt;decrements&lt;/em&gt; &lt;code&gt;x&lt;/code&gt;?&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Oh, gosh. That&amp;rsquo;s basically the exact same definition but with the operation flipped. Plus we probably want these operations for &lt;code&gt;y&lt;/code&gt;, too. Fortunately, there&amp;rsquo;s an easy solution: just pass a function in to &lt;em&gt;transform&lt;/em&gt; the value! We can define an &lt;code&gt;updateX&lt;/code&gt; function that allows us to do that easily, then we can define our derived operations in terms of that:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7
8&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Float&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Not only is that much cleaner, but we can now use it to implement all sorts of other operations that allow us to add, subtract, multiply, or divide the &lt;code&gt;x&lt;/code&gt; field. Now we just need to generalize our solution to work with the &lt;code&gt;x&lt;/code&gt; &lt;em&gt;and&lt;/em&gt; &lt;code&gt;y&lt;/code&gt; fields!&lt;/p&gt;
&lt;p&gt;Oh, wait. &lt;strong&gt;We can&amp;rsquo;t.&lt;/strong&gt;&lt;/p&gt;
&lt;h1 id="the-ugly"&gt;The ugly&lt;/h1&gt;
&lt;p&gt;This is where everything breaks down completely. Elm does not offer enough abstraction to reduce this level of crazy duplication:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Float&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;incrementX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;decrementX&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateX&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;updateY&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Float&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;updateY&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;y&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;point&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;y&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;incrementY&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;incrementY&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateY&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;decrementY&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Point&lt;/span&gt;
&lt;span class="nv"&gt;decrementY&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;updateY&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We sure can give it a shot, though. At the very least, we &lt;em&gt;can&lt;/em&gt; implement the increment and decrement functions in a more general way by passing in an updater function:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;increment&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="kt"&gt;Float&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Float&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;
&lt;span class="nv"&gt;increment&lt;/span&gt; &lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now, with &lt;code&gt;updateX&lt;/code&gt; and &lt;code&gt;updateY&lt;/code&gt;, we can increment either field very clearly and expressively. If we shorten the names to &lt;code&gt;uX&lt;/code&gt; and &lt;code&gt;uY&lt;/code&gt;, then the resulting code is actually very readable:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;pointAbove&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;uY&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="nv"&gt;pointBelow&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;uY&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It&amp;rsquo;s almost like English now: &amp;ldquo;update Y using this transformation&amp;rdquo;. This is actually pretty satisfactory. The trouble arises when you have a struct with many fields:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kr"&gt;type&lt;/span&gt; &lt;span class="kr"&gt;alias&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt;
&lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;
&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;strength&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;
&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;charisma&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;
&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nv"&gt;intellect&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;
&lt;span class="c1"&gt;-- etc.&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It might be very convenient to have generic functional updaters in this case. One could imagine a game that has &lt;code&gt;Potion&lt;/code&gt; items:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kr"&gt;type&lt;/span&gt; &lt;span class="kt"&gt;Potion&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;Potion&lt;/span&gt; &lt;span class="kt"&gt;String&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;And then some different kinds of potions:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;potions&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Potion&lt;/span&gt; &lt;span class="s"&gt;"Health Potion"&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;))),&lt;/span&gt;
&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Potion&lt;/span&gt; &lt;span class="s"&gt;"Greater Intellect Potion"&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;uIntellect&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;(+)&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Potion&lt;/span&gt; &lt;span class="s"&gt;"Potion of Weakness"&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;uStrength&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;\&lt;/span&gt;&lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;//&lt;/span&gt; &lt;span class="mi"&gt;5&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;span class="p"&gt;]&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This is a really elegant way to think about items that can affect a player&amp;rsquo;s stats! Unfortunately, it also means you have to define updater functions for &lt;em&gt;every single field in the record&lt;/em&gt;. This can get tedious rather quickly:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;uStrength&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;uStrength&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;strength&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;strength&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;uCharisma&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;uCharisma&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;charisma&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt;&lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;charisma&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="c1"&gt;-- etc.&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This is pretty icky. Could there be a better way?&lt;/p&gt;
&lt;h1 id="trying-to-create-a-more-general-abstraction"&gt;Trying to create a more general abstraction&lt;/h1&gt;
&lt;p&gt;Interestingly, this pattern doesn&amp;rsquo;t &lt;em&gt;need&lt;/em&gt; to be this bad. There are better ways to do this. Let&amp;rsquo;s revisit our updater functions.&lt;/p&gt;
&lt;p&gt;Really, &lt;code&gt;update&lt;/code&gt; can be defined in terms of two other primitive operations: a read and a (functional) write. What would it look like if we implemented it that way instead of requiring special updater functions to be defined? Well, it would look like this:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;b&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;b&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nv"&gt;a&lt;/span&gt;
&lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="nv"&gt;get&lt;/span&gt; &lt;span class="nv"&gt;set&lt;/span&gt; &lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;set&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;f&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nv"&gt;get&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;The type definition is a little long, but it&amp;rsquo;s really pretty simple. We just supply a getter and a setter, then a function to do the transformation, and finally a record to actually transform. Of course, as you can see from the type, this function isn&amp;rsquo;t actually specific to records: it can be used with any value for which a getter and setter can be provided.&lt;/p&gt;
&lt;p&gt;The trouble here is that writing field setters isn&amp;rsquo;t any easier in Elm than writing field updaters. They still look pretty verbose:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;sHealth&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;sHealth&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nv"&gt;stats&lt;/span&gt; &lt;span class="nf"&gt;|&lt;/span&gt; &lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="nf"&gt;&amp;lt;-&lt;/span&gt; &lt;span class="nv"&gt;x&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="nv"&gt;sHealth&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;So, at the end of it all, this isn&amp;rsquo;t really a better abstraction. Still remember my fantasy &lt;code&gt;!field&lt;/code&gt; setter shorthand half a blog post ago? Now perhaps it makes a little more sense. &lt;em&gt;If&lt;/em&gt; such a syntax existed, then defining the updater would be incredibly simple:&lt;/p&gt;
&lt;div class="brush: elm"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nf"&gt;:&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Integer&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;Integer&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt; &lt;span class="nf"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="kt"&gt;PlayerStats&lt;/span&gt;
&lt;span class="nv"&gt;uHealth&lt;/span&gt; &lt;span class="nf"&gt;=&lt;/span&gt; &lt;span class="nv"&gt;update&lt;/span&gt; &lt;span class="nf"&gt;.&lt;/span&gt;&lt;span class="nv"&gt;health&lt;/span&gt; &lt;span class="err"&gt;!&lt;/span&gt;&lt;span class="nv"&gt;health&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Still, no syntax, no easy updaters, and by extension, no easy, declarative description of behavior without quite a bit of boilerplate.&lt;/p&gt;
&lt;h1 id="conclusions-and-related-work"&gt;Conclusions and related work&lt;/h1&gt;
&lt;p&gt;Elm is a very promising language, and it seems to be in fairly rapid development. So far, its author, &lt;a href="https://twitter.com/czaplic"&gt;Evan Czaplicki&lt;/a&gt;, has taken a very cautious approach to implementing language features, especially potentially redundant ones. This caution is why things like operator slicing, &amp;ldquo;where&amp;rdquo; clauses, and special updater syntax have not yet made it into the language. Maybe at some point these will be deemed important enough to include, but for the time being, they&amp;rsquo;ve been excluded.&lt;/p&gt;
&lt;p&gt;I obviously think that having this sort of thing is incredibly important to being able to write expressive code without a huge amount of overhead. However, I also do &lt;em&gt;not&lt;/em&gt; want to give the impression that I think adding special setter syntax is the only way to do it.&lt;/p&gt;
&lt;p&gt;Seasoned functional programmers will surely have noticed that many of these concepts sound a lot like lenses, and Elm actually already has a lens-like library authored by Evan himself, called &lt;a href="https://github.com/evancz/focus"&gt;Focus&lt;/a&gt;. This, however, does not actually solve the problem: it requires manual description of setters just like the purely function based approach does. Really, lenses are just the logical next step in the line of abstraction I&amp;rsquo;ve already laid out above.&lt;/p&gt;
&lt;p&gt;Interestingly, PureScript and Elm, the two Haskell-likes-on-the-frontend that I&amp;rsquo;ve paid attention to (though PureScript is much closer to Haskell than Elm), both have this very same problem. Haskell itself solves it with macros via Template Haskell. My favorite language, Racket, solves it with its own macro system. Is there another way to do these things that doesn&amp;rsquo;t involve introducing a heavyweight macro system? Definitely. But I think this is a &lt;em&gt;necessary feature&lt;/em&gt;, not a &amp;ldquo;nice to have&amp;rdquo;, so if a macro system is out of the picture, then a simpler, less flexible solution is the obvious logical alternative.&lt;/p&gt;
&lt;p&gt;I really like Elm, and most of my experiences with it have been more than enough to convince me that it is a fantastic language for the job. Unfortunately, the issue of functional record updaters has been quite the frustrating obstacle in my otherwise frictionless ride. I will continue to happily use Elm over other, far less accommodating tools, but I hope that issues like these will be smoothed out as the language and its ecosystem matures.&lt;/p&gt;&lt;/html&gt;</description></item></channel></rss>

106
feeds/envy.atom.xml Normal file
View File

@ -0,0 +1,106 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged 'envy'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/envy.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/envy.html" />
<id>urn:http-lexi-lambda-github-io:-tags-envy-html</id>
<updated>2015-08-30T16:05:37Z</updated>
<entry>
<title type="text">Managing application configuration with Envy</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/08/30/managing-application-configuration-with-envy/?utm_source=envy&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-08-30-managing-application-configuration-with-envy</id>
<published>2015-08-30T16:05:37Z</published>
<updated>2015-08-30T16:05:37Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;Application configuration can be a pain. Modern web apps don&amp;rsquo;t live on dedicated boxes, they run on VPSes somewhere in the amorphous &amp;ldquo;cloud&amp;rdquo;, and keeping configuration out of your application&amp;rsquo;s repository can seem like more trouble than it&amp;rsquo;s worth. Fortunately, &lt;a href="http://12factor.net"&gt;The Twelve-Factor App&lt;/a&gt; provides a set of standards for keeping web apps sane, and &lt;a href="http://12factor.net/config"&gt;one of those guidelines advises keeping configuration in the environment&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;a href="https://github.com/lexi-lambda/envy"&gt;Envy&lt;/a&gt; is the declarative bridge between Racket code and the outside world of the environment.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="introducing-envy"&gt;Introducing Envy&lt;/h1&gt;
&lt;p&gt;I built Envy to distill the common tasks needed when working with environment variables into a single, declarative interface that eliminates boilerplate and makes it easy to see which environment variables an application depends on (instead of having them littered throughout the codebase). Using it is simple. Just require &lt;code&gt;envy&lt;/code&gt; and you&amp;rsquo;re good to go.&lt;/p&gt;
&lt;p&gt;The best way to use Envy is to create a &amp;ldquo;manifest&amp;rdquo; module that declares all the environment variables your application might use. For example, the following module is a manifest that describes an application that uses three environment variables:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7
8
9&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="c1"&gt;; environment.rkt&lt;/span&gt;
&lt;span class="kn"&gt;#lang &lt;/span&gt;&lt;span class="nn"&gt;typed/racket/base&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit"&gt;require&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;envy&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define/provide-environment&lt;/span&gt;
&lt;span class="n"&gt;api-token&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;log-level&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Symbol))" style="color: inherit"&gt;Symbol&lt;/a&gt;&lt;/span&gt; &lt;span class="kd"&gt;#:default&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="ss"&gt;info&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;parallel?&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Boolean))" style="color: inherit"&gt;Boolean&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;When this module is required, Envy will automatically do the following:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Envy will check the values of three environment variables: &lt;code&gt;API_TOKEN&lt;/code&gt;, &lt;code&gt;LOG_LEVEL&lt;/code&gt;, and &lt;code&gt;PARALLEL&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;If either &lt;code&gt;API_TOKEN&lt;/code&gt; or &lt;code&gt;PARALLEL&lt;/code&gt; is not set, an error will be raised:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;envy: The required environment variable "API_TOKEN" is not defined.&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The values for &lt;code&gt;LOG_LEVEL&lt;/code&gt; and &lt;code&gt;PARALLEL&lt;/code&gt; will be parsed to match their type annotations.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;If &lt;code&gt;LOG_LEVEL&lt;/code&gt; is not set, it will use the default value, &lt;code&gt;'info&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The values will be stored in &lt;code&gt;api-token&lt;/code&gt;, &lt;code&gt;log-level&lt;/code&gt;, and &lt;code&gt;parallel?&lt;/code&gt;, all of which will be provided by the enclosing module.&lt;/p&gt;&lt;/li&gt;&lt;/ol&gt;
&lt;p&gt;Now just &lt;code&gt;(require (prefix-in env: "environment.rkt"))&lt;/code&gt;, and the environment variables are guaranteed to be available in your application&amp;rsquo;s code.&lt;/p&gt;
&lt;h1 id="working-with-typed-racket"&gt;Working with Typed Racket&lt;/h1&gt;
&lt;p&gt;As you may have noticed by the example above, Envy is built with Typed Racket in mind. In fact, &lt;code&gt;define/provide-environment&lt;/code&gt; will &lt;em&gt;only&lt;/em&gt; work within a Typed Racket module, but that doesn&amp;rsquo;t mean Envy can&amp;rsquo;t be used with plain Racket—the manifest module can always be required by any kind of Racket module.&lt;/p&gt;
&lt;p&gt;However, when using Typed Racket, Envy provides additional bonuses. Environment variables are inherently untyped—they&amp;rsquo;re all just strings—but Envy assigns the proper type to each environment variable automatically, so no casting is necessary.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;gt; parallel?
- : Boolean
#t&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Envy really shines when using optional environment variables with the &lt;code&gt;#:default&lt;/code&gt; option. The type of the value given to &lt;code&gt;#:default&lt;/code&gt; doesn&amp;rsquo;t need to be the same type of the environment variable itself, and if it isn&amp;rsquo;t, Envy will assign the value a union type.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;gt; (define-environment
[num-threads : Positive-Integer #:default #f])
&amp;gt; num-threads
- : (U Positive-Integer #f)
#f&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This added level of type-safety means it&amp;rsquo;s easy to manage optional variables that don&amp;rsquo;t have reasonable defaults: the type system will enforce that all code considers the possibility that such variables do not exist.&lt;/p&gt;
&lt;h1 id="and-more"&gt;And more&amp;hellip;&lt;/h1&gt;
&lt;p&gt;To see the full set of features that Envy already provides, &lt;a href="https://lexi-lambda.github.io/envy/envy.html"&gt;take a look at the documentation&lt;/a&gt;. That said, this is just the first release based on my initial use-cases, but I&amp;rsquo;m sure there are more features Envy could have to accommodate common application configuration patterns. If you have an idea that could make Envy better, &lt;a href="https://github.com/lexi-lambda/envy/issues"&gt;open an issue and make a suggestion&lt;/a&gt;! I already have plans for a &lt;code&gt;#lang envy&lt;/code&gt; DSL, which will hopefully cut the boilerplate out in its entirety.&lt;/p&gt;
&lt;p&gt;And finally, to give credit where credit is due, Envy is heavily inspired by &lt;a href="https://github.com/eval/envied"&gt;Envied&lt;/a&gt; (both in name and function), an environment variable manager for Ruby, which I&amp;rsquo;ve used to great effect.&lt;/p&gt;
&lt;p&gt;Try it out!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;raco pkg install envy&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/envy"&gt;Envy on GitHub&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://lexi-lambda.github.io/envy/envy.html"&gt;Envy documentation&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</content></entry></feed>

105
feeds/envy.rss.xml Normal file
View File

@ -0,0 +1,105 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged 'envy'</title>
<description>Alexis King's Blog: Posts tagged 'envy'</description>
<link>http://lexi-lambda.github.io/tags/envy.html</link>
<lastBuildDate>Sun, 30 Aug 2015 16:05:37 UT</lastBuildDate>
<pubDate>Sun, 30 Aug 2015 16:05:37 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>Managing application configuration with Envy</title>
<link>http://lexi-lambda.github.io/blog/2015/08/30/managing-application-configuration-with-envy/?utm_source=envy&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-08-30-managing-application-configuration-with-envy</guid>
<pubDate>Sun, 30 Aug 2015 16:05:37 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;Application configuration can be a pain. Modern web apps don&amp;rsquo;t live on dedicated boxes, they run on VPSes somewhere in the amorphous &amp;ldquo;cloud&amp;rdquo;, and keeping configuration out of your application&amp;rsquo;s repository can seem like more trouble than it&amp;rsquo;s worth. Fortunately, &lt;a href="http://12factor.net"&gt;The Twelve-Factor App&lt;/a&gt; provides a set of standards for keeping web apps sane, and &lt;a href="http://12factor.net/config"&gt;one of those guidelines advises keeping configuration in the environment&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;&lt;a href="https://github.com/lexi-lambda/envy"&gt;Envy&lt;/a&gt; is the declarative bridge between Racket code and the outside world of the environment.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="introducing-envy"&gt;Introducing Envy&lt;/h1&gt;
&lt;p&gt;I built Envy to distill the common tasks needed when working with environment variables into a single, declarative interface that eliminates boilerplate and makes it easy to see which environment variables an application depends on (instead of having them littered throughout the codebase). Using it is simple. Just require &lt;code&gt;envy&lt;/code&gt; and you&amp;rsquo;re good to go.&lt;/p&gt;
&lt;p&gt;The best way to use Envy is to create a &amp;ldquo;manifest&amp;rdquo; module that declares all the environment variables your application might use. For example, the following module is a manifest that describes an application that uses three environment variables:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7
8
9&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="c1"&gt;; environment.rkt&lt;/span&gt;
&lt;span class="kn"&gt;#lang &lt;/span&gt;&lt;span class="nn"&gt;typed/racket/base&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit"&gt;require&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;envy&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define/provide-environment&lt;/span&gt;
&lt;span class="n"&gt;api-token&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;log-level&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Symbol))" style="color: inherit"&gt;Symbol&lt;/a&gt;&lt;/span&gt; &lt;span class="kd"&gt;#:default&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="ss"&gt;info&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;parallel?&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Boolean))" style="color: inherit"&gt;Boolean&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;])&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;When this module is required, Envy will automatically do the following:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;Envy will check the values of three environment variables: &lt;code&gt;API_TOKEN&lt;/code&gt;, &lt;code&gt;LOG_LEVEL&lt;/code&gt;, and &lt;code&gt;PARALLEL&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;If either &lt;code&gt;API_TOKEN&lt;/code&gt; or &lt;code&gt;PARALLEL&lt;/code&gt; is not set, an error will be raised:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;envy: The required environment variable "API_TOKEN" is not defined.&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The values for &lt;code&gt;LOG_LEVEL&lt;/code&gt; and &lt;code&gt;PARALLEL&lt;/code&gt; will be parsed to match their type annotations.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;If &lt;code&gt;LOG_LEVEL&lt;/code&gt; is not set, it will use the default value, &lt;code&gt;'info&lt;/code&gt;.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;The values will be stored in &lt;code&gt;api-token&lt;/code&gt;, &lt;code&gt;log-level&lt;/code&gt;, and &lt;code&gt;parallel?&lt;/code&gt;, all of which will be provided by the enclosing module.&lt;/p&gt;&lt;/li&gt;&lt;/ol&gt;
&lt;p&gt;Now just &lt;code&gt;(require (prefix-in env: "environment.rkt"))&lt;/code&gt;, and the environment variables are guaranteed to be available in your application&amp;rsquo;s code.&lt;/p&gt;
&lt;h1 id="working-with-typed-racket"&gt;Working with Typed Racket&lt;/h1&gt;
&lt;p&gt;As you may have noticed by the example above, Envy is built with Typed Racket in mind. In fact, &lt;code&gt;define/provide-environment&lt;/code&gt; will &lt;em&gt;only&lt;/em&gt; work within a Typed Racket module, but that doesn&amp;rsquo;t mean Envy can&amp;rsquo;t be used with plain Racket—the manifest module can always be required by any kind of Racket module.&lt;/p&gt;
&lt;p&gt;However, when using Typed Racket, Envy provides additional bonuses. Environment variables are inherently untyped—they&amp;rsquo;re all just strings—but Envy assigns the proper type to each environment variable automatically, so no casting is necessary.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;gt; parallel?
- : Boolean
#t&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Envy really shines when using optional environment variables with the &lt;code&gt;#:default&lt;/code&gt; option. The type of the value given to &lt;code&gt;#:default&lt;/code&gt; doesn&amp;rsquo;t need to be the same type of the environment variable itself, and if it isn&amp;rsquo;t, Envy will assign the value a union type.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;gt; (define-environment
[num-threads : Positive-Integer #:default #f])
&amp;gt; num-threads
- : (U Positive-Integer #f)
#f&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;This added level of type-safety means it&amp;rsquo;s easy to manage optional variables that don&amp;rsquo;t have reasonable defaults: the type system will enforce that all code considers the possibility that such variables do not exist.&lt;/p&gt;
&lt;h1 id="and-more"&gt;And more&amp;hellip;&lt;/h1&gt;
&lt;p&gt;To see the full set of features that Envy already provides, &lt;a href="https://lexi-lambda.github.io/envy/envy.html"&gt;take a look at the documentation&lt;/a&gt;. That said, this is just the first release based on my initial use-cases, but I&amp;rsquo;m sure there are more features Envy could have to accommodate common application configuration patterns. If you have an idea that could make Envy better, &lt;a href="https://github.com/lexi-lambda/envy/issues"&gt;open an issue and make a suggestion&lt;/a&gt;! I already have plans for a &lt;code&gt;#lang envy&lt;/code&gt; DSL, which will hopefully cut the boilerplate out in its entirety.&lt;/p&gt;
&lt;p&gt;And finally, to give credit where credit is due, Envy is heavily inspired by &lt;a href="https://github.com/eval/envied"&gt;Envied&lt;/a&gt; (both in name and function), an environment variable manager for Ruby, which I&amp;rsquo;ve used to great effect.&lt;/p&gt;
&lt;p&gt;Try it out!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;raco pkg install envy&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/envy"&gt;Envy on GitHub&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://lexi-lambda.github.io/envy/envy.html"&gt;Envy documentation&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</description></item></channel></rss>

271
feeds/frog.atom.xml Normal file
View File

@ -0,0 +1,271 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged 'frog'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/frog.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/frog.html" />
<id>urn:http-lexi-lambda-github-io:-tags-frog-html</id>
<updated>2015-07-18T19:09:01Z</updated>
<entry>
<title type="text">Automatically deploying a Frog-powered blog to GitHub pages</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/?utm_source=frog&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-07-18-automatically-deploying-a-frog-powered-blog-to-github-pages</id>
<published>2015-07-18T19:09:01Z</published>
<updated>2015-07-18T19:09:01Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;So, I have a blog now. It&amp;rsquo;s a simple static blog, but what&amp;rsquo;s unique about it is that it&amp;rsquo;s powered by Racket; specifically, it uses &lt;a href="http://www.greghendershott.com"&gt;Greg Hendershott&lt;/a&gt;&amp;rsquo;s fantastic &lt;a href="https://github.com/greghendershott/frog"&gt;Frog&lt;/a&gt; tool. I&amp;rsquo;ve taken this and moulded it to my tastes to build my blog, including configuring automatic deployment via &lt;a href="https://travis-ci.org"&gt;Travis CI&lt;/a&gt;, so my blog is always up-to-date.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="setting-up-frog"&gt;Setting up Frog&lt;/h1&gt;
&lt;p&gt;I should note that Frog itself was wonderfully easy to drop in and get running. Just following the readme, a simple &lt;code&gt;raco pkg install frog&lt;/code&gt; followed by &lt;code&gt;raco frog --init&lt;/code&gt; and &lt;code&gt;raco frog -bp&lt;/code&gt; created a running blog and opened it in my web browser. There was nothing more to it. Once that&amp;rsquo;s done, all it takes to write a blog post is &lt;code&gt;raco frog -n "Post Title"&lt;/code&gt;, and you&amp;rsquo;re good to go.&lt;/p&gt;
&lt;p&gt;By default, Frog uses Bootstrap, which provides a lot of the necessary scaffolding for you, but I opted to roll my own layout using flexbox. I also decided to use &lt;a href="http://sass-lang.com"&gt;Sass&lt;/a&gt; for my stylesheets, potentially with support for &lt;a href="http://coffeescript.org"&gt;CoffeeScript&lt;/a&gt; later, so I wanted to have a good flow for compiling all the resources for deployment. To do that, I used &lt;a href="http://gulpjs.com"&gt;Gulp&lt;/a&gt; in conjunction with &lt;a href="https://www.npmjs.com"&gt;NPM&lt;/a&gt; for build and dependency management.&lt;/p&gt;
&lt;p&gt;Going this route has a few advantages, primarily the fact that updating dependencies becomes much easier, and I can build and deploy my blog with just a couple of commands without needing to commit compiled or minified versions of my sources to version control.&lt;/p&gt;
&lt;h1 id="configuring-automatic-deployment-with-travis"&gt;Configuring automatic deployment with Travis&lt;/h1&gt;
&lt;p&gt;Once Frog itself was configured and my styling was finished, I started looking into how to deploy my blog to a GitHub page without needing to check in any of the generated files to source control. I found a couple of resources, the most useful one being &lt;a href="https://gist.github.com/domenic/ec8b0fc8ab45f39403dd"&gt;this Gist&lt;/a&gt;, which describes how to set up deployment for any project. The basic idea is to create a deployment script which will automatically generate your project, initialize a git repository with the generated files, and push to GitHub&amp;rsquo;s special &lt;code&gt;gh-pages&lt;/code&gt; branch.&lt;/p&gt;
&lt;p&gt;To make this easy, Frog can be configured to output to a separate directory via the &lt;code&gt;.frogrc&lt;/code&gt; configuration file. I chose to output to the &lt;code&gt;out&lt;/code&gt; directory:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;output-dir = out&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;I also configured my Gulp build to output my CSS into the same output directory. Now, all that&amp;rsquo;s necessary in order to deploy the blog to GitHub is to initialize a Git repository in the output directory, and push the files to the remote branch.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ cd out
$ git init
$ git add .
$ git commit -m "Deploy to GitHub Pages"
$ git push --force "$REMOTE_URL" master:gh-pages&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The next step is to configure Travis so that it can securely push to the GitHub repository with the required credentials. This can be done with Travis&amp;rsquo;s &lt;a href="http://docs.travis-ci.com/user/encryption-keys/"&gt;encryption keys&lt;/a&gt; along with a GitHub &lt;a href="https://github.com/settings/tokens"&gt;personal access token&lt;/a&gt;. Just install the Travis CLI client, copy the access token, and run a command:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ gem install travis
$ travis encrypt GH_TOKEN=&amp;lt;access token...&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The output of that command is an encrypted value to be placed in an environment variable in the project&amp;rsquo;s &lt;code&gt;.travis.yml&lt;/code&gt; configuration file. The URL for the repository on GitHub will also need to be specified as well:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/&amp;lt;gh-username&amp;gt;/&amp;lt;gh-repo&amp;gt;.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;encrypted data...&amp;gt;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now all that&amp;rsquo;s left is configuring the &lt;code&gt;.travis.yml&lt;/code&gt; to run Frog. Since Travis doesn&amp;rsquo;t natively support Racket at the time of this writing, the choice of &amp;ldquo;language&amp;rdquo; is somewhat arbitrary, but since I want Pygments installed for syntax highlighting, I set my project type to &lt;code&gt;python&lt;/code&gt;, then installed Racket and Frog as pre-installation steps.&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/&amp;lt;gh-username&amp;gt;/&amp;lt;gh-repo&amp;gt;.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;encrypted data...&amp;gt;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_DIR&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;~/racket&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;6.2&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;before_install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;git clone https://github.com/greghendershott/travis-racket.git&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;cat travis-racket/install-racket.sh | bash&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;export PATH="${RACKET_DIR}/bin:${PATH}"&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;raco pkg install --deps search-auto frog&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;(It might be worth noting that Greg Hendershott &lt;em&gt;also&lt;/em&gt; maintains the repository that contains the above Travis build script!)&lt;/p&gt;
&lt;p&gt;Finally, in my case, I wasn&amp;rsquo;t deploying to a project-specific GitHub page. Instead, I wanted to deploy to my user page, which uses &lt;code&gt;master&lt;/code&gt;, not &lt;code&gt;gh-pages&lt;/code&gt;. Obviously, I didn&amp;rsquo;t want Travis running on my &lt;code&gt;master&lt;/code&gt; branch, since it would be deploying to that, so I added a branch whitelist:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;branches&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;only&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;source&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;All that was left to do was to write up the actual deployment script to be used by Travis. Based on the one provided in the above Gist, mine looked like this:&lt;/p&gt;
&lt;div class="brush: bash"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="ch"&gt;#!/bin/bash&lt;/span&gt;
&lt;span class="nb"&gt;set&lt;/span&gt; -ev &lt;span class="c1"&gt;# exit with nonzero exit code if anything fails&lt;/span&gt;
&lt;span class="c1"&gt;# clear the output directory&lt;/span&gt;
rm -rf out &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nb"&gt;exit&lt;/span&gt; 0&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="c1"&gt;# build the blog files + install pygments for highlighting support&lt;/span&gt;
npm install
npm run build
pip install pygments
raco frog --build
&lt;span class="c1"&gt;# go to the out directory and create a *new* Git repo&lt;/span&gt;
&lt;span class="nb"&gt;cd&lt;/span&gt; out
git init
&lt;span class="c1"&gt;# inside this git repo we&amp;#39;ll pretend to be a new user&lt;/span&gt;
git config user.name &lt;span class="s2"&gt;"Travis CI"&lt;/span&gt;
git config user.email &lt;span class="s2"&gt;"&amp;lt;your@email.here&amp;gt;"&lt;/span&gt;
&lt;span class="c1"&gt;# The first and only commit to this new Git repo contains all the&lt;/span&gt;
&lt;span class="c1"&gt;# files present with the commit message "Deploy to GitHub Pages".&lt;/span&gt;
git add .
git commit -m &lt;span class="s2"&gt;"Deploy to GitHub Pages"&lt;/span&gt;
&lt;span class="c1"&gt;# Force push from the current repo&amp;#39;s master branch to the remote&lt;/span&gt;
&lt;span class="c1"&gt;# repo. (All previous history on the branch will be lost, since we are&lt;/span&gt;
&lt;span class="c1"&gt;# overwriting it.) We redirect any output to /dev/null to hide any sensitive&lt;/span&gt;
&lt;span class="c1"&gt;# credential data that might otherwise be exposed.&lt;/span&gt;
git push --force --quiet &lt;span class="s2"&gt;"https://&lt;/span&gt;&lt;span class="si"&gt;${&lt;/span&gt;&lt;span class="nv"&gt;GH_TOKEN&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;@&lt;/span&gt;&lt;span class="si"&gt;${&lt;/span&gt;&lt;span class="nv"&gt;GH_REF&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; master &amp;gt; /dev/null 2&amp;gt;&lt;span class="p"&gt;&amp;amp;&lt;/span&gt;1
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;For reference, my final &lt;code&gt;.travis.yml&lt;/code&gt; looked like this:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;language&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;python&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;python&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;3.4&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;branches&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;only&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;source&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/lexi-lambda/lexi-lambda.github.io.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;long secure token...&amp;gt;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_DIR&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;~/racket&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;6.2&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;before_install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;git clone https://github.com/greghendershott/travis-racket.git&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;cat travis-racket/install-racket.sh | bash&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;export PATH="${RACKET_DIR}/bin:${PATH}"&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;raco pkg install --deps search-auto frog&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;script&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;bash ./deploy.sh&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;That&amp;rsquo;s it! Now I have a working blog that I can publish just by pushing to the &lt;code&gt;source&lt;/code&gt; branch on GitHub.&lt;/p&gt;&lt;/html&gt;</content></entry></feed>

270
feeds/frog.rss.xml Normal file
View File

@ -0,0 +1,270 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged 'frog'</title>
<description>Alexis King's Blog: Posts tagged 'frog'</description>
<link>http://lexi-lambda.github.io/tags/frog.html</link>
<lastBuildDate>Sat, 18 Jul 2015 19:09:01 UT</lastBuildDate>
<pubDate>Sat, 18 Jul 2015 19:09:01 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>Automatically deploying a Frog-powered blog to GitHub pages</title>
<link>http://lexi-lambda.github.io/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/?utm_source=frog&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-07-18-automatically-deploying-a-frog-powered-blog-to-github-pages</guid>
<pubDate>Sat, 18 Jul 2015 19:09:01 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;So, I have a blog now. It&amp;rsquo;s a simple static blog, but what&amp;rsquo;s unique about it is that it&amp;rsquo;s powered by Racket; specifically, it uses &lt;a href="http://www.greghendershott.com"&gt;Greg Hendershott&lt;/a&gt;&amp;rsquo;s fantastic &lt;a href="https://github.com/greghendershott/frog"&gt;Frog&lt;/a&gt; tool. I&amp;rsquo;ve taken this and moulded it to my tastes to build my blog, including configuring automatic deployment via &lt;a href="https://travis-ci.org"&gt;Travis CI&lt;/a&gt;, so my blog is always up-to-date.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="setting-up-frog"&gt;Setting up Frog&lt;/h1&gt;
&lt;p&gt;I should note that Frog itself was wonderfully easy to drop in and get running. Just following the readme, a simple &lt;code&gt;raco pkg install frog&lt;/code&gt; followed by &lt;code&gt;raco frog --init&lt;/code&gt; and &lt;code&gt;raco frog -bp&lt;/code&gt; created a running blog and opened it in my web browser. There was nothing more to it. Once that&amp;rsquo;s done, all it takes to write a blog post is &lt;code&gt;raco frog -n "Post Title"&lt;/code&gt;, and you&amp;rsquo;re good to go.&lt;/p&gt;
&lt;p&gt;By default, Frog uses Bootstrap, which provides a lot of the necessary scaffolding for you, but I opted to roll my own layout using flexbox. I also decided to use &lt;a href="http://sass-lang.com"&gt;Sass&lt;/a&gt; for my stylesheets, potentially with support for &lt;a href="http://coffeescript.org"&gt;CoffeeScript&lt;/a&gt; later, so I wanted to have a good flow for compiling all the resources for deployment. To do that, I used &lt;a href="http://gulpjs.com"&gt;Gulp&lt;/a&gt; in conjunction with &lt;a href="https://www.npmjs.com"&gt;NPM&lt;/a&gt; for build and dependency management.&lt;/p&gt;
&lt;p&gt;Going this route has a few advantages, primarily the fact that updating dependencies becomes much easier, and I can build and deploy my blog with just a couple of commands without needing to commit compiled or minified versions of my sources to version control.&lt;/p&gt;
&lt;h1 id="configuring-automatic-deployment-with-travis"&gt;Configuring automatic deployment with Travis&lt;/h1&gt;
&lt;p&gt;Once Frog itself was configured and my styling was finished, I started looking into how to deploy my blog to a GitHub page without needing to check in any of the generated files to source control. I found a couple of resources, the most useful one being &lt;a href="https://gist.github.com/domenic/ec8b0fc8ab45f39403dd"&gt;this Gist&lt;/a&gt;, which describes how to set up deployment for any project. The basic idea is to create a deployment script which will automatically generate your project, initialize a git repository with the generated files, and push to GitHub&amp;rsquo;s special &lt;code&gt;gh-pages&lt;/code&gt; branch.&lt;/p&gt;
&lt;p&gt;To make this easy, Frog can be configured to output to a separate directory via the &lt;code&gt;.frogrc&lt;/code&gt; configuration file. I chose to output to the &lt;code&gt;out&lt;/code&gt; directory:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;output-dir = out&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;I also configured my Gulp build to output my CSS into the same output directory. Now, all that&amp;rsquo;s necessary in order to deploy the blog to GitHub is to initialize a Git repository in the output directory, and push the files to the remote branch.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ cd out
$ git init
$ git add .
$ git commit -m "Deploy to GitHub Pages"
$ git push --force "$REMOTE_URL" master:gh-pages&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The next step is to configure Travis so that it can securely push to the GitHub repository with the required credentials. This can be done with Travis&amp;rsquo;s &lt;a href="http://docs.travis-ci.com/user/encryption-keys/"&gt;encryption keys&lt;/a&gt; along with a GitHub &lt;a href="https://github.com/settings/tokens"&gt;personal access token&lt;/a&gt;. Just install the Travis CLI client, copy the access token, and run a command:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ gem install travis
$ travis encrypt GH_TOKEN=&amp;lt;access token...&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The output of that command is an encrypted value to be placed in an environment variable in the project&amp;rsquo;s &lt;code&gt;.travis.yml&lt;/code&gt; configuration file. The URL for the repository on GitHub will also need to be specified as well:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/&amp;lt;gh-username&amp;gt;/&amp;lt;gh-repo&amp;gt;.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;encrypted data...&amp;gt;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now all that&amp;rsquo;s left is configuring the &lt;code&gt;.travis.yml&lt;/code&gt; to run Frog. Since Travis doesn&amp;rsquo;t natively support Racket at the time of this writing, the choice of &amp;ldquo;language&amp;rdquo; is somewhat arbitrary, but since I want Pygments installed for syntax highlighting, I set my project type to &lt;code&gt;python&lt;/code&gt;, then installed Racket and Frog as pre-installation steps.&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/&amp;lt;gh-username&amp;gt;/&amp;lt;gh-repo&amp;gt;.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;encrypted data...&amp;gt;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_DIR&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;~/racket&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;6.2&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;before_install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;git clone https://github.com/greghendershott/travis-racket.git&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;cat travis-racket/install-racket.sh | bash&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;export PATH="${RACKET_DIR}/bin:${PATH}"&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;raco pkg install --deps search-auto frog&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;(It might be worth noting that Greg Hendershott &lt;em&gt;also&lt;/em&gt; maintains the repository that contains the above Travis build script!)&lt;/p&gt;
&lt;p&gt;Finally, in my case, I wasn&amp;rsquo;t deploying to a project-specific GitHub page. Instead, I wanted to deploy to my user page, which uses &lt;code&gt;master&lt;/code&gt;, not &lt;code&gt;gh-pages&lt;/code&gt;. Obviously, I didn&amp;rsquo;t want Travis running on my &lt;code&gt;master&lt;/code&gt; branch, since it would be deploying to that, so I added a branch whitelist:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;branches&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;only&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;source&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;All that was left to do was to write up the actual deployment script to be used by Travis. Based on the one provided in the above Gist, mine looked like this:&lt;/p&gt;
&lt;div class="brush: bash"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="ch"&gt;#!/bin/bash&lt;/span&gt;
&lt;span class="nb"&gt;set&lt;/span&gt; -ev &lt;span class="c1"&gt;# exit with nonzero exit code if anything fails&lt;/span&gt;
&lt;span class="c1"&gt;# clear the output directory&lt;/span&gt;
rm -rf out &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nb"&gt;exit&lt;/span&gt; 0&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="c1"&gt;# build the blog files + install pygments for highlighting support&lt;/span&gt;
npm install
npm run build
pip install pygments
raco frog --build
&lt;span class="c1"&gt;# go to the out directory and create a *new* Git repo&lt;/span&gt;
&lt;span class="nb"&gt;cd&lt;/span&gt; out
git init
&lt;span class="c1"&gt;# inside this git repo we&amp;#39;ll pretend to be a new user&lt;/span&gt;
git config user.name &lt;span class="s2"&gt;"Travis CI"&lt;/span&gt;
git config user.email &lt;span class="s2"&gt;"&amp;lt;your@email.here&amp;gt;"&lt;/span&gt;
&lt;span class="c1"&gt;# The first and only commit to this new Git repo contains all the&lt;/span&gt;
&lt;span class="c1"&gt;# files present with the commit message "Deploy to GitHub Pages".&lt;/span&gt;
git add .
git commit -m &lt;span class="s2"&gt;"Deploy to GitHub Pages"&lt;/span&gt;
&lt;span class="c1"&gt;# Force push from the current repo&amp;#39;s master branch to the remote&lt;/span&gt;
&lt;span class="c1"&gt;# repo. (All previous history on the branch will be lost, since we are&lt;/span&gt;
&lt;span class="c1"&gt;# overwriting it.) We redirect any output to /dev/null to hide any sensitive&lt;/span&gt;
&lt;span class="c1"&gt;# credential data that might otherwise be exposed.&lt;/span&gt;
git push --force --quiet &lt;span class="s2"&gt;"https://&lt;/span&gt;&lt;span class="si"&gt;${&lt;/span&gt;&lt;span class="nv"&gt;GH_TOKEN&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;@&lt;/span&gt;&lt;span class="si"&gt;${&lt;/span&gt;&lt;span class="nv"&gt;GH_REF&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; master &amp;gt; /dev/null 2&amp;gt;&lt;span class="p"&gt;&amp;amp;&lt;/span&gt;1
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;For reference, my final &lt;code&gt;.travis.yml&lt;/code&gt; looked like this:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;language&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;python&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;python&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;3.4&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;branches&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;only&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;source&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/lexi-lambda/lexi-lambda.github.io.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;long secure token...&amp;gt;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_DIR&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;~/racket&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;6.2&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;before_install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;git clone https://github.com/greghendershott/travis-racket.git&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;cat travis-racket/install-racket.sh | bash&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;export PATH="${RACKET_DIR}/bin:${PATH}"&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;raco pkg install --deps search-auto frog&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;script&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;bash ./deploy.sh&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;That&amp;rsquo;s it! Now I have a working blog that I can publish just by pushing to the &lt;code&gt;source&lt;/code&gt; branch on GitHub.&lt;/p&gt;&lt;/html&gt;</description></item></channel></rss>

176
feeds/heroku.atom.xml Normal file
View File

@ -0,0 +1,176 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged 'heroku'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/heroku.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/heroku.html" />
<id>urn:http-lexi-lambda-github-io:-tags-heroku-html</id>
<updated>2015-08-22T14:47:49Z</updated>
<entry>
<title type="text">Deploying Racket applications on Heroku</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/08/22/deploying-racket-applications-on-heroku/?utm_source=heroku&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-08-22-deploying-racket-applications-on-heroku</id>
<published>2015-08-22T14:47:49Z</published>
<updated>2015-08-22T14:47:49Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;&lt;a href="https://www.heroku.com"&gt;Heroku&lt;/a&gt; is a &amp;ldquo;platform as a service&amp;rdquo; that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but Racket is not currently among them. Fortunately, Heroku provides an interface for adding custom build processes for arbitrary types of applications, called “buildpacks”. I&amp;rsquo;ve built one for Racket apps, and with just a little bit of configuration, it’s possible to get a Racket webserver running on Heroku.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="building-the-server"&gt;Building the server&lt;/h1&gt;
&lt;p&gt;Racket&amp;rsquo;s &lt;a href="http://docs.racket-lang.org/web-server/index.html"&gt;web-server&lt;/a&gt; package makes building and running a simple server incredibly easy. Here&amp;rsquo;s all the code we&amp;rsquo;ll need to get going:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kn"&gt;#lang &lt;/span&gt;&lt;span class="nn"&gt;racket&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit"&gt;require&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;web-server/servlet&lt;/span&gt;
&lt;span class="n"&gt;web-server/servlet-env&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;start&lt;/span&gt; &lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;response/xexpr&lt;/span&gt;
&lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;html&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;head&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;title&lt;/span&gt; &lt;span class="s2"&gt;"Racket Heroku App"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;body&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;h1&lt;/span&gt; &lt;span class="s2"&gt;"It works!"&lt;/span&gt;&lt;span class="p"&gt;)))))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt; &lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Running the above file will start up the server on the default port, 8080. When running on Heroku, however, we&amp;rsquo;re required to bind to the port that Heroku provides via the &lt;code&gt;PORT&lt;/code&gt; environment variable. We can access this using the Racket &lt;code&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/code&gt; function.&lt;/p&gt;
&lt;p&gt;Additionally, the Racket web server specifically binds to localhost, but Heroku doesn&amp;rsquo;t allow that restriction, so we need to pass &lt;code&gt;#f&lt;/code&gt; for the &lt;code&gt;#:listen-ip&lt;/code&gt; argument.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit"&gt;if&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/span&gt; &lt;span class="s2"&gt;"PORT"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._string-~3enumber))" style="color: inherit"&gt;string-&amp;gt;number&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/span&gt; &lt;span class="s2"&gt;"PORT"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="mi"&gt;8080&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt;
&lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;
&lt;span class="kd"&gt;#:listen-ip&lt;/span&gt; &lt;span class="no"&gt;#f&lt;/span&gt;
&lt;span class="kd"&gt;#:port&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Also, by default, &lt;code&gt;serve/servlet&lt;/code&gt; will open a web browser automatically when the program is run, which is very useful for rapid prototyping within something like DrRacket, but we&amp;rsquo;ll want to turn that off.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt;
&lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;
&lt;span class="kd"&gt;#:listen-ip&lt;/span&gt; &lt;span class="no"&gt;#f&lt;/span&gt;
&lt;span class="kd"&gt;#:port&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;
&lt;span class="kd"&gt;#:command-line?&lt;/span&gt; &lt;span class="no"&gt;#t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;That&amp;rsquo;s it! Now we have a Racket web server that can run on Heroku. Obviously it&amp;rsquo;s not a very interesting application right now, but that&amp;rsquo;s fine for our purposes.&lt;/p&gt;
&lt;h1 id="setting-up-our-app-for-heroku"&gt;Setting up our app for Heroku&lt;/h1&gt;
&lt;p&gt;The next step is to actually create an app on Heroku. Don&amp;rsquo;t worry—it&amp;rsquo;s free! That said, explaining precisely how Heroku works is outside the scope of this article. Just make an account, then create an app. I called mine &amp;ldquo;racket-heroku-sample&amp;rdquo;. Once you&amp;rsquo;ve created an app and set up Heroku&amp;rsquo;s command-line tool, you can specify the proper buildpack:&lt;/p&gt;
&lt;div class="brush: sh"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;$ git init
$ heroku git:remote -a racket-heroku-sample
$ heroku buildpacks:set https://github.com/lexi-lambda/heroku-buildpack-racket
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We&amp;rsquo;ll also need to pick a particular Racket version before we deploy our app. At the time of this writing, Racket 6.2.1 is the latest version, so I just set the &lt;code&gt;RACKET_VERSION&lt;/code&gt; environment variable as follows:&lt;/p&gt;
&lt;div class="brush: sh"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;$ heroku config:set &lt;span class="nv"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;6.2.1
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now there&amp;rsquo;s just one thing left to do before we can push to Heroku: we need to tell Heroku what command to use to run our application. To do this, we use something called a &amp;ldquo;Procfile&amp;rdquo; that contains information about the process types for our app. Heroku supports multiple processes of different types, but we&amp;rsquo;re just going to have a single web process.&lt;/p&gt;
&lt;p&gt;Specifically, we just want to run our &lt;code&gt;serve.rkt&lt;/code&gt; module. The Racket buildpack installs the repository as a package, so we can run &lt;code&gt;racket&lt;/code&gt; with the &lt;code&gt;-l&lt;/code&gt; flag to specify a module path, which will be more robust than specifying a filesystem path directly. Therefore, our Procfile will look like this:&lt;/p&gt;
&lt;div class="brush: procfile"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;web: racket -l sample-heroku-app/server
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now all that&amp;rsquo;s left to do is push our repository to Heroku&amp;rsquo;s git remote. Once the build completes, we can &lt;a href="https://racket-heroku-sample.herokuapp.com"&gt;navigate to our app&amp;rsquo;s URL and actually see it running live&lt;/a&gt;!&lt;/p&gt;
&lt;h1 id="conclusion"&gt;Conclusion&lt;/h1&gt;
&lt;p&gt;That&amp;rsquo;s all that&amp;rsquo;s needed to get a Racket app up and running on Heroku, but it probably isn&amp;rsquo;t the best way to manage a real application. Usually it&amp;rsquo;s best to use a continuous integration service to automatically deploy certain GitHub branches to Heroku, after running the tests, of course. Also, a real application would obviously be a little more complicated.&lt;/p&gt;
&lt;p&gt;That said, this provides the foundation and shell. If you&amp;rsquo;d like to see the sample app used in this post, you can &lt;a href="https://github.com/lexi-lambda/racket-sample-heroku-app"&gt;find it on GitHub here&lt;/a&gt;. For more details on the buildpack itself, &lt;a href="https://github.com/lexi-lambda/heroku-buildpack-racket"&gt;it&amp;rsquo;s also available on GitHub here&lt;/a&gt;.&lt;/p&gt;&lt;/html&gt;</content></entry></feed>

175
feeds/heroku.rss.xml Normal file
View File

@ -0,0 +1,175 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged 'heroku'</title>
<description>Alexis King's Blog: Posts tagged 'heroku'</description>
<link>http://lexi-lambda.github.io/tags/heroku.html</link>
<lastBuildDate>Sat, 22 Aug 2015 14:47:49 UT</lastBuildDate>
<pubDate>Sat, 22 Aug 2015 14:47:49 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>Deploying Racket applications on Heroku</title>
<link>http://lexi-lambda.github.io/blog/2015/08/22/deploying-racket-applications-on-heroku/?utm_source=heroku&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-08-22-deploying-racket-applications-on-heroku</guid>
<pubDate>Sat, 22 Aug 2015 14:47:49 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;&lt;a href="https://www.heroku.com"&gt;Heroku&lt;/a&gt; is a &amp;ldquo;platform as a service&amp;rdquo; that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but Racket is not currently among them. Fortunately, Heroku provides an interface for adding custom build processes for arbitrary types of applications, called “buildpacks”. I&amp;rsquo;ve built one for Racket apps, and with just a little bit of configuration, it’s possible to get a Racket webserver running on Heroku.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="building-the-server"&gt;Building the server&lt;/h1&gt;
&lt;p&gt;Racket&amp;rsquo;s &lt;a href="http://docs.racket-lang.org/web-server/index.html"&gt;web-server&lt;/a&gt; package makes building and running a simple server incredibly easy. Here&amp;rsquo;s all the code we&amp;rsquo;ll need to get going:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kn"&gt;#lang &lt;/span&gt;&lt;span class="nn"&gt;racket&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/require.html#(form._((lib._racket/private/base..rkt)._require))" style="color: inherit"&gt;require&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;web-server/servlet&lt;/span&gt;
&lt;span class="n"&gt;web-server/servlet-env&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;start&lt;/span&gt; &lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;response/xexpr&lt;/span&gt;
&lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;html&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;head&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;title&lt;/span&gt; &lt;span class="s2"&gt;"Racket Heroku App"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;body&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;h1&lt;/span&gt; &lt;span class="s2"&gt;"It works!"&lt;/span&gt;&lt;span class="p"&gt;)))))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt; &lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Running the above file will start up the server on the default port, 8080. When running on Heroku, however, we&amp;rsquo;re required to bind to the port that Heroku provides via the &lt;code&gt;PORT&lt;/code&gt; environment variable. We can access this using the Racket &lt;code&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/code&gt; function.&lt;/p&gt;
&lt;p&gt;Additionally, the Racket web server specifically binds to localhost, but Heroku doesn&amp;rsquo;t allow that restriction, so we need to pass &lt;code&gt;#f&lt;/code&gt; for the &lt;code&gt;#:listen-ip&lt;/code&gt; argument.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit"&gt;if&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/span&gt; &lt;span class="s2"&gt;"PORT"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._string-~3enumber))" style="color: inherit"&gt;string-&amp;gt;number&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/envvars.html#(def._((lib._racket/private/misc..rkt)._getenv))" style="color: inherit"&gt;getenv&lt;/a&gt;&lt;/span&gt; &lt;span class="s2"&gt;"PORT"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="mi"&gt;8080&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt;
&lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;
&lt;span class="kd"&gt;#:listen-ip&lt;/span&gt; &lt;span class="no"&gt;#f&lt;/span&gt;
&lt;span class="kd"&gt;#:port&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Also, by default, &lt;code&gt;serve/servlet&lt;/code&gt; will open a web browser automatically when the program is run, which is very useful for rapid prototyping within something like DrRacket, but we&amp;rsquo;ll want to turn that off.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;serve/servlet&lt;/span&gt; &lt;span class="n"&gt;start&lt;/span&gt;
&lt;span class="kd"&gt;#:servlet-path&lt;/span&gt; &lt;span class="s2"&gt;"/"&lt;/span&gt;
&lt;span class="kd"&gt;#:listen-ip&lt;/span&gt; &lt;span class="no"&gt;#f&lt;/span&gt;
&lt;span class="kd"&gt;#:port&lt;/span&gt; &lt;span class="n"&gt;port&lt;/span&gt;
&lt;span class="kd"&gt;#:command-line?&lt;/span&gt; &lt;span class="no"&gt;#t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;That&amp;rsquo;s it! Now we have a Racket web server that can run on Heroku. Obviously it&amp;rsquo;s not a very interesting application right now, but that&amp;rsquo;s fine for our purposes.&lt;/p&gt;
&lt;h1 id="setting-up-our-app-for-heroku"&gt;Setting up our app for Heroku&lt;/h1&gt;
&lt;p&gt;The next step is to actually create an app on Heroku. Don&amp;rsquo;t worry—it&amp;rsquo;s free! That said, explaining precisely how Heroku works is outside the scope of this article. Just make an account, then create an app. I called mine &amp;ldquo;racket-heroku-sample&amp;rdquo;. Once you&amp;rsquo;ve created an app and set up Heroku&amp;rsquo;s command-line tool, you can specify the proper buildpack:&lt;/p&gt;
&lt;div class="brush: sh"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;$ git init
$ heroku git:remote -a racket-heroku-sample
$ heroku buildpacks:set https://github.com/lexi-lambda/heroku-buildpack-racket
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We&amp;rsquo;ll also need to pick a particular Racket version before we deploy our app. At the time of this writing, Racket 6.2.1 is the latest version, so I just set the &lt;code&gt;RACKET_VERSION&lt;/code&gt; environment variable as follows:&lt;/p&gt;
&lt;div class="brush: sh"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;$ heroku config:set &lt;span class="nv"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;6.2.1
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now there&amp;rsquo;s just one thing left to do before we can push to Heroku: we need to tell Heroku what command to use to run our application. To do this, we use something called a &amp;ldquo;Procfile&amp;rdquo; that contains information about the process types for our app. Heroku supports multiple processes of different types, but we&amp;rsquo;re just going to have a single web process.&lt;/p&gt;
&lt;p&gt;Specifically, we just want to run our &lt;code&gt;serve.rkt&lt;/code&gt; module. The Racket buildpack installs the repository as a package, so we can run &lt;code&gt;racket&lt;/code&gt; with the &lt;code&gt;-l&lt;/code&gt; flag to specify a module path, which will be more robust than specifying a filesystem path directly. Therefore, our Procfile will look like this:&lt;/p&gt;
&lt;div class="brush: procfile"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;web: racket -l sample-heroku-app/server
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now all that&amp;rsquo;s left to do is push our repository to Heroku&amp;rsquo;s git remote. Once the build completes, we can &lt;a href="https://racket-heroku-sample.herokuapp.com"&gt;navigate to our app&amp;rsquo;s URL and actually see it running live&lt;/a&gt;!&lt;/p&gt;
&lt;h1 id="conclusion"&gt;Conclusion&lt;/h1&gt;
&lt;p&gt;That&amp;rsquo;s all that&amp;rsquo;s needed to get a Racket app up and running on Heroku, but it probably isn&amp;rsquo;t the best way to manage a real application. Usually it&amp;rsquo;s best to use a continuous integration service to automatically deploy certain GitHub branches to Heroku, after running the tests, of course. Also, a real application would obviously be a little more complicated.&lt;/p&gt;
&lt;p&gt;That said, this provides the foundation and shell. If you&amp;rsquo;d like to see the sample app used in this post, you can &lt;a href="https://github.com/lexi-lambda/racket-sample-heroku-app"&gt;find it on GitHub here&lt;/a&gt;. For more details on the buildpack itself, &lt;a href="https://github.com/lexi-lambda/heroku-buildpack-racket"&gt;it&amp;rsquo;s also available on GitHub here&lt;/a&gt;.&lt;/p&gt;&lt;/html&gt;</description></item></channel></rss>

172
feeds/javascript.atom.xml Normal file
View File

@ -0,0 +1,172 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged 'javascript'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/javascript.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/javascript.html" />
<id>urn:http-lexi-lambda-github-io:-tags-javascript-html</id>
<updated>2015-09-23T16:30:12Z</updated>
<entry>
<title type="text">Canonical factories for testing with factory_girl_api</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/?utm_source=javascript&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-09-23-canonical-factories-for-testing-with-factory-girl-api</id>
<published>2015-09-23T16:30:12Z</published>
<updated>2015-09-23T16:30:12Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;Modern web applications are often built as &lt;em&gt;single-page apps&lt;/em&gt;, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&amp;rsquo;t catch the failure. I haven&amp;rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.&lt;/p&gt;
&lt;p&gt;To attempt to address a fraction of this problem, I built &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;, a way to share context setup between both sides of the application.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="a-brief-overview-of-factorygirl"&gt;A brief overview of factory_girl&lt;/h1&gt;
&lt;p&gt;In the land of Ruby and Rails, &lt;a href="https://github.com/thoughtbot/factory_girl"&gt;factory_girl&lt;/a&gt; is a convenient gem for managing factories for models. Out of the box, it integrates with Rails&amp;rsquo; default ORM, ActiveRecord, and provides declarative syntax for describing what attributes factories should initialize. For example, a factory declaration used to create a widget might look like this:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;define&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;factory&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;sequence&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;:name&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Widget #&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nb"&gt;id&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;
&lt;span class="n"&gt;trait&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This makes it easy to create new instances of &lt;code&gt;Widget&lt;/code&gt; and use them for unit tests. For example, this would create and persist a widget with a unique name and a price of 10 units:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We can also create more expensive widgets by using the &lt;code&gt;:expensive&lt;/code&gt; trait.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;expensive_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Any number of traits can be specified at once. Additionally, it is possible to override individual attributes manually.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;fancy_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It works well, and it keeps initialization boilerplate out of individual tests.&lt;/p&gt;
&lt;h1 id="testing-on-the-front-end"&gt;Testing on the front-end&lt;/h1&gt;
&lt;p&gt;Trouble arises when we need to write tests for the JavaScript application that use the same models. Suddenly, we need to duplicate the same kind of logic in our front-end tests. We might start out by setting up object state manually:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="nx"&gt;fancyWidget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
&lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="nx"&gt;price&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Things can quickly get out of hand when models grow complex. Even if we use a factory library in JavaScript, it&amp;rsquo;s possible for our front-end factories to diverge from their back-end counterparts. This means our integration tests will fail, but our unit tests will still blindly pass. Having to duplicate all that logic in two places is dangerous. It would be nice to have a &lt;em&gt;single, canonical source&lt;/em&gt; for all of our factories.&lt;/p&gt;
&lt;h2 id="reusing-server-side-factories-with-factorygirlapi"&gt;Reusing server-side factories with factory_girl_api&lt;/h2&gt;
&lt;p&gt;To help alleviate this problem, I created the &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt; gem for Rails and the &lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt; Bower package for Angular. These packages cooperate with each other to allow server-side factories to be used in JavaScript tests.&lt;/p&gt;
&lt;p&gt;The Angular module provides a service with syntax comparable to factory_girl itself. Both traits and custom attributes are supported:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nx"&gt;FactoryGirl&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;&amp;#39;widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;expensive&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;In this case, however, a round-trip API call must be made to the server in order to call the factory and return the result. Because of this, the Angular version of FactoryGirl returns a promise that is resolved with the serialized version of the model, which can then be used as sample data in unit tests.&lt;/p&gt;
&lt;h2 id="the-problems-with-relying-on-the-server-for-data"&gt;The problems with relying on the server for data&lt;/h2&gt;
&lt;p&gt;In my preliminary use of this tool, it works. In many ways, it&amp;rsquo;s much nicer than duplicating logic in both places. However, I&amp;rsquo;m not &lt;em&gt;completely&lt;/em&gt; convinced it&amp;rsquo;s the right solution yet.&lt;/p&gt;
&lt;p&gt;First of all, it couples the front-end to the back-end, even during unit testing, which is disappointing. It means that a server needs to be running (in test mode) in order for the tests to run at all. For the kinds of projects I work on, this isn&amp;rsquo;t really a bad thing, and the benefits of the reduced duplication far outweigh the downsides.&lt;/p&gt;
&lt;p&gt;My real concern is that this solves a very small facet of the general problem with fragile front-end test suites. Single-page applications usually depend wholly on their integration with back-end APIs. If those APIs change, the tests will continue to happily pass as long as the API is simply mocked, which seems to be the usual solution in the front-end universe. This is, frankly, unacceptable in real application development.&lt;/p&gt;
&lt;h2 id="potential-improvements-and-other-paths-to-success"&gt;Potential improvements and other paths to success&lt;/h2&gt;
&lt;p&gt;I am ultimately unsatisfied with this approach, but writing brittle end-to-end integration tests is not the solution. This &lt;em&gt;kind&lt;/em&gt; of thing may be a step in the right direction: writing tests that aren&amp;rsquo;t really pure unit tests, but also aren&amp;rsquo;t fragile full-stack integration tests. This is a middle-ground that seems infrequently traveled, perhaps due to a lack of tooling (or perhaps because it just doesn&amp;rsquo;t work). I don&amp;rsquo;t know.&lt;/p&gt;
&lt;p&gt;Either way, I&amp;rsquo;m interested in where this is headed, and I&amp;rsquo;ll be curious to see if I run into any roadblocks using the workflow I&amp;rsquo;ve created. If anyone else is interested in playing with these two libraries, the READMEs are much more comprehensive than what I&amp;rsquo;ve covered here. Take a look, and give them a spin!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</content></entry></feed>

171
feeds/javascript.rss.xml Normal file
View File

@ -0,0 +1,171 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged 'javascript'</title>
<description>Alexis King's Blog: Posts tagged 'javascript'</description>
<link>http://lexi-lambda.github.io/tags/javascript.html</link>
<lastBuildDate>Wed, 23 Sep 2015 16:30:12 UT</lastBuildDate>
<pubDate>Wed, 23 Sep 2015 16:30:12 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>Canonical factories for testing with factory_girl_api</title>
<link>http://lexi-lambda.github.io/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/?utm_source=javascript&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-09-23-canonical-factories-for-testing-with-factory-girl-api</guid>
<pubDate>Wed, 23 Sep 2015 16:30:12 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;Modern web applications are often built as &lt;em&gt;single-page apps&lt;/em&gt;, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&amp;rsquo;t catch the failure. I haven&amp;rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.&lt;/p&gt;
&lt;p&gt;To attempt to address a fraction of this problem, I built &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;, a way to share context setup between both sides of the application.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="a-brief-overview-of-factorygirl"&gt;A brief overview of factory_girl&lt;/h1&gt;
&lt;p&gt;In the land of Ruby and Rails, &lt;a href="https://github.com/thoughtbot/factory_girl"&gt;factory_girl&lt;/a&gt; is a convenient gem for managing factories for models. Out of the box, it integrates with Rails&amp;rsquo; default ORM, ActiveRecord, and provides declarative syntax for describing what attributes factories should initialize. For example, a factory declaration used to create a widget might look like this:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;define&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;factory&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;sequence&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;:name&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Widget #&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nb"&gt;id&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;
&lt;span class="n"&gt;trait&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This makes it easy to create new instances of &lt;code&gt;Widget&lt;/code&gt; and use them for unit tests. For example, this would create and persist a widget with a unique name and a price of 10 units:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We can also create more expensive widgets by using the &lt;code&gt;:expensive&lt;/code&gt; trait.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;expensive_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Any number of traits can be specified at once. Additionally, it is possible to override individual attributes manually.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;fancy_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It works well, and it keeps initialization boilerplate out of individual tests.&lt;/p&gt;
&lt;h1 id="testing-on-the-front-end"&gt;Testing on the front-end&lt;/h1&gt;
&lt;p&gt;Trouble arises when we need to write tests for the JavaScript application that use the same models. Suddenly, we need to duplicate the same kind of logic in our front-end tests. We might start out by setting up object state manually:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="nx"&gt;fancyWidget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
&lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="nx"&gt;price&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Things can quickly get out of hand when models grow complex. Even if we use a factory library in JavaScript, it&amp;rsquo;s possible for our front-end factories to diverge from their back-end counterparts. This means our integration tests will fail, but our unit tests will still blindly pass. Having to duplicate all that logic in two places is dangerous. It would be nice to have a &lt;em&gt;single, canonical source&lt;/em&gt; for all of our factories.&lt;/p&gt;
&lt;h2 id="reusing-server-side-factories-with-factorygirlapi"&gt;Reusing server-side factories with factory_girl_api&lt;/h2&gt;
&lt;p&gt;To help alleviate this problem, I created the &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt; gem for Rails and the &lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt; Bower package for Angular. These packages cooperate with each other to allow server-side factories to be used in JavaScript tests.&lt;/p&gt;
&lt;p&gt;The Angular module provides a service with syntax comparable to factory_girl itself. Both traits and custom attributes are supported:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nx"&gt;FactoryGirl&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;&amp;#39;widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;expensive&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;In this case, however, a round-trip API call must be made to the server in order to call the factory and return the result. Because of this, the Angular version of FactoryGirl returns a promise that is resolved with the serialized version of the model, which can then be used as sample data in unit tests.&lt;/p&gt;
&lt;h2 id="the-problems-with-relying-on-the-server-for-data"&gt;The problems with relying on the server for data&lt;/h2&gt;
&lt;p&gt;In my preliminary use of this tool, it works. In many ways, it&amp;rsquo;s much nicer than duplicating logic in both places. However, I&amp;rsquo;m not &lt;em&gt;completely&lt;/em&gt; convinced it&amp;rsquo;s the right solution yet.&lt;/p&gt;
&lt;p&gt;First of all, it couples the front-end to the back-end, even during unit testing, which is disappointing. It means that a server needs to be running (in test mode) in order for the tests to run at all. For the kinds of projects I work on, this isn&amp;rsquo;t really a bad thing, and the benefits of the reduced duplication far outweigh the downsides.&lt;/p&gt;
&lt;p&gt;My real concern is that this solves a very small facet of the general problem with fragile front-end test suites. Single-page applications usually depend wholly on their integration with back-end APIs. If those APIs change, the tests will continue to happily pass as long as the API is simply mocked, which seems to be the usual solution in the front-end universe. This is, frankly, unacceptable in real application development.&lt;/p&gt;
&lt;h2 id="potential-improvements-and-other-paths-to-success"&gt;Potential improvements and other paths to success&lt;/h2&gt;
&lt;p&gt;I am ultimately unsatisfied with this approach, but writing brittle end-to-end integration tests is not the solution. This &lt;em&gt;kind&lt;/em&gt; of thing may be a step in the right direction: writing tests that aren&amp;rsquo;t really pure unit tests, but also aren&amp;rsquo;t fragile full-stack integration tests. This is a middle-ground that seems infrequently traveled, perhaps due to a lack of tooling (or perhaps because it just doesn&amp;rsquo;t work). I don&amp;rsquo;t know.&lt;/p&gt;
&lt;p&gt;Either way, I&amp;rsquo;m interested in where this is headed, and I&amp;rsquo;ll be curious to see if I run into any roadblocks using the workflow I&amp;rsquo;ve created. If anyone else is interested in playing with these two libraries, the READMEs are much more comprehensive than what I&amp;rsquo;ve covered here. Take a look, and give them a spin!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</description></item></channel></rss>

1086
feeds/macros.atom.xml Normal file
View File

File diff suppressed because it is too large Load Diff

1082
feeds/macros.rss.xml Normal file
View File

File diff suppressed because it is too large Load Diff

271
feeds/meta.atom.xml Normal file
View File

@ -0,0 +1,271 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged 'meta'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/meta.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/meta.html" />
<id>urn:http-lexi-lambda-github-io:-tags-meta-html</id>
<updated>2015-07-18T19:09:01Z</updated>
<entry>
<title type="text">Automatically deploying a Frog-powered blog to GitHub pages</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/?utm_source=meta&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-07-18-automatically-deploying-a-frog-powered-blog-to-github-pages</id>
<published>2015-07-18T19:09:01Z</published>
<updated>2015-07-18T19:09:01Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;So, I have a blog now. It&amp;rsquo;s a simple static blog, but what&amp;rsquo;s unique about it is that it&amp;rsquo;s powered by Racket; specifically, it uses &lt;a href="http://www.greghendershott.com"&gt;Greg Hendershott&lt;/a&gt;&amp;rsquo;s fantastic &lt;a href="https://github.com/greghendershott/frog"&gt;Frog&lt;/a&gt; tool. I&amp;rsquo;ve taken this and moulded it to my tastes to build my blog, including configuring automatic deployment via &lt;a href="https://travis-ci.org"&gt;Travis CI&lt;/a&gt;, so my blog is always up-to-date.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="setting-up-frog"&gt;Setting up Frog&lt;/h1&gt;
&lt;p&gt;I should note that Frog itself was wonderfully easy to drop in and get running. Just following the readme, a simple &lt;code&gt;raco pkg install frog&lt;/code&gt; followed by &lt;code&gt;raco frog --init&lt;/code&gt; and &lt;code&gt;raco frog -bp&lt;/code&gt; created a running blog and opened it in my web browser. There was nothing more to it. Once that&amp;rsquo;s done, all it takes to write a blog post is &lt;code&gt;raco frog -n "Post Title"&lt;/code&gt;, and you&amp;rsquo;re good to go.&lt;/p&gt;
&lt;p&gt;By default, Frog uses Bootstrap, which provides a lot of the necessary scaffolding for you, but I opted to roll my own layout using flexbox. I also decided to use &lt;a href="http://sass-lang.com"&gt;Sass&lt;/a&gt; for my stylesheets, potentially with support for &lt;a href="http://coffeescript.org"&gt;CoffeeScript&lt;/a&gt; later, so I wanted to have a good flow for compiling all the resources for deployment. To do that, I used &lt;a href="http://gulpjs.com"&gt;Gulp&lt;/a&gt; in conjunction with &lt;a href="https://www.npmjs.com"&gt;NPM&lt;/a&gt; for build and dependency management.&lt;/p&gt;
&lt;p&gt;Going this route has a few advantages, primarily the fact that updating dependencies becomes much easier, and I can build and deploy my blog with just a couple of commands without needing to commit compiled or minified versions of my sources to version control.&lt;/p&gt;
&lt;h1 id="configuring-automatic-deployment-with-travis"&gt;Configuring automatic deployment with Travis&lt;/h1&gt;
&lt;p&gt;Once Frog itself was configured and my styling was finished, I started looking into how to deploy my blog to a GitHub page without needing to check in any of the generated files to source control. I found a couple of resources, the most useful one being &lt;a href="https://gist.github.com/domenic/ec8b0fc8ab45f39403dd"&gt;this Gist&lt;/a&gt;, which describes how to set up deployment for any project. The basic idea is to create a deployment script which will automatically generate your project, initialize a git repository with the generated files, and push to GitHub&amp;rsquo;s special &lt;code&gt;gh-pages&lt;/code&gt; branch.&lt;/p&gt;
&lt;p&gt;To make this easy, Frog can be configured to output to a separate directory via the &lt;code&gt;.frogrc&lt;/code&gt; configuration file. I chose to output to the &lt;code&gt;out&lt;/code&gt; directory:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;output-dir = out&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;I also configured my Gulp build to output my CSS into the same output directory. Now, all that&amp;rsquo;s necessary in order to deploy the blog to GitHub is to initialize a Git repository in the output directory, and push the files to the remote branch.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ cd out
$ git init
$ git add .
$ git commit -m "Deploy to GitHub Pages"
$ git push --force "$REMOTE_URL" master:gh-pages&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The next step is to configure Travis so that it can securely push to the GitHub repository with the required credentials. This can be done with Travis&amp;rsquo;s &lt;a href="http://docs.travis-ci.com/user/encryption-keys/"&gt;encryption keys&lt;/a&gt; along with a GitHub &lt;a href="https://github.com/settings/tokens"&gt;personal access token&lt;/a&gt;. Just install the Travis CLI client, copy the access token, and run a command:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ gem install travis
$ travis encrypt GH_TOKEN=&amp;lt;access token...&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The output of that command is an encrypted value to be placed in an environment variable in the project&amp;rsquo;s &lt;code&gt;.travis.yml&lt;/code&gt; configuration file. The URL for the repository on GitHub will also need to be specified as well:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/&amp;lt;gh-username&amp;gt;/&amp;lt;gh-repo&amp;gt;.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;encrypted data...&amp;gt;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now all that&amp;rsquo;s left is configuring the &lt;code&gt;.travis.yml&lt;/code&gt; to run Frog. Since Travis doesn&amp;rsquo;t natively support Racket at the time of this writing, the choice of &amp;ldquo;language&amp;rdquo; is somewhat arbitrary, but since I want Pygments installed for syntax highlighting, I set my project type to &lt;code&gt;python&lt;/code&gt;, then installed Racket and Frog as pre-installation steps.&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/&amp;lt;gh-username&amp;gt;/&amp;lt;gh-repo&amp;gt;.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;encrypted data...&amp;gt;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_DIR&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;~/racket&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;6.2&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;before_install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;git clone https://github.com/greghendershott/travis-racket.git&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;cat travis-racket/install-racket.sh | bash&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;export PATH="${RACKET_DIR}/bin:${PATH}"&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;raco pkg install --deps search-auto frog&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;(It might be worth noting that Greg Hendershott &lt;em&gt;also&lt;/em&gt; maintains the repository that contains the above Travis build script!)&lt;/p&gt;
&lt;p&gt;Finally, in my case, I wasn&amp;rsquo;t deploying to a project-specific GitHub page. Instead, I wanted to deploy to my user page, which uses &lt;code&gt;master&lt;/code&gt;, not &lt;code&gt;gh-pages&lt;/code&gt;. Obviously, I didn&amp;rsquo;t want Travis running on my &lt;code&gt;master&lt;/code&gt; branch, since it would be deploying to that, so I added a branch whitelist:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;branches&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;only&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;source&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;All that was left to do was to write up the actual deployment script to be used by Travis. Based on the one provided in the above Gist, mine looked like this:&lt;/p&gt;
&lt;div class="brush: bash"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="ch"&gt;#!/bin/bash&lt;/span&gt;
&lt;span class="nb"&gt;set&lt;/span&gt; -ev &lt;span class="c1"&gt;# exit with nonzero exit code if anything fails&lt;/span&gt;
&lt;span class="c1"&gt;# clear the output directory&lt;/span&gt;
rm -rf out &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nb"&gt;exit&lt;/span&gt; 0&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="c1"&gt;# build the blog files + install pygments for highlighting support&lt;/span&gt;
npm install
npm run build
pip install pygments
raco frog --build
&lt;span class="c1"&gt;# go to the out directory and create a *new* Git repo&lt;/span&gt;
&lt;span class="nb"&gt;cd&lt;/span&gt; out
git init
&lt;span class="c1"&gt;# inside this git repo we&amp;#39;ll pretend to be a new user&lt;/span&gt;
git config user.name &lt;span class="s2"&gt;"Travis CI"&lt;/span&gt;
git config user.email &lt;span class="s2"&gt;"&amp;lt;your@email.here&amp;gt;"&lt;/span&gt;
&lt;span class="c1"&gt;# The first and only commit to this new Git repo contains all the&lt;/span&gt;
&lt;span class="c1"&gt;# files present with the commit message "Deploy to GitHub Pages".&lt;/span&gt;
git add .
git commit -m &lt;span class="s2"&gt;"Deploy to GitHub Pages"&lt;/span&gt;
&lt;span class="c1"&gt;# Force push from the current repo&amp;#39;s master branch to the remote&lt;/span&gt;
&lt;span class="c1"&gt;# repo. (All previous history on the branch will be lost, since we are&lt;/span&gt;
&lt;span class="c1"&gt;# overwriting it.) We redirect any output to /dev/null to hide any sensitive&lt;/span&gt;
&lt;span class="c1"&gt;# credential data that might otherwise be exposed.&lt;/span&gt;
git push --force --quiet &lt;span class="s2"&gt;"https://&lt;/span&gt;&lt;span class="si"&gt;${&lt;/span&gt;&lt;span class="nv"&gt;GH_TOKEN&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;@&lt;/span&gt;&lt;span class="si"&gt;${&lt;/span&gt;&lt;span class="nv"&gt;GH_REF&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; master &amp;gt; /dev/null 2&amp;gt;&lt;span class="p"&gt;&amp;amp;&lt;/span&gt;1
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;For reference, my final &lt;code&gt;.travis.yml&lt;/code&gt; looked like this:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;language&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;python&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;python&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;3.4&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;branches&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;only&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;source&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/lexi-lambda/lexi-lambda.github.io.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;long secure token...&amp;gt;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_DIR&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;~/racket&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;6.2&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;before_install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;git clone https://github.com/greghendershott/travis-racket.git&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;cat travis-racket/install-racket.sh | bash&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;export PATH="${RACKET_DIR}/bin:${PATH}"&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;raco pkg install --deps search-auto frog&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;script&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;bash ./deploy.sh&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;That&amp;rsquo;s it! Now I have a working blog that I can publish just by pushing to the &lt;code&gt;source&lt;/code&gt; branch on GitHub.&lt;/p&gt;&lt;/html&gt;</content></entry></feed>

270
feeds/meta.rss.xml Normal file
View File

@ -0,0 +1,270 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged 'meta'</title>
<description>Alexis King's Blog: Posts tagged 'meta'</description>
<link>http://lexi-lambda.github.io/tags/meta.html</link>
<lastBuildDate>Sat, 18 Jul 2015 19:09:01 UT</lastBuildDate>
<pubDate>Sat, 18 Jul 2015 19:09:01 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>Automatically deploying a Frog-powered blog to GitHub pages</title>
<link>http://lexi-lambda.github.io/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/?utm_source=meta&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-07-18-automatically-deploying-a-frog-powered-blog-to-github-pages</guid>
<pubDate>Sat, 18 Jul 2015 19:09:01 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;So, I have a blog now. It&amp;rsquo;s a simple static blog, but what&amp;rsquo;s unique about it is that it&amp;rsquo;s powered by Racket; specifically, it uses &lt;a href="http://www.greghendershott.com"&gt;Greg Hendershott&lt;/a&gt;&amp;rsquo;s fantastic &lt;a href="https://github.com/greghendershott/frog"&gt;Frog&lt;/a&gt; tool. I&amp;rsquo;ve taken this and moulded it to my tastes to build my blog, including configuring automatic deployment via &lt;a href="https://travis-ci.org"&gt;Travis CI&lt;/a&gt;, so my blog is always up-to-date.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="setting-up-frog"&gt;Setting up Frog&lt;/h1&gt;
&lt;p&gt;I should note that Frog itself was wonderfully easy to drop in and get running. Just following the readme, a simple &lt;code&gt;raco pkg install frog&lt;/code&gt; followed by &lt;code&gt;raco frog --init&lt;/code&gt; and &lt;code&gt;raco frog -bp&lt;/code&gt; created a running blog and opened it in my web browser. There was nothing more to it. Once that&amp;rsquo;s done, all it takes to write a blog post is &lt;code&gt;raco frog -n "Post Title"&lt;/code&gt;, and you&amp;rsquo;re good to go.&lt;/p&gt;
&lt;p&gt;By default, Frog uses Bootstrap, which provides a lot of the necessary scaffolding for you, but I opted to roll my own layout using flexbox. I also decided to use &lt;a href="http://sass-lang.com"&gt;Sass&lt;/a&gt; for my stylesheets, potentially with support for &lt;a href="http://coffeescript.org"&gt;CoffeeScript&lt;/a&gt; later, so I wanted to have a good flow for compiling all the resources for deployment. To do that, I used &lt;a href="http://gulpjs.com"&gt;Gulp&lt;/a&gt; in conjunction with &lt;a href="https://www.npmjs.com"&gt;NPM&lt;/a&gt; for build and dependency management.&lt;/p&gt;
&lt;p&gt;Going this route has a few advantages, primarily the fact that updating dependencies becomes much easier, and I can build and deploy my blog with just a couple of commands without needing to commit compiled or minified versions of my sources to version control.&lt;/p&gt;
&lt;h1 id="configuring-automatic-deployment-with-travis"&gt;Configuring automatic deployment with Travis&lt;/h1&gt;
&lt;p&gt;Once Frog itself was configured and my styling was finished, I started looking into how to deploy my blog to a GitHub page without needing to check in any of the generated files to source control. I found a couple of resources, the most useful one being &lt;a href="https://gist.github.com/domenic/ec8b0fc8ab45f39403dd"&gt;this Gist&lt;/a&gt;, which describes how to set up deployment for any project. The basic idea is to create a deployment script which will automatically generate your project, initialize a git repository with the generated files, and push to GitHub&amp;rsquo;s special &lt;code&gt;gh-pages&lt;/code&gt; branch.&lt;/p&gt;
&lt;p&gt;To make this easy, Frog can be configured to output to a separate directory via the &lt;code&gt;.frogrc&lt;/code&gt; configuration file. I chose to output to the &lt;code&gt;out&lt;/code&gt; directory:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;output-dir = out&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;I also configured my Gulp build to output my CSS into the same output directory. Now, all that&amp;rsquo;s necessary in order to deploy the blog to GitHub is to initialize a Git repository in the output directory, and push the files to the remote branch.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ cd out
$ git init
$ git add .
$ git commit -m "Deploy to GitHub Pages"
$ git push --force "$REMOTE_URL" master:gh-pages&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The next step is to configure Travis so that it can securely push to the GitHub repository with the required credentials. This can be done with Travis&amp;rsquo;s &lt;a href="http://docs.travis-ci.com/user/encryption-keys/"&gt;encryption keys&lt;/a&gt; along with a GitHub &lt;a href="https://github.com/settings/tokens"&gt;personal access token&lt;/a&gt;. Just install the Travis CLI client, copy the access token, and run a command:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ gem install travis
$ travis encrypt GH_TOKEN=&amp;lt;access token...&amp;gt;&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;The output of that command is an encrypted value to be placed in an environment variable in the project&amp;rsquo;s &lt;code&gt;.travis.yml&lt;/code&gt; configuration file. The URL for the repository on GitHub will also need to be specified as well:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/&amp;lt;gh-username&amp;gt;/&amp;lt;gh-repo&amp;gt;.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;encrypted data...&amp;gt;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now all that&amp;rsquo;s left is configuring the &lt;code&gt;.travis.yml&lt;/code&gt; to run Frog. Since Travis doesn&amp;rsquo;t natively support Racket at the time of this writing, the choice of &amp;ldquo;language&amp;rdquo; is somewhat arbitrary, but since I want Pygments installed for syntax highlighting, I set my project type to &lt;code&gt;python&lt;/code&gt;, then installed Racket and Frog as pre-installation steps.&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/&amp;lt;gh-username&amp;gt;/&amp;lt;gh-repo&amp;gt;.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;encrypted data...&amp;gt;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_DIR&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;~/racket&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;6.2&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;before_install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;git clone https://github.com/greghendershott/travis-racket.git&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;cat travis-racket/install-racket.sh | bash&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;export PATH="${RACKET_DIR}/bin:${PATH}"&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;raco pkg install --deps search-auto frog&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;(It might be worth noting that Greg Hendershott &lt;em&gt;also&lt;/em&gt; maintains the repository that contains the above Travis build script!)&lt;/p&gt;
&lt;p&gt;Finally, in my case, I wasn&amp;rsquo;t deploying to a project-specific GitHub page. Instead, I wanted to deploy to my user page, which uses &lt;code&gt;master&lt;/code&gt;, not &lt;code&gt;gh-pages&lt;/code&gt;. Obviously, I didn&amp;rsquo;t want Travis running on my &lt;code&gt;master&lt;/code&gt; branch, since it would be deploying to that, so I added a branch whitelist:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;branches&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;only&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;source&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;All that was left to do was to write up the actual deployment script to be used by Travis. Based on the one provided in the above Gist, mine looked like this:&lt;/p&gt;
&lt;div class="brush: bash"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="ch"&gt;#!/bin/bash&lt;/span&gt;
&lt;span class="nb"&gt;set&lt;/span&gt; -ev &lt;span class="c1"&gt;# exit with nonzero exit code if anything fails&lt;/span&gt;
&lt;span class="c1"&gt;# clear the output directory&lt;/span&gt;
rm -rf out &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nb"&gt;exit&lt;/span&gt; 0&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="c1"&gt;# build the blog files + install pygments for highlighting support&lt;/span&gt;
npm install
npm run build
pip install pygments
raco frog --build
&lt;span class="c1"&gt;# go to the out directory and create a *new* Git repo&lt;/span&gt;
&lt;span class="nb"&gt;cd&lt;/span&gt; out
git init
&lt;span class="c1"&gt;# inside this git repo we&amp;#39;ll pretend to be a new user&lt;/span&gt;
git config user.name &lt;span class="s2"&gt;"Travis CI"&lt;/span&gt;
git config user.email &lt;span class="s2"&gt;"&amp;lt;your@email.here&amp;gt;"&lt;/span&gt;
&lt;span class="c1"&gt;# The first and only commit to this new Git repo contains all the&lt;/span&gt;
&lt;span class="c1"&gt;# files present with the commit message "Deploy to GitHub Pages".&lt;/span&gt;
git add .
git commit -m &lt;span class="s2"&gt;"Deploy to GitHub Pages"&lt;/span&gt;
&lt;span class="c1"&gt;# Force push from the current repo&amp;#39;s master branch to the remote&lt;/span&gt;
&lt;span class="c1"&gt;# repo. (All previous history on the branch will be lost, since we are&lt;/span&gt;
&lt;span class="c1"&gt;# overwriting it.) We redirect any output to /dev/null to hide any sensitive&lt;/span&gt;
&lt;span class="c1"&gt;# credential data that might otherwise be exposed.&lt;/span&gt;
git push --force --quiet &lt;span class="s2"&gt;"https://&lt;/span&gt;&lt;span class="si"&gt;${&lt;/span&gt;&lt;span class="nv"&gt;GH_TOKEN&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;@&lt;/span&gt;&lt;span class="si"&gt;${&lt;/span&gt;&lt;span class="nv"&gt;GH_REF&lt;/span&gt;&lt;span class="si"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;"&lt;/span&gt; master &amp;gt; /dev/null 2&amp;gt;&lt;span class="p"&gt;&amp;amp;&lt;/span&gt;1
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;For reference, my final &lt;code&gt;.travis.yml&lt;/code&gt; looked like this:&lt;/p&gt;
&lt;div class="brush: yaml"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="l l-Scalar l-Scalar-Plain"&gt;language&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;python&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;python&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;3.4&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;branches&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;only&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;source&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;env&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;global&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;GH_REF&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;github.com/lexi-lambda/lexi-lambda.github.io.git&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;secure&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;&amp;lt;long secure token...&amp;gt;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_DIR&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;~/racket&amp;#39;&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;RACKET_VERSION&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="s"&gt;&amp;#39;6.2&amp;#39;&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;before_install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;git clone https://github.com/greghendershott/travis-racket.git&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;cat travis-racket/install-racket.sh | bash&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;export PATH="${RACKET_DIR}/bin:${PATH}"&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;install&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt;
&lt;span class="p p-Indicator"&gt;-&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;raco pkg install --deps search-auto frog&lt;/span&gt;
&lt;span class="l l-Scalar l-Scalar-Plain"&gt;script&lt;/span&gt;&lt;span class="p p-Indicator"&gt;:&lt;/span&gt; &lt;span class="l l-Scalar l-Scalar-Plain"&gt;bash ./deploy.sh&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;That&amp;rsquo;s it! Now I have a working blog that I can publish just by pushing to the &lt;code&gt;source&lt;/code&gt; branch on GitHub.&lt;/p&gt;&lt;/html&gt;</description></item></channel></rss>

1618
feeds/racket.atom.xml Normal file
View File

File diff suppressed because it is too large Load Diff

1605
feeds/racket.rss.xml Normal file
View File

File diff suppressed because it is too large Load Diff

172
feeds/rails.atom.xml Normal file
View File

@ -0,0 +1,172 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged 'rails'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/rails.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/rails.html" />
<id>urn:http-lexi-lambda-github-io:-tags-rails-html</id>
<updated>2015-09-23T16:30:12Z</updated>
<entry>
<title type="text">Canonical factories for testing with factory_girl_api</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/?utm_source=rails&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-09-23-canonical-factories-for-testing-with-factory-girl-api</id>
<published>2015-09-23T16:30:12Z</published>
<updated>2015-09-23T16:30:12Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;Modern web applications are often built as &lt;em&gt;single-page apps&lt;/em&gt;, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&amp;rsquo;t catch the failure. I haven&amp;rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.&lt;/p&gt;
&lt;p&gt;To attempt to address a fraction of this problem, I built &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;, a way to share context setup between both sides of the application.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="a-brief-overview-of-factorygirl"&gt;A brief overview of factory_girl&lt;/h1&gt;
&lt;p&gt;In the land of Ruby and Rails, &lt;a href="https://github.com/thoughtbot/factory_girl"&gt;factory_girl&lt;/a&gt; is a convenient gem for managing factories for models. Out of the box, it integrates with Rails&amp;rsquo; default ORM, ActiveRecord, and provides declarative syntax for describing what attributes factories should initialize. For example, a factory declaration used to create a widget might look like this:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;define&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;factory&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;sequence&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;:name&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Widget #&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nb"&gt;id&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;
&lt;span class="n"&gt;trait&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This makes it easy to create new instances of &lt;code&gt;Widget&lt;/code&gt; and use them for unit tests. For example, this would create and persist a widget with a unique name and a price of 10 units:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We can also create more expensive widgets by using the &lt;code&gt;:expensive&lt;/code&gt; trait.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;expensive_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Any number of traits can be specified at once. Additionally, it is possible to override individual attributes manually.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;fancy_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It works well, and it keeps initialization boilerplate out of individual tests.&lt;/p&gt;
&lt;h1 id="testing-on-the-front-end"&gt;Testing on the front-end&lt;/h1&gt;
&lt;p&gt;Trouble arises when we need to write tests for the JavaScript application that use the same models. Suddenly, we need to duplicate the same kind of logic in our front-end tests. We might start out by setting up object state manually:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="nx"&gt;fancyWidget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
&lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="nx"&gt;price&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Things can quickly get out of hand when models grow complex. Even if we use a factory library in JavaScript, it&amp;rsquo;s possible for our front-end factories to diverge from their back-end counterparts. This means our integration tests will fail, but our unit tests will still blindly pass. Having to duplicate all that logic in two places is dangerous. It would be nice to have a &lt;em&gt;single, canonical source&lt;/em&gt; for all of our factories.&lt;/p&gt;
&lt;h2 id="reusing-server-side-factories-with-factorygirlapi"&gt;Reusing server-side factories with factory_girl_api&lt;/h2&gt;
&lt;p&gt;To help alleviate this problem, I created the &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt; gem for Rails and the &lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt; Bower package for Angular. These packages cooperate with each other to allow server-side factories to be used in JavaScript tests.&lt;/p&gt;
&lt;p&gt;The Angular module provides a service with syntax comparable to factory_girl itself. Both traits and custom attributes are supported:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nx"&gt;FactoryGirl&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;&amp;#39;widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;expensive&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;In this case, however, a round-trip API call must be made to the server in order to call the factory and return the result. Because of this, the Angular version of FactoryGirl returns a promise that is resolved with the serialized version of the model, which can then be used as sample data in unit tests.&lt;/p&gt;
&lt;h2 id="the-problems-with-relying-on-the-server-for-data"&gt;The problems with relying on the server for data&lt;/h2&gt;
&lt;p&gt;In my preliminary use of this tool, it works. In many ways, it&amp;rsquo;s much nicer than duplicating logic in both places. However, I&amp;rsquo;m not &lt;em&gt;completely&lt;/em&gt; convinced it&amp;rsquo;s the right solution yet.&lt;/p&gt;
&lt;p&gt;First of all, it couples the front-end to the back-end, even during unit testing, which is disappointing. It means that a server needs to be running (in test mode) in order for the tests to run at all. For the kinds of projects I work on, this isn&amp;rsquo;t really a bad thing, and the benefits of the reduced duplication far outweigh the downsides.&lt;/p&gt;
&lt;p&gt;My real concern is that this solves a very small facet of the general problem with fragile front-end test suites. Single-page applications usually depend wholly on their integration with back-end APIs. If those APIs change, the tests will continue to happily pass as long as the API is simply mocked, which seems to be the usual solution in the front-end universe. This is, frankly, unacceptable in real application development.&lt;/p&gt;
&lt;h2 id="potential-improvements-and-other-paths-to-success"&gt;Potential improvements and other paths to success&lt;/h2&gt;
&lt;p&gt;I am ultimately unsatisfied with this approach, but writing brittle end-to-end integration tests is not the solution. This &lt;em&gt;kind&lt;/em&gt; of thing may be a step in the right direction: writing tests that aren&amp;rsquo;t really pure unit tests, but also aren&amp;rsquo;t fragile full-stack integration tests. This is a middle-ground that seems infrequently traveled, perhaps due to a lack of tooling (or perhaps because it just doesn&amp;rsquo;t work). I don&amp;rsquo;t know.&lt;/p&gt;
&lt;p&gt;Either way, I&amp;rsquo;m interested in where this is headed, and I&amp;rsquo;ll be curious to see if I run into any roadblocks using the workflow I&amp;rsquo;ve created. If anyone else is interested in playing with these two libraries, the READMEs are much more comprehensive than what I&amp;rsquo;ve covered here. Take a look, and give them a spin!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</content></entry></feed>

171
feeds/rails.rss.xml Normal file
View File

@ -0,0 +1,171 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged 'rails'</title>
<description>Alexis King's Blog: Posts tagged 'rails'</description>
<link>http://lexi-lambda.github.io/tags/rails.html</link>
<lastBuildDate>Wed, 23 Sep 2015 16:30:12 UT</lastBuildDate>
<pubDate>Wed, 23 Sep 2015 16:30:12 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>Canonical factories for testing with factory_girl_api</title>
<link>http://lexi-lambda.github.io/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/?utm_source=rails&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-09-23-canonical-factories-for-testing-with-factory-girl-api</guid>
<pubDate>Wed, 23 Sep 2015 16:30:12 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;Modern web applications are often built as &lt;em&gt;single-page apps&lt;/em&gt;, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&amp;rsquo;t catch the failure. I haven&amp;rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.&lt;/p&gt;
&lt;p&gt;To attempt to address a fraction of this problem, I built &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;, a way to share context setup between both sides of the application.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="a-brief-overview-of-factorygirl"&gt;A brief overview of factory_girl&lt;/h1&gt;
&lt;p&gt;In the land of Ruby and Rails, &lt;a href="https://github.com/thoughtbot/factory_girl"&gt;factory_girl&lt;/a&gt; is a convenient gem for managing factories for models. Out of the box, it integrates with Rails&amp;rsquo; default ORM, ActiveRecord, and provides declarative syntax for describing what attributes factories should initialize. For example, a factory declaration used to create a widget might look like this:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;define&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;factory&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;sequence&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;:name&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Widget #&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nb"&gt;id&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;
&lt;span class="n"&gt;trait&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This makes it easy to create new instances of &lt;code&gt;Widget&lt;/code&gt; and use them for unit tests. For example, this would create and persist a widget with a unique name and a price of 10 units:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We can also create more expensive widgets by using the &lt;code&gt;:expensive&lt;/code&gt; trait.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;expensive_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Any number of traits can be specified at once. Additionally, it is possible to override individual attributes manually.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;fancy_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It works well, and it keeps initialization boilerplate out of individual tests.&lt;/p&gt;
&lt;h1 id="testing-on-the-front-end"&gt;Testing on the front-end&lt;/h1&gt;
&lt;p&gt;Trouble arises when we need to write tests for the JavaScript application that use the same models. Suddenly, we need to duplicate the same kind of logic in our front-end tests. We might start out by setting up object state manually:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="nx"&gt;fancyWidget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
&lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="nx"&gt;price&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Things can quickly get out of hand when models grow complex. Even if we use a factory library in JavaScript, it&amp;rsquo;s possible for our front-end factories to diverge from their back-end counterparts. This means our integration tests will fail, but our unit tests will still blindly pass. Having to duplicate all that logic in two places is dangerous. It would be nice to have a &lt;em&gt;single, canonical source&lt;/em&gt; for all of our factories.&lt;/p&gt;
&lt;h2 id="reusing-server-side-factories-with-factorygirlapi"&gt;Reusing server-side factories with factory_girl_api&lt;/h2&gt;
&lt;p&gt;To help alleviate this problem, I created the &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt; gem for Rails and the &lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt; Bower package for Angular. These packages cooperate with each other to allow server-side factories to be used in JavaScript tests.&lt;/p&gt;
&lt;p&gt;The Angular module provides a service with syntax comparable to factory_girl itself. Both traits and custom attributes are supported:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nx"&gt;FactoryGirl&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;&amp;#39;widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;expensive&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;In this case, however, a round-trip API call must be made to the server in order to call the factory and return the result. Because of this, the Angular version of FactoryGirl returns a promise that is resolved with the serialized version of the model, which can then be used as sample data in unit tests.&lt;/p&gt;
&lt;h2 id="the-problems-with-relying-on-the-server-for-data"&gt;The problems with relying on the server for data&lt;/h2&gt;
&lt;p&gt;In my preliminary use of this tool, it works. In many ways, it&amp;rsquo;s much nicer than duplicating logic in both places. However, I&amp;rsquo;m not &lt;em&gt;completely&lt;/em&gt; convinced it&amp;rsquo;s the right solution yet.&lt;/p&gt;
&lt;p&gt;First of all, it couples the front-end to the back-end, even during unit testing, which is disappointing. It means that a server needs to be running (in test mode) in order for the tests to run at all. For the kinds of projects I work on, this isn&amp;rsquo;t really a bad thing, and the benefits of the reduced duplication far outweigh the downsides.&lt;/p&gt;
&lt;p&gt;My real concern is that this solves a very small facet of the general problem with fragile front-end test suites. Single-page applications usually depend wholly on their integration with back-end APIs. If those APIs change, the tests will continue to happily pass as long as the API is simply mocked, which seems to be the usual solution in the front-end universe. This is, frankly, unacceptable in real application development.&lt;/p&gt;
&lt;h2 id="potential-improvements-and-other-paths-to-success"&gt;Potential improvements and other paths to success&lt;/h2&gt;
&lt;p&gt;I am ultimately unsatisfied with this approach, but writing brittle end-to-end integration tests is not the solution. This &lt;em&gt;kind&lt;/em&gt; of thing may be a step in the right direction: writing tests that aren&amp;rsquo;t really pure unit tests, but also aren&amp;rsquo;t fragile full-stack integration tests. This is a middle-ground that seems infrequently traveled, perhaps due to a lack of tooling (or perhaps because it just doesn&amp;rsquo;t work). I don&amp;rsquo;t know.&lt;/p&gt;
&lt;p&gt;Either way, I&amp;rsquo;m interested in where this is headed, and I&amp;rsquo;ll be curious to see if I run into any roadblocks using the workflow I&amp;rsquo;ve created. If anyone else is interested in playing with these two libraries, the READMEs are much more comprehensive than what I&amp;rsquo;ve covered here. Take a look, and give them a spin!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</description></item></channel></rss>

172
feeds/ruby.atom.xml Normal file
View File

@ -0,0 +1,172 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged 'ruby'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/ruby.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/ruby.html" />
<id>urn:http-lexi-lambda-github-io:-tags-ruby-html</id>
<updated>2015-09-23T16:30:12Z</updated>
<entry>
<title type="text">Canonical factories for testing with factory_girl_api</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/?utm_source=ruby&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-09-23-canonical-factories-for-testing-with-factory-girl-api</id>
<published>2015-09-23T16:30:12Z</published>
<updated>2015-09-23T16:30:12Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;Modern web applications are often built as &lt;em&gt;single-page apps&lt;/em&gt;, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&amp;rsquo;t catch the failure. I haven&amp;rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.&lt;/p&gt;
&lt;p&gt;To attempt to address a fraction of this problem, I built &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;, a way to share context setup between both sides of the application.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="a-brief-overview-of-factorygirl"&gt;A brief overview of factory_girl&lt;/h1&gt;
&lt;p&gt;In the land of Ruby and Rails, &lt;a href="https://github.com/thoughtbot/factory_girl"&gt;factory_girl&lt;/a&gt; is a convenient gem for managing factories for models. Out of the box, it integrates with Rails&amp;rsquo; default ORM, ActiveRecord, and provides declarative syntax for describing what attributes factories should initialize. For example, a factory declaration used to create a widget might look like this:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;define&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;factory&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;sequence&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;:name&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Widget #&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nb"&gt;id&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;
&lt;span class="n"&gt;trait&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This makes it easy to create new instances of &lt;code&gt;Widget&lt;/code&gt; and use them for unit tests. For example, this would create and persist a widget with a unique name and a price of 10 units:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We can also create more expensive widgets by using the &lt;code&gt;:expensive&lt;/code&gt; trait.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;expensive_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Any number of traits can be specified at once. Additionally, it is possible to override individual attributes manually.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;fancy_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It works well, and it keeps initialization boilerplate out of individual tests.&lt;/p&gt;
&lt;h1 id="testing-on-the-front-end"&gt;Testing on the front-end&lt;/h1&gt;
&lt;p&gt;Trouble arises when we need to write tests for the JavaScript application that use the same models. Suddenly, we need to duplicate the same kind of logic in our front-end tests. We might start out by setting up object state manually:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="nx"&gt;fancyWidget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
&lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="nx"&gt;price&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Things can quickly get out of hand when models grow complex. Even if we use a factory library in JavaScript, it&amp;rsquo;s possible for our front-end factories to diverge from their back-end counterparts. This means our integration tests will fail, but our unit tests will still blindly pass. Having to duplicate all that logic in two places is dangerous. It would be nice to have a &lt;em&gt;single, canonical source&lt;/em&gt; for all of our factories.&lt;/p&gt;
&lt;h2 id="reusing-server-side-factories-with-factorygirlapi"&gt;Reusing server-side factories with factory_girl_api&lt;/h2&gt;
&lt;p&gt;To help alleviate this problem, I created the &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt; gem for Rails and the &lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt; Bower package for Angular. These packages cooperate with each other to allow server-side factories to be used in JavaScript tests.&lt;/p&gt;
&lt;p&gt;The Angular module provides a service with syntax comparable to factory_girl itself. Both traits and custom attributes are supported:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nx"&gt;FactoryGirl&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;&amp;#39;widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;expensive&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;In this case, however, a round-trip API call must be made to the server in order to call the factory and return the result. Because of this, the Angular version of FactoryGirl returns a promise that is resolved with the serialized version of the model, which can then be used as sample data in unit tests.&lt;/p&gt;
&lt;h2 id="the-problems-with-relying-on-the-server-for-data"&gt;The problems with relying on the server for data&lt;/h2&gt;
&lt;p&gt;In my preliminary use of this tool, it works. In many ways, it&amp;rsquo;s much nicer than duplicating logic in both places. However, I&amp;rsquo;m not &lt;em&gt;completely&lt;/em&gt; convinced it&amp;rsquo;s the right solution yet.&lt;/p&gt;
&lt;p&gt;First of all, it couples the front-end to the back-end, even during unit testing, which is disappointing. It means that a server needs to be running (in test mode) in order for the tests to run at all. For the kinds of projects I work on, this isn&amp;rsquo;t really a bad thing, and the benefits of the reduced duplication far outweigh the downsides.&lt;/p&gt;
&lt;p&gt;My real concern is that this solves a very small facet of the general problem with fragile front-end test suites. Single-page applications usually depend wholly on their integration with back-end APIs. If those APIs change, the tests will continue to happily pass as long as the API is simply mocked, which seems to be the usual solution in the front-end universe. This is, frankly, unacceptable in real application development.&lt;/p&gt;
&lt;h2 id="potential-improvements-and-other-paths-to-success"&gt;Potential improvements and other paths to success&lt;/h2&gt;
&lt;p&gt;I am ultimately unsatisfied with this approach, but writing brittle end-to-end integration tests is not the solution. This &lt;em&gt;kind&lt;/em&gt; of thing may be a step in the right direction: writing tests that aren&amp;rsquo;t really pure unit tests, but also aren&amp;rsquo;t fragile full-stack integration tests. This is a middle-ground that seems infrequently traveled, perhaps due to a lack of tooling (or perhaps because it just doesn&amp;rsquo;t work). I don&amp;rsquo;t know.&lt;/p&gt;
&lt;p&gt;Either way, I&amp;rsquo;m interested in where this is headed, and I&amp;rsquo;ll be curious to see if I run into any roadblocks using the workflow I&amp;rsquo;ve created. If anyone else is interested in playing with these two libraries, the READMEs are much more comprehensive than what I&amp;rsquo;ve covered here. Take a look, and give them a spin!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</content></entry></feed>

171
feeds/ruby.rss.xml Normal file
View File

@ -0,0 +1,171 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged 'ruby'</title>
<description>Alexis King's Blog: Posts tagged 'ruby'</description>
<link>http://lexi-lambda.github.io/tags/ruby.html</link>
<lastBuildDate>Wed, 23 Sep 2015 16:30:12 UT</lastBuildDate>
<pubDate>Wed, 23 Sep 2015 16:30:12 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>Canonical factories for testing with factory_girl_api</title>
<link>http://lexi-lambda.github.io/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/?utm_source=ruby&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-09-23-canonical-factories-for-testing-with-factory-girl-api</guid>
<pubDate>Wed, 23 Sep 2015 16:30:12 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;Modern web applications are often built as &lt;em&gt;single-page apps&lt;/em&gt;, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&amp;rsquo;t catch the failure. I haven&amp;rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.&lt;/p&gt;
&lt;p&gt;To attempt to address a fraction of this problem, I built &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;, a way to share context setup between both sides of the application.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="a-brief-overview-of-factorygirl"&gt;A brief overview of factory_girl&lt;/h1&gt;
&lt;p&gt;In the land of Ruby and Rails, &lt;a href="https://github.com/thoughtbot/factory_girl"&gt;factory_girl&lt;/a&gt; is a convenient gem for managing factories for models. Out of the box, it integrates with Rails&amp;rsquo; default ORM, ActiveRecord, and provides declarative syntax for describing what attributes factories should initialize. For example, a factory declaration used to create a widget might look like this:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;define&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;factory&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;sequence&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="ss"&gt;:name&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt;&lt;span class="nb"&gt;id&lt;/span&gt;&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Widget #&amp;#39;&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="nb"&gt;id&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;10&lt;/span&gt;
&lt;span class="n"&gt;trait&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;span class="n"&gt;price&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;span class="k"&gt;end&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This makes it easy to create new instances of &lt;code&gt;Widget&lt;/code&gt; and use them for unit tests. For example, this would create and persist a widget with a unique name and a price of 10 units:&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We can also create more expensive widgets by using the &lt;code&gt;:expensive&lt;/code&gt; trait.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;expensive_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Any number of traits can be specified at once. Additionally, it is possible to override individual attributes manually.&lt;/p&gt;
&lt;div class="brush: ruby"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="n"&gt;fancy_widget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="no"&gt;FactoryGirl&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;create&lt;/span&gt; &lt;span class="ss"&gt;:widget&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="ss"&gt;:expensive&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;name&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It works well, and it keeps initialization boilerplate out of individual tests.&lt;/p&gt;
&lt;h1 id="testing-on-the-front-end"&gt;Testing on the front-end&lt;/h1&gt;
&lt;p&gt;Trouble arises when we need to write tests for the JavaScript application that use the same models. Suddenly, we need to duplicate the same kind of logic in our front-end tests. We might start out by setting up object state manually:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="nx"&gt;fancyWidget&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;new&lt;/span&gt; &lt;span class="nx"&gt;Widget&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
&lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="nx"&gt;price&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="mi"&gt;1000&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Things can quickly get out of hand when models grow complex. Even if we use a factory library in JavaScript, it&amp;rsquo;s possible for our front-end factories to diverge from their back-end counterparts. This means our integration tests will fail, but our unit tests will still blindly pass. Having to duplicate all that logic in two places is dangerous. It would be nice to have a &lt;em&gt;single, canonical source&lt;/em&gt; for all of our factories.&lt;/p&gt;
&lt;h2 id="reusing-server-side-factories-with-factorygirlapi"&gt;Reusing server-side factories with factory_girl_api&lt;/h2&gt;
&lt;p&gt;To help alleviate this problem, I created the &lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt; gem for Rails and the &lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt; Bower package for Angular. These packages cooperate with each other to allow server-side factories to be used in JavaScript tests.&lt;/p&gt;
&lt;p&gt;The Angular module provides a service with syntax comparable to factory_girl itself. Both traits and custom attributes are supported:&lt;/p&gt;
&lt;div class="brush: js"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="nx"&gt;FactoryGirl&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;create&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s1"&gt;&amp;#39;widget&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;expensive&amp;#39;&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;name&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt; &lt;span class="s1"&gt;&amp;#39;Fancy Widget&amp;#39;&lt;/span&gt; &lt;span class="p"&gt;});&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;In this case, however, a round-trip API call must be made to the server in order to call the factory and return the result. Because of this, the Angular version of FactoryGirl returns a promise that is resolved with the serialized version of the model, which can then be used as sample data in unit tests.&lt;/p&gt;
&lt;h2 id="the-problems-with-relying-on-the-server-for-data"&gt;The problems with relying on the server for data&lt;/h2&gt;
&lt;p&gt;In my preliminary use of this tool, it works. In many ways, it&amp;rsquo;s much nicer than duplicating logic in both places. However, I&amp;rsquo;m not &lt;em&gt;completely&lt;/em&gt; convinced it&amp;rsquo;s the right solution yet.&lt;/p&gt;
&lt;p&gt;First of all, it couples the front-end to the back-end, even during unit testing, which is disappointing. It means that a server needs to be running (in test mode) in order for the tests to run at all. For the kinds of projects I work on, this isn&amp;rsquo;t really a bad thing, and the benefits of the reduced duplication far outweigh the downsides.&lt;/p&gt;
&lt;p&gt;My real concern is that this solves a very small facet of the general problem with fragile front-end test suites. Single-page applications usually depend wholly on their integration with back-end APIs. If those APIs change, the tests will continue to happily pass as long as the API is simply mocked, which seems to be the usual solution in the front-end universe. This is, frankly, unacceptable in real application development.&lt;/p&gt;
&lt;h2 id="potential-improvements-and-other-paths-to-success"&gt;Potential improvements and other paths to success&lt;/h2&gt;
&lt;p&gt;I am ultimately unsatisfied with this approach, but writing brittle end-to-end integration tests is not the solution. This &lt;em&gt;kind&lt;/em&gt; of thing may be a step in the right direction: writing tests that aren&amp;rsquo;t really pure unit tests, but also aren&amp;rsquo;t fragile full-stack integration tests. This is a middle-ground that seems infrequently traveled, perhaps due to a lack of tooling (or perhaps because it just doesn&amp;rsquo;t work). I don&amp;rsquo;t know.&lt;/p&gt;
&lt;p&gt;Either way, I&amp;rsquo;m interested in where this is headed, and I&amp;rsquo;ll be curious to see if I run into any roadblocks using the workflow I&amp;rsquo;ve created. If anyone else is interested in playing with these two libraries, the READMEs are much more comprehensive than what I&amp;rsquo;ve covered here. Take a look, and give them a spin!&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/factory_girl_api"&gt;factory_girl_api&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/lexi-lambda/angular-factory-girl-api"&gt;angular-factory-girl-api&lt;/a&gt;&lt;/li&gt;&lt;/ul&gt;&lt;/html&gt;</description></item></channel></rss>

632
feeds/typed-racket.atom.xml Normal file
View File

@ -0,0 +1,632 @@
<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xml:lang="en">
<title type="text">Alexis King's Blog: Posts tagged 'typed racket'</title>
<link rel="self" href="http://lexi-lambda.github.io/feeds/typed-racket.atom.xml" />
<link href="http://lexi-lambda.github.io/tags/typed-racket.html" />
<id>urn:http-lexi-lambda-github-io:-tags-typed-racket-html</id>
<updated>2015-12-21T17:57:07Z</updated>
<entry>
<title type="text">ADTs in Typed Racket with macros</title>
<link rel="alternate" href="http://lexi-lambda.github.io/blog/2015/12/21/adts-in-typed-racket-with-macros/?utm_source=typed-racket&amp;utm_medium=Atom" />
<id>urn:http-lexi-lambda-github-io:-blog-2015-12-21-adts-in-typed-racket-with-macros</id>
<published>2015-12-21T17:57:07Z</published>
<updated>2015-12-21T17:57:07Z</updated>
<author>
<name>Alexis King</name></author>
<content type="html">&lt;html&gt;
&lt;p&gt;Macros are one of Racket&amp;rsquo;s flagship features, and its macro system really is state of the art. Of course, it can sometimes be difficult to demonstrate &lt;em&gt;why&lt;/em&gt; macros are so highly esteemed, in part because it can be hard to find self-contained examples of using macros in practice. Of course, one thing that macros are perfect for is filling a &amp;ldquo;hole&amp;rdquo; in the language by introducing a feature a language lacks, and one of those features in Typed Racket is &lt;strong&gt;ADTs&lt;/strong&gt;.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="warning-this-is-not-a-macro-tutorial"&gt;Warning: this is not a macro tutorial&lt;/h1&gt;
&lt;p&gt;First, a disclaimer: this post assumes at least some knowledge of Scheme/Racket macros. Ideally, you would be familiar with Racket itself. But if you aren&amp;rsquo;t, fear not: if you get lost, don&amp;rsquo;t worry. Hold on to the bigger picture, and you&amp;rsquo;ll likely learn more than someone who knows enough to follow all the way through. If you &lt;em&gt;are&lt;/em&gt; interested in learning about macros, I must recommend Greg Hendershott&amp;rsquo;s &lt;a href="http://www.greghendershott.com/fear-of-macros/"&gt;Fear of Macros&lt;/a&gt;. It is good. This is not that.&lt;/p&gt;
&lt;p&gt;Now, with that out of the way, let&amp;rsquo;s get started.&lt;/p&gt;
&lt;h1 id="what-were-building"&gt;What we&amp;rsquo;re building&lt;/h1&gt;
&lt;p&gt;&lt;a href="https://en.wikipedia.org/wiki/Algebraic_data_type"&gt;Algebraic data types&lt;/a&gt;, or &lt;em&gt;ADTs&lt;/em&gt;, are a staple of the ML family of functional programming languages. I won&amp;rsquo;t go into detail here—I want to focus on the implementation—but they&amp;rsquo;re a very descriptive way of modeling data that encourages designing functions in terms of pattern-matching, something that Racket is already good at.&lt;/p&gt;
&lt;p&gt;Racket also already has a facility for creating custom data structures in the form of &lt;em&gt;structs&lt;/em&gt;, which are extremely flexible, but also a little verbose. Racket structs are more powerful than we need, but that means we can implement our ADTs in terms of Racket&amp;rsquo;s struct system.&lt;/p&gt;
&lt;p&gt;With that in mind, what should our syntax look like? Well, let&amp;rsquo;s consider a quintessential example of ADTs: modeling a simple tree. For now, let&amp;rsquo;s just consider a tree of integers. For reference, the Haskell syntax for such a data structure would look like this:&lt;/p&gt;
&lt;div class="brush: haskell"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kr"&gt;data&lt;/span&gt; &lt;span class="kt"&gt;Tree&lt;/span&gt; &lt;span class="ow"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;Empty&lt;/span&gt;
&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="kt"&gt;Leaf&lt;/span&gt; &lt;span class="kt"&gt;Int&lt;/span&gt;
&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="kt"&gt;Node&lt;/span&gt; &lt;span class="kt"&gt;Tree&lt;/span&gt; &lt;span class="kt"&gt;Tree&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This already demonstrates a few of the core things we&amp;rsquo;ll need to build:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Each ADT has a &lt;em&gt;data type&lt;/em&gt;, in this case &lt;code&gt;Tree&lt;/code&gt;. This name only exists in the world of types, it isn&amp;rsquo;t a value.&lt;/li&gt;
&lt;li&gt;Each ADT has various &lt;em&gt;data constructors&lt;/em&gt;, in this case &lt;code&gt;Leaf&lt;/code&gt; and &lt;code&gt;Node&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Each data constructor may accept any number of arguments, each of which have a specific type.&lt;/li&gt;
&lt;li&gt;The types that data constructors may accept include the ADT&amp;rsquo;s datatype itself—that is, definitions can be recursive.&lt;/li&gt;&lt;/ol&gt;
&lt;p&gt;Of course, there&amp;rsquo;s one more important feature we&amp;rsquo;re missing: polymorphism. Our definition of a tree is overly-specific, and really, it should be able to hold any kind of data, not just integers. In Haskell, we can do that by adding a type parameter:&lt;/p&gt;
&lt;div class="brush: haskell"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kr"&gt;data&lt;/span&gt; &lt;span class="kt"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="ow"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;Empty&lt;/span&gt;
&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="kt"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;
&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="kt"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;With this in mind, we can add a fifth and final point to our list:&lt;/p&gt;
&lt;p&gt;
&lt;ol start="5"&gt;
&lt;li&gt;ADTs must be able to be parametrically polymorphic.&lt;/li&gt;&lt;/ol&gt;&lt;/p&gt;
&lt;p&gt;That covers all of our requirements for basic ADTs. Now we&amp;rsquo;re ready to port this idea to Racket.&lt;/p&gt;
&lt;h2 id="describing-adts-in-racket"&gt;Describing ADTs in Racket&lt;/h2&gt;
&lt;p&gt;How should we take the Haskell syntax for an ADT definition and adapt it to Racket&amp;rsquo;s parenthetical s-expressions? By taking some cues from the Haskell implementation, Typed Racket&amp;rsquo;s type syntax, and Racket&amp;rsquo;s naming conventions, a fairly logical syntax emerges:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define-datatype&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;Empty&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This looks pretty good. Just like with the Haskell implementation, &lt;code&gt;Tree&lt;/code&gt; should only exist at the type level, and &lt;code&gt;Empty&lt;/code&gt;, &lt;code&gt;Leaf&lt;/code&gt;, and &lt;code&gt;Node&lt;/code&gt; should be constructor functions. Our syntax mirrors Racket function application, too—the proper way to create a leaf would be &lt;code&gt;(Leaf 7)&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Now that we can create ADT values, how should we extract the values from them? Well, just like in ML-likes, we can use pattern-matching. We don&amp;rsquo;t need to reinvent the wheel for this one; we should be able to just use Racket&amp;rsquo;s &lt;code&gt;&lt;a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit"&gt;match&lt;/a&gt;&lt;/code&gt; with our datatypes. For example, a function that sums all the values in a tree might look like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;tree-sum&lt;/span&gt; &lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Integer))" style="color: inherit"&gt;Integer&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit"&gt;-&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Integer))" style="color: inherit"&gt;Integer&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tree-sum&lt;/span&gt; &lt;span class="n"&gt;tree&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit"&gt;match&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;tree&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Empty&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="n"&gt;l&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._+))" style="color: inherit"&gt;+&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tree-sum&lt;/span&gt; &lt;span class="n"&gt;l&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tree-sum&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;))]))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Given that Racket&amp;rsquo;s &lt;code&gt;struct&lt;/code&gt; form automatically produces identifiers that cooperate with &lt;code&gt;match&lt;/code&gt;, this shouldn&amp;rsquo;t be hard at all. And with our syntax settled, we&amp;rsquo;re ready to begin implementation.&lt;/p&gt;
&lt;h1 id="implementing-adts-as-syntax"&gt;Implementing ADTs as syntax&lt;/h1&gt;
&lt;p&gt;Now for the fun part. To implement our ADT syntax, we&amp;rsquo;ll employ Racket&amp;rsquo;s industrial-strength macro DSL, &lt;a href="http://docs.racket-lang.org/syntax/stxparse.html"&gt;&lt;code&gt;syntax/parse&lt;/code&gt;&lt;/a&gt;. The &lt;code&gt;syntax/parse&lt;/code&gt; library works like the traditional Scheme &lt;code&gt;syntax-case&lt;/code&gt; on steroids, and one of the most useful features is the ability to define &amp;ldquo;syntax classes&amp;rdquo; that encapsulate reusable parsing rules into declarative components.&lt;/p&gt;
&lt;p&gt;Since this is not a macro tutorial, the following implementation assumes you already know how to use &lt;code&gt;syntax/parse&lt;/code&gt;. However, all of the concepts here are well within the reaches of any intermediate macrologist, so don&amp;rsquo;t be intimidated by some of the more complex topics at play.&lt;/p&gt;
&lt;h2 id="parsing-types-with-a-syntax-class"&gt;Parsing types with a syntax class&lt;/h2&gt;
&lt;p&gt;To implement ADTs, we&amp;rsquo;re going to want to define exactly one syntax class, a class that describes the grammar for a type. As we&amp;rsquo;ve seen, types can be bare identifiers, like &lt;code&gt;Tree&lt;/code&gt;, or they can be identifiers with parameters, like &lt;code&gt;(Tree a)&lt;/code&gt;. We&amp;rsquo;ll want to cover both cases.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit"&gt;begin-for-syntax&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit"&gt;define-syntax-class&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;name:id&lt;/span&gt; &lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name:id&lt;/span&gt; &lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit"&gt;...+&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This syntax class has two rules, one that&amp;rsquo;s a bare identifier, and one that&amp;rsquo;s a list. The ellipsis followed by a plus (&lt;code&gt;...+&lt;/code&gt;) in the second example means &amp;ldquo;one or more&amp;rdquo;, so parsing those parameters will automatically be handled for us. In the bare identifier example, we use &lt;code&gt;#:attr&lt;/code&gt; to give the &lt;code&gt;param&lt;/code&gt; attribute the default value of an empty list, so this syntax class will actually &lt;em&gt;normalize&lt;/em&gt; the input we get in addition to actually parsing it.&lt;/p&gt;
&lt;h2 id="a-first-attempt-at-define-datatype"&gt;A first attempt at &lt;code&gt;define-datatype&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;Now we can move on to actually implementing &lt;code&gt;define-datatype&lt;/code&gt;. The rules are simple: we need to generate a structure type for each one of the data constructors, and we need to generate a type definition for the parent type itself. This is pretty simple to implement using &lt;code&gt;syntax-parser&lt;/code&gt;, which actually does the parsing for our macro.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit"&gt;define-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;define-datatype&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit"&gt;syntax-parser&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit"&gt;_&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type-name:type&lt;/span&gt; &lt;span class="n"&gt;data-constructor:type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;]))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This definition will do all the parsing we need. It parses the entire macro &amp;ldquo;invocation&amp;rdquo;, ignoring the first datum with &lt;code&gt;_&lt;/code&gt; (which will just be the identifier &lt;code&gt;define-datatype&lt;/code&gt;), then expecting a &lt;code&gt;type-name&lt;/code&gt;, which uses the &lt;code&gt;type&lt;/code&gt; syntax class we defined above. Next, we expect zero or more &lt;code&gt;data-constructor&lt;/code&gt;s, which also use the &lt;code&gt;type&lt;/code&gt; syntax class. That&amp;rsquo;s all we have to do for parsing. We now have all the information we need to actually output the expansion for the macro.&lt;/p&gt;
&lt;p&gt;Of course, it won&amp;rsquo;t be that easy: this is the difficult part. The first step is to generate a Racket struct for each data constructor. We can do this pretty easily with some simple use of Racket&amp;rsquo;s syntax templating facility. A naïve attempt would look like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit"&gt;define-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;define-datatype&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit"&gt;syntax-parser&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit"&gt;_&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type-name:type&lt;/span&gt; &lt;span class="n"&gt;data-constructor:type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit"&gt;begin&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit"&gt;struct&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.name&lt;/span&gt; &lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.param&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))]))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This is actually really close to being correct. This will generate a struct definition for each &lt;code&gt;data-constructor&lt;/code&gt;, where each struct has the name of the data constructor and the same number of fields as arguments provided. The trouble is that in Racket structs, all of the fields have &lt;em&gt;names&lt;/em&gt;, but in our ADTs, all the fields are anonymous and by-position. Currently, we&amp;rsquo;re just using the same name for &lt;em&gt;all&lt;/em&gt; the fields, &lt;code&gt;f&lt;/code&gt;, so if any data constructor has two or more fields, we&amp;rsquo;ll get an error.&lt;/p&gt;
&lt;p&gt;Since we don&amp;rsquo;t care about the field names, what we want to do is just generate random names for every field. To do this, we can use a Racket function called &lt;code&gt;generate-temporary&lt;/code&gt;, which generates random identifiers. Our next attempt might look like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="o"&gt;#`&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit"&gt;begin&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit"&gt;struct&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.name&lt;/span&gt;
&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="o"&gt;#,&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/reference/syntax-util.html#(def._((lib._racket/syntax..rkt)._generate-temporary))" style="color: inherit"&gt;generate-temporary&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.param&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;The &lt;code&gt;#,&lt;/code&gt; lets us &amp;ldquo;escape&amp;rdquo; from the template to execute &lt;code&gt;(generate-temporary)&lt;/code&gt; and interpolate its result into the syntax. Unfortunately, this doesn&amp;rsquo;t work. We &lt;em&gt;do&lt;/em&gt; generate a random field name, but the ellipsis will re-use the same generated value when it repeats the fields, rendering our whole effort pointless. We need to generate the field names once per type.&lt;/p&gt;
&lt;h2 id="more-leveraging-syntax-classes"&gt;More leveraging syntax classes&lt;/h2&gt;
&lt;p&gt;As it turns out, this is &lt;em&gt;also&lt;/em&gt; easy to do with syntax classes. We can add an extra attribute to our &lt;code&gt;type&lt;/code&gt; syntax class to generate a random identifier with each one. Again, we can use &lt;code&gt;#:attr&lt;/code&gt; to do that automatically. Our new definition for &lt;code&gt;type&lt;/code&gt; will look like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit"&gt;begin-for-syntax&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit"&gt;define-syntax-class&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;name:id&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;field-id&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name:id&lt;/span&gt; &lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit"&gt;...+&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;field-id&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/stxops.html#(def._((lib._racket/private/stxcase-scheme..rkt)._generate-temporaries))" style="color: inherit"&gt;generate-temporaries&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)))))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Here we&amp;rsquo;re using &lt;code&gt;generate-temporaries&lt;/code&gt; instead of &lt;code&gt;generate-temporary&lt;/code&gt;, which will conveniently generate a new identifier for each of the elements in the list we provide it. This way, we&amp;rsquo;ll get a fresh identifier for each &lt;code&gt;param&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;We can now fix our macro to use this &lt;code&gt;field-id&lt;/code&gt; attribute instead of the static field name:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit"&gt;begin&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit"&gt;struct&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.name&lt;/span&gt;
&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;data-constructor.field-id&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.param&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;h2 id="creating-the-supertype"&gt;Creating the supertype&lt;/h2&gt;
&lt;p&gt;We&amp;rsquo;re almost done—now we just need to implement our overall type, the one defined by &lt;code&gt;type-name&lt;/code&gt;. This is implemented as a trivial type alias, but we need to ensure that polymorphic types are properly handled. For example, a non-polymorphic type would need to be handled like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit"&gt;define-type&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit"&gt;U&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;Empty&lt;/span&gt; &lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;Node&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;However, a polymorphic type alias would need to include the type parameters in each subtype, like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit"&gt;define-type&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit"&gt;U&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Empty&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;How can we do this? Well, so far, we&amp;rsquo;ve been very declarative by using syntax patterns, templates, and classes. However, this is a more pernicious problem to solve with our declarative tools. Fortunately, it&amp;rsquo;s very easy to fall back to using &lt;strong&gt;procedural macros&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;To build each properly-instantiated type, we&amp;rsquo;ll use a combination of &lt;code&gt;define/with-syntax&lt;/code&gt; and Racket&amp;rsquo;s list comprehensions, &lt;code&gt;for/list&lt;/code&gt;. The &lt;code&gt;define/with-syntax&lt;/code&gt; form binds values to pattern identifiers, which can be used within syntax patterns just like the ones bound by &lt;code&gt;syntax-parser&lt;/code&gt;. This will allow us to break up our result into multiple steps. Technically, &lt;code&gt;define/with-syntax&lt;/code&gt; is not strictly necessary—we could just use &lt;code&gt;#`&lt;/code&gt; and &lt;code&gt;#,&lt;/code&gt;—but it&amp;rsquo;s cleaner to work with.&lt;/p&gt;
&lt;p&gt;We&amp;rsquo;ll start by defining a set of instantiated data constructor types, one per &lt;code&gt;data-constructor&lt;/code&gt;:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit"&gt;define/with-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;data-type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit"&gt;for/list&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit"&gt;in-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data-constructor.name&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))])&lt;/span&gt;
&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now we can fill in the body with any code we&amp;rsquo;d like, so long as each body returns a syntax object. We can use some trivial branching logic to determine which form we need:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit"&gt;define/with-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;data-type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit"&gt;for/list&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit"&gt;in-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data-constructor.name&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))])&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit"&gt;if&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/syntax-helpers.html#(def._((lib._syntax/stx..rkt)._stx-null~3f))" style="color: inherit"&gt;stx-null?&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="n"&gt;name&lt;/span&gt;
&lt;span class="o"&gt;#`&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;#,&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now with our definition for &lt;code&gt;data-type&lt;/code&gt;, we can implement our type alias for the supertype extremely easily:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit"&gt;define-type&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type-name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit"&gt;U&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;h2 id="putting-it-all-together"&gt;Putting it all together&lt;/h2&gt;
&lt;p&gt;There&amp;rsquo;s just one more thing to do before we can call this macro finished: we need to ensure that all the type parameters defined by &lt;code&gt;type-name&lt;/code&gt; are in scope for each data constructor&amp;rsquo;s structure definition. We can do this by making use of &lt;code&gt;type-name.param&lt;/code&gt; within each produced struct definition, resulting in this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit"&gt;begin&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit"&gt;struct&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;data-constructor.field-id&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.param&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;And we&amp;rsquo;re done! The final macro, now completed, looks like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit"&gt;begin-for-syntax&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit"&gt;define-syntax-class&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;name:id&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;field-id&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name:id&lt;/span&gt; &lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit"&gt;...+&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;field-id&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/stxops.html#(def._((lib._racket/private/stxcase-scheme..rkt)._generate-temporaries))" style="color: inherit"&gt;generate-temporaries&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)))))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit"&gt;define-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;define-datatype&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit"&gt;syntax-parser&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit"&gt;_&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type-name:type&lt;/span&gt; &lt;span class="n"&gt;data-constructor:type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit"&gt;define/with-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;data-type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit"&gt;for/list&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit"&gt;in-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data-constructor.name&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))])&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit"&gt;if&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/syntax-helpers.html#(def._((lib._syntax/stx..rkt)._stx-null~3f))" style="color: inherit"&gt;stx-null?&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="n"&gt;name&lt;/span&gt;
&lt;span class="o"&gt;#`&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;#,&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))))&lt;/span&gt;
&lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit"&gt;begin&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit"&gt;struct&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;data-constructor.name&lt;/span&gt;
&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;data-constructor.field-id&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.param&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit"&gt;define-type&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type-name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit"&gt;U&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)))]))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It&amp;rsquo;s a little bit dense, certainly, but it is not as complicated or scary as it might seem. It&amp;rsquo;s a simple, mostly declarative, powerful way to transform a DSL into ordinary Typed Racket syntax, and now all we have to do is put it to use.&lt;/p&gt;
&lt;h1 id="using-our-adts"&gt;Using our ADTs&lt;/h1&gt;
&lt;p&gt;With the macro built, we can now actually use our ADTs using the syntax we described! The following is now &lt;em&gt;valid code&lt;/em&gt;:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7
8&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define-datatype&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;Empty&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._~3e))" style="color: inherit"&gt;&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Empty&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="mi"&gt;7&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._-))" style="color: inherit"&gt;-&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Positive-.Byte))" style="color: inherit"&gt;Positive-Byte&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Empty&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="mi"&gt;7&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We can use this to define common data types, such as Haskell&amp;rsquo;s &lt;code&gt;Maybe&lt;/code&gt;:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define-datatype&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Maybe&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Just&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit"&gt;Nothing&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;maybe-default&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.All))" style="color: inherit"&gt;All&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Maybe&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit"&gt;-&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;maybe-default&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit"&gt;match&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Just&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit"&gt;Nothing&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;]))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;maybe-then&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.All))" style="color: inherit"&gt;All&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Maybe&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit"&gt;-&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Maybe&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit"&gt;-&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Maybe&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;maybe-then&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit"&gt;match&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Just&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit"&gt;Nothing&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit"&gt;Nothing&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)]))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;And of course, we can also use it to define ADTs that use concrete types rather that type parameters, if we so desire. This implements a small mathematical language, along with a trivial interpreter:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define-datatype&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Number))" style="color: inherit"&gt;Number&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Add&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Subtract&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Multiply&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Divide&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Expr&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit"&gt;-&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Number))" style="color: inherit"&gt;Number&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit"&gt;match&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Add&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._+))" style="color: inherit"&gt;+&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;))]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Subtract&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._-))" style="color: inherit"&gt;-&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;))]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Multiply&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit"&gt;*&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;))]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Divide&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._/))" style="color: inherit"&gt;/&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;))]))&lt;/span&gt;
&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._~3e))" style="color: inherit"&gt;&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Add&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Multiply&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Divide&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="mi"&gt;7&lt;/span&gt;&lt;span class="p"&gt;))))&lt;/span&gt;
&lt;span class="mi"&gt;4&lt;/span&gt; &lt;span class="m"&gt;1/2&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;There&amp;rsquo;s all the power of ADTs, right in Racket, all implemented in 22 lines of code. If you&amp;rsquo;d like to see all the code together in a runnable form, &lt;a href="https://gist.github.com/lexi-lambda/18cf7a9156f743a1317e"&gt;I&amp;rsquo;ve put together a gist here&lt;/a&gt;.&lt;/p&gt;
&lt;h1 id="conclusions-and-credit"&gt;Conclusions and credit&lt;/h1&gt;
&lt;p&gt;This isn&amp;rsquo;t the simplest macro to create, nor is it the most complex. The code examples might not even make much sense until you try it out yourself. Macros, like any difficult concept, are not always easy to pick up, but they certainly &lt;em&gt;are&lt;/em&gt; powerful. The ability to extend the language in such a way, in the matter of minutes, is unparalleled in languages other than Lisp.&lt;/p&gt;
&lt;p&gt;This is, of course, a blessing and a curse. Lisps reject some of the syntactic landmarks that often aid in readability for the power to abstract programs into their bare components. In the end, is this uniform conciseness more or less readable? That&amp;rsquo;s an incredibly subjective question, one that has prompted powerfully impassioned discussions, and I will not attempt to argue one way or the other here.&lt;/p&gt;
&lt;p&gt;That said, I think it&amp;rsquo;s pretty cool.&lt;/p&gt;
&lt;p&gt;Finally, I must give credit where credit is due. Thanks to &lt;a href="http://andmkent.com"&gt;Andrew M. Kent&lt;/a&gt; for the creation of the &lt;a href="https://github.com/andmkent/datatype"&gt;datatype&lt;/a&gt; package, which served as the inspiration for this blog post. Many thanks to &lt;a href="http://www.ccs.neu.edu/home/samth/"&gt;Sam Tobin-Hochstadt&lt;/a&gt; for his work creating Typed Racket, as well as helping me dramatically simplify the implementation used in this blog post. Also thanks to &lt;a href="http://www.ccs.neu.edu/home/ryanc/"&gt;Ryan Culpepper&lt;/a&gt; and &lt;a href="http://www.ccs.neu.edu/home/matthias/"&gt;Matthias Felleisen&lt;/a&gt; for their work on creating &lt;code&gt;syntax/parse&lt;/code&gt;, which is truly a marvelous tool for exploring the world of macros, and, of course, a big thanks to &lt;a href="http://www.cs.utah.edu/~mflatt/"&gt;Matthew Flatt&lt;/a&gt; for his implementation of hygiene in Racket, as well as much of the rest of Racket itself. Not to mention the entire legacy of those who formulated the foundations of the Scheme macro system and created the framework for all of this to be possible so many decades later.&lt;/p&gt;
&lt;p&gt;Truly, working in Racket feels like standing on the shoulders of giants. If you&amp;rsquo;re intrigued, give it a shot. It&amp;rsquo;s a fun feeling.&lt;/p&gt;&lt;/html&gt;</content></entry></feed>

631
feeds/typed-racket.rss.xml Normal file
View File

@ -0,0 +1,631 @@
<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Alexis King's Blog: Posts tagged 'typed racket'</title>
<description>Alexis King's Blog: Posts tagged 'typed racket'</description>
<link>http://lexi-lambda.github.io/tags/typed-racket.html</link>
<lastBuildDate>Mon, 21 Dec 2015 17:57:07 UT</lastBuildDate>
<pubDate>Mon, 21 Dec 2015 17:57:07 UT</pubDate>
<ttl>1800</ttl>
<item>
<title>ADTs in Typed Racket with macros</title>
<link>http://lexi-lambda.github.io/blog/2015/12/21/adts-in-typed-racket-with-macros/?utm_source=typed-racket&amp;utm_medium=RSS</link>
<guid>urn:http-lexi-lambda-github-io:-blog-2015-12-21-adts-in-typed-racket-with-macros</guid>
<pubDate>Mon, 21 Dec 2015 17:57:07 UT</pubDate>
<description>&lt;html&gt;
&lt;p&gt;Macros are one of Racket&amp;rsquo;s flagship features, and its macro system really is state of the art. Of course, it can sometimes be difficult to demonstrate &lt;em&gt;why&lt;/em&gt; macros are so highly esteemed, in part because it can be hard to find self-contained examples of using macros in practice. Of course, one thing that macros are perfect for is filling a &amp;ldquo;hole&amp;rdquo; in the language by introducing a feature a language lacks, and one of those features in Typed Racket is &lt;strong&gt;ADTs&lt;/strong&gt;.&lt;/p&gt;
&lt;!-- more--&gt;
&lt;h1 id="warning-this-is-not-a-macro-tutorial"&gt;Warning: this is not a macro tutorial&lt;/h1&gt;
&lt;p&gt;First, a disclaimer: this post assumes at least some knowledge of Scheme/Racket macros. Ideally, you would be familiar with Racket itself. But if you aren&amp;rsquo;t, fear not: if you get lost, don&amp;rsquo;t worry. Hold on to the bigger picture, and you&amp;rsquo;ll likely learn more than someone who knows enough to follow all the way through. If you &lt;em&gt;are&lt;/em&gt; interested in learning about macros, I must recommend Greg Hendershott&amp;rsquo;s &lt;a href="http://www.greghendershott.com/fear-of-macros/"&gt;Fear of Macros&lt;/a&gt;. It is good. This is not that.&lt;/p&gt;
&lt;p&gt;Now, with that out of the way, let&amp;rsquo;s get started.&lt;/p&gt;
&lt;h1 id="what-were-building"&gt;What we&amp;rsquo;re building&lt;/h1&gt;
&lt;p&gt;&lt;a href="https://en.wikipedia.org/wiki/Algebraic_data_type"&gt;Algebraic data types&lt;/a&gt;, or &lt;em&gt;ADTs&lt;/em&gt;, are a staple of the ML family of functional programming languages. I won&amp;rsquo;t go into detail here—I want to focus on the implementation—but they&amp;rsquo;re a very descriptive way of modeling data that encourages designing functions in terms of pattern-matching, something that Racket is already good at.&lt;/p&gt;
&lt;p&gt;Racket also already has a facility for creating custom data structures in the form of &lt;em&gt;structs&lt;/em&gt;, which are extremely flexible, but also a little verbose. Racket structs are more powerful than we need, but that means we can implement our ADTs in terms of Racket&amp;rsquo;s struct system.&lt;/p&gt;
&lt;p&gt;With that in mind, what should our syntax look like? Well, let&amp;rsquo;s consider a quintessential example of ADTs: modeling a simple tree. For now, let&amp;rsquo;s just consider a tree of integers. For reference, the Haskell syntax for such a data structure would look like this:&lt;/p&gt;
&lt;div class="brush: haskell"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kr"&gt;data&lt;/span&gt; &lt;span class="kt"&gt;Tree&lt;/span&gt; &lt;span class="ow"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;Empty&lt;/span&gt;
&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="kt"&gt;Leaf&lt;/span&gt; &lt;span class="kt"&gt;Int&lt;/span&gt;
&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="kt"&gt;Node&lt;/span&gt; &lt;span class="kt"&gt;Tree&lt;/span&gt; &lt;span class="kt"&gt;Tree&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This already demonstrates a few of the core things we&amp;rsquo;ll need to build:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Each ADT has a &lt;em&gt;data type&lt;/em&gt;, in this case &lt;code&gt;Tree&lt;/code&gt;. This name only exists in the world of types, it isn&amp;rsquo;t a value.&lt;/li&gt;
&lt;li&gt;Each ADT has various &lt;em&gt;data constructors&lt;/em&gt;, in this case &lt;code&gt;Leaf&lt;/code&gt; and &lt;code&gt;Node&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Each data constructor may accept any number of arguments, each of which have a specific type.&lt;/li&gt;
&lt;li&gt;The types that data constructors may accept include the ADT&amp;rsquo;s datatype itself—that is, definitions can be recursive.&lt;/li&gt;&lt;/ol&gt;
&lt;p&gt;Of course, there&amp;rsquo;s one more important feature we&amp;rsquo;re missing: polymorphism. Our definition of a tree is overly-specific, and really, it should be able to hold any kind of data, not just integers. In Haskell, we can do that by adding a type parameter:&lt;/p&gt;
&lt;div class="brush: haskell"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="kr"&gt;data&lt;/span&gt; &lt;span class="kt"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="ow"&gt;=&lt;/span&gt; &lt;span class="kt"&gt;Empty&lt;/span&gt;
&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="kt"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;
&lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="kt"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;With this in mind, we can add a fifth and final point to our list:&lt;/p&gt;
&lt;p&gt;
&lt;ol start="5"&gt;
&lt;li&gt;ADTs must be able to be parametrically polymorphic.&lt;/li&gt;&lt;/ol&gt;&lt;/p&gt;
&lt;p&gt;That covers all of our requirements for basic ADTs. Now we&amp;rsquo;re ready to port this idea to Racket.&lt;/p&gt;
&lt;h2 id="describing-adts-in-racket"&gt;Describing ADTs in Racket&lt;/h2&gt;
&lt;p&gt;How should we take the Haskell syntax for an ADT definition and adapt it to Racket&amp;rsquo;s parenthetical s-expressions? By taking some cues from the Haskell implementation, Typed Racket&amp;rsquo;s type syntax, and Racket&amp;rsquo;s naming conventions, a fairly logical syntax emerges:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define-datatype&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;Empty&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This looks pretty good. Just like with the Haskell implementation, &lt;code&gt;Tree&lt;/code&gt; should only exist at the type level, and &lt;code&gt;Empty&lt;/code&gt;, &lt;code&gt;Leaf&lt;/code&gt;, and &lt;code&gt;Node&lt;/code&gt; should be constructor functions. Our syntax mirrors Racket function application, too—the proper way to create a leaf would be &lt;code&gt;(Leaf 7)&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Now that we can create ADT values, how should we extract the values from them? Well, just like in ML-likes, we can use pattern-matching. We don&amp;rsquo;t need to reinvent the wheel for this one; we should be able to just use Racket&amp;rsquo;s &lt;code&gt;&lt;a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit"&gt;match&lt;/a&gt;&lt;/code&gt; with our datatypes. For example, a function that sums all the values in a tree might look like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;tree-sum&lt;/span&gt; &lt;span class="p"&gt;((&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Integer))" style="color: inherit"&gt;Integer&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit"&gt;-&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Integer))" style="color: inherit"&gt;Integer&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tree-sum&lt;/span&gt; &lt;span class="n"&gt;tree&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit"&gt;match&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;tree&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Empty&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="n"&gt;l&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._+))" style="color: inherit"&gt;+&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tree-sum&lt;/span&gt; &lt;span class="n"&gt;l&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;tree-sum&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;))]))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Given that Racket&amp;rsquo;s &lt;code&gt;struct&lt;/code&gt; form automatically produces identifiers that cooperate with &lt;code&gt;match&lt;/code&gt;, this shouldn&amp;rsquo;t be hard at all. And with our syntax settled, we&amp;rsquo;re ready to begin implementation.&lt;/p&gt;
&lt;h1 id="implementing-adts-as-syntax"&gt;Implementing ADTs as syntax&lt;/h1&gt;
&lt;p&gt;Now for the fun part. To implement our ADT syntax, we&amp;rsquo;ll employ Racket&amp;rsquo;s industrial-strength macro DSL, &lt;a href="http://docs.racket-lang.org/syntax/stxparse.html"&gt;&lt;code&gt;syntax/parse&lt;/code&gt;&lt;/a&gt;. The &lt;code&gt;syntax/parse&lt;/code&gt; library works like the traditional Scheme &lt;code&gt;syntax-case&lt;/code&gt; on steroids, and one of the most useful features is the ability to define &amp;ldquo;syntax classes&amp;rdquo; that encapsulate reusable parsing rules into declarative components.&lt;/p&gt;
&lt;p&gt;Since this is not a macro tutorial, the following implementation assumes you already know how to use &lt;code&gt;syntax/parse&lt;/code&gt;. However, all of the concepts here are well within the reaches of any intermediate macrologist, so don&amp;rsquo;t be intimidated by some of the more complex topics at play.&lt;/p&gt;
&lt;h2 id="parsing-types-with-a-syntax-class"&gt;Parsing types with a syntax class&lt;/h2&gt;
&lt;p&gt;To implement ADTs, we&amp;rsquo;re going to want to define exactly one syntax class, a class that describes the grammar for a type. As we&amp;rsquo;ve seen, types can be bare identifiers, like &lt;code&gt;Tree&lt;/code&gt;, or they can be identifiers with parameters, like &lt;code&gt;(Tree a)&lt;/code&gt;. We&amp;rsquo;ll want to cover both cases.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit"&gt;begin-for-syntax&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit"&gt;define-syntax-class&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;name:id&lt;/span&gt; &lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name:id&lt;/span&gt; &lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit"&gt;...+&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This syntax class has two rules, one that&amp;rsquo;s a bare identifier, and one that&amp;rsquo;s a list. The ellipsis followed by a plus (&lt;code&gt;...+&lt;/code&gt;) in the second example means &amp;ldquo;one or more&amp;rdquo;, so parsing those parameters will automatically be handled for us. In the bare identifier example, we use &lt;code&gt;#:attr&lt;/code&gt; to give the &lt;code&gt;param&lt;/code&gt; attribute the default value of an empty list, so this syntax class will actually &lt;em&gt;normalize&lt;/em&gt; the input we get in addition to actually parsing it.&lt;/p&gt;
&lt;h2 id="a-first-attempt-at-define-datatype"&gt;A first attempt at &lt;code&gt;define-datatype&lt;/code&gt;&lt;/h2&gt;
&lt;p&gt;Now we can move on to actually implementing &lt;code&gt;define-datatype&lt;/code&gt;. The rules are simple: we need to generate a structure type for each one of the data constructors, and we need to generate a type definition for the parent type itself. This is pretty simple to implement using &lt;code&gt;syntax-parser&lt;/code&gt;, which actually does the parsing for our macro.&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit"&gt;define-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;define-datatype&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit"&gt;syntax-parser&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit"&gt;_&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type-name:type&lt;/span&gt; &lt;span class="n"&gt;data-constructor:type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;]))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This definition will do all the parsing we need. It parses the entire macro &amp;ldquo;invocation&amp;rdquo;, ignoring the first datum with &lt;code&gt;_&lt;/code&gt; (which will just be the identifier &lt;code&gt;define-datatype&lt;/code&gt;), then expecting a &lt;code&gt;type-name&lt;/code&gt;, which uses the &lt;code&gt;type&lt;/code&gt; syntax class we defined above. Next, we expect zero or more &lt;code&gt;data-constructor&lt;/code&gt;s, which also use the &lt;code&gt;type&lt;/code&gt; syntax class. That&amp;rsquo;s all we have to do for parsing. We now have all the information we need to actually output the expansion for the macro.&lt;/p&gt;
&lt;p&gt;Of course, it won&amp;rsquo;t be that easy: this is the difficult part. The first step is to generate a Racket struct for each data constructor. We can do this pretty easily with some simple use of Racket&amp;rsquo;s syntax templating facility. A naïve attempt would look like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit"&gt;define-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;define-datatype&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit"&gt;syntax-parser&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit"&gt;_&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type-name:type&lt;/span&gt; &lt;span class="n"&gt;data-constructor:type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit"&gt;begin&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit"&gt;struct&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.name&lt;/span&gt; &lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.param&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))]))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;This is actually really close to being correct. This will generate a struct definition for each &lt;code&gt;data-constructor&lt;/code&gt;, where each struct has the name of the data constructor and the same number of fields as arguments provided. The trouble is that in Racket structs, all of the fields have &lt;em&gt;names&lt;/em&gt;, but in our ADTs, all the fields are anonymous and by-position. Currently, we&amp;rsquo;re just using the same name for &lt;em&gt;all&lt;/em&gt; the fields, &lt;code&gt;f&lt;/code&gt;, so if any data constructor has two or more fields, we&amp;rsquo;ll get an error.&lt;/p&gt;
&lt;p&gt;Since we don&amp;rsquo;t care about the field names, what we want to do is just generate random names for every field. To do this, we can use a Racket function called &lt;code&gt;generate-temporary&lt;/code&gt;, which generates random identifiers. Our next attempt might look like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="o"&gt;#`&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit"&gt;begin&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit"&gt;struct&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.name&lt;/span&gt;
&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="o"&gt;#,&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/reference/syntax-util.html#(def._((lib._racket/syntax..rkt)._generate-temporary))" style="color: inherit"&gt;generate-temporary&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.param&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;The &lt;code&gt;#,&lt;/code&gt; lets us &amp;ldquo;escape&amp;rdquo; from the template to execute &lt;code&gt;(generate-temporary)&lt;/code&gt; and interpolate its result into the syntax. Unfortunately, this doesn&amp;rsquo;t work. We &lt;em&gt;do&lt;/em&gt; generate a random field name, but the ellipsis will re-use the same generated value when it repeats the fields, rendering our whole effort pointless. We need to generate the field names once per type.&lt;/p&gt;
&lt;h2 id="more-leveraging-syntax-classes"&gt;More leveraging syntax classes&lt;/h2&gt;
&lt;p&gt;As it turns out, this is &lt;em&gt;also&lt;/em&gt; easy to do with syntax classes. We can add an extra attribute to our &lt;code&gt;type&lt;/code&gt; syntax class to generate a random identifier with each one. Again, we can use &lt;code&gt;#:attr&lt;/code&gt; to do that automatically. Our new definition for &lt;code&gt;type&lt;/code&gt; will look like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit"&gt;begin-for-syntax&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit"&gt;define-syntax-class&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;name:id&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;field-id&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name:id&lt;/span&gt; &lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit"&gt;...+&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;field-id&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/stxops.html#(def._((lib._racket/private/stxcase-scheme..rkt)._generate-temporaries))" style="color: inherit"&gt;generate-temporaries&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)))))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Here we&amp;rsquo;re using &lt;code&gt;generate-temporaries&lt;/code&gt; instead of &lt;code&gt;generate-temporary&lt;/code&gt;, which will conveniently generate a new identifier for each of the elements in the list we provide it. This way, we&amp;rsquo;ll get a fresh identifier for each &lt;code&gt;param&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;We can now fix our macro to use this &lt;code&gt;field-id&lt;/code&gt; attribute instead of the static field name:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit"&gt;begin&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit"&gt;struct&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.name&lt;/span&gt;
&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;data-constructor.field-id&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.param&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;h2 id="creating-the-supertype"&gt;Creating the supertype&lt;/h2&gt;
&lt;p&gt;We&amp;rsquo;re almost done—now we just need to implement our overall type, the one defined by &lt;code&gt;type-name&lt;/code&gt;. This is implemented as a trivial type alias, but we need to ensure that polymorphic types are properly handled. For example, a non-polymorphic type would need to be handled like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit"&gt;define-type&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit"&gt;U&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;Empty&lt;/span&gt; &lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;Node&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;However, a polymorphic type alias would need to include the type parameters in each subtype, like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit"&gt;define-type&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit"&gt;U&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Empty&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;How can we do this? Well, so far, we&amp;rsquo;ve been very declarative by using syntax patterns, templates, and classes. However, this is a more pernicious problem to solve with our declarative tools. Fortunately, it&amp;rsquo;s very easy to fall back to using &lt;strong&gt;procedural macros&lt;/strong&gt;.&lt;/p&gt;
&lt;p&gt;To build each properly-instantiated type, we&amp;rsquo;ll use a combination of &lt;code&gt;define/with-syntax&lt;/code&gt; and Racket&amp;rsquo;s list comprehensions, &lt;code&gt;for/list&lt;/code&gt;. The &lt;code&gt;define/with-syntax&lt;/code&gt; form binds values to pattern identifiers, which can be used within syntax patterns just like the ones bound by &lt;code&gt;syntax-parser&lt;/code&gt;. This will allow us to break up our result into multiple steps. Technically, &lt;code&gt;define/with-syntax&lt;/code&gt; is not strictly necessary—we could just use &lt;code&gt;#`&lt;/code&gt; and &lt;code&gt;#,&lt;/code&gt;—but it&amp;rsquo;s cleaner to work with.&lt;/p&gt;
&lt;p&gt;We&amp;rsquo;ll start by defining a set of instantiated data constructor types, one per &lt;code&gt;data-constructor&lt;/code&gt;:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit"&gt;define/with-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;data-type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit"&gt;for/list&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit"&gt;in-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data-constructor.name&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))])&lt;/span&gt;
&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now we can fill in the body with any code we&amp;rsquo;d like, so long as each body returns a syntax object. We can use some trivial branching logic to determine which form we need:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit"&gt;define/with-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;data-type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit"&gt;for/list&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit"&gt;in-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data-constructor.name&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))])&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit"&gt;if&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/syntax-helpers.html#(def._((lib._syntax/stx..rkt)._stx-null~3f))" style="color: inherit"&gt;stx-null?&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="n"&gt;name&lt;/span&gt;
&lt;span class="o"&gt;#`&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;#,&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;Now with our definition for &lt;code&gt;data-type&lt;/code&gt;, we can implement our type alias for the supertype extremely easily:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit"&gt;define-type&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type-name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit"&gt;U&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;h2 id="putting-it-all-together"&gt;Putting it all together&lt;/h2&gt;
&lt;p&gt;There&amp;rsquo;s just one more thing to do before we can call this macro finished: we need to ensure that all the type parameters defined by &lt;code&gt;type-name&lt;/code&gt; are in scope for each data constructor&amp;rsquo;s structure definition. We can do this by making use of &lt;code&gt;type-name.param&lt;/code&gt; within each produced struct definition, resulting in this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit"&gt;begin&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit"&gt;struct&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;data-constructor.field-id&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.param&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;And we&amp;rsquo;re done! The final macro, now completed, looks like this:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin-for-syntax))" style="color: inherit"&gt;begin-for-syntax&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._define-syntax-class))" style="color: inherit"&gt;define-syntax-class&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;name:id&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;field-id&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;'&lt;/span&gt;&lt;span class="p"&gt;())&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-specifying.html#(form._((lib._syntax/parse..rkt)._pattern))" style="color: inherit"&gt;pattern&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name:id&lt;/span&gt; &lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/stxparse-patterns.html#(form._((lib._syntax/parse..rkt)._......+))" style="color: inherit"&gt;...+&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="kd"&gt;#:attr&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;field-id&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/stxops.html#(def._((lib._racket/private/stxcase-scheme..rkt)._generate-temporaries))" style="color: inherit"&gt;generate-temporaries&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)))))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define-syntax))" style="color: inherit"&gt;define-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;define-datatype&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/Parsing_Syntax.html#(form._((lib._syntax/parse..rkt)._syntax-parser))" style="color: inherit"&gt;syntax-parser&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt).__))" style="color: inherit"&gt;_&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type-name:type&lt;/span&gt; &lt;span class="n"&gt;data-constructor:type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/reference/syntax-util.html#(form._((lib._racket/syntax..rkt)._define/with-syntax))" style="color: inherit"&gt;define/with-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;data-type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/for.html#(form._((lib._racket/private/base..rkt)._for/list))" style="color: inherit"&gt;for/list&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/unstable/sequence.html#(def._((lib._unstable/sequence..rkt)._in-syntax))" style="color: inherit"&gt;in-syntax&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;data-constructor.name&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))])&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/if.html#(form._((quote._~23~25kernel)._if))" style="color: inherit"&gt;if&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/syntax/syntax-helpers.html#(def._((lib._syntax/stx..rkt)._stx-null~3f))" style="color: inherit"&gt;stx-null?&lt;/a&gt;&lt;/span&gt; &lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="n"&gt;name&lt;/span&gt;
&lt;span class="o"&gt;#`&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;#,&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))))&lt;/span&gt;
&lt;span class="o"&gt;#'&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/begin.html#(form._((quote._~23~25kernel)._begin))" style="color: inherit"&gt;begin&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define-struct.html#(form._((lib._racket/private/base..rkt)._struct))" style="color: inherit"&gt;struct&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;type-name.param&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;data-constructor.name&lt;/span&gt;
&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;data-constructor.field-id&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-constructor.param&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed/racket/base..rkt)._define-type))" style="color: inherit"&gt;define-type&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;type-name&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.U))" style="color: inherit"&gt;U&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;data-type&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/stx-patterns.html#(form._((lib._racket/private/stxcase-scheme..rkt)._......))" style="color: inherit"&gt;...&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)))]))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;It&amp;rsquo;s a little bit dense, certainly, but it is not as complicated or scary as it might seem. It&amp;rsquo;s a simple, mostly declarative, powerful way to transform a DSL into ordinary Typed Racket syntax, and now all we have to do is put it to use.&lt;/p&gt;
&lt;h1 id="using-our-adts"&gt;Using our ADTs&lt;/h1&gt;
&lt;p&gt;With the macro built, we can now actually use our ADTs using the syntax we described! The following is now &lt;em&gt;valid code&lt;/em&gt;:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt;1
2
3
4
5
6
7
8&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define-datatype&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;Empty&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Tree&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._~3e))" style="color: inherit"&gt;&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Empty&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="mi"&gt;7&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._-))" style="color: inherit"&gt;-&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Positive-.Byte))" style="color: inherit"&gt;Positive-Byte&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Node&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Empty&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Leaf&lt;/span&gt; &lt;span class="mi"&gt;7&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;We can use this to define common data types, such as Haskell&amp;rsquo;s &lt;code&gt;Maybe&lt;/code&gt;:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define-datatype&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Maybe&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Just&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit"&gt;Nothing&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;maybe-default&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.All))" style="color: inherit"&gt;All&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Maybe&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit"&gt;-&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;maybe-default&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit"&gt;match&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Just&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit"&gt;Nothing&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;v&lt;/span&gt;&lt;span class="p"&gt;]))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;maybe-then&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types-extra..rkt)._.All))" style="color: inherit"&gt;All&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Maybe&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit"&gt;-&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Maybe&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit"&gt;-&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Maybe&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;maybe-then&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt; &lt;span class="n"&gt;f&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit"&gt;match&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;m&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Just&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;f&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit"&gt;Nothing&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Nothing))" style="color: inherit"&gt;Nothing&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)]))&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;And of course, we can also use it to define ADTs that use concrete types rather that type parameters, if we so desire. This implements a small mathematical language, along with a trivial interpreter:&lt;/p&gt;
&lt;div class="brush: racket"&gt;
&lt;table class="sourcetable"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td class="linenos"&gt;
&lt;div class="linenodiv"&gt;
&lt;pre&gt; 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20&lt;/pre&gt;&lt;/div&gt;&lt;/td&gt;
&lt;td class="code"&gt;
&lt;div class="source"&gt;
&lt;pre&gt;&lt;span&gt;&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;define-datatype&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Number))" style="color: inherit"&gt;Number&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Add&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Subtract&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Multiply&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Divide&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt; &lt;span class="n"&gt;Expr&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/special-forms.html#(form._((lib._typed-racket/base-env/prims..rkt)._~3a))" style="color: inherit"&gt;:&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Expr&lt;/span&gt; &lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/function-contracts.html#(form._((lib._racket/contract/base..rkt)._-~3e))" style="color: inherit"&gt;-&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;&lt;a href="http://docs.racket-lang.org/ts-reference/type-ref.html#(form._((lib._typed-racket/base-env/base-types..rkt)._.Number))" style="color: inherit"&gt;Number&lt;/a&gt;&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/define.html#(form._((lib._racket/private/base..rkt)._define))" style="color: inherit"&gt;define&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;&lt;a href="http://docs.racket-lang.org/reference/match.html#(form._((lib._racket/match..rkt)._match))" style="color: inherit"&gt;match&lt;/a&gt;&lt;/span&gt; &lt;span class="n"&gt;e&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;x&lt;/span&gt; &lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Add&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._+))" style="color: inherit"&gt;+&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;))]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Subtract&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._-))" style="color: inherit"&gt;-&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;))]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Multiply&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._*))" style="color: inherit"&gt;*&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;))]&lt;/span&gt;
&lt;span class="p"&gt;[(&lt;/span&gt;&lt;span class="n"&gt;Divide&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._/))" style="color: inherit"&gt;/&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;a&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;))]))&lt;/span&gt;
&lt;span class="nb"&gt;&lt;a href="http://docs.racket-lang.org/reference/generic-numbers.html#(def._((quote._~23~25kernel)._~3e))" style="color: inherit"&gt;&amp;gt;&lt;/a&gt;&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;evaluate&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Add&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Multiply&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Divide&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Value&lt;/span&gt; &lt;span class="mi"&gt;7&lt;/span&gt;&lt;span class="p"&gt;))))&lt;/span&gt;
&lt;span class="mi"&gt;4&lt;/span&gt; &lt;span class="m"&gt;1/2&lt;/span&gt;
&lt;/pre&gt;&lt;/div&gt;
&lt;/td&gt;&lt;/tr&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;p&gt;There&amp;rsquo;s all the power of ADTs, right in Racket, all implemented in 22 lines of code. If you&amp;rsquo;d like to see all the code together in a runnable form, &lt;a href="https://gist.github.com/lexi-lambda/18cf7a9156f743a1317e"&gt;I&amp;rsquo;ve put together a gist here&lt;/a&gt;.&lt;/p&gt;
&lt;h1 id="conclusions-and-credit"&gt;Conclusions and credit&lt;/h1&gt;
&lt;p&gt;This isn&amp;rsquo;t the simplest macro to create, nor is it the most complex. The code examples might not even make much sense until you try it out yourself. Macros, like any difficult concept, are not always easy to pick up, but they certainly &lt;em&gt;are&lt;/em&gt; powerful. The ability to extend the language in such a way, in the matter of minutes, is unparalleled in languages other than Lisp.&lt;/p&gt;
&lt;p&gt;This is, of course, a blessing and a curse. Lisps reject some of the syntactic landmarks that often aid in readability for the power to abstract programs into their bare components. In the end, is this uniform conciseness more or less readable? That&amp;rsquo;s an incredibly subjective question, one that has prompted powerfully impassioned discussions, and I will not attempt to argue one way or the other here.&lt;/p&gt;
&lt;p&gt;That said, I think it&amp;rsquo;s pretty cool.&lt;/p&gt;
&lt;p&gt;Finally, I must give credit where credit is due. Thanks to &lt;a href="http://andmkent.com"&gt;Andrew M. Kent&lt;/a&gt; for the creation of the &lt;a href="https://github.com/andmkent/datatype"&gt;datatype&lt;/a&gt; package, which served as the inspiration for this blog post. Many thanks to &lt;a href="http://www.ccs.neu.edu/home/samth/"&gt;Sam Tobin-Hochstadt&lt;/a&gt; for his work creating Typed Racket, as well as helping me dramatically simplify the implementation used in this blog post. Also thanks to &lt;a href="http://www.ccs.neu.edu/home/ryanc/"&gt;Ryan Culpepper&lt;/a&gt; and &lt;a href="http://www.ccs.neu.edu/home/matthias/"&gt;Matthias Felleisen&lt;/a&gt; for their work on creating &lt;code&gt;syntax/parse&lt;/code&gt;, which is truly a marvelous tool for exploring the world of macros, and, of course, a big thanks to &lt;a href="http://www.cs.utah.edu/~mflatt/"&gt;Matthew Flatt&lt;/a&gt; for his implementation of hygiene in Racket, as well as much of the rest of Racket itself. Not to mention the entire legacy of those who formulated the foundations of the Scheme macro system and created the framework for all of this to be possible so many decades later.&lt;/p&gt;
&lt;p&gt;Truly, working in Racket feels like standing on the shoulders of giants. If you&amp;rsquo;re intrigued, give it a shot. It&amp;rsquo;s a fun feeling.&lt;/p&gt;&lt;/html&gt;</description></item></channel></rss>

44
gulpfile.coffee
View File

@ -1,44 +0,0 @@
gulp = require 'gulp'
autoprefixer = require 'gulp-autoprefixer'
bower = require 'gulp-bower'
coffee = require 'gulp-coffee'
concat = require 'gulp-concat'
rename = require 'gulp-rename'
sass = require 'gulp-sass'
sourcemaps = require 'gulp-sourcemaps'
uglify = require 'gulp-uglify'
gutil = require 'gulp-util'
bowerFiles = require 'main-bower-files'
gulp.task 'default', ['build']
gulp.task 'build', ['bower', 'coffee', 'sass']
gulp.task 'bower', ['bower-install', 'bower-files']
gulp.task 'bower-install', -> bower()
gulp.task 'bower-files', ->
gulp.src [], base: 'bower_components/'
gulp.task 'coffee', ->
gulp.src './coffee/**/*.coffee'
.pipe sourcemaps.init()
.pipe(coffee()).on 'error', gutil.log
.pipe concat 'application.js'
.pipe uglify()
.pipe rename extname: '.min.js'
.pipe sourcemaps.write()
.pipe gulp.dest './out/js/'
gulp.task 'sass', ->
gulp.src './scss/**/*.scss'
.pipe sourcemaps.init()
.pipe sass().on 'error', sass.logError
.pipe autoprefixer()
.pipe rename extname: '.min.css'
.pipe sourcemaps.write()
.pipe gulp.dest './out/css/'
gulp.task 'watch', ->
gulp.watch './coffee/**/*.coffee', ['coffee']
gulp.watch './scss/**/*.scss', ['sass']

2
gulpfile.js
View File

@ -1,2 +0,0 @@
require('coffee-script/register');
require('./gulpfile.coffee');

182
index.html Normal file
View File

@ -0,0 +1,182 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Alexis King's Blog</title>
<meta name="description" content="Alexis King's Blog">
<meta name="author" content="Alexis King">
<meta name="keywords" content="macros, elm, javascript, meta, typed racket, all, racket, heroku, ruby, angular, 12factor, rails, frog, envy">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/index.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/all.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/all.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2016/02/18/simple-safe-multimethods-in-racket/'>Simple, safe multimethods in Racket</a></h2>
<div class='date-and-tags'>
<time datetime="2016-02-18T18:48:32">
2016-02-18
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/macros.html">macros</a></span>
</div>
</header>
<p>Racket ships with <code>racket/generic</code>, a system for defining <em>generic methods</em>, functions that work differently depending on what sort of value they are supplied. I have made heavy use of this feature in my collections library, and it has worked well for my needs, but that system does have a bit of a limitation: it only supports <em>single dispatch</em>. Method implementations may only be chosen based on a single argument, so multiple dispatch is impossible.</p>
<footer class="read-more"><a href="/blog/2016/02/18/simple-safe-multimethods-in-racket/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/12/21/adts-in-typed-racket-with-macros/'>ADTs in Typed Racket with macros</a></h2>
<div class='date-and-tags'>
<time datetime="2015-12-21T17:57:07">
2015-12-21
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/typed-racket.html">typed racket</a>, <a href="/tags/macros.html">macros</a></span>
</div>
</header>
<p>Macros are one of Racket&rsquo;s flagship features, and its macro system really is state of the art. Of course, it can sometimes be difficult to demonstrate <em>why</em> macros are so highly esteemed, in part because it can be hard to find self-contained examples of using macros in practice. Of course, one thing that macros are perfect for is filling a &ldquo;hole&rdquo; in the language by introducing a feature a language lacks, and one of those features in Typed Racket is <strong>ADTs</strong>.</p>
<footer class="read-more"><a href="/blog/2015/12/21/adts-in-typed-racket-with-macros/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/11/06/functionally-updating-record-types-in-elm/'>Functionally updating record types in Elm</a></h2>
<div class='date-and-tags'>
<time datetime="2015-11-06T19:58:40">
2015-11-06
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/elm.html">elm</a></span>
</div>
</header>
<p><a href="http://elm-lang.org">Elm</a> is a wonderful language for building web apps, and I love so much of its approach to language design. Elm does so many things <em>right</em> straight out of the box, and that&rsquo;s a real breath of fresh air in the intersection of functional programming and web development. Still, it gets one thing wrong, and unfortunately, that one thing is incredibly important. Elm took the &ldquo;functions&rdquo; out of &ldquo;functional record types&rdquo;.</p>
<footer class="read-more"><a href="/blog/2015/11/06/functionally-updating-record-types-in-elm/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/'>Canonical factories for testing with factory_girl_api</a></h2>
<div class='date-and-tags'>
<time datetime="2015-09-23T16:30:12">
2015-09-23
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/ruby.html">ruby</a>, <a href="/tags/rails.html">rails</a>, <a href="/tags/javascript.html">javascript</a>, <a href="/tags/angular.html">angular</a></span>
</div>
</header>
<p>Modern web applications are often built as <em>single-page apps</em>, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&rsquo;t catch the failure. I haven&rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.</p>
<p>To attempt to address a fraction of this problem, I built <a href="https://github.com/lexi-lambda/factory_girl_api">factory_girl_api</a>, a way to share context setup between both sides of the application.</p>
<footer class="read-more"><a href="/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/08/30/managing-application-configuration-with-envy/'>Managing application configuration with Envy</a></h2>
<div class='date-and-tags'>
<time datetime="2015-08-30T16:05:37">
2015-08-30
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/envy.html">envy</a>, <a href="/tags/racket.html">racket</a>, <a href="/tags/12factor.html">12factor</a></span>
</div>
</header>
<p>Application configuration can be a pain. Modern web apps don&rsquo;t live on dedicated boxes, they run on VPSes somewhere in the amorphous &ldquo;cloud&rdquo;, and keeping configuration out of your application&rsquo;s repository can seem like more trouble than it&rsquo;s worth. Fortunately, <a href="http://12factor.net">The Twelve-Factor App</a> provides a set of standards for keeping web apps sane, and <a href="http://12factor.net/config">one of those guidelines advises keeping configuration in the environment</a>.</p>
<p><a href="https://github.com/lexi-lambda/envy">Envy</a> is the declarative bridge between Racket code and the outside world of the environment.</p>
<footer class="read-more"><a href="/blog/2015/08/30/managing-application-configuration-with-envy/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/08/22/deploying-racket-applications-on-heroku/'>Deploying Racket applications on Heroku</a></h2>
<div class='date-and-tags'>
<time datetime="2015-08-22T14:47:49">
2015-08-22
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/heroku.html">heroku</a>, <a href="/tags/12factor.html">12factor</a></span>
</div>
</header>
<p><a href="https://www.heroku.com">Heroku</a> is a &ldquo;platform as a service&rdquo; that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but Racket is not currently among them. Fortunately, Heroku provides an interface for adding custom build processes for arbitrary types of applications, called “buildpacks”. I&rsquo;ve built one for Racket apps, and with just a little bit of configuration, it’s possible to get a Racket webserver running on Heroku.</p>
<footer class="read-more"><a href="/blog/2015/08/22/deploying-racket-applications-on-heroku/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/'>Automatically deploying a Frog-powered blog to GitHub pages</a></h2>
<div class='date-and-tags'>
<time datetime="2015-07-18T19:09:01">
2015-07-18
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/frog.html">frog</a>, <a href="/tags/meta.html">meta</a></span>
</div>
</header>
<p>So, I have a blog now. It&rsquo;s a simple static blog, but what&rsquo;s unique about it is that it&rsquo;s powered by Racket; specifically, it uses <a href="http://www.greghendershott.com">Greg Hendershott</a>&rsquo;s fantastic <a href="https://github.com/greghendershott/frog">Frog</a> tool. I&rsquo;ve taken this and moulded it to my tastes to build my blog, including configuring automatic deployment via <a href="https://travis-ci.org">Travis CI</a>, so my blog is always up-to-date.</p>
<footer class="read-more"><a href="/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

27
npm-debug.log
View File

@ -1,27 +0,0 @@
0 info it worked if it ends with ok
1 verbose cli [ '/usr/local/Cellar/node/5.5.0/bin/node',
1 verbose cli '/usr/local/bin/npm',
1 verbose cli 'run',
1 verbose cli 'build:watch' ]
2 info using npm@3.5.3
3 info using node@v5.5.0
4 verbose stack Error: missing script: build:watch
4 verbose stack at run (/usr/local/lib/node_modules/npm/lib/run-script.js:147:19)
4 verbose stack at /usr/local/lib/node_modules/npm/lib/run-script.js:57:5
4 verbose stack at /usr/local/lib/node_modules/npm/node_modules/read-package-json/read-json.js:345:5
4 verbose stack at checkBinReferences_ (/usr/local/lib/node_modules/npm/node_modules/read-package-json/read-json.js:309:45)
4 verbose stack at final (/usr/local/lib/node_modules/npm/node_modules/read-package-json/read-json.js:343:3)
4 verbose stack at then (/usr/local/lib/node_modules/npm/node_modules/read-package-json/read-json.js:113:5)
4 verbose stack at /usr/local/lib/node_modules/npm/node_modules/read-package-json/read-json.js:300:12
4 verbose stack at /usr/local/lib/node_modules/npm/node_modules/graceful-fs/graceful-fs.js:76:16
4 verbose stack at tryToString (fs.js:414:3)
4 verbose stack at FSReqWrap.readFileAfterClose [as oncomplete] (fs.js:401:12)
5 verbose cwd /Users/Jake/gits/blog
6 error Darwin 15.2.0
7 error argv "/usr/local/Cellar/node/5.5.0/bin/node" "/usr/local/bin/npm" "run" "build:watch"
8 error node v5.5.0
9 error npm v3.5.3
10 error missing script: build:watch
11 error If you need help, you may report this error at:
11 error <https://github.com/npm/npm/issues>
12 verbose exit [ 1, true ]

20
package.json
View File

@ -1,20 +0,0 @@
{
"scripts": {
"build": "gulp",
"watch": "gulp watch"
},
"devDependencies": {
"coffee-script": "~1.9.3",
"gulp": "~3.9.0",
"gulp-autoprefixer": "^2.3.1",
"gulp-bower": "0.0.10",
"gulp-coffee": "~2.3.1",
"gulp-concat": "^2.6.0",
"gulp-rename": "~1.2.2",
"gulp-sass": "^2.0.4",
"gulp-sourcemaps": "~1.5.2",
"gulp-uglify": "~1.2.0",
"gulp-util": "~3.0.6",
"main-bower-files": "^2.9.0"
}
}

51
scss/_code.scss
View File

@ -1,51 +0,0 @@
@import 'colors';
@import 'fonts';
pre, code {
font-family: $font-monospace;
}
p code, li code {
background-color: $color-section-background;
border-radius: 3px;
padding: 2px 5px;
}
pre code, table.sourcetable pre {
font-size: 0.9em;
line-height: 1.4em;
}
pre code {
display: block;
}
pre code, div[class^='brush: '] {
background-color: $color-section-background;
width: 100%;
overflow: auto;
}
table.sourcetable {
width: 100%;
td.linenos {
color: desaturate(darken($color-section-background, 20%), 40%);
white-space: nowrap;
width: 1%;
font-weight: 300;
}
pre {
margin: 0;
}
}
pre code, table.sourcetable {
padding: 20px;
}
td.linenos {
padding-right: 15px;
}

9
scss/_colors.scss
View File

@ -1,9 +0,0 @@
$color-background: #fffcfc;
$color-primary: #e45b5b;
$color-section-background: lighten($color-primary, 35%);
$text-color-light: lighten($color-primary, 30%);
$text-color-link: desaturate(darken($color-primary, 10%), 20%);
$text-color-link-light: lighten($text-color-link, 10%);
$text-color-primary: #473737;

4
scss/_fonts.scss
View File

@ -1,4 +0,0 @@
$font-serif: 'Merriweather', serif;
$font-sans-serif: 'Merriweather Sans', sans-serif;
$font-monospace: 'Source Code Pro', monospace;

179
scss/application.scss
View File

@ -1,179 +0,0 @@
@import 'colors';
@import 'code';
@import 'fonts';
html {
background-color: $color-background;
font-family: $font-serif;
}
* {
box-sizing: border-box;
}
html, body {
margin: 0;
padding: 0;
height: 100%;
width: 100%;
}
#page-content {
display: flex;
flex-direction: column;
width: 100%;
min-height: 100%;
}
#page-content > section[role=main] {
flex: 1;
padding: 0 30px;
& > .content {
margin: 0 auto;
padding: 40px 0;
max-width: 780px;
}
p {
line-height: 1.9em;
}
li {
line-height: 1.8em;
}
a {
color: $text-color-link;
&:hover {
color: $text-color-link-light;
text-decoration: none;
}
}
}
// hide the blog title in the navbar on small screen sizes
@media (max-width: 550px) {
#blog-title-header {
display: none;
}
}
#page-content > footer {
background-color: $color-primary;
color: $text-color-light;
font-family: $font-sans-serif;
text-align: center;
& > .content {
margin: 0 auto;
padding: 10px 0;
max-width: 940px;
}
a {
color: inherit;
font-weight: bold;
text-decoration: underline;
}
h2, h3 {
font-weight: 300;
margin: 0.8em;
}
h2 {
font-size: 1.1em;
}
h3 {
font-size: 0.8em;
}
}
article > header {
.date-and-tags {
margin-bottom: 20px;
time {
color: $text-color-primary;
font-size: 1.5em;
font-weight: 300;
}
}
.tags a {
color: $text-color-link;
}
}
article.inline > header .title {
font-size: 2.3em;
margin-bottom: 10px;
}
article.main > header .title {
font-size: 2.7em;
margin-bottom: 10px;
}
article h1 {
font-size: 2em;
}
article.main > footer {
margin-top: 40px;
}
h1, h2, h3, h4, h5, h6 {
font-family: $font-sans-serif;
}
a {
text-decoration: none;
transition: color 0.15s ease-in-out;
&:hover {
text-decoration: underline;
}
}
.navigation-bar {
align-items: center;
background-color: $color-primary;
display: flex;
font-size: 1.2em;
font-family: $font-sans-serif;
font-weight: 300;
width: 100%;
a {
color: $text-color-light;
display: block;
letter-spacing: 0.1em;
text-transform: uppercase;
text-decoration: none;
&:hover { color: white; }
}
h1 {
margin: 5px 0;
text-decoration: none;
font-size: 1.5em;
font-weight: inherit;
}
.navigation-items {
padding: 0;
&.left, &.right { margin: 15px; }
&.center { flex: 1; }
li {
display: inline-block;
margin: 0 20px;
}
}
}

64
scss/pygments.scss
View File

@ -1,64 +0,0 @@
$semibold: 600;
$string: #BA2121;
td.code .source {
.c, .cm, .c1 { color: #9e5555; font-weight: 300; } /* Comment */
.err { border: 1px solid #FF0000 } /* Error */
.k { color: #19177C; font-weight: $semibold } /* Keyword */
.o { color: #666666 } /* Operator */
.cp { color: #BC7A00 } /* Comment.Preproc */
.cs { color: #408080; font-style: italic } /* Comment.Special */
.gd { color: #A00000 } /* Generic.Deleted */
.ge { font-style: italic } /* Generic.Emph */
.gr { color: #FF0000 } /* Generic.Error */
.gh { color: #000080; font-weight: bold } /* Generic.Heading */
.gi { color: #00A000 } /* Generic.Inserted */
.go { color: #808080 } /* Generic.Output */
.gp { color: #000080; font-weight: bold } /* Generic.Prompt */
.gs { font-weight: bold } /* Generic.Strong */
.gu { color: #800080; font-weight: bold } /* Generic.Subheading */
.gt { color: #0040D0 } /* Generic.Traceback */
.kc { color: #008000; font-weight: bold } /* Keyword.Constant */
.kd { color: $string; font-weight: $semibold } /* Keyword.Declaration */
.kn { color: $string; font-weight: bold } /* Keyword.Namespace */
.kp { color: #008000 } /* Keyword.Pseudo */
.kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
.kt { color: #B00040 } /* Keyword.Type */
.m { color: #666666 } /* Literal.Number */
.s { color: $string } /* Literal.String */
.na { color: #7D9029 } /* Name.Attribute */
.nb { color: #03877c; font-weight: $semibold; } /* Name.Builtin */
.nc { color: #0000FF; font-weight: bold } /* Name.Class */
.no { color: #880000 } /* Name.Constant */
.nd { color: #AA22FF } /* Name.Decorator */
.ni { color: #999999; font-weight: bold } /* Name.Entity */
.ne { color: #D2413A; font-weight: bold } /* Name.Exception */
.nf { color: #0000FF } /* Name.Function */
.nl { color: #A0A000 } /* Name.Label */
.nn { color: $string; font-weight: bold } /* Name.Namespace */
.nt { color: #008000; font-weight: bold } /* Name.Tag */
.nv { color: #1c7805 } /* Name.Variable */
.ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
.w { color: #bbbbbb } /* Text.Whitespace */
.mf { color: #666666 } /* Literal.Number.Float */
.mh { color: #666666 } /* Literal.Number.Hex */
.mi { color: #666666 } /* Literal.Number.Integer */
.mo { color: #666666 } /* Literal.Number.Oct */
.sb { color: $string } /* Literal.String.Backtick */
.sc { color: $string } /* Literal.String.Char */
.sd { color: $string; font-style: italic } /* Literal.String.Doc */
.s2 { color: $string } /* Literal.String.Double */
.se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */
.sh { color: $string } /* Literal.String.Heredoc */
.si { color: $string; font-weight: $semibold } /* Literal.String.Interpol */
.sx { color: #008000 } /* Literal.String.Other */
.sr { color: #BB6688 } /* Literal.String.Regex */
.s1 { color: $string } /* Literal.String.Single */
.ss { color: #19177C } /* Literal.String.Symbol */
.bp { color: #008000 } /* Name.Builtin.Pseudo */
.vc { color: #19177C } /* Name.Variable.Class */
.vg { color: #19177C } /* Name.Variable.Global */
.vi { color: #19177C } /* Name.Variable.Instance */
.il { color: #666666 } /* Literal.Number.Integer.Long */
}

8
sitemap.txt Normal file
View File

@ -0,0 +1,8 @@
http://lexi-lambda.github.io/blog/2015/08/30/managing-application-configuration-with-envy/
http://lexi-lambda.github.io/blog/2015/08/22/deploying-racket-applications-on-heroku/
http://lexi-lambda.github.io/blog/2015/11/06/functionally-updating-record-types-in-elm/
http://lexi-lambda.github.io/blog/2015/12/21/adts-in-typed-racket-with-macros/
http://lexi-lambda.github.io/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/
http://lexi-lambda.github.io/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/
http://lexi-lambda.github.io/blog/2016/02/18/simple-safe-multimethods-in-racket/
http://lexi-lambda.github.io/about.html

105
tags/12factor.html Normal file
View File

@ -0,0 +1,105 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged '12factor'</title>
<meta name="description" content="Posts tagged '12factor'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="12factor">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/12factor.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/12factor.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/12factor.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>12factor</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/08/30/managing-application-configuration-with-envy/'>Managing application configuration with Envy</a></h2>
<div class='date-and-tags'>
<time datetime="2015-08-30T16:05:37">
2015-08-30
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/envy.html">envy</a>, <a href="/tags/racket.html">racket</a>, <a href="/tags/12factor.html">12factor</a></span>
</div>
</header>
<p>Application configuration can be a pain. Modern web apps don&rsquo;t live on dedicated boxes, they run on VPSes somewhere in the amorphous &ldquo;cloud&rdquo;, and keeping configuration out of your application&rsquo;s repository can seem like more trouble than it&rsquo;s worth. Fortunately, <a href="http://12factor.net">The Twelve-Factor App</a> provides a set of standards for keeping web apps sane, and <a href="http://12factor.net/config">one of those guidelines advises keeping configuration in the environment</a>.</p>
<p><a href="https://github.com/lexi-lambda/envy">Envy</a> is the declarative bridge between Racket code and the outside world of the environment.</p>
<footer class="read-more"><a href="/blog/2015/08/30/managing-application-configuration-with-envy/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/08/22/deploying-racket-applications-on-heroku/'>Deploying Racket applications on Heroku</a></h2>
<div class='date-and-tags'>
<time datetime="2015-08-22T14:47:49">
2015-08-22
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/heroku.html">heroku</a>, <a href="/tags/12factor.html">12factor</a></span>
</div>
</header>
<p><a href="https://www.heroku.com">Heroku</a> is a &ldquo;platform as a service&rdquo; that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but Racket is not currently among them. Fortunately, Heroku provides an interface for adding custom build processes for arbitrary types of applications, called “buildpacks”. I&rsquo;ve built one for Racket apps, and with just a little bit of configuration, it’s possible to get a Racket webserver running on Heroku.</p>
<footer class="read-more"><a href="/blog/2015/08/22/deploying-racket-applications-on-heroku/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

90
tags/angular.html Normal file
View File

@ -0,0 +1,90 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'angular'</title>
<meta name="description" content="Posts tagged 'angular'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="angular">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/angular.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/angular.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/angular.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>angular</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/'>Canonical factories for testing with factory_girl_api</a></h2>
<div class='date-and-tags'>
<time datetime="2015-09-23T16:30:12">
2015-09-23
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/ruby.html">ruby</a>, <a href="/tags/rails.html">rails</a>, <a href="/tags/javascript.html">javascript</a>, <a href="/tags/angular.html">angular</a></span>
</div>
</header>
<p>Modern web applications are often built as <em>single-page apps</em>, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&rsquo;t catch the failure. I haven&rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.</p>
<p>To attempt to address a fraction of this problem, I built <a href="https://github.com/lexi-lambda/factory_girl_api">factory_girl_api</a>, a way to share context setup between both sides of the application.</p>
<footer class="read-more"><a href="/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

88
tags/elm.html Normal file
View File

@ -0,0 +1,88 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'elm'</title>
<meta name="description" content="Posts tagged 'elm'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="elm">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/elm.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/elm.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/elm.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>elm</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/11/06/functionally-updating-record-types-in-elm/'>Functionally updating record types in Elm</a></h2>
<div class='date-and-tags'>
<time datetime="2015-11-06T19:58:40">
2015-11-06
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/elm.html">elm</a></span>
</div>
</header>
<p><a href="http://elm-lang.org">Elm</a> is a wonderful language for building web apps, and I love so much of its approach to language design. Elm does so many things <em>right</em> straight out of the box, and that&rsquo;s a real breath of fresh air in the intersection of functional programming and web development. Still, it gets one thing wrong, and unfortunately, that one thing is incredibly important. Elm took the &ldquo;functions&rdquo; out of &ldquo;functional record types&rdquo;.</p>
<footer class="read-more"><a href="/blog/2015/11/06/functionally-updating-record-types-in-elm/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

90
tags/envy.html Normal file
View File

@ -0,0 +1,90 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'envy'</title>
<meta name="description" content="Posts tagged 'envy'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="envy">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/envy.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/envy.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/envy.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>envy</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/08/30/managing-application-configuration-with-envy/'>Managing application configuration with Envy</a></h2>
<div class='date-and-tags'>
<time datetime="2015-08-30T16:05:37">
2015-08-30
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/envy.html">envy</a>, <a href="/tags/racket.html">racket</a>, <a href="/tags/12factor.html">12factor</a></span>
</div>
</header>
<p>Application configuration can be a pain. Modern web apps don&rsquo;t live on dedicated boxes, they run on VPSes somewhere in the amorphous &ldquo;cloud&rdquo;, and keeping configuration out of your application&rsquo;s repository can seem like more trouble than it&rsquo;s worth. Fortunately, <a href="http://12factor.net">The Twelve-Factor App</a> provides a set of standards for keeping web apps sane, and <a href="http://12factor.net/config">one of those guidelines advises keeping configuration in the environment</a>.</p>
<p><a href="https://github.com/lexi-lambda/envy">Envy</a> is the declarative bridge between Racket code and the outside world of the environment.</p>
<footer class="read-more"><a href="/blog/2015/08/30/managing-application-configuration-with-envy/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

88
tags/frog.html Normal file
View File

@ -0,0 +1,88 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'frog'</title>
<meta name="description" content="Posts tagged 'frog'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="frog">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/frog.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/frog.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/frog.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>frog</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/'>Automatically deploying a Frog-powered blog to GitHub pages</a></h2>
<div class='date-and-tags'>
<time datetime="2015-07-18T19:09:01">
2015-07-18
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/frog.html">frog</a>, <a href="/tags/meta.html">meta</a></span>
</div>
</header>
<p>So, I have a blog now. It&rsquo;s a simple static blog, but what&rsquo;s unique about it is that it&rsquo;s powered by Racket; specifically, it uses <a href="http://www.greghendershott.com">Greg Hendershott</a>&rsquo;s fantastic <a href="https://github.com/greghendershott/frog">Frog</a> tool. I&rsquo;ve taken this and moulded it to my tastes to build my blog, including configuring automatic deployment via <a href="https://travis-ci.org">Travis CI</a>, so my blog is always up-to-date.</p>
<footer class="read-more"><a href="/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

88
tags/heroku.html Normal file
View File

@ -0,0 +1,88 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'heroku'</title>
<meta name="description" content="Posts tagged 'heroku'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="heroku">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/heroku.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/heroku.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/heroku.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>heroku</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/08/22/deploying-racket-applications-on-heroku/'>Deploying Racket applications on Heroku</a></h2>
<div class='date-and-tags'>
<time datetime="2015-08-22T14:47:49">
2015-08-22
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/heroku.html">heroku</a>, <a href="/tags/12factor.html">12factor</a></span>
</div>
</header>
<p><a href="https://www.heroku.com">Heroku</a> is a &ldquo;platform as a service&rdquo; that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but Racket is not currently among them. Fortunately, Heroku provides an interface for adding custom build processes for arbitrary types of applications, called “buildpacks”. I&rsquo;ve built one for Racket apps, and with just a little bit of configuration, it’s possible to get a Racket webserver running on Heroku.</p>
<footer class="read-more"><a href="/blog/2015/08/22/deploying-racket-applications-on-heroku/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

90
tags/javascript.html Normal file
View File

@ -0,0 +1,90 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'javascript'</title>
<meta name="description" content="Posts tagged 'javascript'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="javascript">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/javascript.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/javascript.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/javascript.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>javascript</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/'>Canonical factories for testing with factory_girl_api</a></h2>
<div class='date-and-tags'>
<time datetime="2015-09-23T16:30:12">
2015-09-23
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/ruby.html">ruby</a>, <a href="/tags/rails.html">rails</a>, <a href="/tags/javascript.html">javascript</a>, <a href="/tags/angular.html">angular</a></span>
</div>
</header>
<p>Modern web applications are often built as <em>single-page apps</em>, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&rsquo;t catch the failure. I haven&rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.</p>
<p>To attempt to address a fraction of this problem, I built <a href="https://github.com/lexi-lambda/factory_girl_api">factory_girl_api</a>, a way to share context setup between both sides of the application.</p>
<footer class="read-more"><a href="/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

103
tags/macros.html Normal file
View File

@ -0,0 +1,103 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'macros'</title>
<meta name="description" content="Posts tagged 'macros'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="macros">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/macros.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/macros.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/macros.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>macros</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2016/02/18/simple-safe-multimethods-in-racket/'>Simple, safe multimethods in Racket</a></h2>
<div class='date-and-tags'>
<time datetime="2016-02-18T18:48:32">
2016-02-18
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/macros.html">macros</a></span>
</div>
</header>
<p>Racket ships with <code>racket/generic</code>, a system for defining <em>generic methods</em>, functions that work differently depending on what sort of value they are supplied. I have made heavy use of this feature in my collections library, and it has worked well for my needs, but that system does have a bit of a limitation: it only supports <em>single dispatch</em>. Method implementations may only be chosen based on a single argument, so multiple dispatch is impossible.</p>
<footer class="read-more"><a href="/blog/2016/02/18/simple-safe-multimethods-in-racket/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/12/21/adts-in-typed-racket-with-macros/'>ADTs in Typed Racket with macros</a></h2>
<div class='date-and-tags'>
<time datetime="2015-12-21T17:57:07">
2015-12-21
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/typed-racket.html">typed racket</a>, <a href="/tags/macros.html">macros</a></span>
</div>
</header>
<p>Macros are one of Racket&rsquo;s flagship features, and its macro system really is state of the art. Of course, it can sometimes be difficult to demonstrate <em>why</em> macros are so highly esteemed, in part because it can be hard to find self-contained examples of using macros in practice. Of course, one thing that macros are perfect for is filling a &ldquo;hole&rdquo; in the language by introducing a feature a language lacks, and one of those features in Typed Racket is <strong>ADTs</strong>.</p>
<footer class="read-more"><a href="/blog/2015/12/21/adts-in-typed-racket-with-macros/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

88
tags/meta.html Normal file
View File

@ -0,0 +1,88 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'meta'</title>
<meta name="description" content="Posts tagged 'meta'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="meta">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/meta.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/meta.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/meta.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>meta</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/'>Automatically deploying a Frog-powered blog to GitHub pages</a></h2>
<div class='date-and-tags'>
<time datetime="2015-07-18T19:09:01">
2015-07-18
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/frog.html">frog</a>, <a href="/tags/meta.html">meta</a></span>
</div>
</header>
<p>So, I have a blog now. It&rsquo;s a simple static blog, but what&rsquo;s unique about it is that it&rsquo;s powered by Racket; specifically, it uses <a href="http://www.greghendershott.com">Greg Hendershott</a>&rsquo;s fantastic <a href="https://github.com/greghendershott/frog">Frog</a> tool. I&rsquo;ve taken this and moulded it to my tastes to build my blog, including configuring automatic deployment via <a href="https://travis-ci.org">Travis CI</a>, so my blog is always up-to-date.</p>
<footer class="read-more"><a href="/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

150
tags/racket.html Normal file
View File

@ -0,0 +1,150 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'racket'</title>
<meta name="description" content="Posts tagged 'racket'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="racket">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/racket.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/racket.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/racket.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>racket</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2016/02/18/simple-safe-multimethods-in-racket/'>Simple, safe multimethods in Racket</a></h2>
<div class='date-and-tags'>
<time datetime="2016-02-18T18:48:32">
2016-02-18
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/macros.html">macros</a></span>
</div>
</header>
<p>Racket ships with <code>racket/generic</code>, a system for defining <em>generic methods</em>, functions that work differently depending on what sort of value they are supplied. I have made heavy use of this feature in my collections library, and it has worked well for my needs, but that system does have a bit of a limitation: it only supports <em>single dispatch</em>. Method implementations may only be chosen based on a single argument, so multiple dispatch is impossible.</p>
<footer class="read-more"><a href="/blog/2016/02/18/simple-safe-multimethods-in-racket/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/12/21/adts-in-typed-racket-with-macros/'>ADTs in Typed Racket with macros</a></h2>
<div class='date-and-tags'>
<time datetime="2015-12-21T17:57:07">
2015-12-21
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/typed-racket.html">typed racket</a>, <a href="/tags/macros.html">macros</a></span>
</div>
</header>
<p>Macros are one of Racket&rsquo;s flagship features, and its macro system really is state of the art. Of course, it can sometimes be difficult to demonstrate <em>why</em> macros are so highly esteemed, in part because it can be hard to find self-contained examples of using macros in practice. Of course, one thing that macros are perfect for is filling a &ldquo;hole&rdquo; in the language by introducing a feature a language lacks, and one of those features in Typed Racket is <strong>ADTs</strong>.</p>
<footer class="read-more"><a href="/blog/2015/12/21/adts-in-typed-racket-with-macros/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/08/30/managing-application-configuration-with-envy/'>Managing application configuration with Envy</a></h2>
<div class='date-and-tags'>
<time datetime="2015-08-30T16:05:37">
2015-08-30
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/envy.html">envy</a>, <a href="/tags/racket.html">racket</a>, <a href="/tags/12factor.html">12factor</a></span>
</div>
</header>
<p>Application configuration can be a pain. Modern web apps don&rsquo;t live on dedicated boxes, they run on VPSes somewhere in the amorphous &ldquo;cloud&rdquo;, and keeping configuration out of your application&rsquo;s repository can seem like more trouble than it&rsquo;s worth. Fortunately, <a href="http://12factor.net">The Twelve-Factor App</a> provides a set of standards for keeping web apps sane, and <a href="http://12factor.net/config">one of those guidelines advises keeping configuration in the environment</a>.</p>
<p><a href="https://github.com/lexi-lambda/envy">Envy</a> is the declarative bridge between Racket code and the outside world of the environment.</p>
<footer class="read-more"><a href="/blog/2015/08/30/managing-application-configuration-with-envy/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/08/22/deploying-racket-applications-on-heroku/'>Deploying Racket applications on Heroku</a></h2>
<div class='date-and-tags'>
<time datetime="2015-08-22T14:47:49">
2015-08-22
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/heroku.html">heroku</a>, <a href="/tags/12factor.html">12factor</a></span>
</div>
</header>
<p><a href="https://www.heroku.com">Heroku</a> is a &ldquo;platform as a service&rdquo; that provides an incredibly simple way to deploy simple internet applications, and I take liberal advantage of its free tier for testing out simple applications. It has support for a variety of languages built-in, but Racket is not currently among them. Fortunately, Heroku provides an interface for adding custom build processes for arbitrary types of applications, called “buildpacks”. I&rsquo;ve built one for Racket apps, and with just a little bit of configuration, it’s possible to get a Racket webserver running on Heroku.</p>
<footer class="read-more"><a href="/blog/2015/08/22/deploying-racket-applications-on-heroku/">&hellip;more&hellip;</a></footer>
</article>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/'>Automatically deploying a Frog-powered blog to GitHub pages</a></h2>
<div class='date-and-tags'>
<time datetime="2015-07-18T19:09:01">
2015-07-18
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/frog.html">frog</a>, <a href="/tags/meta.html">meta</a></span>
</div>
</header>
<p>So, I have a blog now. It&rsquo;s a simple static blog, but what&rsquo;s unique about it is that it&rsquo;s powered by Racket; specifically, it uses <a href="http://www.greghendershott.com">Greg Hendershott</a>&rsquo;s fantastic <a href="https://github.com/greghendershott/frog">Frog</a> tool. I&rsquo;ve taken this and moulded it to my tastes to build my blog, including configuring automatic deployment via <a href="https://travis-ci.org">Travis CI</a>, so my blog is always up-to-date.</p>
<footer class="read-more"><a href="/blog/2015/07/18/automatically-deploying-a-frog-powered-blog-to-github-pages/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

90
tags/rails.html Normal file
View File

@ -0,0 +1,90 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'rails'</title>
<meta name="description" content="Posts tagged 'rails'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="rails">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/rails.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/rails.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/rails.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>rails</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/'>Canonical factories for testing with factory_girl_api</a></h2>
<div class='date-and-tags'>
<time datetime="2015-09-23T16:30:12">
2015-09-23
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/ruby.html">ruby</a>, <a href="/tags/rails.html">rails</a>, <a href="/tags/javascript.html">javascript</a>, <a href="/tags/angular.html">angular</a></span>
</div>
</header>
<p>Modern web applications are often built as <em>single-page apps</em>, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&rsquo;t catch the failure. I haven&rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.</p>
<p>To attempt to address a fraction of this problem, I built <a href="https://github.com/lexi-lambda/factory_girl_api">factory_girl_api</a>, a way to share context setup between both sides of the application.</p>
<footer class="read-more"><a href="/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

90
tags/ruby.html Normal file
View File

@ -0,0 +1,90 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'ruby'</title>
<meta name="description" content="Posts tagged 'ruby'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="ruby">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/ruby.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/ruby.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/ruby.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>ruby</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/'>Canonical factories for testing with factory_girl_api</a></h2>
<div class='date-and-tags'>
<time datetime="2015-09-23T16:30:12">
2015-09-23
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/ruby.html">ruby</a>, <a href="/tags/rails.html">rails</a>, <a href="/tags/javascript.html">javascript</a>, <a href="/tags/angular.html">angular</a></span>
</div>
</header>
<p>Modern web applications are often built as <em>single-page apps</em>, which are great for keeping concerns separated, but problematic when tested. Logic needs to be duplicated in front- and back-end test suites, and if the two apps diverge, the tests won&rsquo;t catch the failure. I haven&rsquo;t found a very good solution to this problem aside from brittle, end-to-end integration tests.</p>
<p>To attempt to address a fraction of this problem, I built <a href="https://github.com/lexi-lambda/factory_girl_api">factory_girl_api</a>, a way to share context setup between both sides of the application.</p>
<footer class="read-more"><a href="/blog/2015/09/23/canonical-factories-for-testing-with-factory-girl-api/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>

88
tags/typed-racket.html Normal file
View File

@ -0,0 +1,88 @@
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Posts tagged 'typed racket'</title>
<meta name="description" content="Posts tagged 'typed racket'">
<meta name="author" content="Alexis King">
<meta name="keywords" content="typed racket">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link rel="icon" href="/favicon.ico">
<link rel="canonical" href="http://lexi-lambda.github.io/tags/typed-racket.html">
<!-- CSS -->
<link rel="stylesheet" type="text/css" href="//fonts.googleapis.com/css?family=Merriweather+Sans:400,300,300italic,400italic,700,700italic,800,800italic|Merriweather:400,300,300italic,400italic,700,700italic,900,900italic|Source+Code+Pro:200,300,400,500,600,700,900">
<link rel="stylesheet" type="text/css" href="/css/application.min.css">
<link rel="stylesheet" type="text/css" href="/css/pygments.min.css">
<!-- Feeds -->
<link rel="alternate" type="application/atom+xml"
href="/feeds/typed-racket.atom.xml" title="Atom Feed">
<link rel="alternate" type="application/rss+xml"
href="/feeds/typed-racket.rss.xml" title="RSS Feed">
<!-- JS -->
<!-- <script src="/js/application.min.js"></script> -->
<script type="text/javascript">
(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
ga('create', 'UA-65250372-1', 'auto');
ga('send', 'pageview');
</script>
</head>
<body>
<div id="page-content">
<!-- Navigation Bar -->
<header>
<nav role="navigation" class="navigation-bar">
<ul class="navigation-items left">
<li id="blog-title-header"><a href="/"><h1>Alexis King</h1></a></li>
</ul>
<ul class="navigation-items center"></ul>
<ul class="navigation-items right">
<li><a href="/">Home</a></li>
<li><a href="/about.html">About</a></li>
</ul>
</nav>
</header>
<section role="main">
<!-- Main column -->
<div class="content" class="col-md-12">
<h1>Posts tagged <em>typed racket</em></h1>
<article class="inline">
<header>
<h2 class="title"><a href='/blog/2015/12/21/adts-in-typed-racket-with-macros/'>ADTs in Typed Racket with macros</a></h2>
<div class='date-and-tags'>
<time datetime="2015-12-21T17:57:07">
2015-12-21
</time>
<span style="margin: 0 3px">⦿</span>
<span class="tags"><a href="/tags/racket.html">racket</a>, <a href="/tags/typed-racket.html">typed racket</a>, <a href="/tags/macros.html">macros</a></span>
</div>
</header>
<p>Macros are one of Racket&rsquo;s flagship features, and its macro system really is state of the art. Of course, it can sometimes be difficult to demonstrate <em>why</em> macros are so highly esteemed, in part because it can be hard to find self-contained examples of using macros in practice. Of course, one thing that macros are perfect for is filling a &ldquo;hole&rdquo; in the language by introducing a feature a language lacks, and one of those features in Typed Racket is <strong>ADTs</strong>.</p>
<footer class="read-more"><a href="/blog/2015/12/21/adts-in-typed-racket-with-macros/">&hellip;more&hellip;</a></footer>
</article>
</div>
</section>
<footer>
<div class="content">
<h2 id="copyright-notice">© 2016, Alexis King</h2>
<h3>
Built with <a href="https://github.com/greghendershott/frog">Frog</a>, the
<strong>fr</strong>ozen bl<strong>og</strong> tool.
</h3>
<h3>
Feeds are available via <a href="/feeds/all.atom.xml">Atom</a>
or <a href="/feeds/all.rss.xml">RSS</a>.
</h3>
</div>
</footer>
</div>
</body>
</html>