s-expression

Nokogiri is awesome. I can do things like #css('.bla') which will return the first matching element. Right now we need to do some parsing of Ruby source code - finding all methods within a class etc. We're using the ruby_parser gem, but all it does is comb your source code and spit out S-expressions. Is there anything like Nokogiri for these S-expressions which can do things like "return S-expression for first method found named 'foo'"? The only thing I can think of, is Adam Sanderson's SExpPath library . Although I am accepting Jörg's answer because it is more complete, I ended up discovering

I'm working with a service that provides data as a Lisp-like S-Expression string. This data is arriving thick and fast, and I want to churn through it as quickly as possible, ideally directly on the byte stream (it's only single-byte characters) without any backtracking. These strings can be quite lengthy and I don't want the GC churn of allocating a string for the whole message. My current implementation uses CoCo/R with a grammar, but it has a few problems. Due to the backtracking, it assigns the whole stream to a string. It's also a bit fiddly for users of my code to change if they have to.

I ran into this question earlier today: Example Input: I ran into Joe and Jill and then we went shopping Example Output: [TOP [S [S [NP [PRP I]] [VP [VBD ran] [PP [IN into] [NP [NNP Joe] [CC and] [NNP Jill]]]]] [CC and] [S [ADVP [RB then]] [NP [PRP we]] [VP [VBD went] [NP [NN shopping]]]]]] I was about to suggest simply parsing the expected output (as it looks like an s-expression) into an object (in our case a tree) and then using simple LINQ methods to process it. However, to my surprise, I was unable to find a C# s-expression parser. The only thing I could think of is using Clojure to parse

Can you name languages with static type checking (like Java) and where code is data (like in LISP)? I mean both things in one language. Qi is a statically-typed Lisp dialect. Also, many other Lisp dialects have (optional) static typing. Java itself has very limited capabilities of this kind. The interesting question is not so much whether you can have metaprogramming and static typing, it's whether you can have dynamic metaprogramming be statically type-safe . There is Template Haskell which does metaprogramming and is type-safe, but it is static metaprogramming. At the moment I can not think

I'm getting up-list: Scan error: "Unbalanced parentheses" from this position: (foo "bar|") Snippet from up-list doc: This command assumes point is not in a string or comment. So this is the expected behavior. But I don't care. I just want to go upwards from a list. Could someone suggest an up-list clone that does the proper thing? I'm looking for something better than this naive code: (defun up-list-naive () (interactive) (while (not (ignore-errors (up-list) t)) (forward-char))) Tyler EDIT: incorporated Andreas Rohler's suggestion: This works for me in your test case: (defun my-up-list ()

I do not see why we need nil [1] when to cons a sequence (so-called proper list) of items. It seems to me we can achieve the same goal by using the so-called improper list ( cons -ed pairs without an ending nil ) alone. Since Lisps [2] have already provided a primitive procedure to distinguish between a pair? and an atom (some implementations even provide atom? ), when defining a procedure on a list, e.g., length , I can do the same with just dotted-pairs, as shown below: (define len (lambda (l) (cond ((pair? l) (+ 1 (len (cdr l)))) (else 1) ) ) ) It is obvious that we can apply this procedure