S-expressions: Difference between revisions

 

The reader should be able to read the following input

and turn it into a native datastructure. (see the [[#Pike|Pike]], [[#Python|Python]] and [[#Ruby|Ruby]] implementations for examples of native data structures.)

 

Let the writer produce pretty printed output with indenting and line-breaks.

<br><br>

 

=={{header|Ada}}==

Specification of package S_Expr:

 

private with Ada.Containers.Indefinite_Vectors;

 

end record;

 

 

The implementation of S_Expr:

 

 

package body S_Expr is

end Print;

 

 

Specification and Implementation of S_Expr.Parser (a child package of S_Expr):

 

package S_Expr.Parser is

 

-- the result of a parse process is always a list of expressions

 

 

 

package body S_Expr.Parser is

end Parse;

 

 

The main program Test_S_Expr:

 

 

procedure Test_S_Expr is

Expression_List.First.Print(Indention => 0);

-- Parse will output a list of S-Expressions. We need the first Expression.

 

{{out}}

 

=={{header|ALGOL 68}}==

CHAR nl = REPR 10;

# mode representing an S-expression #

+ nl

)

{{out}}

<pre>

)

</pre>

 

=={{header|AutoHotkey}}==

Str := RegExReplace(Str, "s)(?<![\\])"".*?[^\\]""(*SKIP)(*F)|((?<![\\])[)(]|\s)", "`n$0`n")

Str := RegExReplace(Str, "`am)^\s*\v+") , Cnt := 0

Res .= "`t"

return Res

(

((data da\(\)ta "quot\\ed data" 123 4.5)

("data" (!@# (4.5) "(mo\"re" "data)")))

)

{{out}}

<pre>(

 

=={{header|C}}==

#include <stdlib.h>

#include <ctype.h>

print_expr(x, 0);

return 0;

((data da\(\)ta "quot\\ed data" 123 4.5)

("data" (!@# (4.5) "(mo\"re" "data)")))

)

)

 

=={{header|Ceylon}}==

shared String symbol;

string => symbol;

prettyPrint(tree);

}

{{out}}

<pre>

=={{header|CoffeeScript}}==

{{improve|CoffeeScript|This solution does not reproduce unquoted strings as per task description}}

# This code works with Lisp-like s-expressions.

#

console.log "output:\n#{pp output}\n"

console.log "round trip:\n#{sexp output}\n"

{{out}}

> coffee sexp.coffee

input:

round trip:

(("data" "quoted data with escaped \"" 123 4.5 "14") ("data" ("!@#" (4.5) "(more" "data)")))

 

=={{header|Common Lisp}}==

Unfortunately, our pointy-haired boss has asked you to write a parser for an unusual s-expression syntax that uses square brackets instead of parenthesis. In most programming languages, this would necessitate writing an entire parser. Fortunately, the Common Lisp reader can be modified through the use of macro-characters to accomplish this task. When the reader parses a macro-character token, a function associated with the macro-character is called. As evidenced below, modifying the behavior of the Lisp reader by setting macro-character functions to handle additional sytax requires far less work than writing a complete parser from scratch.

 

(declare (ignore char))

(read-delimited-list #\] stream t))

(set-macro-character #\[ #'lsquare-reader) ;;Call the lsquare-reader function when a '[' token is parsed

Unit test code:

;;test string and the cdr (right side) the expected result of reading the S-Exp.

(setf unit-tests

(dolist (test unit-tests)

(format t "String: ~23s Expected: ~23s Actual: ~s~%"

{{out| Unit test output}}

<pre>CL-USER> (run-tests)

===Writing S-Expressions===

The next step in this task is to write a standard Lisp s-expression in the square bracket notation.

"Writes a Lisp s-expression in square bracket notation."

(labels ((parse (sexp)

(subseq str 0 last-char)

str)))))))

Unit test code:

(1 (2 (3 (4)))) ((1) (2) (3)) ()))

 

(dolist (test unit-tests)

(format t "Before: ~18s After: ~s~%"

{{out|Unit test output}}

<pre>CL-USER> (run-tests)

CL-USER> </pre>

 

 

 

 

 

 

 

 

 

 

else

 

 

 

 

 

{{out}}

 

=={{header|D}}==

std.functional, std.string;

 

"Printed: ".write;

pTest.writeSexp;

{{out}}

<pre>Parsed: [[data, quoted data, 123, 4.5], [data, [!@#, [4.5], (more, data)]]]

=={{header|EchoLisp}}==

The '''(read-from-string input-string)''' function parses a string into an s-expression, which is the native representation of program/data in EchoLisp and the majority of Lisps .

(define input-string #'((data "quoted data" 123 4.5)\n(data (!@# (4.5) "(more" "data)")))'#)

 

(first(rest s-expr))

→ (data (!@# (4.5) "(more" "data)"))

 

 

=={{header|Go}}==

 

import (

fmt.Println(s.i)

}

{{out}}

<pre>

 

=={{header|Haskell}}==

import Text.Parsec.Char (noneOf)

import Text.Parsec.Language (haskell)

 

 

tProg = many tExpr <?> "program"

 

p = either print (putStrLn . unwords . map show) . parse tProg ""

 

main = do

 

=={{header|Icon}} and {{header|Unicon}}==

The example takes single and double quotes. <br>

Single quotes were used instead of doubles in the input.

 

procedure main()

}

return T

 

{{libheader|Icon Programming Library}}

This implementation does not support escape characters. If escape characters were added, we would need additional support in the tokenizer (an extra character class, and in the state table an extra column and two extra rows, or almost double the number of state transitions: 35 instead of 20), and additional support in the data language (unfmt would need to strip out escape characters and fmt would need to insert escape characters -- so each of these routines would also perhaps double in size.) And that's a lot of bulk for serialize/deserialize mechanism which, by design, cannot represent frequently used data elements (such as matrices and gerunds).

 

chrMap=: '()';'"';' ',LF,TAB,CR

 

 

readSexpr=: fmt L:0 @rdSexpr :.writeSexpr

 

 

Example use:

 

┌───────────────────────────┬────────────────────────────────┐

│┌─────┬───────────┬───┬───┐│┌─────┬────────────────────────┐│

└───────────────────────────┴────────────────────────────────┘

writeSexpr readSexpr '((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))'

 

=={{header|Java}}==

 

====LispTokenizer.java====

 

import java.io.BufferedReader;

{

}

 

====Token.java====

import java.io.StreamTokenizer;

 

}

}

 

====Atom.java====

 

import jfkbits.LispParser.Expr;

}

 

 

====StringAtom.java====

 

public class StringAtom extends Atom

}

}

 

====ExprList.java====

 

import java.util.AbstractCollection;

}

 

 

====LispParser.java====

 

 

 

}

 

====LispParserDemo.java====

import jfkbits.LispParser;

import jfkbits.LispParser.ParseException;

}

}

 

=={{header|JavaScript}}==

var t = this.match(/\s*("[^"]*"|\(|\)|"|[^\s()"]+)/g)

for (var o, c=0, i=t.length-1; i>=0; i--) {

document.write('Invalid s-expr!', '<br>')

else

((data "quoted data" 123 4.5)

(data (!@# (4.5) "(more" "data)")))

)

)

</pre>

 

=={{header|Julia}}==

function rewritequotedparen(s)

segments = split(s, "\"")

println("The processed native structure is:\n", nat)

println("The reconstructed string is:\n"), printAny(nat)

{{output}}<pre>

The input string is:

=={{header|Kotlin}}==

{{trans|JavaScript}}

 

const val INDENT = 2

tokens2.prettyPrint()

}

 

{{out}}

</pre>

 

 

 

The file <code>SExpr.mli</code> containing the interface:

 

(* Copyright (C) 2009 Florent Monnier, released under MIT license. *)

 

 

val string_of_sexpr_indent : sexpr list -> string

 

The file <code>SExpr.ml</code> containing the implementation:

 

(* Copyright (C) 2009 Florent Monnier, released under MIT license. *)

(* modified to match the task description *)

 

let print_sexpr_indent s =

 

Then we compile this small module and test it in the interactive loop:

 

=={{header|Perl}}==

use strict;

use warnings;

ref($_) eq 'ARRAY' ? sexpr2txt($_) : $$_

} @{$_[0]} ]})}

Check:

 

((data "quoted data" 123 4.5)

 

# Convert back

Output:

<pre>$VAR1 = [

]

];

((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))</pre>

 

that may not be clear on the display: 4e-5 and 4-e5 may appear similar but the latter is probably a parse failure. It may

be more sensible for get_term() to raise an error if the scanf fails, than assume it is a symbol like it does now.

{{out}}

<pre>

=={{header|PicoLisp}}==

The '[http://software-lab.de/doc/refA.html#any any]' function parses an s-expression from a string (indentical to the way '[http://software-lab.de/doc/refR.html#read read]' does this from an input stream).

-> ((data "quoted data" 123 5) (data (!@# (5) "(more" "data)")))

 

+-- "(more"

|

Implementing a subset of 'any' explicitly:

(case (skip)

("(" (char) (readList))

(until (or (sp? (peek)) (member (peek) '("(" ")")))

(link (char)) ) )

It can be used in a pipe to read from a string:

'[http://software-lab.de/doc/refS.html#sym sym]' does the reverse (i.e. builds a symbol (string) from an expression).

Implementing a subset of the built-in printer:

(cond

((pair Expr)

(mapc Fun (chop Expr))

(Fun "\"") )

This can be used for plain printing

'((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))

prin )

or to collect the characters into a string:

(make

(printSexpr

'((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))

link ) ) )

 

=={{header|Pike}}==

{

string _sprintf(int type)

string input = "((data \"quoted data\" 123 4.5)\n (data (!@# (4.5) \"(more\" \"data)\")))";

array data = group(tokenizer(input))[0];

 

Output:

=={{header|Potion}}==

How values are stored: Tuples for list, integers for integers, floats for floats, strings for symbols, quoted strings for strings. This implementation is not the most elegant/succinct or practical (it's trusty and has no real error handling).

iswhitespace = (c): c ord == 10 or c ord == 13 or c == " ".

 

parsesexpr("((data \"quoted data\" 123 4.5)

(data (!@# (4.5) \"(more\" \"data)\")))") string print

 

=={{header|Python}}==

 

dbg = False

print("\nParsed to Python:", parsed)

 

 

;Output:

;Simpler parser:

Note that in the example above the parser also recognises and changes the type of some tokens as well as generating a nested list. If that functionality is not needed, or better done elsewhere, then the parse function can be achieved more simply by just applying the regexp:

>>> x = [[(t,v) for t,v in termtypes.groupdict().items() if v][0] for termtypes in re.finditer(term_regex, sexp)]

>>> pp(x)

('brackr', ')'),

('brackr', ')')]

 

=={{header|Racket}}==

 

Racket has builtin support for S-expressions in the form of the read function.

#lang racket

(define input

 

(read (open-input-string input))

Output:

<pre>

'((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))

</pre>

 

=={{header|REXX}}==

<br>Also added were two more separators &nbsp; (a comma and semicolon).

<br>Separators that could be added are more whitespace characters (vertical/horizontal tabs, line feed, form feed, tab char, etc).

input= '((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))'

say center('input', length(input), "═") /*display the header title to terminal.*/

end /*n*/ /* [↑] handle a bunch of grouping syms*/

literals=

end /*k*/

!=; literalStart=

 

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

=={{header|Ruby}}==

{{works with|Ruby|1.9}}

def initialize(str)

@original = str

puts "original sexpr:\n#{sexpr.original}"

puts "\nruby data structure:\n#{sexpr.data}"

 

{{out}}

((data "quoted data" 123 4.5) (data (!@# (4.5) "(more" "data)")))

</pre>