(defparameter ht (make-hash-table))

(ht 'foo) == (gethash 'foo ht)
(setf (ht 'foo) t) == (setf (gethash 'foo ht) t)

It should be easy to emulate the hash table reader at least in
function context, by defining a custom DEFUN-wrapping macro that
dispatches either to FUNCALL or to GETHASH depending on the data type.

Is this also possible for the SETF expansion? I think it should be,
but I hardly ever use the DEFSETF facilities so I'm not sure how.

Command: ("abc" 1)
#\b

That's an old Lisp feature to make some data objects
having a functional interpretation. In LML for examples
arrays in functional position were evaluated as doing
AREF.

bobi

(funcall *ht* 1)

The missing part could be a macro which enables writing single-
namespace lisp code:

(defmacro with-single-namespace ((&rest fns) &body forms)
   `(macrolet (,@(mapcar (lambda (fn) `(,fn (&rest args)
                                       `(funcall ,',fn ,@,'args)))
fns))
                  ,@forms))

(with-single-namespace (*ht*)
  (+ (*ht* 1) (*ht* 2)))

-> (+ (funcall *ht* 1) (funcall *ht* 2))

Another solution could be:

(defmacro with-hashtables ((&rest hts) &body forms)
  `(macrolet (,@(mapcar (lambda (ht) `(,ht (key)
                                        `(gethash ,,'key ,',ht)))
hts))
     ,@forms))

(defmacro with-arrays ((&rest as) &body forms)
   `(macrolet (,@(mapcar (lambda (a) `(,a (&rest args)
                                       `(aref ,',a ,@,'args))) as))
                  ,@forms))

Or as generalization of this:

(defmacro with-collections ((&rest cs) &body forms)
   `(macrolet (,@(mapcar (lambda (c) `(,c (&rest args)
                                       `(element ,',c ,@,'args)))
cs))
                  ,@forms))

(defmethod element ((ht hash-table) &rest keys)
  (if (rest keys)
    (apply #'element (gethash (first keys) ht) (rest keys))
  (gethash (first keys) ht)))

(defmethod element ((a array) &rest keys)
  (apply #'aref a keys))

(defun alist->ht (alist &key (test 'eql))
  (loop with ht = (make-hash-table :test test)
        for (key . value) in alist do (setf (gethash key ht) value)
        finally (return ht)))

(defun plist->ht (plist &key (test 'eql))
  (loop with ht = (make-hash-table :test test)
        for (key value) on plist by #'cddr do (setf (gethash key ht)
value)
        finally (return ht)))

(let ((ht (alist->ht `((a . ,(alist->ht '((1 . "Foo")(2 . "Bar")(3 .
"Baz"))))
                       (b . ,(alist->ht '((1 . "FOO")(2 . "BAR")(3 .
"BAZ")))))))
      (a #(a b c d e f))
      (mix (plist->ht `(a #(p q r) b #(x y z)))))
  (with-collections (ht a mix) (values (ht 'b 3) (a 2) (mix 'b 1))))

==>
"BAZ"
C
Y

--
Jochen Schmidt
CRISPYLOGICS
Uhlandstr. 9, 90408 Nuremberg

Fon +49 (0)911 517 999 82
Fax +49 (0)911 517 999 83

 LPP> (defparameter ht (make-hash-table))

 LPP> (ht 'foo) == (gethash 'foo ht)
 LPP> (setf (ht 'foo) t) == (setf (gethash 'foo ht) t)

 LPP> It should be easy to emulate the hash table reader at least in
 LPP> function context, by defining a custom DEFUN-wrapping macro that
 LPP> dispatches either to FUNCALL or to GETHASH depending on the data type.

 LPP> Is this also possible for the SETF expansion? I think it should be,
 LPP> but I hardly ever use the DEFSETF facilities so I'm not sure how.

it is fairly easy to do this for custom binding contstructs. something like
this:

(defmacro defhash (name value)
 `(progn (defparameter ,name ,value)
            (defun ,name (key) (gethash key ,name))
            (defun (setf ,name) (value key) (setf (gethash key ,name)
value))))

(defmacro lethash ((name value) &body body)
 `(let ((,name ,value))
   (macrolet ((,name (key) `(gethash ,key ,,name)))
    ,@body)))

if you want to use normal lisp binding constructs, that becomes more tricky.
you can do this for special variables one way or another. but for lexical
bindings
that becomes really hard -- basically you need to modify all binding
constructs
and inject macros via macrolet that will deal with the case where variable
name
is used like a function. handling setf wil be even more problematic..
but there is actually have little sense -- essentially that will be not a
Common Lisp
but some new Lisp-1 dialect [*]. perhaps then just port Clojure (or Arc or
whatever) to
 Common Lisp..

*: consider such case:

 (defun foo (x)
   (let ((foo (make-hash-table)))
       (foo x)))

(print :foo-val)  ==> will it print 100 or 200?
(print (:foo h1)) ==> prints 100 and is not dramatically much verbose.

or
user> [(:foo h2) (h2 :name)]
[200 "Slodoban"]

When keywords (symbols with a : in the front) were used then these
keywords act as getter function. But one can in general also have the
collection object first and then the key:
([10 20 30] 1) ==> 20

But your suggestion of (ht '(foo bar baz)) is really not good, as Alex
already mentioned. People want to have the list (foo bar baz) as the key
for their hash map.

Why not just (map #(like (str %) "*-bar") (keys ht)) to get all keys
that end with "-bar"?
Or instead of map you could
(first (filter #(like (str %) "*-bar") (keys ht)))

Consider a syntax transformation via code walker that does something
like

  (fn-or-ht arg)

  =>

Error: The variable FN-OR-HT is unbound.
  1 (continue) Try evaluating FN-OR-HT again.
  2 Specify a value to use this time instead of evaluating FN-OR-HT.
  3 Specify a value to set FN-OR-HT to.
  4 (abort) Return to level 0.
  5 Return to top loop level 0.

Type :b for backtrace or :c <option number> to proceed.
Type :bug-form "<subject>" for a bug report template or :? for other options.

CL-USER 5 : 1 > :top

CL-USER 6 > (flet ((fn-or-ht (foo) foo))
  (if (typep fn-or-ht 'hash-table)
      (gethash fn-or-ht arg)
    (funcall (function fn-or-ht) arg)))

Error: The variable FN-OR-HT is unbound.
  1 (continue) Try evaluating FN-OR-HT again.
  2 Specify a value to use this time instead of evaluating FN-OR-HT.
  3 Specify a value to set FN-OR-HT to.
  4 (abort) Return to level 0.
  5 Return to top loop level 0.

Type :b for backtrace or :c <option number> to proceed.
Type :bug-form "<subject>" for a bug report template or :? for other options.

CL-USER 7 : 1 >

 LPP> Why not?

(setq car (make-hash-table))

Treating as a symbol is fine
  (setf (gethash 'a car) 'quux)

(gethash 'a car) => quux

But what happens with

(car '(foo or quux)) ?

It clashes with the CL:CAR function. Is the compiler supposed to
understand that the value of the symbol is a hashtable hence
effectively producing (gethash ...)? Is the value of CAR (value is
changeable) now the hash table? Yes, probably. And what is the value
of the function slot? (car '(a b c)) => a or does it now have
#'gethash. But what happens if it finds (funcall car 'a).

http://exploring-lisp.blogspot.com/2007/05/objects-as-functions.html

This doesn't provide an entire solution, since you'd still need to
write a hash table implementation. In your own package, though, you
could shadow the CL hash table functions and provide the same
interface though your own symbols (make-hash-table, gethash, …).

There are still some issue with the idea though, since CL is a Lisp-2,
you end up having to do things such as those in Geoff's post, such as:

(defun f () nil)
(setf (symbol-function 'f)
      (make-instance 'setl-map :pairs '((1 . 100) (2 . 200))))

so that (f …) will be a call to the correct object, but you still
can't do things like:

(let ((f (make-funcallable-hash-table …)))
  (f …))

and be calling the local funcallable object. Instead you'd have to:

(let ((f (make-funcallable-hash-table …)))
  (funcall f …))

but (funcall f …) isn't really any more concise than (gethash f …), so
we're right back where we started.

JavaScript:

js> h = {foo: 77, bar: 88}
[object Object]
js> h.foo
77
js> h.bar
88

h = {:foo, "foo_val", :bar, "bar_val", :baz, "baz_val"}
    ==>{:baz=>"baz_val", :foo=>"foo_val", :bar=>"bar_val"}
h.values_at( :foo, :bar, :baz )
    ==>["foo_val", "bar_val", "baz_val"]

Please, just ignore these questions, until we see them asked in clc++ or
similarly in other cl* groups:

    What can be done to be able to write:

        int f(){
           std::map<std::string,int> m;
           m("toto")=42;
           return m("toto");
        }

    in C++?

int f(){
    std::map<std::string,int> m;
    m["toto"]=42;
    return m["toto"];

Although they could have chosen to define it as
mapped_type & operator()(const key_type &);

(lst 1)
2
(arr 1)
2
(lst 0 2)
(1 3)
(arr 0 2)
(1 3)

2nd map is generalized operator it could operate over multiple
containers:
(map #'> '(1 2 3) '(2 3 4))
while  (container key(s)) or (container predicate) is a current
container accessor.

bobi

I love design by newsgroup.

That's slightly better for accessing  a single element, token count is
the same 2 but you don't have to use braces instead have a dot, but
how would you access more elements or use a predicate WITHOUT
breaking the consistency NOR adding new tokens?

See your cheap ruby tricks doesn't scale well. You already losing 3:1
Now the real challenge?
Given ht : keys 1 2 3 '(1 2)   :values 1-val 2-val 3-val 1-2-val
(h 1 2 '(1 2) (lambda (x) (and (numberp x) (oddp x))))
-> (1-val 2-val 1-2-val (1-val 3-val))

Your move.

WITH-HTS
CL-USER(37): (defparameter ht (make-hash-table))

HT
CL-USER(39): (setf (gethash 2 ht) t)

T
CL-USER(40): (with-hts (ht 2))

T
T
CL-USER(41): (with-hts (ht 1))

NIL
NIL
CL-USER(42): (with-hts (identity 1))

1

This is what I had in mind.