Posts Tagged ‘Languages’

Lisp: Emacs Autocomplete

December 29, 2010 4 comments

Today I hacked some lisp in emacs because I got two new books (Let over Lambda & Land of Lisp).
After a while when the function-definitions became more frequent I missed a language-specific autocomplete (and didn’t only want to use the built-in autocomplete that completes words you wrote earlier) and after some research I found the solution: Emacs Autocomplete. It integrates different language-dictionaries and inserts new words on the fly (with the right settings).

After installing the autocomplete into .emacs.d I inserted the following lines into my .emacs-file to enable it:

;; add .emacs.d to load path
(add-to-list 'load-path "~/.emacs.d")

;; enable autocomplete
(require 'auto-complete-config)
(add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict")
(global-auto-complete-mode t)
(auto-complete-mode t)

To get a lisp-specific autocomplete you’ve got to include ac-slime (found at github): put it into your .emacs.d-folder and include it in your .emacs-file via

;; add lisp autocomplete-support
(require 'ac-slime)
(add-hook 'slime-mode-hook 'set-up-slime-ac)

and to switch on autocomplete globally you have to apply a “dirty fix”:

;; dirty fix for having AC everywhere
(define-globalized-minor-mode real-global-auto-complete-mode
  auto-complete-mode (lambda ()
                       (if (not (minibufferp (current-buffer)))
                         (auto-complete-mode 1))))
(real-global-auto-complete-mode t)

Now only one thing is missing: the mentioned inserting of new words on the fly:

;; create and add new words to the dictionary on the fly
(when (require 'auto-complete-config nil 'noerror)
(add-to-list 'ac-dictionary-directories "~/.emacs.d/ac-dict")
  (setq ac-comphist-file  "~/.emacs.d/ac-comphist.dat")

Lisp: Implementation Competition between Programming Languages

December 8, 2008 3 comments

Today I have found an ‘Implementation Competition between Programming Languages’ at fefe´s Blog.

A simple Problem has been implemented and tested in different Languages [ReadMe]:

  1. Read in from stdio
  2. Split into Words
  3. Count the Words
  4. Sort Words
  5. Print sorted Words

I saw that it wasn´t implemented in LISP yet so I asked Christopher if we don´t want to do that!

So here is the Program in LISP:

; Splits the given 'string' at 'split-string'-Sequence
(defun string-split (split-string string)
(loop with l = (length split-string)
   for n = 0 then (+ pos l)
   for pos = (search split-string string :start2 n)
   if pos collect (subseq string n pos)
   else collect (subseq string n)
   while pos))

; If 'word' in the Hashtable 'ht', increment + 1
; else create new Key-/Value-Pair with Value = 1
(defun insert-key-value (word ht)
  (when (and (stringp word)
	     (string/= word "")
	     (string/= word " ")
	     (not (null word))))   ; no blank words
    (if (gethash word ht)
	(incf (gethash word ht))
	(setf (gethash word ht) 1)))

; Gets a Hashtable 'ht' and a Sort-Function 'sort-fn'
; Optional Parameter: 'by' can be :keys or :values
; Returns a sorted Hashtable of key-value-Pairs
(defun sort-hash-table (ht sort-fn &optional &key (by :keys))
  (let ((sorted-entries nil))
    (maphash #'(lambda (k v) (push (cons k v) sorted-entries)) ht)
    (let ((sort-key #'car))
      (if (equal by :values)
	  (setf sort-key #'cdr))
      (sort sorted-entries sort-fn :key sort-key))))

; Prints a given Hash-Entry = Key-Value-Pair formatted
(defun print-hash-entry (key-value-pair)
  (format t "key: ~t~t~t~S  -  value: ~t~t~t~S~&" (cdr key-value-pair) (car key-value-pair)))

; Counts the Words in a Line and puts them into a Hashtable
;   - Gets a line 'line-in' and a Hashtable
;   - Splits the String into Words
;   - Puts the Words into a Hashmap
(defun count-words (line-in ht)
  (mapcar #'(lambda (word)
	      (insert-key-value word ht))
	  (string-split " " line-in)))

; Creates a Hashtable 'ht'
;   - Reads in Lines fom the Prompt
;   - Calls Count-Words
;   - Sorts and prints the Hash-Table
(let ((ht (make-hash-table :test 'equal)))
  (do ((line-in t))
      ((null line-in) nil)
    (setf line-in (read-line *query-io* nil nil nil))
    (count-words line-in ht))
  (mapcar #'print-hash-entry (sort-hash-table ht #'> :by :values)))

Here the other Implementations and here the Timings.


Get every new post delivered to your Inbox.