Python composeの例

コード例 #1

    def test_compose_composition(self):
        u = lambda x: x * 42
        v = lambda x: x + 42
        w = 42

        a = compose(u, v)(w)
        b = u(v(w))
        self.assertEqual(a, b)

コード例 #2

ファイル: test_util.py プロジェクト: cbenz/OSlash

    def test_compose_composition(self):
        u = lambda x: x * 42
        v = lambda x: x + 42
        w = 42

        a = compose(u, v)(w)
        b = u(v(w))
        self.assertEquals(a, b)

コード例 #3

ファイル: test_list.py プロジェクト: hsavit1/OSlash

    def test_list_functor_law2(self):
        # fmap (f . g) x = fmap f (fmap g x)
        def f(x):
            return x + 10

        def g(x):
            return x * 10

        # Singleton list
        x = unit(42)
        self.assertEquals(x.map(compose(f, g)), x.map(g).map(f))

        # Empty list
        y = List([])
        self.assertEquals(y.map(compose(f, g)), y.map(g).map(f))

        # Long list
        z = List(range(42))
        self.assertEquals(z.map(compose(f, g)), z.map(g).map(f))

コード例 #4

    def test_list_functor_law2(self):
        # fmap (f . g) x = fmap f (fmap g x)
        def f(x):
            return x + 10

        def g(x):
            return x * 10

        # Singleton list
        x = unit(42)
        self.assertEquals(x.map(compose(f, g)), x.map(g).map(f))

        # Empty list
        y = List.empty()
        self.assertEquals(y.map(compose(f, g)), y.map(g).map(f))

        # Long list
        z = List.from_iterable(range(42))
        self.assertEquals(z.map(compose(f, g)), z.map(g).map(f))

コード例 #5

    def test_cont_functor_law2(self):
        # fmap (f . g) x = fmap f (fmap g x)
        def f(x):
            return x + 10

        def g(x):
            return x * 10

        x = unit(42)

        self.assertEqual(x.map(compose(f, g)), x.map(g).map(f))

コード例 #6

ファイル: test_maybe.py プロジェクト: yuhangwang/OSlash

    def test_nothing_functor_law2(self):
        # fmap (f . g) x = fmap f (fmap g x)
        def f(x):
            return x + 10

        def g(x):
            return x * 10

        x = Nothing()

        self.assertEquals(x.map(compose(f, g)), x.map(g).map(f))

コード例 #7

    def test_state_functor_law2(self) -> None:
        # fmap (f . g) x = fmap f (fmap g x)
        def f(x):
            return x + 10

        def g(x):
            return x * 10

        x: State[int, int] = unit(42)

        self.assertEqual(
            x.map(compose(f, g)).run(state),
            x.map(g).map(f).run(state))

コード例 #8

ファイル: test_reader.py プロジェクト: stjordanis/OSlash

    def test_reader_functor_law2(self) -> None:
        # fmap (f . g) x = fmap f (fmap g x)
        def f(x):
            return x + 10

        def g(x):
            return x * 10

        x = unit(42)

        self.assertEqual(
            x.map(compose(f, g)).run(env),
            x.map(g).map(f).run(env))

コード例 #9

ファイル: test_reader.py プロジェクト: cbenz/OSlash

    def test_reader_functor_law2(self):
        # fmap (f . g) x = fmap f (fmap g x)
        def f(x):
            return x+10

        def g(x):
            return x*10

        x = unit(42)

        self.assertEquals(
            x.map(compose(f, g)),
            x.map(g).map(f)
        )

コード例 #10

ファイル: test_maybe.py プロジェクト: cbenz/OSlash

    def test_nothing_functor_law2(self):
        # fmap (f . g) x = fmap f (fmap g x)
        def f(x):
            return x+10

        def g(x):
            return x*10

        x = Nothing()

        self.assertEquals(
            x.map(compose(f, g)),
            x.map(g).map(f)
        )

コード例 #11

ファイル: test_util.py プロジェクト: cbenz/OSlash

 def test_compose_1(self):
     f = lambda x: x*42
     g = compose(f)
     self.assertEqual(420, g(10))

コード例 #12

 def test_compose_0(self):
     f_id = compose()
     self.assertEqual(42, f_id(42))

コード例 #13

ファイル: test_util.py プロジェクト: cbenz/OSlash

 def test_compose_2(self):
     f = lambda x: x*42
     g = lambda y: y+10
     h = compose(g, f)
     self.assertEqual(430, h(10))

コード例 #14

 def test_compose_3(self):
     f = lambda x: x * 42
     g = lambda y: y + 10
     h = lambda z: z / 2
     i = compose(h, g, f)
     self.assertEqual(215, i(10))

コード例 #15

 def test_compose_2(self):
     f = lambda x: x * 42
     g = lambda y: y + 10
     h = compose(g, f)
     self.assertEqual(430, h(10))

コード例 #16

 def test_compose_1(self):
     f = lambda x: x * 42
     g = compose(f)
     self.assertEqual(420, g(10))

コード例 #17

def build_dict(formatted_records: Iterable[Dict[str, str]], ) -> dict:
    keys = next(formatted_records).keys()
    if len(keys) > 2:
        raise ValueError('More than two keys given.')

    result = {}
    for record in formatted_records:
        k1, k2 = keys
        result[record[k1]] = record[k2]
    return result


split = partial(methodcaller, 'split')
split_newlines, split_commas = split('\n'), split(',')
build_records = compose(dict, zip)
build_rows = compose(map(split_commas), split_newlines,
                     IOService.handle_outcome, IOService.read_file)


def produce_records(csvfile: str) -> Iterable[Dict[str, str]]:
    rows = build_rows(csvfile)
    headers = next(rows)
    for record in map(partial(build_records, headers), rows):
        yield record


def handle_csv(csvfile: str,
               *columns_and_formatters: Tuple[str, Callable[..., Any]]):
    rows = build_rows(csvfile)
    headers = next(rows)

コード例 #18

ファイル: test_util.py プロジェクト: cbenz/OSlash

 def test_compose_0(self):
     f_id = compose()
     self.assertEqual(42, f_id(42))

コード例 #19

ファイル: test_util.py プロジェクト: cbenz/OSlash

 def test_compose_3(self):
     f = lambda x: x*42
     g = lambda y: y+10
     h = lambda z: z/2
     i = compose(h, g, f)
     self.assertEqual(215, i(10))