Monads/Maybe monad: Difference between revisions

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

{{trans|JavaScript}}

 

# This is a translation of the Javascript sample, main differences are because Algol 68 #

print( ( "]", newline ) )

{{out}}

<pre>

 

 

 

on run {}

return lst

end map

 

{{Out}}

 

=={{header|C}}==

#include <stdio.h>

#include <stdlib.h>

print_Maybe(bind_maybe(bind_maybe(m_1, f_1), f_2)); // (m_1 `bind` f_1) `bind` f_2 :: Maybe String -- it prints 49 'x' characters in a row

}

{{out}}

<pre>

 

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

#include <cmath>

#include <optional>

}

}

{{out}}

<pre>

=={{header|C sharp|C#}}==

 

 

namespace RosettaMaybe

}

}

 

 

=={{header|Clojure}}==

 

(defn bind [val f]

(if-let [v (:value val)] (f v) val))

(bind (bind (unit 8) opt_add_3) opt_str) ; evaluates to {:value "11"}

(bind (bind (unit nil) opt_add_3) opt_str) ; evaluates to {:value nil}

 

=={{header|Delphi}}==

{{libheader| System.SysUtils}}

{{Trans|Go}}

program Maybe_monad;

 

end;

Readln;

{{out}}

<pre> 3 -> 6

Functions which return something not in Maybe.domain are unsafe and return (#f . input-value), If a function is given as input a (#f . value) element, it will return this element.

 

(define (Maybe.domain? x) (or (number? x) (string? x)))

(define (Maybe.unit elem (bool #t)) (cons bool elem))

(->> 1 Maybe.unit (Maybe.bind u-log) (Maybe.bind u-inv) (Maybe.bind number->string) Maybe.print)

→ ❌ (#f . 0)

 

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

// We can use Some as return, Option.bind and the pipeline operator in order to have a very concise code

 

f1 4 |> Option.bind f2 |> printfn "Value is %A" // bind when option (maybe) has data

None |> Option.bind f2 |> printfn "Value is %A" // bind when option (maybe) does not have data

{{out}}

<pre>

=={{header|Factor}}==

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

FROM: monads => do ;

 

! Prints "nothing"

nothing >>= [ 2 * maybe-monad return ] swap call

Or:

Or with <code>do</code> notation:

[ 3 <just> ]

[ 2 * <just> ]

[ 2 * <just> ]

[ 1 + <just> ]

 

=={{header|Go}}==

 

import (

fmt.Printf("%4s -> %s\n", s1, s2)

}

 

{{out}}

 

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

 

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

y <- return (x*2)

z <- return (y+1)

y <- return (x*2)

z <- return (y+1)

 

Or alternately:

let y = x*2

let z = y+1

let y = x*2

let z = y+1

 

Deriving and composing safe versions of reciprocal, square root and log functions. :

 

safeVersion :: (a -> b) -> (a -> Bool) -> a -> Maybe b

safeLogRootReciprocal = safeReciprocal >=> safeRoot >=> safeLog

 

{{out}}

<pre>[Nothing,Nothing,Nothing,Nothing,Just 0.5,Just 0.0,Just (-0.3465735902799726),Just (-0.5),Just (-0.5493061443340549),Just (-0.6931471805599453),Just (-0.8047189562170503)]</pre>

 

=={{header|Hoon}}==

:- %say

|= [^ [[txt=(unit ,@tas) ~] ~]]

(some (mul a 2))

--

 

Hoon has a built-in rune, %smsg (;~) that binds gates under a monad.

It's difficult to find a useful and illustrative (but simple) example of this task in J. So we shall not try to be useful.

 

NB. monad implementation:

unit=: <

┌──┐

│_.│

 

=={{header|JavaScript}}==

Example: deriving and composing safe versions of reciprocal, square root and log functions.

 

'use strict';

 

);

 

 

{{Out}}

 

=={{header|Julia}}==

 

Base.show(io::IO, m::maybe) = print(io, m.x)

 

println(b, " -> ", bind(f2, bind(f1, b)))

<pre>

3 -> 19

 

Rather than write something from scratch, we use this class to complete this task.

 

import java.util.Optional

/* prints 'false' as there is no value present in the Optional<String> instance */

println(getOptionalInt(0).flatMap(::getOptionalString2).isPresent)

 

{{out}}

=={{header|Lua}}==

{{works with|lua|5.3}}

-- None is represented by an empty table. Some is represented by any

-- array with one element. You SHOULD NOT compare maybe values with the

local outList = map(safeComputation, inList)

print("output:", table.concat(map(maybeToStr, outList), ", "), "\n")

=={{header|Nim}}==

template checkAndWrap(x:float,body:typed): untyped =

if x.classify in {fcNormal,fcZero,fcNegZero}:

when isMainModule:

for i in [0.9,0.0,-0.9,3.0]:

{{out}}<pre>some("0.11")

none(string)

=={{header|OCaml}}==

The Option module already has our bind and return operations. If we wanted to redefine them :

| Some x -> func x

| None -> None

 

To easily manipulate bind, we can use infix operators and let pruning :

let (let*) = bind

 

let print_str_opt x =

Example:

let safe_root x = if x < 0.0 then None else return (sqrt x)

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

let* y = if x < 0.0 then None else return (sqrt x) in

return (Format.sprintf "%#f" y)

 

=={{header|Perl}}==

{{trans|Haskell}}

 

use strict;

->flat_map( \&safeLog );

$safeLogRootReciprocal->is_nothing ? "NaN" : $safeLogRootReciprocal->value;

{{out}}

<pre>NaN NaN NaN NaN 0.5 0 -0.346573590279973 -0.5 -0.549306144334055 -0.693147180559945 -0.80471895621705</pre>

Phix has an "object" type which can be an integer or a string, so not entirely un-like Perl.<br>

Here we simply treat all strings or rather non-integers as the "unknown" type.

<span style="color: #008080;">function</span> <span style="color: #000000;">bindf</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: #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;">test</span><span style="color: #0000FF;">(</span><span style="color: #000000;">3</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">test</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"none"</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

syntax error.

 

from __future__ import annotations

 

# result = m_int.bind(plus_one).bind(currency)

print(f"{str(case):<4} -> {result}")

 

{{out}}

It is idiomatic in Racket to use <code>#f</code> for <code>Nothing</code>, and every other value is considered implicitly tagged with <code>Just</code>.

 

 

(require syntax/parse/define)

(return x)))

 

 

{{out}}

below.

 

say 'Is $monad an Int?: ', $monad ~~ Int;

say 'Is $monad a Str?: ', $monad ~~ Str;

{{out}}

<pre>Is $monad an Int?: True

candidate.

 

# When treated as a Numeric, returns the value 'Nil'.

class NOTHING {

# all; but Ethiopic number 30, times vulgar fraction 1/7, is.

put ($_, .&recip, .&root, .&ln, .&(&ln o &root o &recip) )».&center

{{out}}

<pre> "Number" Reciprocal Square root Natural log Composed

=={{header|REXX}}==

This REXX version is modeled after the Zkl version.

call add 1, 2

call add 1, 2.0

end /*k*/

say 'sum=' $

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

OOP version using Ruby's block syntax

 

def initialize(value)

@value = value

Maybe.unit(nil).bind { |n| Maybe.unit(2*n) }.bind { |n| Maybe.unit(n+1) }

#=> #<Maybe @value=nil>

 

=={{header|Wren}}==

{{trans|Go}}

{{libheader|Wren-fmt}}

 

class Maybe {

var s2 = (m2.value) ? "%(m2.value)" : "none"

System.print("%(Fmt.s(4, s1)) -> %(s2)")

 

{{out}}

 

Here we use the Void object as Nothing and define some functions. Since zkl is type-less, we can consider Maybe as a native type and don't need to define it.

fcn just(x){ if(Deferred.isType(x)) x() else x } // force lazy evaluation

Since zkl is eager, add needs to gyrate a bit by creating a lazy result and evaluating that after the binds have done their bizness.

bind(mx,Int,

bind(my,Int,

add(1,2).println(); // two ints

add(1,2.0).println(); // int and float

{{out}}

<pre>