�_���Љ�FHow to Declare an Imperative
Philip Wadler. ACM Computing Surveys, 29(3):240--263, September 1997.�iWWW:Wadler: Monads�j
�������ꂽ�X�g���[���isynchronized stream�j
<![if !supportEmptyParas]> <![endif]>
�S�͐��̂Ƃǂ����ݍ�p����̂��H
���ʑB�i���ʑ��j�ɂ����āA
<![if !supportLists]>�N <![endif]>�S�̃C���[�W����̂̊��o���h�������B
<![if !supportLists]>�N <![endif]>�̂̓�������S�Ɉӌ������܂��B
�ƍl�����B
���ʑ��i���傤�������j �Ԕ]�̑�3�]���̏�ǍŌ㕔��������ɓˏo����0.2�O�����قǂ̏��́B7���炢�܂ł͂悭���B���C�����ɏ��ʍזE�Ƃ����B�זE�l�̂��̂��W�܂�B�N��i�ނƐΊD�����N����]���Ƃ����N���̎���̋Ìŕ�������������B���ʑ̂̕��啨�͐��B��̐��n��}������Ƃ�����������C������B�̈�ɐ������C���ʑB�Ƃ��Ăꂽ���C���̋@�\�͕s���ȓ_�������B�����Ғœ���(���ށC�g�J�Q�Ȃ�)�ł͐F�f�זE�����k�������p�����B �i���}�Ѓ}�C�y�f�B�A�S�Ȏ��T���j |
���z�I�ȑ��݂ł���\�t�g�E�F�A�͂ǂ̂悤�Ɏ����E�Ƒ��ݍ�p���邩�H
<![if !supportLists]>�N <![endif]>�����ɂ͌v�Z�@�́A�e��̌v�Z���s���悤�ȁu�S�v�̉��������ł������B
<![if !supportLists]>�N <![endif]>���݂ł͌v�Z�@�́A�e��̑�����s���悤�ȁu�́v�̉��������ł���B
<![if !supportLists]>�N <![endif]>�ÓT�I�Ȍv�Z���f��(Turing�@�B��Ɍv�Z)�͑̂������Ȃ��S�̂悤�Ȃ��́B
(�e�[�v����e�[�v�A�ɍ����琳�K�`)
�����̃��f���ł́A�v�Z�̍ŏ��ɓ���(�e�[�v�⍀)�����A�v�Z�̏I����ɏo��(�e�[�v�⍀)���o���̂ŁA�o�b�`�����ɂ͓K�����Ă���B
Turing�@�B��t���[�`���[�g�͖��ߌ^�ł͂��邪�A�����ÓT�I���f���ł̓v���O�����͓��͂���o�͂ւ̊��ƍl�����Ă���A�{���I�ɂ͐錾�I�������B
���ݍ�p���܂ތv�Z�̃��f�������B���Ă����B(�̂̒��ɂ���S�ɗގ�)
<![if !supportLists]>�N <![endif]>petri net�F�g�[�N�������A(������)�ʒu��Ԃ��B
<![if !supportLists]>�N <![endif]>MacQueen's stream�F�f�[�^�̓R���[�`���̊Ԃ�����B
<![if !supportLists]>�N <![endif]>process calculi�F�`���l���̊ԂŃ��b�Z�[�W������肳���B
�����ł͓���/�o�͂ɓ��ʂȔz���͂��炸�A�e�X�ɂ��ăg�[�N���̌��ƍs����A�lj��̃X�g���[���A�lj��̃`�����l���𑝂��悢�B
�����̗��_�ɂ��A�P����́\�P��o�͂��玞�ԋy�ы�ԓI�ɕ��z�������d���́\���d�o�͂ɂȂ�A���ۓI�ȑ��ݍ�p�̂���v�Z�ɓK������悤�ɂȂ����B
�����ł́A���ݍ�p���������߂̉�@�Ƃ��āA���^�v���O���~���O�Œm����悤�ɂȂ����Amonad�i�P�q�j�Ƃ����T�O���Љ�B
<![if !supportLists]>�N <![endif]>���_�icategory theory�j�Ō��o���ꂽ�B
<![if !supportLists]>�N <![endif]>�����錾��ɂ��Ĕ��~���inon-termination�j�A��ԁistate�j�A��O�iexception�j�Acontinuation�A���ݍ�p�iinteraction�j�Ƃ�����������������B
<![if !supportLists]>�N <![endif]>pure��lazy�Ȋ��^����Haskell�ɂ���Glasgow�łœ�������AChalmers�ŁAYale�ŁA�W���ɂ��������ꂽ�B
<![if !supportLists]>�N <![endif]>1���s�ȏ�̒����v���O������GUI���܂ޗl�X�ȕ���̃A�v���P�[�V�����Ŏ�����Ă���B
<![if !supportLists]>�N <![endif]>�錾�^�v���O���~���O����Escher�Ř_���^�Ɗ��^�v���O���~���O�̓����ɗ��p���ꂽ�B
<![if !supportLists]>�N <![endif]>pure���^����ɑ��ݍ�p��lj�������̂Ƃ���monad���Љ�B
<![if !supportLists]>�N <![endif]>lazy�Ȋ��^����ł���Haskell�̕W����monad���������ʁA�����ȒP�ɂȂ������𑼕����isynchronized stream�Acontinuations�Alinear logic��side effect�j�Ƃ̔�r�ɂ���ďЉ�B
<![if !supportLists]>�N <![endif]>�����I�Ō���I�Ȏ���ɂ��ďq�ׁA���ݍ�p�Ƃ����Ί֘A�t��������iconcurrency�j�A�萫�inon-determinism�j�ɂ��Ă̓|�C���^�����ɗ��߂�B
<![if !supportLists]>�N <![endif]>Haskell�̂悤�ȏ����Ȋ��^�����SML�̂悤�ȏ����łȂ����^����ł̃v���O���~���O�̊�{�B
<![if !supportLists]>�N <![endif]>���_�Ɋւ��闝���͕s�v�B
IO()�^�̍��͍�p���������A�ilazy�Ȋ��^����ł́j���̎��s���ۏ���Ă���킯�ł͂Ȃ��i�܂��u�S�v�̗̈�ɂ���j�B
���̓���̈Ӑ}�Ƃ��̎��s�̋�ʂ͏d�v�B
IO�̌�ɑ���()�̈Ӗ��͌�q�B
�\ 2.1�F��{���߁i��Ƃ��ďo�͂Ɋւ���j
�� |
�^ |
���� |
putc |
Char->IO() |
�����̏o�͈Ӑ}���������B |
done |
IO() |
���������ɐ���I������Ӑ}�������萔�B |
>> |
IO()->IO() ->IO() |
����̒����I�Ȏ��s�Ӑ}������2���������Z�q�B�iHaskell�̗��V�ɏ]��curry������Ă���j |
puts |
String ->IO() |
������̏o�͈Ӑ}���������B�ȉ��̂悤�ɂ���putc�Adone��>>�ŋL�q�ł���B puts [] = done puts (c:s) = put c >>puts s |
main |
IO() |
��A�̍����Ԃ����s�Ӑ}�������l���A�����g�b�v�E���x���ɂ���ϐ��ɑ�������ď��߂Ď��s���ۏ����B�i�u���ʑ́v�j ��F main::IO() main = puts "!?" |
���s�Ӑ}�����s�Ɍ��т���main�Ƃ����u�����v�C���^�[�t�F�[�X���{�g���l�b�N�Ɍ����邪�A���͑��ݍ�p�ƌv�Z��C�ӂɍ����ł���قǂɕ\���͂�����B
�d�v�Ȍ����ł���equational reasoning�ɂ́u�Q�Ƃ̓��ߐ��v�ireferential transparency�j�A�u���C�v�j�b�c�̋K���v�ithe rule of Leibniz�j�ȂǑ����̕ʖ�������B
�����ŏq�ׂ�A�v���[�`�ł͖��߂͒P����equational reasoning���\�ɂ���悤�A����p�������Ȃ��悤�ɂ���B
putcML #'h'; putcML #'a'; putcML #'h'; putcML #'a'; |
�̏o�͂�"haha"�����A
let val x = (putcML #'h'; putcML #'a') in x; x end |
�Ƃ���equational reasoning���s����Əo�͂�"ha"�ix�ɑ��������Ƃ������j�ƂȂ��ĈӐ}�������̂ƈقȂ�B
let fun f() = (putcML #'h'; putcML #'a') in f(); f() end |
�̂悤�Ƀ_�~�[�����������Ƃ��āu�s�ׁv���`����ΈӐ}�ʂ蓮�����A�l�ƍs�ׂ͈قȂ������̂Ƃ��Ē��ۉ����˂Ȃ�Ȃ��Ȃ�B
putc 'h' >> putc 'a'>> putc 'h' >> putc 'a' |
��
let x = (putc 'h' >> putc 'a') in x >> x |
�̏o�͂͂ǂ��������"haha"�ƂȂ�B�i���̕Ԃ�IO()�^�̒l���̂��̂́u�o�͂̈Ӑ}�v�������Ă��邾���ŕ���p�͂Ȃ��B�j
IO a�͌^a�̒l�������Ƃ�������Ӑ}�������B
�\ 2.2�F���͂Ɋւ����{����
�� |
�^ |
���� |
getc |
IO char |
�����̓��͈Ӑ}���������B |
return |
a -> IO a |
�^a�̒l����^a�̓��͈Ӑ}���������������B |
>>* |
IO a -> IO b -> IO (a,b) |
���͓���̒����I�Ȏ��s�ƁA���͒l�̑g�̍쐬�Ӑ}������2���������Z�q�B�iHaskell�̗��V�ɏ]��curry������Ă���j |
>>@ |
IO a -> (a -> b) -> IO b |
���͈Ӑ}�������l�ƃt�B���^��������������āA���͂��t�B���^�����O����Ӑ}������2�����Z�q�B�iHaskell�̗��V�ɏ]��curry������Ă���j |
gets |
Int -> IO String |
������̓��͈Ӑ}���������B�ȉ��̂悤��return�Agetc�A>>*�A>>@���g���Ē�`�ł���B gets 0 = return [] gets (i+1) = (getc >>* gets i) >>@ \(c,s)-> c:s |
gets�͎w�肳�ꂽ���̕�����getc�œǂ݂��ނ܂ŁA>>*�œ��͂��������Ȃ���ċA�I��gets���Ăяo���A�e�i��getc���Ԃ���������gets���Ԃ���������Ȃ�g���i>>@�ɓn���ꂽ�t�B���^�����g���āj������ɕϊ�����i�Ƃ����Ӑ}�������j�B
�O�߂�>>*��>>@�̑g�ݍ��킹�͎��R�ł͂��邪�A�ǂ݈Ղ��Ƃ͌����Ȃ��B
�i���̓o�b�N�X���b�V���ł��BHaskell�Ńo�b�N�X���b�V���̓ɒ��ۂ�\�킵�܂��B�j
�\ 2.3�F�����ibind�j���Z�q
�� |
�^ |
���� |
>>= |
IO a -> (a -> IO b) -> IO b |
�����ibind�j�ƌĂ��2�����Z�q�B���͈Ӑ}���������A�Ƃ��̓��͒l���Ƃ��Ď��̓��͈Ӑ}����������Ԃ���������Č������A�����I�ȓ��͓���������B�iHaskell�̗��V�ɏ]��curry������Ă���j |
<![if !vml]>
<![endif]>
let���̌^���_��
<![if !supportEmptyParas]> <![endif]>
<![if !vml]>
<![endif]>
>>=���̌^���_��
����2�҂�����ׂ�Ǝ��Ă���B�������炱��>>=���̈Ӗ����l����B
>>=�ƃɌ`���̊������p����Ă���ꍇ�A���̎������s�����A���͓���m�̓��͒l��x�ɑ������Ď��̓��͓���n���s�Ȃ��Ɖ��߂ł���B
����͓��͂�let�ł̑������ɕ���p�Ƃ��čs�Ȃ�SML�̏ꍇ�Ǝ��Ă��邪�A>>=���p�̏ꍇ��equational reasoning���\�B
>>=���g���Ċ���̖��߂͋L�q�ł���ق��A�d�������@�\�̖��߂�����팸�ł���B
�\ 2.4�F ���߂̐���
�� |
��L�q |
m >>* n |
m >>= \x-> n >>= \y-> return (x,y) |
m >>@ f |
m >>= \x-> return (f x) |
done |
return () |
m >> n |
m >>= \() -> n |
�ȉ��͏���������gets�̒�`
gets 0 = return [] gets (i+1) = getc >>= \c -> gets i >>= \s -> return (c:s) |
����͐�قǂ��ǂ݂₷���i�ʏ�̖��ߌ^�v���O���~���O�̌`���ɋ߂��Ȃ��Ă���j�B
�\ 2.5�F �ŏI�I�ɐ����c������{���o�͖���
�� |
�^ |
return |
a -> IO a |
>>= |
IO a -> (a -> IO b) -> IO b |
putc |
Char -> IO () |
getc |
IO Char |
�����̖��߂�IO a�Ƃ������ۃf�[�^�^�ɑ����鑀��B�i�����ɂ���č��ꂽ�����ϐ�main�ɑ��������Ǝ��s���m�肷��B�j
done >> m = m m >> done = m m >> (n >> o) = (m >> n) >> o |
�ȏ�̂悤��>>�Ƃ������Z�͌����������藧���Adone��P�ʌ��Ƃ��郂�m�C�h�i�P�ʓI���Q�F�P�ʌ��������Q�A���łȂ��t���̑��݂��ۏ���Ȃ��j���\������B���l�ɁA
return v >>= \x->m = m[x := v] m >>= \x-> return x = m m >>= \x -> ( n >>= \y -> o) = (m >>= \x-> n) >>= \y-> o |
>>=���Z�ɂ������������藧���Areturn��P�ʌ��Ƃ��ă��m�C�h���`������B
Kant����ؗp����category�Ƃ����ꎩ�g���n�߂Ƃ��āA���_�icategory�j���N�w����p���q���Ă��邱�Ƃ͂��܂�L���ł͂Ȃ��B��L�̂悤�ȍ\���ɑ���Leibniz����ؗp����monad�́Amonoid�ɐG�����ꂽ�����ł���B�iLeibniz�̏ꍇ�A�_�Ɠ��l�Ɋe����monad�ł������̂�monad�͐S�Ƒ̖̂��̒��S�ł������B�j �i�{�����j |
�����œ��o�͂łȂ��^�\���q�ɂ��Ă��ȉ��̂悤�ɒ�`����Ɠ��l�̐��������B
�\ 2.6�F��ʂ̌^�\���qmonad
�� |
�^ |
return |
a -> M a |
>>= |
M a -> (a -> M b) -> M b |
���l�ɂ��đ����̂��Ƃ�monad�Ƃ��ĕ\�킹�邪�A����ɂ��Ă͌�q�B
�@�܂����̂悤�ȊW��
(let x=v in m) = m[x:=v] (let x=m in x) = m (let y=(let x=m in n) in o) = (let x=m in (let y=n in o)) |
�̂悤�ɁAlet�ɂ��Ă����藧���ASML�̏ꍇ�͕���p�̑��݂ɂ�蕔���I�ɐ������Ȃ��Ȃ�B�i��F�ŏ��̖@�������藧�ɂ�v�͔C�ӂ̍��ł͂Ȃ�����p�Ȃ��]���\�Ȓl�łȂ���Ȃ�Ȃ��B�j
����p�̂Ȃ�Haskell�ł͂�苭���@�������藧��(�ϐ��Ɍ����Ă���v���C�ӂ̍�n�ɂȂ�B)�F
(let x=m in n) = n[x:=m] |
monad�̖@�����g���ăv���O�����̋������ؖ��ł���B
��F
puts r >> puts s = puts (r++s) |
��
gets i >>= \r -> gets j >>= \s -> return(r++s) |
�������A
[]++s = s (c:r)++s = c:(r++s) |
�i�ؖ��͏ȗ��F���Ɏ���W�J���āA�P�ʌ��Ƃ̉��Z���ȖĂ���A�[�@�j
echo: Haskell�imonad�j��
echo :: IO() echo = getc >>= \c -> if (c== '\n') then return () else putc >> echo |
echo: C��
echo () { int c; loop: c = getchar() if (c == '\n') { return } else { putchar (c); goto loop; } } |
���̗��҂͗ǂ����Ă���B���^�����monad���g���Ė��ߌ^�v���O���~���O��͕킷��Ӗ��͂���̂��H
<![if !supportLists]>�N <![endif]>����B�����̑��ݍ�p�͖��ߌ^�ŏ����������f���ɕ\�킹��B
<![if !supportLists]>�N <![endif]>�Ȃ��B���Ɋ��^�Ǝ��̃e�N�j�b�N���m���Ă��āA������g���Ηǂ��B
���҂͓����ʂɖ��ʂ��Ȃ��A�R���p�C������Ύ��ʂ����R�[�h�ɂȂ邾�낤�B�iGlasgow Haskell�R���p�C���ł�equational reasoning�����p�����œK���ɂ��A�����������ʂĂ���B�j
�����Amonad�𗘗p���Ă���ꍇ�A���҂��������ė��p�ł���B
��F
prod :: [IO a] -> IO [a] prod [] = return [] prod (m:ms) = m >>= \x-> prod ms >>= \xs-> return (x:xs) |
���K����p�����ł�puts�Agets�ł��̊��𗘗p�ł���B
puts = prod (map putc s) >>= \_-> return () gets i = prod (take i (repeat getc)) |
prod�̂悤�ȓ����̍��K���������グ��\�͖͂��ߌ^����ɐV���ȓ��ʖړI�̍\�����`����\�͂ɋ߂����̂�����B
�����܂ł̎d�g�݂��g�������Haskell����C�ӂ�C�̊��i���C�u���������܂߂āj�ڌĂяo����B�i���_�I�ɂ͓��o�͂ƌ��Ȃ��邩��B�j
ccall proc e1 e2 ... en |
proc��C�̊����Ae1�`en���ꂼ���Char�AInt�AFloat�̂����ꂩ�̌^�������Ŏ��S�̂�IO Char�AIO Int�AIO Float�̂����ꂩ�̌^�����B�iHaskell�ɂ����Ă����ȊO�̌^��C�œ���Ȋ����������ɂ���肷����@�͏����̉ۑ�j
put c = ccall putchar c getc = ccall getchar |
�@��̂悤��putc�Agetc���ȒP�ɒ�`�ł���B
���ݍ�p��\�����邽�߂ɗp���������̕��@��monad�Ɣ�r����B
<![if !supportLists]>�N <![endif]>monad��\��
<![if !supportLists]>�N <![endif]>monad�ŕ\���i�\�Ȃ�j
���o�͂Ɋւ���stream���f���͊�����̂��̂ق��̋@�\���l�A�錾�I�ȈӖ��_�Ɋւ��錤�����狻�����B
�ȑO�̔ł�Haskell�ł��g���Ă����B
�\ 3.1�Fsynchronized stream�̊�{�f�[�^�^
data Request = Getq | Putq Char data Response = Getp Char | Putp |
�X�g���[���̓v���O�������쐬����v���iGetq��Putq c�j�̃��X�g�ƃv���O���������鉞���iGetp c��Putp�j�̃��X�g�ł���킳���B
type Dialogue = [Response] -> [Request] |
�g�b�v���x���̊��͉������X�g����v�����X�g�ւ̊��B
�v���O��������̊e�v���i���͂ɉ����čs�Ȃ�ꂽ����j�͑Ή����锽���i���ۂɓ��͂��ꂽ��j�ɐ旧���ďo����Ȃ���Ȃ�Ȃ��悤�ɁA���o�͂ɑ��邱�̃A�v���[�`��lazy�ȕ]���Ɉˑ�����B
��echoD�Fsynchronized stream��
echoD :: Dialogue echoD p = Getq : case p of Getp c : p' -> if (C == '\n') then [] else Putq c : case p' of Putp : p'' -> echoD p'' |
:�̓��X�g�̘A�����Z�q�Bcase v of p ->�̓p�^�[���}�b�`���O�B
���o�͗�F
echoD [Getp'A',Putp ,Getp'B',Putp ,Getp'\n'] |
= [Getq ,Putq'A',Getq ,Putq'B',Getq ] |
IO a ::([Response],[Request]) ->(a,[Response],[Request]) |
IO a�����ŕ\�킷�B���̊���[Response]�̍��������������[Request]�̍����쐬����B
�\ 3.2�F synchronized stream�ŕ\�킵��monad�̊�{����
�� |
�^ |
��` |
putc c |
Char->IO () |
\(p,q)->let q = Putq c : q' Putp : p' = p in ((),p',q) |
getc |
IO Char |
\(p,q)->let q = Getq : q' Getp c : p' = p in (c,p',q) |
return x |
a -> IO a |
\(p,q)->(x,p,q) |
m >>= k |
IO a ->(a->IO b) ->IO b |
\(p,q'')->let (x,p',q)=m(p,q') (y,p'',q')=k x (p',q'') in (y,p'',q) |
�������Ē�`���ꂽmonad�͑O�q�̖@�������i�ؖ����j�B
�\�ł͂��邪��ό������������Ƃ��킩���Ă���B
monad��stream�ŕ\�����邱�Ƃ͔�r�I�e�Ղ����A�t�͗e�ՂłȂ��B
�����Γ��o�͂Ɋւ���Z�}���e�B�N�X�Ƃ��ė��p�����̂ŁAmonad��stream�̊ϓ_�����`�������̂́A���o��monad�̃Z�}���e�B�N�X�ƌ��Ȃ���B
�������v���Ɖ����Ƃ����Q�̃X�g���[���ɒ��ӂ�˂Ȃ炸�ώG�B
monad�ł̂悤�ɘA�����邱�Ƃ�����A���W�������e�B���B�����Â炢�B
continuation�͓��o�͂Ɋւ���stream���f���Ō����Ȃ��ŕ�ނ��߂�monad���l�ɗ��p����Ă���B
continuation�͏�����Haskell�Ŏg���Ă����B�����Hope�ł͒��ۃf�[�^�^��p�ӂ��Ďg���Ă����B���j�I�ɂ�monad�̐�y�ɓ�����Amonad���l����̐���̃��f���Ƃ��Č��o���ꂽ�B
�����ł͒��ۃf�[�^�^�����continuation���l����B
��p���s�Ȃ����͈��������čs�Ȃ��ׂ����������Answer�^�̈������lj�����Ă���B
�g�b�v���x���̕ϐ���Answer�^<![if !supportFootnotes]>[1]<![endif]>�B
�\ 3.3�Fcontinuation�̊�{����
�� |
�^ |
putcK |
Char->Answer ->Answer |
getcK |
(Char->Answer) ->Answer |
doneK |
Answer |
��echoK'�Fcontinuation��
echoK' :: Answer->Answer echoK' k = getcK(\c-> if (C == '\n') then k else putcK c (echoK' k) ) |
��Fcontinuation�ł̘A��
mainK = echoK' (echoK' doneK) |
���������̒�`���ȉ��̂悤��
��echoK�Fcontinuation�Łi���Y��Łj
echoK :: Answer echoK k = getcK(\c-> if (C == '\n') then doneK else putcK c echoK ) |
�Ȃ��Ă���ꍇ�́AAnswer�������悤�ɍ���Ă��Ȃ��̂ŘA���ł��Ȃ��B
IO a ::(a->Answer)->Answer |
IO a�����ŕ\�킷�B���̊��͌��݂̓���œ�������́i��()�����m��Ȃ��j���Ƃ��Ď��̏������s�Ȃ�����continuation�Ƃ��Ď��B
�\ 3.4�F continuation�ŕ\�킵��monad�̊�{����
�� |
�^ |
��` |
putc c |
Char->IO () |
\j->putcK c (j ()) |
getc |
IO Char |
\j->getcK j |
return x |
a -> IO a |
\j->j x |
m >>= k |
IO a ->(a->IO b) ->IO b |
\j-> m(\x->k x(\y->j y)) |
�������Ē�`���ꂽmonad�͑O�q�̖@�������i�ؖ����j�B
�ȒP�ɉ\�B
�\ 3.5�Fmonad�ŕ\�킵��continuation�̊�{����
�� |
�^ |
��` |
Answer |
IO () | IO c |
<![if !supportEmptyParas]> <![endif]> |
putcK c a |
Char->Answer ->Answer |
putc c >>= a |
getcK a |
(Char->Answer) ->Answer |
getc >>= a |
�@���f���Ƃ��Ă͓����B
�v���O�����̍\���͖w�Ǔ���B�T�O�I�ɂ��ގ����Ă���B
continuation��>>=�̂悤�Ȍ������Z�̋@�\�����Ɋ܂߂Ă���B
���ꂾ���ɕ��Y���echoK�̂悤�ɒ�`����Ƃ���continuation�������悤�ɍ��̂�Y���ƁA�ォ�璼�ڂɌ����ł��Ȃ��B
continuation�p�̕ϐ����\�[�X���ɎU����Ă��č������Ղ��̂Ŏmonad�̕������ۓI�B
�����A�G���[���̕���ق��A�t���[�̐��䂪���ڂɃT�|�[�g�ł��闘�_������B
Girald�ɂ���Ē��ꂽlinear logic�͘_�����g�����č��̐���ۑ����鐄�_�K������������́BCurry-Howard���^����āA�_�����v���O�����A���聨�^�i�������������Ȃ��j�Ǝʑ����ăv���O�����̓���̏ؖ��ɗp����ꂽ�B
linear logic��Clean�ő��ݍ�p�̕\���Ɏg���AMachintosh�̃O���t�B�b�N�X�E�c�[���Ɠ����̕\���͂���������x�ȃC���^�[�t�F�[�X�����A�v���P�[�V�������쐬����Ă���B
�����ł́u��ԁv�̕�����h���ړI�Ő��`�_���Ɋ�Â����ʂɐ������ꂽ�^�V�X�e���𗘗p����B
��p�ɂ���ĕω�����O�E�̏�Ԃ�\�킷*World�^�𗘗p����B��Ԃ̍����A����ɂ��čl�����ɍς܂����߁A���*World�͕����ł��Ȃ��^�Ƃ���B
�g�b�v���x���̊�mainL��*World����*World�ւ̊��B
<![if !supportEmptyParas]> <![endif]>
<![if !supportEmptyParas]> <![endif]>
�\ 3.6�Flinear logic�̊�{����
�� |
�^ |
putcL |
Char->*World ->*World |
getcL |
*World ->*(Char,*World) |
mainL |
*World->*World |
*���擪�ɂ��Ă���^�͊ۂ��Ƃ͕����ł��Ȃ��^��\�킷�B*(Char,*World)�ł�*(Char,*World)��*World�͕����ł��Ȃ����AChar�͕����\�Ŏ��o���ė��p�ł���B
��echoL�Flinear logic��
echoL :: *World->*World echoL w = let (c,w') = getcL w in if (C == '\n') then w' else let w'' = putcL c w' in echoL w'' |
��Flinear logic�ł̘A��
mainL = echoL (echoL w) |
IO a ::*World->(a,*World) |
IO a�����ŕ\�킷�B���̊��͍�p�O�̏�Ԃ�\�킷�������Ƃ�A���͂��ꂽ�l�ƍ�p��̏�ԂƂ̑�Ԃ��B
�\ 3.7�F linear logic�ŕ\�킵��monad�̊�{����
�� |
�^ |
��` |
putc c |
Char->IO () |
\w->((),putcL c w) |
getc |
IO Char |
\w->getcL w |
return x |
a -> IO a |
\w->(x,w) |
m >>= k |
IO a ->(a->IO b) ->IO b |
\w->let (x,w')=m w (y,w'')=k x w' in (y,w'') |
�������Ē�`���ꂽmonad�͑O�q�̖@�������i�ؖ����j�B
��F mainL��main�ߍ���
mainL::*World->*World mainL = \w->let ((),w')=main w in w' |
������main::IO ()�͏�����Ԃ������()�ƍŏI��ԂƂ̑�Ԃ����ɂȂ�B
��`������@�͖��炩�łȂ��B
linear logic�͐������ꂽ�^�V�X�e����K�v�Ƃ���B
��ԕϐ����\�[�X���ɎU����Ă��č������Ղ��B�i���̏�A���Ⴆ��ƌ��I�ɈӖ����ς��B�j������linear logic���monad���`������̍����͗}������B
��Ԃ���̓I��(��F�X�N���[���̏�Ԃ�t�@�C���̕ۑ���ԂȂ�)�����̏�Ԃ���Ȃ��Ԃɕ����ł���Ȃ�A��Ԃ������ł��闘�_������B
�o�����X���ǂ̂�����ɗ����������͍���̉ۑ�B
side effect��LISP��Iswim����Scheme��SML�Ɏ���܂ł����p���Ă���`���I�ȕ��@�B
�\ 3.8�F�\�L�Ώƕ\
Haskell |
SML |
()::() |
():unit |
'\n'::Char |
#"\n":char |
(\x->x)::a->a |
(fn x=>x):'a->'a |
�^�ϐ��͏������n�܂� |
�^�ϐ���'�Ŏn�܂� |
�^�\���q�̌�Ɉ��� |
�^�\���q�̑O�Ɉ��� |
�\ |
�^signaure��val�Ŏn�܂�A�v���O�������̂��������ɂ���B |
�\ |
��`��val��fun�Ŏn�܂�A���K�I�ɃO���[�v�ɂ܂Ƃ߂� |
�\ |
��`�̒����signature��u���Ȃ��̂����� |
�\ 3.9�Fside effect�̊�{����
�� |
�^ |
putcML |
char->unit |
getcML |
unit->char |
�����̊��͓K�p���ꂽ�Ƃ��ɑ��ݍ�p�����s���܂��B
�\ 3.10�Fside effect�ɂ�����S�Ƒ�
�u�l���v |
�u�s�ׁv |
abstraction |
application |
(fn c => putcML c; putcML c) |
f #"!" |
����p�ɂ��ꍇ�́A���̑S�Ă̗�Ƃ͈قȂ���ʂȃg�b�v�E���x���̕ϐ��͕K�v�Ȃ��B
��echoML�FSML�\�L side effect��
val echoML : unit->unit fun echoML () = let val c = getcML () in if (c = #"\n") then () else (putcML c; echoML()) |
�t�^�F��{���߂̒�`
fun putcML c = TextIO.output1(TextIO.stdOut,c); |
fun putcML c = TextIO.input1(TextIO.stdIn); |
side effect��monad�̓��ɕ����߂鎖���ł���B�������đ��ݍ�p�ɑ���monad���̂����ƕ���p�����S�ɍ����ł���B
type 'a io :unit->'a |
IO a����'a io�����ŕ\�킷�B���̊��͈����Ȃ��ɕ���p�Ƃ��đ��ݍ�p���s�Ȃ��A���͂��ꂽ�l�i������Ȃ��j��Ԃ��B
�\ 3.11�F side effect�ŕ\�킵��monad�̊�{���߁iSML�\�L�j
�� |
�^ |
��` |
putc c |
char->unit io |
fn()=>putcML c |
getc |
char io |
fn()=>getcML () |
return x |
'a -> 'a io |
fn() => x |
m >>= k |
'a io * ('a-<'b io) ->'b io |
fn()=>let val x=m () val y=k x () in y end |
done |
unit io |
return () |
m >> n |
unit io * unit io -> unit io |
m>>=(fn()=>n) |
fix h |
('a io->'a io) ->'a io |
let fun f() = h f() in f end |
SML�ł͍ċA��`�͊��ɂ��Ă����\�Ȃ̂ŁA���ۃf�[�^�^'a io�𗘗p���邽�߂ɂ͕s���_���Z�qfix���`����B����͒��ۃf�[�^�^'a io��unit->'a�Ǝ����㓯��ł��邱�ƂɈˑ��B�������������������`������'a io�͒��ۃf�[�^�^�Ƃ��ẴX�R�[�v�ɂ���B�������� val execute : unit io -> unit fun execute m = m() �ɂ��u���ʑ́v�Ŋ��Ƃ��Ď��s�ł���l�������� |
��F side effect�Œ�`����monad�̎g�p�iSML�Łj
val echo : unit io val echo = fix( fn echo => getc >>= ( fn c => if (c=#"\n") then done else putc c >> echo ) ) |
fix���Z�q�ȂǕ��@��̓s�����炭��}�C�i�[�ȍ��وȊO��Haskell�łƓ���̃R�[�h�B
�������Ē�`���ꂽmonad�͑O�q�̖@�������i�ؖ����j�B
��������1��
return v >>= fn x=>m = m[x:=v] |
�͍�v�͔C�ӂłȂ��A�l�łȂ���Ȃ�Ȃ��B
��Q��SML�̂悤��strict�Ȍ����Haskell�̂悤��lazy�Ȍ���Ƃ͈Ⴄrestriction reasoning���s�Ȃ��B
�ʏ�̒l�Ăяo���icall-by-value�j��v�v�Z�͂����̖@�����ؖ�����ɂ͏\���ł͂Ȃ��B��苭�͂ȃ�c�v�Z�iMoggi�ɂ��j�𗘗p����ׂ��B
��`�ł��Ȃ��B
�i�ȗ��j
monad�͐錾�I�ȃv���O���~���O�ɂ����ċ����I�ȑ��ݍ�p�̊J���ɓK������@
�v���O���~���O����͌Ǘ����ėp�����邱�Ƃ͂Ȃ��A�������l�X�ȗv�f�i�l�b�g���[�N�A�f�[�^�x�[�X�A�E�E�E�j�Ƃ̋������A�ė��p�����K�v�B
���������Ė{������C����Ƃ̘A�g�̗Ⴊ�d�v�ɂȂ��Ă���B���ɂ����G�ȃf�[�^�̂����̂����A�������Ǘ��A���AGUI�E�E�E�ɂ���monad�͗L���B
<![if !supportLists]>�N <![endif]>�[���܂ŏ����Ă���monad���g�����Ƃ���Ə����������K�v�B�i�I�[���E�I�A�E�i�b�V���O�j
<![if !supportLists]>�N <![endif]>��̑��ݍ�p���K�v�ȍۂɂP��monad�œ�������X��������B
monad�Ȃ�����monad�P�A����monad�̗��p�܂ł����炩�Ɉڍs�ł���K�v������B
>>=�����K������Ƃ����āAprolog�̂悤�Ȉ�K�̌����monad�̊T�O�����p�ł��Ȃ��킯�ł͂Ȃ��B�iMoggi�͓�������A���K����Ƃ͓Ɨ��ɁA��K�̌���ɑ��ēK�p�ł���悤�ɍ���܂��Ă����B�j
���K��(\x->n)m�͈�K��let x=m in n�Ɏ��Ă��邩��A���K��m>>=\x->n�͖{���I�ɂ͈�K�ł���let�\���Ɏ��Ă���B�����let x<-m in n�Ƃ��Ē�Ă��Ă���B
���������āA��K�̌^�t�������monad��lj����Ă����͂Ȃ��B�ȉ���lj�����Ηǂ��B
<![if !supportLists]>�N <![endif]>�^�\���qIO
<![if !supportLists]>�N <![endif]>�\��return v
<![if !supportLists]>�N <![endif]>�\��let x<-m in n
�iv�Am�An�͍��Ax�͕ϐ��j
<![if !supportLists]>�N <![endif]>�^���_�K���F
<![if !supportLists]>�N
<![endif]>�u���ʑ́v<![if !vml]>
<![endif]>
�Ƃ��āA�v���O�����̍�p�������iHaskell��main�ɓ�����jIO�^�̒l�B
�ȏ�͌^�̂Ȃ�����ł����l�B�����R���p�C�����̌������Ȃ��Ď��s���̌����Œu��������K�v������B
�����A���K����Ȃ�Έ�K�̌���ł͍\����lj����Ȃ���Ȃ�Ȃ��悤�ȑ������A�\���̒lj��Ȃ��ɉ\�B�i��FChurch�̃�(��x.A)�j
monad�̗��p��Haskell�̂悤�ȍ��K����̂ق����y�����A��K�̘_���^����ł��g������Ή\�B�ڍׂɂ��Ă͍���̉ۑ�B
�_���^�v���O���~���O����֓��o�͂�lj�����ɂ͍Ō�̏�Q�Ƃ��ăo�b�N�E�g���b�N���̑��ݍ�p������B���s�͊ȒP�ɖ߂��邪�A�����߂����Ɓiundo�j�͊ȒP�ł͂Ȃ��B
���^����ł͂����A�\�ȉ��̃��X�g�i���邢�͏W���j�Ƃ��ă��f���������B���ꂪ����lazy�ł���A�����͂܂��Ƀo�b�N�E�g���b�N�ɂȂ�B�i���̂悤�ȃ��X�g�̎g�����͂܂���monad�𗘗p���铮�@�B�j
�\����͂́A�o�b�N�E�g���b�N�̉��p�Ƃ��Ę_���^����̃v���O���}���A�܂����X�g��monad�̉��p�Ƃ��Ċ��^����̃v���O���}���S�������Ă���B
monad�͑��ݍ�p�̗����������邾���łȂ��A�o�b�N�E�g���b�N�̗��������邩�H���邢�͗��҂ɊW�����邩�H
<![if !supportFootnotes]>[1]<![endif]> �Â��ł�Haskell�ł͑O�߂�Dialogue�^�̖��������^��Answer�ƌĂ�Ă����B