Monads/Writer monad: Difference between revisions

=={{header|ALGOL 68}}==

{{Trans|Go}}

MODE MWRITER = STRUCT( LONG REAL value

, STRING log

print( ( newline, "This was derived as follows:-", newline ) );

print( ( log OF mw2 ) )

{{out}}

<pre>

More than a light-weight scripting language is really likely to need, but a way of stretching it a bit, and understanding its relationship to other languages. What AppleScript mainly lacks (apart from a well-developed library, and introspective records/dictionaries which know what keys/fields they have), is a coherent type of first class (and potentially anonymous) function. To get first class objects, we have to wrap 2nd class handlers in 1st class scripts.

 

 

-- How can we compose functions which take simple values as arguments

end call

end script

 

{{Out}}

divided by two -> 1.61803398875"

}</pre>

 

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

#include <iostream>

#include <string>

 

// Define a function to create writer monads from the simple functions

{

return [=](double x){return LoggingMonad(f(x), message);};

 

// Derive writer versions of the simple functions

 

 

cout << result.Log << "\nResult: " << result.Value;

}

{{out}}

<pre>

Result: 1.61803

</pre>

 

=={{header|EchoLisp}}==

Our monadic Writer elements will be pairs (string . value), where string is the log string.

 

(define (Writer.unit x (log #f))

(if log (cons log x)

add-one → 2

half → 1

 

=={{header|Factor}}==

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

{{works with|Factor|0.99 2019-10-06}}

FROM: monads => do ;

 

[ 1 + "added one, " <writer> ]

[ 2 / "divided by two." <writer> ]

{{out}}

<pre>

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

fmt.Println("\nThis was derived as follows:-")

fmt.Println(mw2.log)

 

{{out}}

 

Making a logging version of functions (unfortunately, if we use the built-in writer monad we cannot get the values into the logs when binding):

import Control.Monad ((>=>))

 

halfOfAddOneOfRoot = logRoot >=> logAddOne >=> logHalf

 

 

{{Out}}

Based on javascript implementation:

 

incr=: >:

half=: -:

loggingCompose=: dyad define

;(dyad def '<x`:6 loggingBind;y')/x,<loggingUnit y

 

Task example:

 

1.61803

1{::Lhalf`Lincr`Lroot loggingCompose 5

obtained square root -> 2.23607

added 1 -> 3.23607

 

=={{header|JavaScript}}==

===ES5===

 

'use strict';

 

 

return half_of_addOne_of_root(5);

 

{{Out}}

From Javascript ES5 entry.

 

 

/* writer monad, in Jsish */

divided by 2 -> 1.61803398874989

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

 

Base.show(io::IO, w::Writer) = print(io, w.msg, ": ", w.x)

println("$a => $b => $c")

println(bind(f2, "after plus 8", bind(f1, "after times 7", unit(3, "after intialization"))))

<pre>

after intialization: 3 => after intialization, after times 7: 21 => after intialization, after times 7, after plus 8: 29

 

=={{header|Kotlin}}==

 

import kotlin.math.sqrt

println("The Golden Ratio is ${fv.value}")

println("\nThis was derived as follows:-\n${fv.log}")

 

{{out}}

 

=={{header|Nim}}==

from sugar import `=>`, `->`

 

 

echo 5.doneWith.logRoot.logAddOne.logHalf

{{out}}

<pre>

=={{header|Perl}}==

{{trans|Raku}}

 

package Writer;

 

print Unit(5, "Initial value")->Bind(\&root)->Bind(\&addOne)->Bind(\&half)->[1];

{{out}}

<pre>

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PHP}}==

 

/** @var mixed */

 

print "The Golden Ratio is: {$result->value()}\n";

 

{{out}}

=={{header|Python}}==

 

from __future__ import annotations

 

import os

 

from typing import Callable

from typing import Generic

 

T = TypeVar("T")

 

 

self.msgs = list(f"{msg}: {self.value}" for msg in msgs)

 

writer = func(self.value)

return Writer(writer, *self.msgs)

 

return self.bind(func)

 

 

 

"""Return a writer monad version of the simple function `func`."""

 

@functools.wraps(func)

return Writer(func(value), msg)

 

if __name__ == "__main__":

square_root = lift(math.sqrt, "square root")

 

print(Writer(5, "initial") >> square_root >> add_one >> half)

 

{{out}}

Basic semantic borrowed from the Monads/List monad entry

{{trans|Go}}

 

class Writer { has Numeric $.value ; has Str $.log }

sub half(\v) { Unit v/2, "Divided by two" }

 

{{out}}

<pre>Initial value : 5.000000000000

Added one : 3.236067977500

Divided by two : 1.618033988750

</pre>

 

{{trans|Go}}

{{libheader|Wren-fmt}}

 

class Mwriter {

System.print("The Golden Ratio is %(mw2.value)")

System.print("\nThis was derived as follows:-")

 

{{out}}

=={{header|zkl}}==

{{trans|EchoLisp}}

fcn init(x){ var X=x, logText=Data(Void," init \U2192; ",x.toString()) }

fcn unit(text) { logText.append(text); self }

fcn half{ lift('/(2),"half") }

fcn inc { lift('+(1),"inc") }

{{out}}

<pre>

half → 1.61803

</pre>

{{out}}

<pre>

</pre>

Use bind to add functions to an existing Writer:

root,inc,half := w.bind(fcn(x){ x.sqrt() },"root"), w.bind('+(1),"+ 1"), w.bind('/(2),"/ 2");

{{out}}

<pre>