LibAcc: 0.6364=14/22, ProjAcc: 1.0000=0/0, Missing: 102
Module: src/index
Module: src/monad
type 𝓟[ty]1{Monoid} = {mempty: 𝓟[ty]1{Monoid}, mappend: (𝓟[ty]1{Monoid})->𝓟[ty]1{Monoid}, mconcat: (𝓛[ty]8670{Array})->𝓟[ty]1{Monoid}}
type 𝓟[ty]2{Functor} = {fmap: (((any)->any))->𝓟[ty]2{Functor}, lift: (((any)->any))->𝓟[ty]2{Functor}, map: (((any)->any))->𝓟[ty]2{Functor}}
type 𝓟[ty]3{Monad} = {unit: (any)->𝓟[ty]3{Monad}, bind: (((any)->𝓟[ty]3{Monad}))->𝓟[ty]3{Monad}, of: (any)->𝓟[ty]3{Monad}, chain: (((any)->𝓟[ty]3{Monad}))->𝓟[ty]3{Monad}}
type 𝓟[ty]4{MonadPlus} extends 𝓟[ty]3{Monad} = {mzero: 𝓟[ty]3{Monad}, mplus: (𝓟[ty]3{Monad})->𝓟[ty]3{Monad}}
type 𝓟[ty]5{Eq} = {equals: (any)->𝓛[ty]8666{Boolean}}
function 𝓟6{eq} (𝓟7{a}: [OOV]any,𝓟8{b}: [OOV]any): (𝓟9: [OOV]any)
{
let 𝓟10{idx}: [miss]𝓛[ty]8655{Number} = 𝓛8745{Number};
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟7{a},𝓟8{b}))
{
return 𝓟9 = 𝓛8744{Boolean}
}
if (𝓛12559{EqualsEqualsEqualsToken}(𝓛12580{$TypeOf}(𝓟7{a}.equals),𝓛8743{String}))
{
return 𝓟9 = 𝓟7{a}.equals(𝓟8{b})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛12595{GreaterThanToken}(𝓟7{a}.length,𝓛8745{Number}),𝓛12559{EqualsEqualsEqualsToken}(𝓟7{a}.length,𝓟8{b}.length)))
{
{
while (𝓛1{<UNKNOWN>}(𝓟10{idx},𝓟7{a}.length))
{
{
if (𝓛12569{ExclamationToken}(𝓟6{eq}(𝓟7{a}.access(𝓟10{idx}),𝓟8{b}.access(𝓟10{idx}))))
{
return 𝓟9 = 𝓛8744{Boolean}
}
}
𝓛12564{FirstCompoundAssignment}(𝓟10{idx},𝓛8745{Number})
}
}
return 𝓟9 = 𝓛8744{Boolean}
}
return 𝓟9 = 𝓛8744{Boolean}
}
Module: src/writer
type 𝓟[ty]11{WriterPatterns} = {writer: (𝓛[ty]8670{Array},any)->any}
function 𝓟12{writer} (𝓟13{story}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟14{value}: [OOV]any): (𝓟15: [OOV]𝓟[ty]29{Writer})
{
return 𝓟15 = 𝓟22{writer}(𝓟13{story},𝓟14{value})
}
function 𝓟16{CONSTRUCTOR} (𝓟17{story}: 𝓛[ty]8670{Array},𝓟18{value}: [OOV]any): (𝓟[ty]29{Writer})
{
const 𝓟[ty]29{Writer};
const 𝓟[ty]29{Writer};
𝓟[ty]29{Writer}.chain ⟵ 𝓟[ty]29{Writer}.bind;
𝓟[ty]29{Writer}.of ⟵ 𝓟[ty]29{Writer}.unit;
𝓟[ty]29{Writer}.lift ⟵ 𝓟[ty]29{Writer}.fmap;
𝓟[ty]29{Writer}.map ⟵ 𝓟[ty]29{Writer}.fmap;
}
function 𝓟22{writer} (𝓟23{story}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8670{Array}),𝓟24{value}: [OOV]any): (𝓟25: [OOV]𝓟[ty]29{Writer})
{
return 𝓟25 = 𝓟16{CONSTRUCTOR}(𝓟23{story},𝓟24{value})
}
function 𝓟26{tell} (𝓟27{s}: [OOV]any): (𝓟28: [OOV]𝓟[ty]29{Writer})
{
return 𝓟28 = 𝓟16{CONSTRUCTOR}(𝓛8757{Array}(𝓟27{s}),𝓛8745{Number})
}
class 𝓟[ty]29{Writer} extends 𝓟[ty]3{Monad}{
𝓟31{of}: [miss]𝓛[ty]8696{Function};
𝓟32{chain}: [miss]𝓛[ty]8696{Function};
𝓟33{lift}: [miss]𝓛[ty]8696{Function};
𝓟34{map}: [miss]𝓛[ty]8696{Function};
function 𝓟52{equals} (𝓟53{other}: [OOV]𝓟[ty]29{Writer}): (𝓟54: [miss]𝓛[ty]8666{Boolean})
{
let 𝓟55{i}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number});
let 𝓟56{sameStory}: 𝓛[ty]8666{Boolean} = 𝓛8744{Boolean};
{
𝓛1{<UNKNOWN>}(𝓟55{i},𝓛8745{Number})
while (𝓛1{<UNKNOWN>}(𝓟55{i},𝓟[ty]29{Writer}.story.length))
{
{
𝓟56{sameStory} ⟵ 𝓛12592{AmpersandAmpersandToken}(𝓟56{sameStory},𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]29{Writer}.story.access(𝓟55{i}),𝓟53{other}.story.access(𝓟55{i})));
}
𝓛12564{FirstCompoundAssignment}(𝓟55{i},𝓛8745{Number})
}
}
return 𝓟54 = 𝓛12592{AmpersandAmpersandToken}(𝓟56{sameStory},𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]29{Writer}.value,𝓟53{other}.value))
}
function 𝓟43{fmap} (𝓟44{f}: 𝓛[ty]8696{Function}): (𝓟45: [OOV]𝓟[ty]29{Writer})
{
function 𝓟46{$Lambda13} (𝓟47{v}): (𝓟48: [OOV]𝓟[ty]29{Writer})
{
return 𝓟48 = 𝓟[ty]29{Writer}.unit(𝓟44{f}(𝓟47{v}))
}
return 𝓟45 = 𝓟[ty]29{Writer}.bind(𝓟46{$Lambda13})
}
function 𝓟38{bind} (𝓟39{f}: 𝓛[ty]8696{Function}): (𝓟40: [OOV]𝓟[ty]29{Writer})
{
let 𝓟41{wu}: [OOV]𝓟[ty]29{Writer} = 𝓟39{f}(𝓟[ty]29{Writer}.value);
let 𝓟42{newStory}: [miss]𝓛[ty]8670{Array} = 𝓟[ty]29{Writer}.story.concat(𝓟41{wu}.story);
return 𝓟40 = 𝓟16{CONSTRUCTOR}(𝓟42{newStory},𝓟41{wu}.value)
}
function 𝓟35{unit} (𝓟36{u}: [OOV]any): (𝓟37: [OOV]𝓟[ty]29{Writer})
{
return 𝓟37 = 𝓟16{CONSTRUCTOR}(𝓛8757{Array}(),𝓟36{u})
}
function 𝓟49{caseOf} (𝓟50{patterns}: [OOV]𝓟[ty]11{WriterPatterns}): (𝓟51: [OOV]any)
{
return 𝓟51 = 𝓟50{patterns}.writer(𝓟[ty]29{Writer}.story,𝓟[ty]29{Writer}.value)
}
}
Module: src/either
type 𝓛[ty]8655{Number} = 𝓛[ty]8655{Number}
type 𝓛[ty]8689{Partial} = 𝓛[ty]8689{Partial}
type 𝓟[ty]59{EitherPatterns} = {left: (any)->any, right: (any)->any}
const 𝓟60{EitherType} = {Left: 𝓛8745{Number},Right: 𝓛8745{Number}};
function 𝓟61{exists} (𝓟62{t}: [OOV]any): (𝓟63: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟63 = 𝓛12592{AmpersandAmpersandToken}(𝓛12612{ExclamationEqualsEqualsToken}(𝓟62{t},𝓛12643{undefined}),𝓛12612{ExclamationEqualsEqualsToken}(𝓟62{t},𝓛12643{undefined}))
}
function 𝓟64{either} (𝓟65{l}: [OOV]any,𝓟66{r}: [OOV]any): (𝓟67: [OOV]𝓟[ty]81{Either})
{
if (𝓛12592{AmpersandAmpersandToken}(𝓟61{exists}(𝓟65{l}),𝓟61{exists}(𝓟66{r})))
{
𝓛8754{TypeError}.CONSTRUCTOR(𝓛8743{String})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟61{exists}(𝓟65{l})),𝓛12569{ExclamationToken}(𝓟61{exists}(𝓟66{r}))))
{
𝓛8754{TypeError}.CONSTRUCTOR(𝓛8743{String})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓟61{exists}(𝓟65{l}),𝓛12569{ExclamationToken}(𝓟61{exists}(𝓟66{r}))))
{
return 𝓟67 = 𝓟75{left}(𝓟65{l})
}
if (𝓛12592{AmpersandAmpersandToken}(𝓛12569{ExclamationToken}(𝓟61{exists}(𝓟65{l})),𝓟61{exists}(𝓟66{r})))
{
return 𝓟67 = 𝓟78{right}(𝓟66{r})
}
}
function 𝓟68{CONSTRUCTOR} (𝓟69{type}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟70{l}: [OOV]any,𝓟71{r}: [OOV]any): (𝓟[ty]81{Either})
{
const 𝓟[ty]81{Either};
const 𝓟[ty]81{Either};
𝓟[ty]81{Either}.chain ⟵ 𝓟[ty]81{Either}.bind;
𝓟[ty]81{Either}.of ⟵ 𝓟[ty]81{Either}.unit;
𝓟[ty]81{Either}.lift ⟵ 𝓟[ty]81{Either}.fmap;
𝓟[ty]81{Either}.map ⟵ 𝓟[ty]81{Either}.fmap;
}
function 𝓟75{left} (𝓟76{l}: [OOV]any): (𝓟77: [OOV]𝓟[ty]81{Either})
{
return 𝓟77 = 𝓟68{CONSTRUCTOR}(𝓟60{EitherType}.Left,𝓟76{l})
}
function 𝓟78{right} (𝓟79{r}: [OOV]any): (𝓟80: [OOV]𝓟[ty]81{Either})
{
return 𝓟80 = 𝓟68{CONSTRUCTOR}(𝓟60{EitherType}.Right,𝓛12643{undefined},𝓟79{r})
}
class 𝓟[ty]81{Either} extends 𝓟[ty]3{Monad}{
𝓟83{of}: [miss]𝓛[ty]8696{Function};
𝓟84{chain}: [miss]𝓛[ty]8696{Function};
𝓟85{lift}: [miss]𝓛[ty]8696{Function};
𝓟86{map}: [miss]𝓛[ty]8696{Function};
function 𝓟114{equals} (𝓟115{other}: [OOV]𝓟[ty]81{Either}): (𝓟116: [OOV]any)
{
return 𝓟116 = 𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟115{other}.type,𝓟[ty]81{Either}.type),𝓛12546{BarBarToken}(𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]81{Either}.type,𝓟60{EitherType}.Left),𝓟6{eq}(𝓟115{other}.l,𝓟[ty]81{Either}.l)),𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]81{Either}.type,𝓟60{EitherType}.Right),𝓟6{eq}(𝓟115{other}.r,𝓟[ty]81{Either}.r))))
}
function 𝓟117{do} (𝓟118{patterns}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8689{Partial})): (𝓟119: [OOV]𝓟[ty]81{Either})
{
function 𝓟120{$Lambda5} (𝓟121{l}: [OOV]any): (𝓟122: [miss]𝓛[ty]10033{Void})
{
}
function 𝓟123{$Lambda6} (𝓟124{r}: [OOV]any): (𝓟125: [miss]𝓛[ty]10033{Void})
{
}
let 𝓟126{noop_pattern}: [miss]𝓛[ty]8642{Object} = {left: 𝓟120{$Lambda5},right: 𝓟123{$Lambda6}};
let 𝓟127{merged} = 𝓛8741{Object}.assign(𝓟126{noop_pattern},𝓟118{patterns});
𝓟[ty]81{Either}.caseOf(𝓟127{merged})
return 𝓟119 = 𝓟[ty]81{Either}
}
function 𝓟105{fmap} (𝓟106{f}: 𝓛[ty]8696{Function}): (𝓟107: [OOV]𝓟[ty]81{Either})
{
function 𝓟108{$Lambda4} (𝓟109{v}): (𝓟110: [OOV]𝓟[ty]81{Either})
{
return 𝓟110 = 𝓟[ty]81{Either}.unit(𝓟106{f}(𝓟109{v}))
}
return 𝓟107 = 𝓟[ty]81{Either}.bind(𝓟108{$Lambda4})
}
function 𝓟87{isLeft} (): (𝓟88: [miss]𝓛[ty]8666{Boolean})
{
function 𝓟89{$Lambda0} (): (𝓟90: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟90 = 𝓛8744{Boolean}
}
function 𝓟91{$Lambda1} (): (𝓟92: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟92 = 𝓛8744{Boolean}
}
return 𝓟88 = 𝓟[ty]81{Either}.caseOf({left: 𝓟89{$Lambda0},right: 𝓟91{$Lambda1}})
}
function 𝓟102{bind} (𝓟103{f}: 𝓛[ty]8696{Function}): (𝓟104: [OOV]𝓟[ty]81{Either})
{
return 𝓟104 = (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]81{Either}.type,𝓟60{EitherType}.Right) ? 𝓟103{f}(𝓟[ty]81{Either}.r) : 𝓟75{left}(𝓟[ty]81{Either}.l)
}
function 𝓟93{isRight} (): (𝓟94: [miss]𝓛[ty]8666{Boolean})
{
function 𝓟95{$Lambda2} (): (𝓟96: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟96 = 𝓛8744{Boolean}
}
function 𝓟97{$Lambda3} (): (𝓟98: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟98 = 𝓛8744{Boolean}
}
return 𝓟94 = 𝓟[ty]81{Either}.caseOf({left: 𝓟95{$Lambda2},right: 𝓟97{$Lambda3}})
}
function 𝓟99{unit} (𝓟100{t}: [OOV]any): (𝓟101: [OOV]𝓟[ty]81{Either})
{
return 𝓟101 = 𝓟78{right}(𝓟100{t})
}
function 𝓟111{caseOf} (𝓟112{pattern}: [OOV]𝓟[ty]59{EitherPatterns}): (𝓟113: [OOV]any)
{
return 𝓟113 = (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]81{Either}.type,𝓟60{EitherType}.Right) ? 𝓟112{pattern}.right(𝓟[ty]81{Either}.r) : 𝓟112{pattern}.left(𝓟[ty]81{Either}.l)
}
}
Module: src/maybe
type 𝓟[ty]128{MaybePatterns} = {just: (any)->any, nothing: ()->any}
type 𝓛[ty]8689{Partial} = 𝓛[ty]8689{Partial}
type 𝓛[ty]8655{Number} = 𝓛[ty]8655{Number}
const 𝓟131{MaybeType} = {Nothing: 𝓛8745{Number},Just: 𝓛8745{Number}};
function 𝓟132{maybe} (𝓟133{t}: [OOV]any): (𝓟134: [OOV]𝓟[ty]167{Maybe})
{
return 𝓟134 = 𝓟153{maybe}(𝓟133{t})
}
function 𝓟135{$Lambda8} (𝓟136{t}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8642{Object})): (𝓟137: [OOV]𝓟[ty]167{Maybe})
{
return 𝓟137 = 𝓟145{sequence}(𝓟136{t})
}
const 𝓟138{all}: [miss]𝓛[ty]8696{Function} = 𝓟135{$Lambda8};
function 𝓟139{CONSTRUCTOR} (𝓟140{type}: (𝓛[ty]10051{String} ≠ 𝓛[ty]8655{Number}),𝓟141{value}: [OOV]any): (𝓟[ty]167{Maybe})
{
const 𝓟[ty]167{Maybe};
const 𝓟[ty]167{Maybe};
𝓟[ty]167{Maybe}.chain ⟵ 𝓟[ty]167{Maybe}.bind;
𝓟[ty]167{Maybe}.of ⟵ 𝓟[ty]167{Maybe}.unit;
𝓟[ty]167{Maybe}.lift ⟵ 𝓟[ty]167{Maybe}.fmap;
𝓟[ty]167{Maybe}.map ⟵ 𝓟[ty]167{Maybe}.fmap;
}
function 𝓟145{sequence} (𝓟146{t}: 𝓛[ty]8642{Object}): (𝓟147: [OOV]𝓟[ty]167{Maybe})
{
function 𝓟148{$Lambda7} (𝓟149{k}): (𝓟150: [miss]𝓛[ty]8666{Boolean})
{
return 𝓟150 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟146{t}.access(𝓟149{k}).type,𝓟131{MaybeType}.Nothing)
}
if (𝓛8741{Object}.keys(𝓟146{t}).filter(𝓟148{$Lambda7}).length)
{
return 𝓟147 = 𝓟159{nothing}()
}
let 𝓟151{result}: 𝓛[ty]8642{Object} = {};
{
let 𝓟152{k}: [miss]𝓛[ty]10051{String} = 𝓛12589{$ArrayAccess}(𝓟146{t});
while (𝓛8744{Boolean})
{
if (𝓟146{t}.hasOwnProperty(𝓟152{k}))
{
𝓟151{result}.access(𝓟152{k}) ⟵ 𝓟146{t}.access(𝓟152{k}).value;
}
}
}
return 𝓟147 = 𝓟156{just}(𝓟151{result})
}
function 𝓟153{maybe} (𝓟154{t}: [OOV]any): (𝓟155: [OOV]𝓟[ty]167{Maybe})
{
return 𝓟155 = (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟154{t},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟154{t},𝓛12643{undefined})) ? 𝓟139{CONSTRUCTOR}(𝓟131{MaybeType}.Nothing) : 𝓟139{CONSTRUCTOR}(𝓟131{MaybeType}.Just,𝓟154{t})
}
function 𝓟156{just} (𝓟157{t}: [OOV]any): (𝓟158: [OOV]𝓟[ty]167{Maybe})
{
if (𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟157{t},𝓛12643{undefined}),𝓛12559{EqualsEqualsEqualsToken}(𝓟157{t},𝓛12643{undefined})))
{
𝓛8754{TypeError}.CONSTRUCTOR(𝓛8743{String})
}
return 𝓟158 = 𝓟139{CONSTRUCTOR}(𝓟131{MaybeType}.Just,𝓟157{t})
}
function 𝓟159{nothing} (): (𝓟160: [OOV]𝓟[ty]167{Maybe})
{
return 𝓟160 = 𝓟139{CONSTRUCTOR}(𝓟131{MaybeType}.Nothing)
}
function 𝓟161{isJust} (𝓟162{t}: [OOV]𝓟[ty]167{Maybe}): (𝓟163: 𝓛[ty]8666{Boolean})
{
return 𝓟163 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟162{t}.type,𝓟131{MaybeType}.Just)
}
function 𝓟164{isNothing} (𝓟165{t}: [OOV]𝓟[ty]167{Maybe}): (𝓟166: 𝓛[ty]8666{Boolean})
{
return 𝓟166 = 𝓛12559{EqualsEqualsEqualsToken}(𝓟165{t}.type,𝓟131{MaybeType}.Nothing)
}
class 𝓟[ty]167{Maybe} extends 𝓟[ty]3{Monad}{
𝓟169{of}: [miss]𝓛[ty]8696{Function};
𝓟170{chain}: [miss]𝓛[ty]8696{Function};
𝓟171{lift}: [miss]𝓛[ty]8696{Function};
𝓟172{map}: [miss]𝓛[ty]8696{Function};
function 𝓟202{valueOrThrow} (𝓟203{error}: 𝓛[ty]10053{Error}): (𝓟204: [OOV]any)
{
if (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]167{Maybe}.type,𝓟131{MaybeType}.Just))
{
return 𝓟204 = 𝓟[ty]167{Maybe}.value
}
𝓛12546{BarBarToken}(𝓟203{error},𝓛8749{Error}.CONSTRUCTOR(𝓛8743{String}))
}
function 𝓟191{equals} (𝓟192{other}: [OOV]𝓟[ty]167{Maybe}): (𝓟193: [OOV]any)
{
return 𝓟193 = 𝓛12592{AmpersandAmpersandToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟192{other}.type,𝓟[ty]167{Maybe}.type),𝓛12546{BarBarToken}(𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]167{Maybe}.type,𝓟131{MaybeType}.Nothing),𝓟6{eq}(𝓟192{other}.value,𝓟[ty]167{Maybe}.value)))
}
function 𝓟205{do} (𝓟206{patterns}: (𝓛[ty]8642{Object} ≠ 𝓛[ty]8689{Partial})): (𝓟207: [OOV]𝓟[ty]167{Maybe})
{
function 𝓟208{$Lambda11} (𝓟209{t}: [OOV]any): (𝓟210: [miss]𝓛[ty]10033{Void})
{
}
function 𝓟211{$Lambda12} (): (𝓟212: [miss]𝓛[ty]10033{Void})
{
}
let 𝓟213{noop_pattern}: [miss]𝓛[ty]8642{Object} = {just: 𝓟208{$Lambda11},nothing: 𝓟211{$Lambda12}};
let 𝓟214{merged} = 𝓛8741{Object}.assign(𝓟213{noop_pattern},𝓟206{patterns});
𝓟[ty]167{Maybe}.caseOf(𝓟214{merged})
return 𝓟207 = 𝓟[ty]167{Maybe}
}
function 𝓟179{fmap} (𝓟180{f}: 𝓛[ty]8696{Function}): (𝓟181: [OOV]𝓟[ty]167{Maybe})
{
function 𝓟182{$Lambda9} (𝓟183{v}): (𝓟184: [OOV]𝓟[ty]167{Maybe})
{
return 𝓟184 = 𝓟[ty]167{Maybe}.unit(𝓟180{f}(𝓟183{v}))
}
return 𝓟181 = 𝓟[ty]167{Maybe}.bind(𝓟182{$Lambda9})
}
function 𝓟199{valueOrCompute} (𝓟200{defaultValueFunction}: 𝓛[ty]8696{Function}): (𝓟201: [OOV]any)
{
return 𝓟201 = (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]167{Maybe}.type,𝓟131{MaybeType}.Just) ? 𝓟[ty]167{Maybe}.value : 𝓟200{defaultValueFunction}()
}
function 𝓟176{bind} (𝓟177{f}: 𝓛[ty]8696{Function}): (𝓟178: [OOV]𝓟[ty]167{Maybe})
{
return 𝓟178 = (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]167{Maybe}.type,𝓟131{MaybeType}.Just) ? 𝓟177{f}(𝓟[ty]167{Maybe}.value) : 𝓟159{nothing}()
}
function 𝓟188{defaulting} (𝓟189{defaultValue}: [OOV]any): (𝓟190: [OOV]𝓟[ty]167{Maybe})
{
return 𝓟190 = 𝓟156{just}(𝓟[ty]167{Maybe}.valueOr(𝓟189{defaultValue}))
}
function 𝓟173{unit} (𝓟174{u}: [OOV]any): (𝓟175: [OOV]𝓟[ty]167{Maybe})
{
return 𝓟175 = 𝓟153{maybe}(𝓟174{u})
}
function 𝓟194{valueOr} (𝓟195{defaultValue}: [OOV]any): (𝓟196: [OOV]any)
{
function 𝓟197{$Lambda10} (): (𝓟198: [OOV]any)
{
return 𝓟198 = 𝓟195{defaultValue}
}
return 𝓟196 = 𝓟[ty]167{Maybe}.valueOrCompute(𝓟197{$Lambda10})
}
function 𝓟185{caseOf} (𝓟186{patterns}: [OOV]𝓟[ty]128{MaybePatterns}): (𝓟187: [OOV]any)
{
return 𝓟187 = (𝓛12559{EqualsEqualsEqualsToken}(𝓟[ty]167{Maybe}.type,𝓟131{MaybeType}.Just) ? 𝓟186{patterns}.just(𝓟[ty]167{Maybe}.value) : 𝓟186{patterns}.nothing()
}
}