Hatena::Groupcadr

わだばLisperになる このページをアンテナに追加 RSSフィード

2004 | 12 |
2005 | 01 | 02 | 07 | 10 | 11 |
2006 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
2007 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
2008 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
2009 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
2010 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 08 | 09 | 10 | 11 | 12 |
2011 | 01 | 02 | 03 | 04 | 05 | 06 | 07 | 11 |

2008-05-21

無名総称関数

| 12:43 | 無名総称関数 - わだばLisperになる を含むブックマーク はてなブックマーク - 無名総称関数 - わだばLisperになる

CLtL2には、generic-functionという無名総称関数を作成するものがあったりしたのですが、ANSI CLでは姿を消してしまいました。

何となく面白そうなので、このgeneric-functionをどうやったら再現できるのかと以前から探っていたのですが、make-instanceで、総称関数が作れることが分かったので、add-methodと組み合わせてgeneric-functionの代わりにしてみました。

まあ、見るからに役に立ちそうもありませんが…。

(let* ((gf (make-instance 'standard-generic-function))
       (gf (add-method 
            gf
            (make-instance 'standard-method 
                           :function (lambda (x y) 
                                       (declare (ignore y))
                                       (format nil "~A => string." (car x)))
                           :lambda-list '(x)
                           :specializers (list (find-class 'string)))))
       (gf (add-method 
            gf
            (make-instance 'standard-method 
                           :function (lambda (x y) 
                                       (declare (ignore y))
                                       (format nil "~A => symbol." (car x)))
                           :lambda-list '(x)
                           :specializers (list (find-class 'symbol))))))
  (mapcar gf '("foo" "bar" x y z)))

;=> ("foo => string." "bar => string." "X => symbol." "Y => symbol." "Z => symbol.")

DylanでL-99 (P07 リストの平坦化)

| 11:48 | DylanでL-99 (P07 リストの平坦化) - わだばLisperになる を含むブックマーク はてなブックマーク - DylanでL-99 (P07 リストの平坦化) - わだばLisperになる

最近の?Dylanはドットで連結できるのですが、これだと見た目は、かなりLispっぽくなくなる気がします。

let seq = #(1, #(2, 3, #(4, 5, #(#(#(6, 7)),8))), 9);
format-out("%= => %=\n",seq, seq.flatten);
//=> #(1, #(2, 3, #(4, 5, #(#(#(6, 7)), 8))), 9)
//  => #(1, 2, 3, 4, 5, 6, 7, 8, 9)

// Code
module: l99-07

define generic flatten
    (sequence :: <sequence>)
 => (result :: <sequence>);

define method flatten
    (sequence :: <list>)
 => (result :: <list>)
  case
    sequence.empty? 
      => sequence;
    instance?(sequence.head, <list>)
      => concatenate(sequence.head.flatten,
                     sequence.tail.flatten);
    otherwise
      => pair(sequence.head,
              sequence.tail.flatten);
  end
end method flatten;

ゲスト



トラックバック - http://cadr.g.hatena.ne.jp/g000001/20080521