이번에 한 삽질 보기
(setf hunchentoot:*hunchentoot-default-external-format* :UTF-8)
(defun foo ()
"한글")
(defun baz ()
(let ((s (send-headers)))
(fill-and-print-template (create-template-printer "안녕 <!-- TMPL_VAR world -->")
'(:world "세상")
:stream s)))
아 쉬바...
;;;
;;; loop-with-file-contents
;;; buf : body 안에서 쓸, 파일의 일부가 담긴 배열
;;; path : 읽을 파일 경로
;;; element-type : 그냥 기본값쓰자. 박아두기 뭐해서 뽑아둔것.
;;; buffer-length : buf 크기. 한번에 얼마씩 읽을지 결정하는 값
;;; body : buf 에 담긴 내용을 알아서 써먹어라.
;;;
;;; 리턴값은 총 읽은 바이트 수
;;;
;;;
;;;
;;; 파일을 바이너리 형태로 읽어오고 싶어서 만들어봤다. 짜다 보니 아주
;;; 복잡해졌는데.. 남들은 이렇게 복잡하게 쓰지는 않을거란 생각이
;;; 드는군.
;;;
;;; 1. 어쩌다 보니 with- 라는 이름으로 했는데 짜놓고 보니 이게 안에서
;;; 루프를 도는 식이라 좀 쌩뚱맞은 이름이 되버렸네. 적절한 이름을
;;; 찾아보자... 였다가 그냥 성의없이 loop 를 앞에 붙여줬다 낄낄. with
;;; 로 시작해야 간지나는데 말이지.
;;;
;;; 2. 매크로의 body 부분에 buf 외에 buflen 까지 넘겨야 하는 상황을
;;; 피하기 위해서 buf 길이가 필요에 따라 줄어들길 바랬다. 즉 10 바이트
;;; 파일을 읽을때 버퍼길이가 4 라면 4,4,2 로 세번 바디가 실행이
;;; 되도록... 그런데 이짓을 하려고 보니 read-sequence 가 fill-pointer
;;; 를 받지를 않네. 좀더 고민을 해봐야 하나 하다가 문서에 displaced
;;; array 가 보이길래 그냥 그걸 썼다.
;;;
;;; 3. 매크로내에서 쓰이는 변수들이 매크로 외부의 심볼들과 쫑나지
;;; 않도록 gensyms 를 썼는데 이거 꽤나 성가시군.
;;;
;;;
(defmacro loop-with-file-contents ((buf path &key (element-type ''(unsigned-byte 8)) (buffer-length 8192)) &body body)
(let ((s (gensym))
(total-readed (gensym))
(readed (gensym)))
`(let ((,buf (make-array ,buffer-length :element-type ,element-type)))
(with-open-file (,s ,path :element-type ,element-type)
(loop
with ,total-readed fixnum = 0
for ,readed fixnum = (read-sequence ,buf ,s)
when (zerop ,readed) return ,total-readed
do (progn
(incf ,total-readed ,readed)
(let ((,buf (if (= ,readed ,buffer-length)
,buf
(make-array ,readed :element-type ,element-type :displaced-to ,buf))))
,@body)))))))
;;; 사용은 요렇게 하면 된다. 파일명이 od.lisp 인것은 원래 od 를 짜보려던것이라..
(loop-with-file-contents (buf "/tmp/od.lisp" :buffer-length 128)
(print buf))
;;; od 비슷하게 마저 짜봤다.
;;; format 의 ~X 에 인자를 줄때 두번째 인자가 캐릭터라고 되어있길래
;;; #\0 등을 주는 삽질을 했는데 그냥 '0 로 쿼트해서 주면 되는거였네...
;;; 너무 loop 에 의존하는 코딩을 하게 되는것 같아 찝찝하군.
(loop-with-file-contents (buf "/tmp/od.lisp" :buffer-length 16)
(loop for c fixnum across buf
do (format t " ~2,'0X" c)
finally (fresh-line)))
//
// 아래 소스 빌드할때 써먹은 CMakeLists.txt
// 별거없고 USE_INTERFACE 를 디파인했다는것만 기억해두자
// 그외 여러가지 조정할게 많아 보이는데 아직 모름.
//
// PROJECT(play-with-tinyscheme)
// INCLUDE_DIRECTORIES(/home/yoonkn/tmp/tinyscheme1.39)
// LINK_DIRECTORIES(/home/yoonkn/tmp/tinyscheme1.39)
// LINK_LIBRARIES(tinyscheme)
// ADD_DEFINITIONS(-DUSE_INTERFACE)
//
// ADD_EXECUTABLE(a a.cpp)
extern "C" {
#include "scheme-private.h"
#include "scheme.h"
}
#include <unistd.h>
#include <iostream>
using namespace std;
static void die(const char* msg) {puts(msg); exit(-1);}
static pointer c_add(scheme* sc, pointer args);
int main()
{
// 초기화. 전역이 아니라 멀티쓰레드간에 써도 안심?
scheme* sc = scheme_init_new();
if(!sc) die("init failed");
// display 등으로 출력되는 값이 튀어나오는 곳이겠군.
scheme_set_output_port_file(sc, stdout);
// scheme 코드를 실행하려면 load_string 이나 load_file 을 쓰자
// scheme.c 를 보니 init.scm 등을 먼저 읽고 시작하는게 바른
// 사용방법인듯 하다. load_string 류 함수는 코드 실행후 실행여부를
// retcode 에, 평가된 값을 value 에 담아주는 모냥이다.
sc->vptr->load_string(sc, "(define foo \"fuckshit\")");
if(sc->retcode != 0) die("exec failed");
// scheme 내의 값을 읽으려면 요렇게. 심벌만 넣어서 실행하고
// .value 를 읽어오면 되는듯
sc->vptr->load_string(sc, "foo");
const char* foo_value = sc->vptr->string_value(sc->value);
puts(foo_value);
// C 쪽에서 만든 덧셈 함수를 scheme 인터프리터에 추가하자.
sc->vptr->scheme_define(sc,
sc->global_env,
sc->vptr->mk_symbol(sc, "c-add"),
sc->vptr->mk_foreign_func(sc, c_add));
// c_add 함 불러보고 리턴값을 찍어보자
sc->vptr->load_string(sc, "(c-add 111 222)");
if(sc->retcode != 0) die("fucked");
printf("(c-add ..) return : %d\n", sc->vptr->ivalue(sc->value));
// 이번엔 반대로 scheme 쪽에서 함수를 만들어보자
sc->vptr->load_string(sc, "(define (scm-add a b) (+ a b))");
if(sc->retcode != 0) die("fucked");
// 이걸 C 쪽에서 부르자.. 음 물론 scheme 코드 만들어서 load_string
// 써도 되겠지만.. C 레벨에서.. 어라? 인터페이스가 안빠져있네
// scheme_call 이란 함수가 있긴 한데 외부로 노출된 함수는 아니네
// 음.. 뭐 일단 내가 원했던 내용까지는 파악이 됐으니 걍 여기까지
// 정리. 그런데 scheme_init_new 는 안쪽에서 sc 를 malloc 해서
// 주는데 deinit 함수중에는 sc 자체를 free 까지 해주는 함수가
// 안보이네 일단 샘플이니 여기서 그냥 free 를 했지만 정말 써먹을
// 상황이 온다면 dll 간에 malloc/free 가 섞일수도 주의하자.
scheme_deinit(sc);
free(sc);
}
// scheme 에 노출할 함수는 pointer foo(scheme*, pointer) 형태의
// 시그너쳐를 가지고 pointer 를 통해서 인자들이 리스트 형태로
// 들어온다. 복잡한데 쓸거 아니니 이정도만 알면 안심
pointer c_add(scheme* sc, pointer args)
{
// 첫번째 인자가 존재하고 정수가 맞는지 확인
if(args == sc->NIL) return sc->NIL;
pointer a = pair_car(args);
if(!is_integer(a)) return sc->NIL;
// 이거.. 변수 따로 잡기 귀찮아서 그냥 덮어썼는데
// 그래서 arg list 들의 첫번째 car 를 팝 한 효과가 났다.
args = pair_cdr(args);
// 다음 인자가 존재하고 정수가 맞는지 확인 꼴을 보니 좀 머리 쓰면
// 이쁘게 짤수 있을거 같은데 오늘은 샘플이니 그냥..
if(args == sc->NIL) return sc->NIL;
pointer b = pair_car(args);
if(!is_integer(b)) return sc->NIL;
// 더한값을 scheme 자료형태로 리턴
return mk_integer(sc, ivalue(a) + ivalue(b));
}
-- Network.HTTP 로 구글을 읽어오는 걸 짜봤다.
-- 그런데 302 moved 를 안따라가네.. 불친절하군.
-- response 받아서 2xx 나올때까지 재귀돌려야 하나?
-- 아니면 Network.HTTP 는 로우레벨이고 좀더 하이레벨 함수들이 있을까?
--
-- 어쨌건 이번에 배운건 Maybe 라는 놈이랑 Either 라는 놈
--
-- Maybe a 는 Just a 나 Nothing 이 될수있는데 패턴매칭으로 어떤 경우인지
-- 가려내서 에러처리를 해야 겠지만 샘플이니 그냥 fromJust 을 써먹었다.
--
-- Either a b 는 Left a 나 Right b 로 떨어지는놈.
-- 역시 마찬가지로 패턴매칭으로 적당히 처리를 해야 곘지만 불편하니 fromRight 이란걸 만들어봤다.
--
-- 역시 IO (IO 와 모나드의 정확한 관계는 모르겠다. 모나드중의 IO 인것은
-- 맞는데 모든 모나드가 IO 처럼 시퀀셜한 액션을 나타내는것은 아닌것
-- 같기도 하고.. 단순히 사이드이펙트를 가질수있는 모든것들이 모나드인가??
-- 이부분은 좀더 공부하면 알게되겠지)..
--
-- ..IO 위주의 코딩이 되니 편안하네. 문법만 조금 달라졌을뿐 돌아가는
-- 모양새는 C 와 다를게 없으니. 그런데 아무리 생각해도 내가 만들
-- 대부분의 프로그램들은 이런식의 절차적인 특성을 지닐텐데.. 아님 내
-- 생각이 절차적인 한계를 벗어나지 못하는 건가.
--
--
-- 이 모나드라는게 정말 끝까지 따라다닐거 같은데..
-- lisp 이라면 mapcar 류함수와 와 IO 함수를 쉽게 섞을수 있는데
-- (mapc #'print '(1 2 3 4))
--
-- haskell 의 map 은 IO 함수를 받지를 않네.
-- map putStr ["fucking", "hard"]
--
-- 뭐 저런걸 돌리는 다른 함수가 있긴 하겠지.
--
-- 음. 검색을 좀 해보니 mapM 이란게 있네. M 은 모나드의 M 이겠지.
-- 내 원래 이걸 직접 만들어볼려고 했는데 아직 모나드는 커녕 타입조차도 몰라서 실패했다.
-- 내가 만들어보려고 한 함수는
-- (a -> IO b) -> [a] -> IO [b]
-- 뭐 이런식으로 해볼라고 했는데 이게 터무니 없는 것이었나보다.
-- mapM 의 타입은
-- Monad a => (b -> a c) -> [b] -> a [c]
-- 이렇네..
--
-- Monad a=> 라면 a 가 Monad 클래스에 속한다는걸 나타내던가.. 좀더 읽고 짜봐야겠다.
import Network.HTTP
import Network.URI
import Data.Maybe(fromJust)
fromRight :: (Either a b) -> b
fromRight e = case e of
Right r -> r
Left l -> error "not right"
main =
let req = Request (fromJust $ parseURI "http://www.google.com") GET [] ""
in do
rep <- simpleHTTP req
putStrLn $ show $ fromRight rep
return ()
for i ← 0 to n-2 do
min ← i
for j ← (i + 1) to n-1 do
if A[j] < A[min]
min ← j
swap A[i] and A[min]
mport List
selectSort :: Ord a => [a] -> [a]
selectSort [] = []
selectSort ns =
m : selectSort (remove m ns)
where m = minimum ns
insertSort :: Ord a => [a] -> [a]
insertSort [] = []
insertSort (n:ns) =
insert n (insertSort ns)
이렇더라.. 음..
헐... 놀랍다.
함수형 언어와 절차형 언어의 접근이 다르다는걸 머리론 알고 있었지만 그걸 느끼긴 처음이네.
그리고 이미 몇년간 C/C++ 식 코딩을 해온 나한테 저런건 머리를 쥐어짜도 안나올거란걸 느꼈다.
좀더 공부를 해볼까? 그냥 접을까?
PS 그런데 저 잘난 구현도 리스트의 사본을 계속해서 만드는데 기분이 편치 않네.
성능 생각하면 모나드쪽의 어래이를 써야 할것 같은데 정말 헤스켈로 프로젝트 뛰는
애들이 어떤식으로 코딩하는지 궁금하네.
