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>

 

 

wspace←' ',⎕TC ⍝ whitespace is space, tab, cr, lf

 

}

 

 

=={{header|Arturo}}==

((data "quoted data" 123 4.5)

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

s: first to :block code

inspect.muted s

 

{{out}}

 

=={{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|C sharp|C#}}==

Git repository with code and tests can be found here: https://github.com/ichensky/SExpression/tree/rosettacode

 

using System;

using System.Collections.Generic;

}

 

using System;

using System.Collections.Generic;

}

}

using System;

using System.Collections.Generic;

}

}

{{out}}

<pre>

apart from writing it out, which fulfils this task's requirements. With some more work

this code might actually be useful.

#include <iomanip>

#include <iostream>

}

return 0;

 

{{out}}

 

=={{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)

a native floating point type, floating point numbers are not.

 

include "strings.coh";

include "malloc.coh";

print("Parsed:\n");

prettyprint(ParseSExp(str));

 

{{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)"))

 

 

Implementation of S-expression parser in F# 4.7 language.

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

 

module SExpr

(* This module is a very simple port of the OCaml version to F# (F-Sharp) *)

(* print_endline (string_of_sexpr_indent s) *)

printfn "%s" (string_of_sexpr_indent s)

 

 

Read the experession from a file of preset it in the code.

 

module Program

(* Learn more about F# at https://fsharp.org *)

(* return an integer exit code *)

0

 

{{out}}

Factor has a comprehensive prettyprinter which can print any Factor object in a readable way. Not only can we leverage it to easily print our native data structure, but we can also call <code>unparse</code> to convert it to a string. This leaves us with a string reminiscent of the original input, and we are able to take it the rest of the way with two simple regular expressions.

 

regexp sequences prettyprint words ;

IN: rosetta-code.s-expressions

sexp>seq dup seq>sexp

"Native:\n%u\n\nRound trip:\n%s\n" printf

{{out}}

<pre>

 

=={{header|Go}}==

 

import (

fmt.Println(s.i)

}

{{out}}

<pre>

 

=={{header|Haskell}}==

import qualified Text.Parsec.Prim as Prim

import Text.Parsec

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

putStrLn ("The input:\n" ++ expr ++ "\n\nParsed as:")

{{Out}}

<pre>The input:

 

Or, parsing by hand (rather than with a parser combinator library) and printing a parse tree diagram:

import Data.List.Split (splitOn)

import Data.Maybe (catMaybes, fromMaybe, listToMaybe)

------------------------ DATA TYPE -----------------------

data Val

= Int Integer

| List [Val]

deriving (Eq, Show, Read)

--------------------------- MAIN -------------------------

main :: IO ()

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

]

------------------- S-EXPRESSION PARSER ------------------

----------------------- TOKEN PARSER ---------------------

atom :: String -> Val

atom s@('"' : _) =

maybeRead :: String -> Maybe Val

maybeRead = fmap fst . listToMaybe . reads

----------------------- TOKENIZATION ---------------------

tokenized :: String -> [String]

tokenized s = quoteTokens '"' s >>= go

go token@('"' : _) = [token]

go s = words $ spacedBrackets s

quoteTokens :: Char -> String -> [String]

where

spacedBrackets :: String -> String

spacedBrackets [] = []

spacedBrackets (c : cs)

| c `elem` "()" = ' ' : c : " " <> spacedBrackets cs

{{Out}}

<pre>Symbol "List"

+- String "(more"

|

 

=={{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}}==

===Procedural===

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

{{out}}

<pre>text:

 

===Functional===

"use strict";

 

 

 

// A tuple of (parsed trees, residual tokens)

// derived from a list of tokens.

 

 

 

 

 

 

};

 

 

// atom :: String -> Expr

const atom = s =>

 

 

// Brackets and quoted or unquoted atomic strings.

quoteTokens("\"")(s).flatMap(

.split(/\s+/u)

.filter(Boolean)

);

 

// Alternating unquoted and quoted segments.

s => s.split(q).flatMap(

);

 

 

 

};

 

 

// --------------------- GENERIC ---------------------

 

// even :: Int -> Bool

// True if 2 is a factor of n.

0 === n % 2;

 

 

f => {

const go = x =>

 

return go;

 

return main();

{{Out}}

 

=={{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}}

Tested with Lua 5.3.5 and LPeg 1.0.2-1.

 

 

imports = 'P R S C V match'

'S';

S = ws * lpar * C((atom + V'S')^0) * rpar / tolist

 

Now to use the <i>sexpr</i> pattern:

 

((data "quoted data" 123 4.5)

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

check(eg_produced, eg_expected)

print("checks out!") -- won't get here if any <i>check()</i> assertion fails

 

And here's the pretty printer, whose output looks like all the others:

 

local function prindent(fmt, expr)

io.write(indent) -- no line break

end

 

 

=={{header|Nim}}==

 

 

const Input = """

else: nil

 

 

{{out}}

 

=={{header|OCaml}}==

 

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 = [

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>

This parses the task, but it isn't really a good lisp parser, because it always wants whitespace between lists, so <code>(()())</code> will fail ( <code>(() ())</code> wont)

 

rule TOP {^ <s-list> $};

 

say "the expression:\n$s-exp\n";

say "the Raku expression:\n{$raku_array.raku}\n";

 

{{out}}

 

It would normally be considered improper, but the literal string delimiters were left intact; making it much easier to understand what is/was being parsed.

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

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

exit 0 /*stick a fork in it, we're all done. */

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

{{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}}

=={{header|Rust}}==

lib.rs:

//! This implementation isn't based on anything in particular, although it's probably informed by a

//! lot of Rust's JSON encoding code. It should be very fast (both encoding and decoding the toy

println!("{:?}", SExp::parse(ctx));

}

<pre>

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

Using guile scheme 2.0.11

 

(define (help port)

(let ((char (read-char port)))

 

(format-sexpr (sexpr-read

 

Output:

=={{header|Sidef}}==

{{trans|Perl}}

txt.trim!

 

 

say s # dump structure

{{out}}

<pre>

=={{header|Tcl}}==

Note that because Tcl doesn't expose a type system (well, not in a conventional sense) the parts of the parsed out data structure are tagged lists; the first element is one of “<tt>string</tt>”, “<tt>int</tt>”, “<tt>real</tt>” and “<tt>atom</tt>” to indicate a leaf token, or “<tt>list</tt>” to indicate a sublist. A “native” data structure could also be generated, but then that would turn things into lists that are not in the original.

 

proc fromSexp {str} {

return [lindex $content 0]

}

Demonstrating with the sample data:

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

set parsed [fromSexp $sample]

puts "sample: $sample"

puts "parsed: $parsed"

Output:

<pre>

Code:

 

@(local (tok))@\

@(cases)@\

expr: @(format nil "~s" e)

junk: @junk

 

Run:

Explanation of most confusing line:

 

 

First, we match an open parenthesis that can be embedded in whitespace. Then we have a <code>@(coll)</code> construct which terminates with <code>@(end)</code>. This is a repetition construct for collecting zero or more items. The <code>:vars (e)</code> argument makes the collect strict: each repetition must bind the variable <code>e</code>. More importantly, in this case, if nothing is

{{libheader|Wren-pattern}}

{{libheader|Wren-fmt}}

 

var INDENT = 2

System.print("\nRecovered S-Expression (pretty print):")

prettyPrint.call(tokens)

 

{{out}}