Monads/List monad: Difference between revisions

We can use a list monad in AppleScript to express set comprehension for the Pythagorean triples, but the lack of nestable first class (and anonymous) functions means that the closure can only be achieved using script objects, which makes the idiom rather less direct and transparent. AppleScript is creaking at the seams here.

-- Monadic bind for lists is simply ConcatMap

end script

end if

{{Out}}

=={{header|C}}==

Still, the task example is constrained enough that we can provide an implementation like:

#include <stdlib.h>

int main() {

task(13);

Which, from the command line, might look like:

=={{header|C++}}==

#include <vector>

PrintTriples(pythagoreanTriples);

}

{{out}}

<pre>

=={{header|Clojure}}==

(defn bind [coll f] (apply vector (mapcat f coll)))

(defn unit [val] (vector val))

(bind doubler)

(bind vecstr)) ; also evaluates to ["6" "8" "10"]

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{Trans|Go}}

program List_monad;

Writeln(ml1.ToString, ' -> ', ml2.ToString);

readln;

{{out}}

<pre>[ 3, 4, 5] -> [ 8, 10, 12]</pre>

=={{header|EchoLisp}}==

Our monadic lists will take the form (List a b c ...), ie raw lists prefixed by the List symbol.

;; -> and ->> are the pipeline operators

;; (-> x f g h) = (h (g ( f x)))

(-> '(1 -2 3 -5) List.unit (List.bind List.cube) (List.bind List.tostr))

→ (List "1" "-8" "27" "-125")

=={{header|F_Sharp|F#}}==

type ListMonad() =

member o.Bind( (m:'a list), (f: 'a -> 'b list) ) = List.concat( List.map f m )

printf "%A" (pyth_triples 100)

The list monad is equivalent to [[List comprehensions]] which are built into F#:

// Monads/List monad . Nigel Galloway: March 8th., 2021

List.iter ((+) 1>>(*) 2>>printf "%d ") [3;4;5]; printfn "";;

let test n=match valid(Ok n) with Ok g->printfn "%d is valid" g|Error e->printfn "Error: %d %s" n e

[5..10]|>List.iter test

{{out}}

<pre>

=={{header|Factor}}==

Factor comes with an implementation of Haskell-style monads in the <code>monads</code> vocabulary.

FROM: monads => do ;

{ 3 4 5 }

>>= [ 1 + array-monad return ] swap call

Or:

[ 1 + array-monad return ] bind

Or:

[ { 3 4 5 } ]

[ 1 + array-monad return ]

[ 2 * array-monad return ]

{{out}}

<pre>

=={{header|FreeBASIC}}==

{{trans|Ring}}

Dim As String m2 = "["

Dim As Integer x, y ,z

m2 &= "]"

Print m2

{{out}}

<pre>[8, 10, 12]</pre>

=={{header|Go}}==

import "fmt"

ml2 := ml1.bind(increment).bind(double)

fmt.Printf("%v -> %v\n", ml1.value, ml2.value)

{{out}}

Haskell has the built-in <code>Monad</code> type class, and the built-in list type already conforms to the <code>Monad</code> type class.

Or, written using <code>do</code> notation:

y <- return (x+1)

z <- return (y*2)

Or alternately:

let y = x+1

let z = y*2

Using the list monad to express set comprehension for Pythagorean triples:

pythagoreanTriples n =

[1 .. n] >>= (\x ->

if x^2 + y^2 == z^2 then return (x,y,z) else [])))

{{out}}

<pre>[(3,4,5),(5,12,13),(6,8,10),(7,24,25),(8,15,17),(9,12,15),(12,16,20),(15,20,25)]</pre>

Which can be written using <code>do</code> notation:

pythagoreanTriples n = do x <- [1 .. n]

y <- [x+1 .. n]

z <- [y+1 .. n]

Or directly as a list comprehension:

=={{header|J}}==

That said, here is an implementation which might be adequate for the current task description:

unit=: boxopen

m_num=: unit

Task example:

┌─┐

│5│

=={{header|Javascript}}==

Array.prototype.bind = function (func) {

return this.map(func).reduce(function (acc, a) { return acc.concat(a); });

[3,4,5].bind(listy_inc).bind(listy_doub); // [8, 10, 12]

ES5 Example: Using the list monad to express set comprehension

// ENCODING A SET COMPREHENSION IN TERMS OF A LIST MONAD

}

{{Out}}

Julia uses the function bind for binding a channel to a task, but this can be imported and overloaded.

The |> syntax in Julia can also be used to chain functions taking one argument.

unit (generic function with 1 method)

8

10

=={{header|Kotlin}}==

class MList<T : Any> private constructor(val value: List<T>) {

val fv = iv.bind(::doubler).bind(::letters)

println(fv.value)

{{out}}

=={{header|Nim}}==

a natural use of a list-wrapped return value is when there can be more than one result from a function, for example square roots have a positive and negative solution, and the inverse sine function has multiple solutions we might be interested in.

func root(x:float):seq[float] = @[sqrt(x),-sqrt(x)]

func asin(x:float):seq[float] = @[arcsin(x),arcsin(x)+TAU,arcsin(x)-TAU]

input.map(f).concat

{{out}}<pre>@["0.79", "7.07", "-5.50", "-0.79", "5.50", "-7.07"]</pre>

=={{header|OCaml}}==

Defining the list monad is fairly straightforward:

fun l f -> List.flatten (List.map f l)

For convenience, the example will also use the following definitions:

let (let*) = bind (* let pruning for easy bind *)

let print_str_list l =

First example: increment and print

let hex x = return (Format.sprintf "%#x" x)

let* x = List.init 5 (fun x -> x) in

let* y = incr x in hex y

Second example: pythegorean triplets

let pythegorean_triple n =

let x = List.init n (fun x -> x) in

let* y = List.init n (fun x -> x) in

let* z = List.init n (fun x -> x) in

=={{header|Perl}}==

With the help of the CPAN module <code>Data::Monad</code>, we can work with list monads.

use feature 'say';

use Data::Monad::List;

for (@{shift @triples}) {

say keys %$_ if keys %$_;

{{out}}

<pre>000

=={{header|Phix}}==

{{trans|Go}}

<span style="color: #008080;">function</span> <span style="color: #000000;">bindf</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">m</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #000000;">f</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">m2</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">bindf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">bindf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">m1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">increment</span><span style="color: #0000FF;">),</span><span style="color: #000000;">double</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%v -&gt; %v\n"</span><span style="color: #0000FF;">,</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">m1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">m2</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

=={{header|Python}}==

from __future__ import annotations

from itertools import chain

)

)

{{out}}

Note that this also demonstrates how to use Racket's macro system to implement the do syntax.

(define (bind x f) (append-map f x))

(pythagorean-triples* 25)

=== With functional package ===

The [https://docs.racket-lang.org/functional/interfaces.html functional] package has already implemented the list monad.

(require data/monad

(pythagorean-triples 25)

=={{header|Raku}}==

The * in the bind blocks are typically referred to as "whatever"; whatever + 3 etc. The guillemot (») is the hyper operator; descend into the data structure and apply the following operator/function to each member.

multi bind ($item, &code) { $item.&code };

sub divisors (Int $int) { gather for 1 .. $int { .take if $int %% $_ } }

{{out}}

=={{header|Ring}}==

# Project : Monads/List monad

str = str + "]"

see str + nl

Output:

<pre>

=={{header|Ruby}}==

class Array

def bind(f)

[3,4,5].bind_comp(listy_doub, listy_inc) #=> [8, 10, 12]

=={{header|uBasic/4tH}}==

{{trans|Ring}}

Do While Used ()

Print Show (Set (s, Join (Clip (s, 2), "]")))

{{out}}

<pre>

=={{header|Wren}}==

{{trans|Go}}

construct new(value) { _value = value }

var ml1 = Mlist.unit([3, 4, 5])

var ml2 = ml1.bind(increment).bind(double)

{{out}}

{{trans|Ruby}}

Here we create a class to do Monad like things. Unlike Ruby, we can't augment the baked in List/Array object so this more verbose. Also unlike Ruby, we can directly compose as we are applying the composition to each element (vs the list-as-object).

fcn init(xs){ var list=vm.arglist }

fcn bind(f) { list=list.apply(f); self }

fcn toString{ list.toString() }

str:="toString";

MList(3,4,5).bind(inc).bind(str).println(" == (4,5,6)");

comp:=Utils.Helpers.fcomp; // comp(f,g) == f.g == f(g(x))

{{out}}

<pre>