From b2fdd3f580bb8ff7aabb8b64feb0d354ac151352 Mon Sep 17 00:00:00 2001 From: jim Date: Sat, 4 Apr 2015 17:12:59 -0400 Subject: [PATCH] create page --- topics/week9_using_the_juli8_library.mdwn | 85 +++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) create mode 100644 topics/week9_using_the_juli8_library.mdwn diff --git a/topics/week9_using_the_juli8_library.mdwn b/topics/week9_using_the_juli8_library.mdwn new file mode 100644 index 00000000..bdceb622 --- /dev/null +++ b/topics/week9_using_the_juli8_library.mdwn @@ -0,0 +1,85 @@ +[[!toc]] + +## Using the Juli8 Libraries ## + +In addition to the fine programming language Kapulet, which doesn't yet exist in a form you can actually execute --- though the full-featured interpreter we provided last week is a good start --- I decided it would be useful to have a collection of basic libraries for our teaching (and other) purposes, that brought OCaml, Haskell, and the Scheme implementations we recommend, more onto even footing. Of course there are fundamental differences between these languages, such as the lack of types in Scheme (though both Racket and Chicken have some facility for working with types in extensions), or the default lazy evaluation strategy in Haskell. But there are also many simply accidental differences between the languages too, in that this one provides a library function doing so-and-so, but the other one doesn't, or calls it by a different name. The Juli8 collection of libraries is aimed to reduce these differences, to make it easier to move back and forth between the languages, and also to just make some of the languages generally easier to use (from my perspective). Juli8 will eventually have components that you can install into each of Haskell, OCaml, Racket, and Chicken. For the moment, OCaml is the most developed of these, and Haskell a bit, with the Scheme components deferred for another time. + +Juli8 tries to give OCaml more-or-less the same functionality that you have in Haskell's Maybe, List, and Monad libraries, as well as a few others. It doesn't try for an exact match, and it doesn't strictly use the same names as Haskell does. I've aimed also to at least stay close to the existing OCaml naming patterns, and also the Scheme naming patterns when they are salient to me. + +First we'll give instructions on how to install Juli8 into your existing Haskell and/or OCaml setups. Then we'll give instructions on how to use the non-monadic parts of the Juli8 libraries for OCaml. We discuss how to use the monadic parts of the Juli8 libraries for OCaml [[here]]. At the end, we say a little bit about what Juli8 provides you if you're using Haskell. + +## Setting up OCaml ## + +1. In our instructions for installing OCaml, some of the strategies involved installing the OPAM package manager. (This doesn't appear to be available for Windows.) If you did install OPAM, then we recommend typing the following commands inside a terminal session (that is, *not* inside an OCaml session, but inside the prompt where you'd start OCaml by typing `ocaml`). + + opam update + opam upgrade + opam install delimcc + + We also recommend upgrading to one of the more recent versions of OCaml. This gets you the most recent stable release: + + opam switch 4.02.1 && opam install --switch=4.02.1 delimcc && eval `opam config env` + + This will get you a slightly older release, which however has "improved type error messages": + + opam switch 4.02.0+improved-errors && opam install --switch=4.02.0+improved-errors delimcc && eval `opam config env` + + Installing the `delimcc` library gives you Oleg's Delimited Continuation library for OCaml, which we will encourage you to play around with later in the term. It's not essential to have it, though. There are some advantages to using one of the 4.02.x versions of OCaml, though, rather than the 4.01.0 version I think most of us ended up installing. One advantage is that now you can use the special #show symbol command in OCaml sessions, which works like Haskell's special :info symbol inside a GHCi session. Then for example, instead of having to type: + + module type SOMETHING = Monad.OPTION + + as I directed you [[elsewhere]], you can instead just type: + + #show Monad.OPTION + +2. The program that starts up when you type `ocaml` is OCaml's Standard "Toplevel" Interactive Interpreter. There's an alternative interactive interpreter that you can try out, which some people like. It's called utop and [you can read about it here](https://github.com/diml/utop) or [here](https://opam.ocaml.org/blog/about-utop). To install it, you can just type `opam install utop`. I'm not so crazy about it myself. But I prefer to use *some* kind of helper program with OCaml's Standard Toplevel, because the Standard Toplevel itself doesn't let you scroll back through commands you typed previously, has only very rudimentary facilities for editing a line if you made a mistake and so on. One virtue of utop is that it does those things better, but there are also other ways to do them better. What I use is a wrapper program called `rlwrap`. Here are instructions for how to install that: + + > First, I had to upgrade the version of the "GNU readline" library on my computer. My Mac with System 10.9.5 has a version of that library, but it's too old to use with recent versions of `rlwrap`. So I downloaded [the source code for GNU readline](http://ftp.gnu.org/gnu/readline/readline-6.3.tar.gz). Double click the downloaded archive to expand it, if your browser doesn't do that automatically. Then go inside the `readline-6.3` folder in a Terminal. On a Mac, you can click on the folder in the Finder and do a Copy (or cmd-C). Then open a Terminal and type `cd` followed by a space then do a Paste (cmd-V). Then press return. Once you're inside the `readline-6.3` folder, type this command in the Terminal: + + > ./configure --prefix=$HOME && make && make install + + > That should build and install the readline library in your local user directories. It will take a couple of minutes. Next, download [the source code for rlwrap](http://utopia.knoware.nl/~hlub/rlwrap/rlwrap-0.42.tar.gz). Double-click to expand and go inside the `rlwrap-0.42` folder in a Terminal, as before. Then type this command in the Terminal: + + > ./configure --prefix=$HOME && make CFLAGS="-g -O2 -I $HOME/include -L $HOME/lib" && make install + + If that all completes without errors, then you have gotten `rlwrap` installed. Congratulations. To use it, you just will now type `rlwrap ocaml ...` wherever before you would ordinarily type `ocaml ...` This is just to make interactive OCaml sessions nicer. To compile code with `ocamlc ...` and so on, you don't use `rlwrap` for that. (If you see error messages of the form `-bash: rlwrap: command not found`, then you should make sure that you have a `.bash_profile` or `.bashrc` in your `$HOME` directory which has a line containing something like `export PATH="$HOME/bin:$HOME/Library/Haskell/bin:$PATH"`. Then maybe start up a new Terminal.) + + Some key commands you can now use are: + + * BLAH + + If you want to customize `rlwrap` or these keycommands, you can read the documentation at `man rlwrap` and `man readline`, and also look into the Preferences of your Terminal program. (On the Mac, look under Terminal menu/Preferences/Keyboard tab.) This gets complicated quickly, but those are the places to start looking if you want to experiment. You should of course also read around on the web, rather than just changing these blindly. + +3. Whether you use `utop` or `rlwrap ocaml` or just plain `ocaml`, you will need to set up some initialization commands in order to use the Juli8 libraries. You'll want to edit or create an file called `.ocamlinit` in your `$HOME` directory. The file may already be there and have some commands in it if you used OPAM. + + After any commands that are already there, add these lines: + + #load "str.cma";; + module Std = struct + include Pervasives + module List = List + module Random = Random + module String = String + end + + #directory "+../delimcc";; + + #directory "/Users/jim/.juli8/ocaml";; (* you'll have to substitute your own $HOME directory in for `/Users/jim/` *) + + #use "juli8.ml";; + +4. Next create a folder in your `$HOME` directory named `.juli8`. Download the Juli8 code from [[here]]. That link will no doubt be updated frequently in April and May 2015. The current version is: 1.2, posted 4 April 2015. Copy the contents of the `Juli8` folder that you downloaded into the `$HOME/.juli8` folder that you created. + + Now whenever you start up OCaml, the Juli8 OCaml libraries (including their monad components, which we'll be making extensive use of) will automatically be loaded. + + +If you're only going to use Juli8 for OCaml and not for Haskell, you can skip ahead to later in this document... + +## Setting up Haskell for use with Juli8 ## + +Will add... + +## Using the Juli8 libraries with OCaml ## + +Will add here some guidance on using the non-monadic parts of the Juli8 library. For the monadic part, [[see here]]. + -- 2.11.0