Myu: 4月 2017

2017年4月30日日曜日

関数型プログラミングの基礎　リスト７．６２　reduceメソッドによるfromArray関数

var fromArray= (array) => {
retrun array.reduce((acumulator,item) => {
return list.append(acumulator)(list.cons(item,list.empty()));
},list.empty());
};

reduceは、配列用のfoldr関数という説明があった。
最初、なぜ、それで、上記のfromArrayがリストを返すのかがよくわからなかったが、
よく考えたらわかった。
accumuratorがリスト（配列からreduceを使って蓄積されたもの）だから、確かにそうなる。

2017年4月22日土曜日

yコンビネータ

関数型プログラミングの基礎に
コラムとしてYコンビネータのことがでていた。

わかったような、わからないような。。。
なぜ明示的に再帰を使わずに、再帰ができるかの証明がWikipediaに出ていた。

https://ja.wikipedia.org/wiki/%E4%B8%8D%E5%8B%95%E7%82%B9%E3%82%B3%E3%83%B3%E3%83%93%E3%83%8D%E3%83%BC%E3%82%BF

他のサイトからscriptをコピペして試してみた
<script>
function Y(f) {
return (function(g) {
return function(m) {
return f(g(g))(m);
};
})(function(g) {
return function(m) {
return f(g(g))(m);
};
})
}

var factorial = Y((fact) => {
return (n) => {
if (n==0) {
return 1;
}else {
return n*fact(n-1);
}
};
});
alert(factorial(4));
</script>

2017年4月11日火曜日

elm使ってみた

　pipeが標準装備されてるようなjavascriptのフレームワークでもないかといろいろ見ていたら、elmという言語を見つける。
　Haskellっぽい言語で、javascriptにコンパイルして使う。
手軽に関数型プログラミングを試せる点では優れものですが、最新情報は英語の資料でみるしかない。signalとやらを一時期使っていたけど、最新版ではsubscriptionを使うのだとか、変化も激しい。これから注目されそうな発展途上言語といったところでしょうか。

少し試しみた。

import Html exposing (beginnerProgram, div, button, text)
import Html.Events exposing (onClick)


main =
  beginnerProgram { model = "0", view = view, update = update }


view model =
  div []
    [ button [ onClick One ] [ text "1" ]
    , button [ onClick Two ] [ text "2" ]
    , button [ onClick Pl ] [ text "+" ]
    ,  div [] [ text model ]
    ]


type Msg = One | Two | Pl


update msg model =
  case msg of
    One ->
      model++"1"
    Two ->
      model++"2"
    Pl ->
      model++"+"

コンパイラはオンラインのもので
http://elm-lang.org/try
が使える。PCにインストールできない環境でも、上記のサイトでコンパイルして、ソースを表示して、javascriptをコピペして、htmlファイルにしておけば、保管できる。

2017年4月9日日曜日

複雑な条件分岐は、関数型で処理したほうががシンプルになる

元のサイトは
https://medium.com/@chetcorcos/functional-programming-for-javascript-people-1915d8775504で、和訳された方のサイトが
http://postd.cc/functional-programming-for-javascript-people-1/
です。
各関数は１つだけ処理をおこなうので、関数の合成がわかりすい。
これを、if文等で処理するのは、複雑になることが、よくわかります。

pipe は配列にある関数を順に処理する便利な関数ですが、javascriptに標準である関数かと思ったらそうでなく、以下のように簡単に、つくれるということが判明。
よくみたら、上記サイトにも定義されていたのを見逃してしまっていました。
http://javascript-demo.w3c.tokyo/js/status/740

試しに、自分でもつくってみました。関数定義の手間はかかりますが、その分複雑な条件分岐が必要なプログラミングでは威力を発揮しそうです。

<script>
const faisatu = (name) => "おはようございます "+name;
const caisatu = (name) => "おはよう"+name;

const male = (name) => name+"君";
const female = (name) => name+"さん";
const doctor = (name) => name+"先生";

//alert(faisatu(male("佐藤")));

const identity = (x) =>x;

const pipe = (fns) => (x) => fns.reduce((v, f) => f(v), x);

const aisatu = (name,options) => {
 return pipe([options.formal ? faisatu : caisatu,
  options.male ? male : options.female ? female :  options.doctor ? doctor :  identity ])(name)
};

var opt = {formal:false,male:false,female:false,doctor:false};

alert(aisatu("鈴木",opt));

</script>

2017年4月2日日曜日

関数型プログラミングの基礎　P２７７

リスト７．９１、７．９２のmatchiの定義を exp.call(pattern,pattern)から、exp(pattern)にかえてみた。これでも動くようだが、call(pattern,pattern)を使う意味がいまいちわからない。

<script>
 /* #@range_begin(algebraic_type_maybe) */
      var maybe = {
        match: (exp, pattern) => {
          return exp(pattern);
        },
        just: (value) => {
          return (pattern) => {
            return pattern.just(value);
          };
        },
        nothing: (_) => {
          return (pattern) => {
            return pattern.nothing(_);
          };
        }
      };
      /* #@range_end(algebraic_type_maybe) */

var MAYBE = {
        /* #@range_begin(maybe_monad) */
        /* unit:: T => MAYBE[T] */
        unit: (value) => {
          return maybe.just(value);
        },
        /* flatMap:: MAYBE[T] => FUN[T => MAYBE[U]] => MAYBE[U] */
        flatMap: (instanceM) => {
          return (transform) => {
            return maybe.match(instanceM,{
              /* 正常な値の場合は、transform関数を計算する */
              just: (value) => { 
                return transform(value);
              },
              /* エラーの場合は、何もしない */
              nothing: (_) => { 
                return maybe.nothing();
              }
            });
          };
        },
        /* ヘルパー関数  */
        getOrElse: (instanceM) => {
          return (alternate) => {
            return maybe.match(instanceM,{
              just: (value) => {
                return value;
              },
              nothing: (_) => {
                return alternate;
              }
            });
          };
        },
        /* #@range_end(maybe_monad) */
      };

      
       var add = (maybeA,maybeB) => {
          return MAYBE.flatMap(maybeA)((a) => {
            return MAYBE.flatMap(maybeB)((b) => {
              return MAYBE.unit(a + b);
            });
          });
        };
        var justOne = maybe.just(1);
        var justTwo = maybe.just(2);

alert(MAYBE.getOrElse(add(justOne,justOne))(null) );
   alert(MAYBE.getOrElse(add(justOne,maybe.nothing()))(null));
   
        
</script>