Re: input data for babel blocks

[Eric Schulte <schulte.eric@gmail.com>]

Alan Schmitt <alan.schmitt@polytechnique.org> writes:

> Hello,
>
> In my quest for analyzing my data in org mode tables, I'm trying to see
> if I can use my favorite language (i.e., ocaml). I'm thus looking at how
> to input such tables in a caml program. I found that the following works
> well:
>
> --8<---------------cut here---------------start------------->8---
> #+name: data
> | 12 |
> | 42 |
>
> #+BEGIN_SRC ocaml :var x=data
> x
> #+END_SRC
>
> #+RESULTS:
> : - : int array array = [|[|12|]; [|42|]|]
> --8<---------------cut here---------------end--------------->8---
>
> (The only "bad" thing is that a single value is an array, but this is
> probably related to the following thing.) Unfortunately (for interaction
> with org mode), caml is strongly typed, and arrays must be
> homogeneous. Thus the following fails:
>
> --8<---------------cut here---------------start------------->8---
> #+name: myinput
> | x | 12 |
> | y | 24 |
>
> #+BEGIN_SRC ocaml :var x=myinput
> x
> #+END_SRC
> --8<---------------cut here---------------end--------------->8---
>
> with the error in the toplevel:
>
> --8<---------------cut here---------------start------------->8---
> # let x = [|[|"x"; 12|]; [|"y"; 24|]|];;
> x;;
> "org-babel-ocaml-eoe";;
> Characters 17-19:
>   let x = [|[|"x"; 12|]; [|"y"; 24|]|];;
>                    ^^
> Error: This expression has type int but an expression was expected of type
>          string
> --8<---------------cut here---------------end--------------->8---
>
> I would like to change the parsing of table in ob-ocaml so that it
> generates an array of _tuples_, for instance for the previous example:
>
> #+BEGIN_SRC ocaml
> let x = [| ("x", 12); ("y", 24) |];;
> #+END_SRC
>
> I looked at the code, and this seems to be the relevant part:
>
> #+BEGIN_SRC emacs-lisp
> (defun org-babel-variable-assignments:ocaml (params)
>   "Return list of ocaml statements assigning the block's variables."
>   (mapcar
>    (lambda (pair) (format "let %s = %s;;" (car pair)
> 			  (org-babel-ocaml-elisp-to-ocaml (cdr pair))))
>    (mapcar #'cdr (org-babel-get-header params :var))))
>
> (defun org-babel-ocaml-elisp-to-ocaml (val)
>   "Return a string of ocaml code which evaluates to VAL."
>   (if (listp val)
>       (concat "[|" (mapconcat #'org-babel-ocaml-elisp-to-ocaml val "; ") "|]")
>     (format "%S" val)))
> #+END_SRC
>
> I tried tweaking this to the following:
>
> #+BEGIN_SRC emacs-lisp
> (defun org-babel-variable-assignments:ocaml (params)
>   "Return list of ocaml statements assigning the block's variables."
>   (mapcar
>    (lambda (pair) (format "let %s = %s;;" (car pair)
> 			  (org-babel-ocaml-elisp-to-ocaml (cdr pair))))
>    (mapcar #'cdr (org-babel-get-header params :var))))
>
> (defun org-babel-ocaml-elisp-to-ocaml (val)
>   "Return a string of ocaml code which evaluates to VAL."
>   (if (listp val)
>       (concat "[|" (mapconcat #'org-babel-ocaml-elisp-to-ocaml-tuple val "; ") "|]")
>     (format "%S" val)))
>
> (defun org-babel-ocaml-elisp-to-ocaml-tuple (val)
>   "Return a string of ocaml code which evaluates to VAL, as a tuple."
>   (if (listp val)
>       (concat "(" (mapconcat #'org-babel-ocaml-elisp-to-ocaml-tuple val ", ") ")")
>     (format "%S" val)))
> #+END_SRC
>
> Now the example seems to work:
>
> --8<---------------cut here---------------start------------->8---
> #+name: myinput
> | x | 12 |
> | y | 24 |
>
> #+BEGIN_SRC ocaml :var x=myinput
> x
> #+END_SRC
>
> #+RESULTS:
> : - : (string * int) array = [|("x", 12); ("y", 24)|]
> --8<---------------cut here---------------end--------------->8---
>
> (and the previous example is even nicer:
> --8<---------------cut here---------------start------------->8---
> #+name: data
> | 12 |
> | 42 |
>
> #+BEGIN_SRC ocaml :var x=data
> x
> #+END_SRC
>
> #+RESULTS:
> : - : int array = [|12; 42|]
> --8<---------------cut here---------------end--------------->8---
> )
>
> I have the following questions for the list:
> - can I always assume that tables are passed as lists of lists?

Currently this is the default behavior in (I believe) every language.

> 
> - would the patch above be a useful way to deal with this?

My problem with the patch above is that it makes OCaml different from
every other language (especially ob-haskell which has similar type
restraints), and that it doesn't work for tables with different
alignment, e.g.,

| x | y |
| 0 | 1 |

I guess one possible "correct" solution would be to use a variant type
with something like the following.

    type orgCell =
      | Int of int
      | Float of float
      | String of string

> - is there a way to specify the :var parsing in a code block or in the
> table?
>

Currently there is not.  Perhaps there is an elegant solution using a
new header argument to control how values are represented in literal
source code.

This is an interesting question.  I'm not sure what is best here, but
ideally any solution will generalize to other strongly typed languages,
will support all possible tables, and will work simply for simple tables
allowing users to use tables without having to jump through typed hoops.

Cheers,

>
> Thanks,
>
> Alan
>

-- 
Eric Schulte
https://cs.unm.edu/~eschulte
PGP: 0x614CA05D