�_���Љ�FHow to Declare an Imperative

Philip Wadler. ACM Computing Surveys, 29(3):240--263, September 1997.�iWWW:Wadler: Monads�j


1. ����.. 1

2. ���ݍ�p�ւ�monad�A�v���[�`.. 3

��{�I�Ȗ���.. 3

Equational reasoning. 3

�l���󂯓���閽��.. 4

let�̗ގ���.. 4

monad�̖������@��.. 26

monad�Ɩ��ߌ^�v���O���~���O.. 51

C�֐��̒��ڌĂяo��.. 66

3. ���ݍ�p�ɑ΂��邻�̑��̂���.. 72

�������ꂽ�X�g���[���isynchronized stream�j   76

continuation. 109

���`�_���ilinear logic�j.. 153

����p�iside effect�j.. 192

4. �֘A����.. 246

5. ���_.. 248

��K�ƍ��K.. 257

�o�b�N�E�g���b�N.. 269

<![if !supportEmptyParas]> <![endif]>

<![if !supportLists]>1.<![endif]>����

400�N���O�f�J���g�̖��

�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

����̌v�Z�@�Ȋw�ɂ�����S�Ƒ̖̂��

���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

�ÓT�I�Ȍv�Z���f��

<![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

�ߔN�̌v�Z���f��

���ݍ�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

monad

�����ł́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

�ǎ҂ɂ‚��Ă̑O��

<![if !supportLists]>�N         <![endif]>Haskell�̂悤�ȏ����Ȋ֐��^�����SML�̂悤�ȏ����łȂ��֐��^����ł̃v���O���~���O�̊�{�B

<![if !supportLists]>�N         <![endif]>���_�Ɋւ��闝���͕s�v�B

<![if !supportLists]>2.<![endif]>���ݍ�p�ւ�monad�A�v���[�`

��{�I�Ȗ���

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

Equational reasoning

�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

��i����p�ŏo�͂���r�l�k�j

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

��imonad�𗘗p����Haskell�j

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

�l���󂯓���閽��

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

let�̗ގ���

�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

monad�̖������@��

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

monad�Ɩ��ߌ^�v���O���~���O

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

C�֐��̒��ڌĂяo��

�����܂ł̎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

<![if !supportLists]>3.<![endif]>���ݍ�p�ɑ΂��邻�̑��̂���

���ݍ�p��\�����邽�߂ɗp�������‚��̕��@��monad�Ɣ�r����B

<![if !supportLists]>�N         <![endif]>monad��\��

<![if !supportLists]>�N         <![endif]>monad�ŕ\���i�”\�Ȃ�΁j

�������ꂽ�X�g���[���isynchronized stream�j

���o�͂Ɋւ���stream���f���͊֐�����̂��̂ق��̋@�\���l�A�錾�I�ȈӖ��_�Ɋւ��錤�����狻�����B

�ȑO�̔ł�Haskell�ł��g���Ă����B

synchronized stream�ɂ�鑊�ݍ�p

�\ 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    ]

synchronized stream�ɂ��monad�̕\��

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

monad �ɂ��synchronized stream�̕\��

�”\�ł͂��邪��ό������������Ƃ��킩���Ă���B

monad��stream�ŕ\�����邱�Ƃ͔�r�I�e�Ղ����A�t�͗e�ՂłȂ��B

synchronized stream��monad

���΂��Γ��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

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

continuation�ɂ�鑊�ݍ�p

��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

continuation�ɂ��monad�̕\��

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

monad �ɂ��continuation�̕\��

�Ȓ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

continuation��monad

�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

���`�_���ilinear logic�j

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

linear logic�ɂ�鑊�ݍ�p

��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)

linear logic�ɂ��monad�̕\��

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

monad �ɂ��linear logic�̕\��

��`������@�͖��炩�łȂ��B

linear logic��monad

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

����p�iside effect�j

side effect��LISP��Iswim����Scheme��SML�Ɏ���܂ł����p���Ă���`���I�ȕ��@�B

Haskell��SML�̕\�L�@

�\ 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���Ȃ��̂�����

side effect�ɂ�鑊�ݍ�p

�\ 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�̕\��

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

monad �ɂ��side effect�̕\��

��`�ł��Ȃ��B

<![if !supportLists]>4.<![endif]>�֘A����

�i�ȗ��j

<![if !supportLists]>5.<![endif]>���_

monad�͐錾�I�ȃv���O���~���O�ɂ����ċ����I�ȑ��ݍ�p�̊J���ɓK������@

�A�g

�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�ƍ��K

>>=�����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

�o�b�N�E�g���b�N

�_���^�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]>

<![endif]>

<![if !supportFootnotes]>[1]<![endif]> �Â��ł�Haskell�ł͑O�߂�Dialogue�^�̖��������Œ^��Answer�ƌĂ΂�Ă����B