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

 

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

#include <iostream>

#include <string>

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

}

{{out}}

<pre>

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|F_Sharp|F#}}==

// Monads/Writer monad . Nigel Galloway: July 20th., 2022

type Riter<'n>=Riter of 'n * List<string>

log|>List.iter(printfn "%s")

printfn "Final value = %f" result

{{out}}

<pre>

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

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">bind</span><span style="color: #0000FF;">(</span><span style="color: #004080;">object</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: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%f obtained by\n%s"</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">bind</span><span style="color: #0000FF;">(</span><span style="color: #000000;">bind</span><span style="color: #0000FF;">(</span><span style="color: #000000;">bind</span><span style="color: #0000FF;">({</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #008000;">""</span><span style="color: #0000FF;">},</span><span style="color: #000000;">root</span><span style="color: #0000FF;">),</span><span style="color: #000000;">addOne</span><span style="color: #0000FF;">),</span><span style="color: #000000;">half</span><span style="color: #0000FF;">))</span>

{{out}}

<pre>

 

=={{header|PHP}}==

 

/** @var mixed */

 

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

 

{{out}}

=={{header|Python}}==

 

from __future__ import annotations

 

 

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

=={{header|Ruby}}==

 

class Writer

attr_reader :value, :log

puts "This value was derived as follows:"

puts m2.log

 

{{out}}

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